Commit 872f68c9cbef44817fdbd57e2b1fb90b5c2ddd8c | zig

author	Ali Chraghi <alichraghi@proton.me> 2025-06-16 01:16:15+03:30
committer	Ali Chraghi <alichraghi@proton.me> 2025-06-16 13:22:19+03:30
log	872f68c9cbef44817fdbd57e2b1fb90b5c2ddd8c
tree	f5103c5acad66895724eef94513a9300953fe615
parent	c126d6554fbe18630f4237d0b8e6b0783ebee394
signature	Commit is signed but in an unrecognized format.

rename spirv backend name

`stage2_spirv64` -> `stage2_spirv`

111 files changed, 921 insertions(+), 921 deletions(-)

lib
- std
src
test

lib/std/builtin.zig+1-1

...	...	@@ -1121,7 +1121,7 @@ pub const CompilerBackend = enum(u64) {
1121	1121	stage2_sparc64 = 10,
1122	1122	/// The reference implementation self-hosted compiler of Zig, using the
1123	1123	/// spirv backend.
1124		stage2_spirv64 = 11,
	1124	stage2_spirv = 11,
1125	1125	/// The reference implementation self-hosted compiler of Zig, using the
1126	1126	/// powerpc backend.
1127	1127	stage2_powerpc = 12,

lib/std/debug.zig+1-1

...	...	@@ -607,7 +607,7 @@ pub fn defaultPanic(
607	607	.stage2_arm,
608	608	.stage2_powerpc,
609	609	.stage2_riscv64,
610		.stage2_spirv64,
	610	.stage2_spirv,
611	611	.stage2_wasm,
612	612	.stage2_x86,
613	613	=> @trap(),

lib/std/mem.zig+1-1

...	...	@@ -680,7 +680,7 @@ const eqlBytes_allowed = switch (builtin.zig_backend) {
680	680	.stage2_riscv64,
681	681	=> false,
682	682	// The SPIR-V backend does not support the optimized path yet.
683		.stage2_spirv64 => false,
	683	.stage2_spirv => false,
684	684	// The naive memory comparison implementation is more useful for fuzzers to
685	685	// find interesting inputs.
686	686	else => !builtin.fuzz,

lib/std/start.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub const simplified_logic = switch (builtin.zig_backend) {
19	19	.stage2_arm,
20	20	.stage2_powerpc,
21	21	.stage2_sparc64,
22		.stage2_spirv64,
	22	.stage2_spirv,
23	23	.stage2_x86,
24	24	=> true,
25	25	else => false,

lib/std/testing.zig+1-1

...	...	@@ -35,7 +35,7 @@ pub var log_level = std.log.Level.warn;
35	35	pub const backend_can_print = switch (builtin.zig_backend) {
36	36	.stage2_powerpc,
37	37	.stage2_riscv64,
38		.stage2_spirv64,
	38	.stage2_spirv,
39	39	=> false,
40	40	else => true,
41	41	};

src/Zcu.zig+1-1

...	...	@@ -4585,7 +4585,7 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu
4585	4585	.naked => true,
4586	4586	else => false,
4587	4587	},
4588		.stage2_spirv64 => switch (cc) {
	4588	.stage2_spirv => switch (cc) {
4589	4589	.spirv_device, .spirv_kernel => true,
4590	4590	.spirv_fragment, .spirv_vertex => target.os.tag == .vulkan,
4591	4591	else => false,

src/Zcu/PerThread.zig+1-1

...	...	@@ -4386,7 +4386,7 @@ pub fn runCodegen(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air, ou
4386	4386	zcu.comp.config.use_llvm,
4387	4387	)) {
4388	4388	else => unreachable, // assertion failure
4389		.stage2_spirv64,
	4389	.stage2_spirv,
4390	4390	.stage2_llvm,
4391	4391	=> {},
4392	4392	},

src/codegen.zig+3-3

...	...	@@ -37,7 +37,7 @@ fn devFeatureForBackend(backend: std.builtin.CompilerBackend) dev.Feature {
37	37	.stage2_powerpc => .powerpc_backend,
38	38	.stage2_riscv64 => .riscv64_backend,
39	39	.stage2_sparc64 => .sparc64_backend,
40		.stage2_spirv64 => .spirv64_backend,
	40	.stage2_spirv => .spirv64_backend,
41	41	.stage2_wasm => .wasm_backend,
42	42	.stage2_x86 => .x86_backend,
43	43	.stage2_x86_64 => .x86_64_backend,
...	...	@@ -55,7 +55,7 @@ fn importBackend(comptime backend: std.builtin.CompilerBackend) type {
55	55	.stage2_powerpc => @import("arch/powerpc/CodeGen.zig"),
56	56	.stage2_riscv64 => @import("arch/riscv64/CodeGen.zig"),
57	57	.stage2_sparc64 => @import("arch/sparc64/CodeGen.zig"),
58		.stage2_spirv64 => @import("codegen/spirv.zig"),
	58	.stage2_spirv => @import("codegen/spirv.zig"),
59	59	.stage2_wasm => @import("arch/wasm/CodeGen.zig"),
60	60	.stage2_x86, .stage2_x86_64 => @import("arch/x86_64/CodeGen.zig"),
61	61	_ => unreachable,
...	...	@@ -76,7 +76,7 @@ pub fn legalizeFeatures(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) ?*co
76	76	.stage2_x86,
77	77	.stage2_riscv64,
78	78	.stage2_sparc64,
79		.stage2_spirv64,
	79	.stage2_spirv,
80	80	.stage2_powerpc,
81	81	=> \|backend\| {
82	82	dev.check(devFeatureForBackend(backend));

src/target.zig+2-2

...	...	@@ -813,8 +813,8 @@ pub fn zigBackend(target: std.Target, use_llvm: bool) std.builtin.CompilerBacken
813	813	.powerpc, .powerpcle, .powerpc64, .powerpc64le => .stage2_powerpc,
814	814	.riscv64 => .stage2_riscv64,
815	815	.sparc64 => .stage2_sparc64,
816		.spirv32 => if (target.os.tag == .opencl) .stage2_spirv64 else .other,
817		.spirv, .spirv64 => .stage2_spirv64,
	816	.spirv32 => if (target.os.tag == .opencl) .stage2_spirv else .other,
	817	.spirv, .spirv64 => .stage2_spirv,
818	818	.wasm32, .wasm64 => .stage2_wasm,
819	819	.x86 => .stage2_x86,
820	820	.x86_64 => .stage2_x86_64,

test/behavior.zig+4-4

...	...	@@ -121,18 +121,18 @@ test {
121	121	_ = @import("behavior/wasm.zig");
122	122	}
123	123
124		if (builtin.zig_backend != .stage2_spirv64 and builtin.os.tag != .wasi) {
	124	if (builtin.zig_backend != .stage2_spirv and builtin.os.tag != .wasi) {
125	125	_ = @import("behavior/asm.zig");
126	126	}
127	127
128	128	if (builtin.zig_backend != .stage2_arm and
129	129	builtin.zig_backend != .stage2_aarch64 and
130		builtin.zig_backend != .stage2_spirv64)
	130	builtin.zig_backend != .stage2_spirv)
131	131	{
132	132	_ = @import("behavior/export_keyword.zig");
133	133	}
134	134
135		if (builtin.zig_backend != .stage2_spirv64 and !builtin.cpu.arch.isWasm()) {
	135	if (builtin.zig_backend != .stage2_spirv and !builtin.cpu.arch.isWasm()) {
136	136	// Due to lack of import/export of global support
137	137	// (https://github.com/ziglang/zig/issues/4866), these tests correctly
138	138	// cause linker errors, since a data symbol cannot be exported when
...	...	@@ -145,7 +145,7 @@ test {
145	145
146	146	// This bug only repros in the root file
147	147	test "deference @embedFile() of a file full of zero bytes" {
148		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	148	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
149	149
150	150	const contents = @embedFile("behavior/zero.bin").*;
151	151	try @import("std").testing.expect(contents.len == 456);

test/behavior/abs.zig+7-7

...	...	@@ -7,7 +7,7 @@ test "@abs integers" {
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	try comptime testAbsIntegers();
13	13	try testAbsIntegers();
...	...	@@ -94,7 +94,7 @@ test "@abs big int <= 128 bits" {
94	94	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
95	95	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
96	96	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
97		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	97	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
98	98	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
99	99
100	100	try comptime testAbsSignedBigInt();
...	...	@@ -165,9 +165,9 @@ test "@abs floats" {
165	165	try comptime testAbsFloats(f64);
166	166	try testAbsFloats(f64);
167	167	try comptime testAbsFloats(f80);
168		if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv64 and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
	168	if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f80);
169	169	try comptime testAbsFloats(f128);
170		if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv64 and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
	170	if (builtin.zig_backend != .stage2_wasm and builtin.zig_backend != .stage2_spirv and builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f128);
171	171	}
172	172
173	173	fn testAbsFloats(comptime T: type) !void {
...	...	@@ -214,7 +214,7 @@ test "@abs int vectors" {
214	214	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
215	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216	216	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
217		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	217	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
218	218
219	219	try comptime testAbsIntVectors(1);
220	220	try testAbsIntVectors(1);
...	...	@@ -281,7 +281,7 @@ test "@abs unsigned int vectors" {
281	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
282	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283	283	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
284		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	284	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
285	285
286	286	try comptime testAbsUnsignedIntVectors(1);
287	287	try testAbsUnsignedIntVectors(1);
...	...	@@ -339,7 +339,7 @@ test "@abs float vectors" {
339	339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
340	340	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
341	341	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
342		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	342	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
343	343	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
344	344	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
345	345

test/behavior/addrspace_and_linksection.zig+1-1

...	...	@@ -79,7 +79,7 @@ test "addrspace and linksection on container-level var" {
79	79	}
80	80
81	81	test "addrspace on fn" {
82		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	83
84	84	const S = struct {
85	85	fn f() addrspace(.generic) u32 {

test/behavior/align.zig+23-23

...	...	@@ -18,7 +18,7 @@ test "global variable alignment" {
18	18	test "large alignment of local constant" {
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
21		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
	21	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
22	22
23	23	const x: f32 align(128) = 12.34;
24	24	try std.testing.expect(@intFromPtr(&x) % 128 == 0);
...	...	@@ -27,7 +27,7 @@ test "large alignment of local constant" {
27	27	test "slicing array of length 1 can not assume runtime index is always zero" {
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
	30	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
31	31
32	32	var runtime_index: usize = 1;
33	33	_ = &runtime_index;
...	...	@@ -52,7 +52,7 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {
52	52	}
53	53
54	54	test "@alignCast pointers" {
55		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	55	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
56	56
57	57	var x: u32 align(4) = 1;
58	58	expectsOnly1(&x);
...	...	@@ -162,7 +162,7 @@ test "alignment and size of structs with 128-bit fields" {
162	162	test "implicitly decreasing slice alignment" {
163	163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
164	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	165	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
166	166
167	167	const a: u32 align(4) = 3;
168	168	const b: u32 align(8) = 4;
...	...	@@ -175,7 +175,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
175	175	test "specifying alignment allows pointer cast" {
176	176	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
177	177	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
178		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	178	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
179	179
180	180	try testBytesAlign(0x33);
181	181	}
...	...	@@ -189,7 +189,7 @@ test "@alignCast slices" {
189	189	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
190	190	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
191	191	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
192		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	192	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
193	193
194	194	var array align(4) = [_]u32{ 1, 1 };
195	195	const slice = array[0..];
...	...	@@ -208,7 +208,7 @@ test "return error union with 128-bit integer" {
208	208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
209	209	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
210	210	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	211	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
212	212
213	213	try expect(3 == try give());
214	214	}
...	...	@@ -221,7 +221,7 @@ test "page aligned array on stack" {
221	221	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
222	222	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
223	223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	224	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
225	225
226	226	// Large alignment value to make it hard to accidentally pass.
227	227	var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
...	...	@@ -241,7 +241,7 @@ test "function alignment" {
241	241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
242	242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
243	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
244		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	244	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
245	245
246	246	// function alignment is a compile error on wasm
247	247	if (native_arch.isWasm()) return error.SkipZigTest;
...	...	@@ -271,7 +271,7 @@ test "implicitly decreasing fn alignment" {
271	271	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
272	272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
273	273	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
274		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	274	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
275	275
276	276	// function alignment is a compile error on wasm
277	277	if (native_arch.isWasm()) return error.SkipZigTest;
...	...	@@ -295,7 +295,7 @@ test "@alignCast functions" {
295	295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
296	296	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
297	297	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
298		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	298	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
299	299
300	300	// function alignment is a compile error on wasm
301	301	if (native_arch.isWasm()) return error.SkipZigTest;
...	...	@@ -315,7 +315,7 @@ fn simple4() align(4) i32 {
315	315
316	316	test "runtime-known array index has best alignment possible" {
317	317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	318	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
319	319
320	320	// take full advantage of over-alignment
321	321	var array align(4) = [_]u8{ 1, 2, 3, 4 };
...	...	@@ -356,7 +356,7 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
356	356	}
357	357
358	358	test "alignment of function with c calling convention" {
359		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	359	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
360	360
361	361	const a = @alignOf(@TypeOf(nothing));
362	362
...	...	@@ -379,7 +379,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
379	379	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
380	380	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
381	381	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
382		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	382	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
383	383
384	384	var default_aligned = DefaultAligned{
385	385	.nevermind = 1,
...	...	@@ -399,7 +399,7 @@ test "read 128-bit field from default aligned struct in global memory" {
399	399	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
400	400	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
401	401	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	402	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
403	403
404	404	try expect(12 == default_aligned_global.badguy);
405	405	}
...	...	@@ -408,7 +408,7 @@ test "struct field explicit alignment" {
408	408	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
409	409	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
410	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
411		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
	411	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
412	412
413	413	const S = struct {
414	414	const Node = struct {
...	...	@@ -452,7 +452,7 @@ test "align(N) on functions" {
452	452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
453	453	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
454	454	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
455		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	455	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
456	456
457	457	if (builtin.zig_backend == .stage2_c) {
458	458	// https://github.com/ziglang/zig/issues/16845
...	...	@@ -480,7 +480,7 @@ test "comptime alloc alignment" {
480	480	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
481	481	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
482	482	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
483		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
	483	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
484	484
485	485	comptime var bytes1 = [_]u8{0};
486	486	_ = &bytes1;
...	...	@@ -493,7 +493,7 @@ test "comptime alloc alignment" {
493	493	test "@alignCast null" {
494	494	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
495	495	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
496		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	496	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
497	497
498	498	var ptr: ?*anyopaque = null;
499	499	_ = &ptr;
...	...	@@ -510,7 +510,7 @@ test "sub-aligned pointer field access" {
510	510	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
511	511	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
512	512	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
513		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	513	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
514	514
515	515	// Originally reported at https://github.com/ziglang/zig/issues/14904
516	516
...	...	@@ -530,7 +530,7 @@ test "sub-aligned pointer field access" {
530	530	test "alignment of zero-bit types is respected" {
531	531	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
532	532	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
533		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	533	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
534	534	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
535	535
536	536	const S = struct { arr: [0]usize = .{} };
...	...	@@ -563,7 +563,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
563	563	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
564	564	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
565	565	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
566		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	566	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
567	567	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
568	568
569	569	const S = extern struct {
...	...	@@ -588,7 +588,7 @@ test "zero-bit fields in extern struct pad fields appropriately" {
588	588	}
589	589
590	590	test "function pointer @intFromPtr/@ptrFromInt roundtrip" {
591		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	591	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
592	592
593	593	// This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`
594	594	// will incorrectly trip an alignment safety check.

test/behavior/alignof.zig+1-1

...	...	@@ -29,7 +29,7 @@ test "comparison of @alignOf(T) against zero" {
29	29	}
30	30
31	31	test "correct alignment for elements and slices of aligned array" {
32		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	32	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33	33
34	34	var buf: [1024]u8 align(64) = undefined;
35	35	var start: usize = 1;

test/behavior/array.zig+33-33

...	...	@@ -49,7 +49,7 @@ fn getArrayLen(a: []const u32) usize {
49	49	test "array concat with undefined" {
50	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
51	51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
52		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	52	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
53	53
54	54	const S = struct {
55	55	fn doTheTest() !void {
...	...	@@ -71,7 +71,7 @@ test "array concat with undefined" {
71	71	}
72	72
73	73	test "array concat with tuple" {
74		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	74	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75	75	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
76	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
77	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -88,7 +88,7 @@ test "array concat with tuple" {
88	88	}
89	89
90	90	test "array init with concat" {
91		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	91	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
92	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
93	93
94	94	const a = 'a';
...	...	@@ -97,7 +97,7 @@ test "array init with concat" {
97	97	}
98	98
99	99	test "array init with mult" {
100		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
101	101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
102	102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
103	103
...	...	@@ -161,7 +161,7 @@ test "array len field" {
161	161	}
162	162
163	163	test "array with sentinels" {
164		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	164	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
165	165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
166	166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
167	167
...	...	@@ -199,7 +199,7 @@ test "void arrays" {
199	199	}
200	200
201	201	test "nested arrays of strings" {
202		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	202	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
203	203	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
204	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
205	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -245,7 +245,7 @@ fn plusOne(x: u32) u32 {
245	245	test "single-item pointer to array indexing and slicing" {
246	246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
247	247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
248		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	248	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
249	249
250	250	try testSingleItemPtrArrayIndexSlice();
251	251	try comptime testSingleItemPtrArrayIndexSlice();
...	...	@@ -307,7 +307,7 @@ var s_array: [8]Sub = undefined;
307	307	const Sub = struct { b: u8 };
308	308	const Str = struct { a: []Sub };
309	309	test "set global var array via slice embedded in struct" {
310		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	310	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
311	311	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
312	312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313	313
...	...	@@ -344,7 +344,7 @@ test "read/write through global variable array of struct fields initialized via
344	344	}
345	345
346	346	test "implicit cast single-item pointer" {
347		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	347	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
348	348	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
349	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350	350
...	...	@@ -375,7 +375,7 @@ test "comptime evaluating function that takes array by value" {
375	375	}
376	376
377	377	test "runtime initialize array elem and then implicit cast to slice" {
378		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	378	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
379	379	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
380	380	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
381	381
...	...	@@ -386,7 +386,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
386	386	}
387	387
388	388	test "array literal as argument to function" {
389		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	389	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
390	390	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
391	391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
392	392
...	...	@@ -414,7 +414,7 @@ test "array literal as argument to function" {
414	414	}
415	415
416	416	test "double nested array to const slice cast in array literal" {
417		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	417	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
418	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
419	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
420	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -539,7 +539,7 @@ test "type deduction for array subscript expression" {
539	539	}
540	540
541	541	test "sentinel element count towards the ABI size calculation" {
542		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	542	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
543	543	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
544	544	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
545	545	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -566,7 +566,7 @@ test "sentinel element count towards the ABI size calculation" {
566	566	test "zero-sized array with recursive type definition" {
567	567	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
568	568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
569		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	569	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
570	570
571	571	const U = struct {
572	572	fn foo(comptime T: type, comptime n: usize) type {
...	...	@@ -587,7 +587,7 @@ test "zero-sized array with recursive type definition" {
587	587	}
588	588
589	589	test "type coercion of anon struct literal to array" {
590		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	590	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
591	591	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
592	592	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
593	593	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -640,7 +640,7 @@ test "tuple to array handles sentinel" {
640	640	}
641	641
642	642	test "array init of container level array variable" {
643		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	643	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
644	644	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
645	645	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
646	646	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -664,7 +664,7 @@ test "array init of container level array variable" {
664	664	}
665	665
666	666	test "runtime initialized sentinel-terminated array literal" {
667		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	667	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
668	668
669	669	var c: u16 = 300;
670	670	_ = &c;
...	...	@@ -728,7 +728,7 @@ test "slicing array of zero-sized values" {
728	728	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
729	729	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
730	730	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
731		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	731	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
732	732
733	733	var arr: [32]u0 = undefined;
734	734	for (arr[0..]) \|*zero\|
...	...	@@ -752,7 +752,7 @@ test "array init with no result pointer sets field result types" {
752	752	}
753	753
754	754	test "runtime side-effects in comptime-known array init" {
755		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	755	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
756	756
757	757	var side_effects: u4 = 0;
758	758	const init = [4]u4{
...	...	@@ -778,7 +778,7 @@ test "runtime side-effects in comptime-known array init" {
778	778	}
779	779
780	780	test "slice initialized through reference to anonymous array init provides result types" {
781		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	781	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
782	782
783	783	var my_u32: u32 = 123;
784	784	var my_u64: u64 = 456;
...	...	@@ -793,7 +793,7 @@ test "slice initialized through reference to anonymous array init provides resul
793	793	}
794	794
795	795	test "sentinel-terminated slice initialized through reference to anonymous array init provides result types" {
796		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	796	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
797	797
798	798	var my_u32: u32 = 123;
799	799	var my_u64: u64 = 456;
...	...	@@ -808,7 +808,7 @@ test "sentinel-terminated slice initialized through reference to anonymous array
808	808	}
809	809
810	810	test "many-item pointer initialized through reference to anonymous array init provides result types" {
811		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	811	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
812	812	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
813	813
814	814	var my_u32: u32 = 123;
...	...	@@ -827,7 +827,7 @@ test "many-item pointer initialized through reference to anonymous array init pr
827	827	}
828	828
829	829	test "many-item sentinel-terminated pointer initialized through reference to anonymous array init provides result types" {
830		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	830	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
831	831	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
832	832
833	833	var my_u32: u32 = 123;
...	...	@@ -847,7 +847,7 @@ test "many-item sentinel-terminated pointer initialized through reference to ano
847	847	}
848	848
849	849	test "pointer to array initialized through reference to anonymous array init provides result types" {
850		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	850	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
851	851
852	852	var my_u32: u32 = 123;
853	853	var my_u64: u64 = 456;
...	...	@@ -862,7 +862,7 @@ test "pointer to array initialized through reference to anonymous array init pro
862	862	}
863	863
864	864	test "pointer to sentinel-terminated array initialized through reference to anonymous array init provides result types" {
865		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	865	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
866	866
867	867	var my_u32: u32 = 123;
868	868	var my_u64: u64 = 456;
...	...	@@ -877,7 +877,7 @@ test "pointer to sentinel-terminated array initialized through reference to anon
877	877	}
878	878
879	879	test "tuple initialized through reference to anonymous array init provides result types" {
880		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	880	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
881	881
882	882	const Tuple = struct { u64, *const u32 };
883	883	const foo: *const Tuple = &.{
...	...	@@ -904,7 +904,7 @@ test "copied array element doesn't alias source" {
904	904
905	905	test "array initialized with string literal" {
906	906	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
907		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	907	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
908	908
909	909	const S = struct {
910	910	a: u32,
...	...	@@ -924,7 +924,7 @@ test "array initialized with string literal" {
924	924	}
925	925
926	926	test "array initialized with array with sentinel" {
927		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	927	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
928	928	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
929	929
930	930	const S = struct {
...	...	@@ -972,7 +972,7 @@ test "store array of array of structs at comptime" {
972	972	test "accessing multidimensional global array at comptime" {
973	973	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
974	974	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
975		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	975	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
976	976
977	977	const S = struct {
978	978	const array = [_][]const []const u8{
...	...	@@ -986,7 +986,7 @@ test "accessing multidimensional global array at comptime" {
986	986	}
987	987
988	988	test "union that needs padding bytes inside an array" {
989		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	989	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
990	990	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
991	991	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
992	992	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -1010,7 +1010,7 @@ test "union that needs padding bytes inside an array" {
1010	1010	}
1011	1011
1012	1012	test "runtime index of array of zero-bit values" {
1013		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1013	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1014	1014
1015	1015	var runtime: struct { array: [1]void, index: usize } = undefined;
1016	1016	runtime = .{ .array = .{{}}, .index = 0 };
...	...	@@ -1045,7 +1045,7 @@ test "@splat array" {
1045	1045	}
1046	1046
1047	1047	test "@splat array with sentinel" {
1048		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1048	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1049	1049	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1050	1050	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1051	1051	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -1069,7 +1069,7 @@ test "@splat array with sentinel" {
1069	1069	}
1070	1070
1071	1071	test "@splat zero-length array" {
1072		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1072	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1073	1073	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1074	1074	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1075	1075	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

test/behavior/asm.zig+4-4

...	...	@@ -19,7 +19,7 @@ comptime {
19	19	\\.type this_is_my_alias, @function;
20	20	\\.set this_is_my_alias, derp;
21	21	);
22		} else if (builtin.zig_backend == .stage2_spirv64) {
	22	} else if (builtin.zig_backend == .stage2_spirv) {
23	23	asm (
24	24	\\%a = OpString "hello there"
25	25	);
...	...	@@ -45,7 +45,7 @@ test "output constraint modifiers" {
45	45	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
46	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
47	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
48		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	48	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
49	49	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
50	50
51	51	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
...	...	@@ -69,7 +69,7 @@ test "alternative constraints" {
69	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
70	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
71	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	72	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
73	73	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
74	74
75	75	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
...	...	@@ -88,7 +88,7 @@ test "sized integer/float in asm input" {
88	88	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	89	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
90	90	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
91		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	91	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
92	92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
93	93
94	94	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

...	...	@@ -15,7 +15,7 @@ test "cmpxchg" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
19	19
20	20	try testCmpxchg();
21	21	try comptime testCmpxchg();
...	...	@@ -42,7 +42,7 @@ test "atomicrmw and atomicload" {
42	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43	43	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
44	44	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
45		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	45	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
46	46	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
47	47
48	48	var data: u8 = 200;
...	...	@@ -71,7 +71,7 @@ test "cmpxchg with ptr" {
71	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
72	72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73	73	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
74		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	74	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75	75	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
76	76
77	77	var data1: i32 = 1234;
...	...	@@ -97,7 +97,7 @@ test "cmpxchg with ignored result" {
97	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
99	99	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
100		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
101	101
102	102	var x: i32 = 1234;
103	103
...	...	@@ -142,7 +142,7 @@ test "cmpxchg on a global variable" {
142	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
143	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
144	144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	145	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
146	146
147	147	_ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .acquire, .monotonic);
148	148	try expect(a_global_variable == 42);
...	...	@@ -152,7 +152,7 @@ test "atomic load and rmw with enum" {
152	152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
153	153	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
154	154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	155	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
156	156
157	157	const Value = enum(u8) { a, b, c };
158	158	var x = Value.a;
...	...	@@ -169,7 +169,7 @@ test "atomic store" {
169	169	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
170	170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171	171	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
172		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	172	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
173	173
174	174	try comptime testAtomicStore();
175	175	try testAtomicStore();
...	...	@@ -187,7 +187,7 @@ test "atomicrmw with floats" {
187	187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
188	188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
189	189	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
190		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	190	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
191	191
192	192	try testAtomicRmwFloat();
193	193	try comptime testAtomicRmwFloat();
...	...	@@ -212,7 +212,7 @@ test "atomicrmw with ints" {
212	212	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
213	213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214	214	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
215		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	215	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
216	216	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
217	217
218	218	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
...	...	@@ -360,7 +360,7 @@ test "atomics with different types" {
360	360	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
361	361	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
362	362	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
363		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	363	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
364	364	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
365	365
366	366	try testAtomicsWithType(bool, true, false);
...	...	@@ -410,7 +410,7 @@ test "return @atomicStore, using it as a void value" {
410	410	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
411	411	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
412	412	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
413		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	413	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
414	414
415	415	const S = struct {
416	416	const A = struct {

test/behavior/basic.zig+35-35

...	...	@@ -24,7 +24,7 @@ fn testTruncate(x: u32) u8 {
24	24	}
25	25
26	26	test "truncate to non-power-of-two integers" {
27		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
28	28	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29	29
30	30	try testTrunc(u32, u1, 0b10101, 0b1);
...	...	@@ -42,7 +42,7 @@ test "truncate to non-power-of-two integers from 128-bit" {
42	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
45		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	45	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
46	46
47	47	try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010101, 0x01);
48	48	try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010110, 0x00);
...	...	@@ -209,14 +209,14 @@ fn first4KeysOfHomeRow() []const u8 {
209	209	}
210	210
211	211	test "return string from function" {
212		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	212	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
213	213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214	214
215	215	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
216	216	}
217	217
218	218	test "hex escape" {
219		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	219	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
220	220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
221	221
222	222	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
...	...	@@ -224,7 +224,7 @@ test "hex escape" {
224	224
225	225	test "multiline string" {
226	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
227		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	227	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
228	228
229	229	const s1 =
230	230	\\one
...	...	@@ -237,7 +237,7 @@ test "multiline string" {
237	237
238	238	test "multiline string comments at start" {
239	239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	240	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
241	241
242	242	const s1 =
243	243	//\\one
...	...	@@ -250,7 +250,7 @@ test "multiline string comments at start" {
250	250
251	251	test "multiline string comments at end" {
252	252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
253		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	253	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
254	254
255	255	const s1 =
256	256	\\one
...	...	@@ -263,7 +263,7 @@ test "multiline string comments at end" {
263	263
264	264	test "multiline string comments in middle" {
265	265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	266	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
267	267
268	268	const s1 =
269	269	\\one
...	...	@@ -276,7 +276,7 @@ test "multiline string comments in middle" {
276	276
277	277	test "multiline string comments at multiple places" {
278	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
279		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	279	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
280	280
281	281	const s1 =
282	282	\\one
...	...	@@ -290,14 +290,14 @@ test "multiline string comments at multiple places" {
290	290	}
291	291
292	292	test "string concatenation simple" {
293		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	293	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
294	294
295	295	try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
296	296	}
297	297
298	298	test "array mult operator" {
299	299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
300		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	300	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
301	301
302	302	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
303	303	}
...	...	@@ -307,7 +307,7 @@ const OpaqueB = opaque {};
307	307
308	308	test "opaque types" {
309	309	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
310		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	310	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
311	311
312	312	try expect(OpaqueA != OpaqueB);
313	313
...	...	@@ -319,7 +319,7 @@ const global_a: i32 = 1234;
319	319	const global_b: *const i32 = &global_a;
320	320	const global_c: const f32 = @as(const f32, @ptrCast(global_b));
321	321	test "compile time global reinterpret" {
322		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	322	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
323	323
324	324	const d = @as(*const i32, @ptrCast(global_c));
325	325	try expect(d.* == 1234);
...	...	@@ -396,7 +396,7 @@ fn fB() []const u8 {
396	396
397	397	test "call function pointer in struct" {
398	398	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
399		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	399	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
400	400
401	401	try expect(mem.eql(u8, f3(true), "a"));
402	402	try expect(mem.eql(u8, f3(false), "b"));
...	...	@@ -438,7 +438,7 @@ test "call result of if else expression" {
438	438	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
439	439	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
440	440	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
441		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	441	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
442	442
443	443	try expect(mem.eql(u8, f2(true), "a"));
444	444	try expect(mem.eql(u8, f2(false), "b"));
...	...	@@ -448,7 +448,7 @@ fn f2(x: bool) []const u8 {
448	448	}
449	449
450	450	test "variable is allowed to be a pointer to an opaque type" {
451		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	451	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
452	452
453	453	var x: i32 = 1234;
454	454	_ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));
...	...	@@ -472,7 +472,7 @@ fn testTakeAddressOfParameter(f: f32) !void {
472	472	}
473	473
474	474	test "pointer to void return type" {
475		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	475	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
476	476
477	477	try testPointerToVoidReturnType();
478	478	}
...	...	@@ -489,7 +489,7 @@ test "array 2D const double ptr" {
489	489	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
490	490	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
491	491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
492		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	492	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
493	493
494	494	const rect_2d_vertexes = [_][1]f32{
495	495	[_]f32{1.0},
...	...	@@ -502,7 +502,7 @@ test "array 2D const double ptr with offset" {
502	502	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
503	503	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
504	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
505		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	505	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
506	506
507	507	const rect_2d_vertexes = [_][2]f32{
508	508	[_]f32{ 3.0, 4.239 },
...	...	@@ -515,7 +515,7 @@ test "array 3D const double ptr with offset" {
515	515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
516	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
517	517	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
518		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	518	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
519	519
520	520	const rect_3d_vertexes = [_][2][2]f32{
521	521	[_][2]f32{
...	...	@@ -571,7 +571,7 @@ fn testStructInFn() !void {
571	571
572	572	test "fn call returning scalar optional in equality expression" {
573	573	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
574		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	574	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
575	575
576	576	try expect(getNull() == null);
577	577	}
...	...	@@ -583,7 +583,7 @@ fn getNull() ?*i32 {
583	583	test "global variable assignment with optional unwrapping with var initialized to undefined" {
584	584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
585	585	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
586		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	586	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
587	587
588	588	const S = struct {
589	589	var data: i32 = 1234;
...	...	@@ -672,7 +672,7 @@ test "comptime cast fn to ptr" {
672	672	}
673	673
674	674	test "equality compare fn ptrs" {
675		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Uses function pointers
	675	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Uses function pointers
676	676
677	677	var a = &emptyFn;
678	678	_ = &a;
...	...	@@ -680,7 +680,7 @@ test "equality compare fn ptrs" {
680	680	}
681	681
682	682	test "self reference through fn ptr field" {
683		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	683	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
684	684
685	685	const S = struct {
686	686	const A = struct {
...	...	@@ -699,7 +699,7 @@ test "self reference through fn ptr field" {
699	699
700	700	test "global variable initialized to global variable array element" {
701	701	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
702		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	702	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
703	703
704	704	try expect(global_ptr == &gdt[0]);
705	705	}
...	...	@@ -732,7 +732,7 @@ test "global constant is loaded with a runtime-known index" {
732	732
733	733	test "multiline string literal is null terminated" {
734	734	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
735		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	735	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
736	736
737	737	const s1 =
738	738	\\one
...	...	@@ -747,7 +747,7 @@ test "string escapes" {
747	747	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
748	748	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
749	749	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
750		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	750	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
751	751
752	752	try expectEqualStrings("\"", "\x22");
753	753	try expectEqualStrings("\'", "\x27");
...	...	@@ -765,7 +765,7 @@ test "explicit cast optional pointers" {
765	765	}
766	766
767	767	test "pointer comparison" {
768		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	768	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
769	769
770	770	const a = @as([]const u8, "a");
771	771	const b = &a;
...	...	@@ -817,7 +817,7 @@ fn maybe(x: bool) anyerror!?u32 {
817	817	test "auto created variables have correct alignment" {
818	818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
819	819	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
820		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	820	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
821	821
822	822	const S = struct {
823	823	fn foo(str: [*]const u8) u32 {
...	...	@@ -837,7 +837,7 @@ test "extern variable with non-pointer opaque type" {
837	837	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
838	838	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
839	839	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
840		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	840	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
841	841
842	842	@export(&var_to_export, .{ .name = "opaque_extern_var" });
843	843	try expect(@as(align(1) u32, @ptrCast(&opaque_extern_var)). == 42);
...	...	@@ -1180,7 +1180,7 @@ test "orelse coercion as function argument" {
1180	1180	}
1181	1181
1182	1182	test "runtime-known globals initialized with undefined" {
1183		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1183	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1184	1184
1185	1185	const S = struct {
1186	1186	var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
...	...	@@ -1201,7 +1201,7 @@ test "arrays and vectors with big integers" {
1201	1201	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1202	1202	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1203	1203	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1204		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1204	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1205	1205	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1206	1206	if (builtin.zig_backend == .stage2_llvm and (builtin.abi == .gnuabin32 or builtin.abi == .muslabin32)) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23805
1207	1207
...	...	@@ -1275,7 +1275,7 @@ fn testUnsignedCmp(comptime T: type) !void {
1275	1275	}
1276	1276
1277	1277	test "integer compare <= 64 bits" {
1278		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1278	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1279	1279
1280	1280	inline for (.{ u8, u16, u32, u64, usize, u10, u20, u30, u60 }) \|T\| {
1281	1281	try testUnsignedCmp(T);
...	...	@@ -1289,7 +1289,7 @@ test "integer compare <= 64 bits" {
1289	1289
1290	1290	test "integer compare <= 128 bits" {
1291	1291	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1292		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1292	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1293	1293
1294	1294	inline for (.{ u65, u96, u127, u128 }) \|T\| {
1295	1295	try testUnsignedCmp(T);
...	...	@@ -1449,7 +1449,7 @@ test "allocation and looping over 3-byte integer" {
1449	1449	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1450	1450	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1451	1451	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1452		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1452	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1453	1453	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1454	1454
1455	1455	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {

test/behavior/bit_shifting.zig+3-3

...	...	@@ -65,7 +65,7 @@ test "sharded table" {
65	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
66	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
67	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	68	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
69	69
70	70	// realistic 16-way sharding
71	71	try testShardedTable(u32, 4, 8);
...	...	@@ -115,7 +115,7 @@ test "Saturating Shift Left where lhs is of a computed type" {
115	115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
116	116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
117	117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
118		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	118	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
119	119	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
120	120
121	121	const S = struct {
...	...	@@ -163,7 +163,7 @@ comptime {
163	163	test "Saturating Shift Left" {
164	164	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
165	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
166		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	166	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
167	167	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
168	168	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
169	169	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;

test/behavior/bitcast.zig+13-13

...	...	@@ -24,7 +24,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
27		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
28	28
29	29	const bit_values = [_]usize{ 8, 16, 128 };
30	30
...	...	@@ -39,7 +39,7 @@ test "@bitCast iX -> uX exotic integers" {
39	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
40	40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
41	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	42	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
43	43	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
44	44
45	45	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
...	...	@@ -84,7 +84,7 @@ test "bitcast uX to bytes" {
84	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
85	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
86	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	87	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
88	88	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
89	89
90	90	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
...	...	@@ -153,7 +153,7 @@ test "bitcast literal [4]u8 param to u32" {
153	153	}
154	154
155	155	test "bitcast generates a temporary value" {
156		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	156	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
157	157
158	158	var y: u16 = 0x55AA;
159	159	_ = &y;
...	...	@@ -191,7 +191,7 @@ test "@bitCast packed structs at runtime and comptime" {
191	191	test "@bitCast extern structs at runtime and comptime" {
192	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
193	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	194	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
195	195
196	196	const Full = extern struct {
197	197	number: u16,
...	...	@@ -301,7 +301,7 @@ test "@bitCast packed struct of floats" {
301	301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
302	302	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
303	303	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
304		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	304	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
305	305	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
306	306	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
307	307
...	...	@@ -340,7 +340,7 @@ test "comptime @bitCast packed struct to int and back" {
340	340	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
341	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
342	342	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
343		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	343	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
344	344	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
345	345	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
346	346
...	...	@@ -399,7 +399,7 @@ test "bitcast vector to integer and back" {
399	399	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
400	400	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
401	401	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
402		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	402	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
403	403	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
404	404	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
405	405
...	...	@@ -425,7 +425,7 @@ test "bitcast nan float does not modify signaling bit" {
425	425	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
426	426	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
427	427	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
428		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	428	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
429	429	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
430	430	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
431	431
...	...	@@ -479,7 +479,7 @@ test "@bitCast of packed struct of bools all true" {
479	479	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
480	480	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
481	481	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
482		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	482	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
483	483
484	484	const P = packed struct {
485	485	b0: bool,
...	...	@@ -499,7 +499,7 @@ test "@bitCast of packed struct of bools all false" {
499	499	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500	500	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
501	501	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
502		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	502	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
503	503
504	504	const P = packed struct {
505	505	b0: bool,
...	...	@@ -520,7 +520,7 @@ test "@bitCast of packed struct containing pointer" {
520	520	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
521	521	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
522	522	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
523		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	523	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
524	524	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179
525	525
526	526	const S = struct {
...	...	@@ -550,7 +550,7 @@ test "@bitCast of extern struct containing pointer" {
550	550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
551	551	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
552	552	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
553		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	553	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
554	554
555	555	const S = struct {
556	556	const A = extern struct {

test/behavior/bitreverse.zig+4-4

...	...	@@ -11,7 +11,7 @@ test "@bitReverse" {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16	16
17	17	try comptime testBitReverse();
...	...	@@ -125,7 +125,7 @@ test "bitReverse vectors u8" {
125	125	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
126	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127	127	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	128	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129	129	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
130	130
131	131	try comptime vector8();
...	...	@@ -145,7 +145,7 @@ test "bitReverse vectors u16" {
145	145	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
146	146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
147	147	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
148		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	148	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
149	149	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
150	150
151	151	try comptime vector16();
...	...	@@ -165,7 +165,7 @@ test "bitReverse vectors u24" {
165	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
166	166	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
167	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
168		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	168	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
169	169	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
170	170
171	171	try comptime vector24();

test/behavior/bool.zig+1-1

...	...	@@ -10,7 +10,7 @@ test "bool literals" {
10	10
11	11	test "cast bool to int" {
12	12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	13	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
14	14
15	15	const t = true;
16	16	const f = false;

test/behavior/builtin_functions_returning_void_or_noreturn.zig+1-1

...	...	@@ -10,7 +10,7 @@ test {
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	13	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
14	14
15	15	var val: u8 = undefined;
16	16	try testing.expectEqual({}, @atomicStore(u8, &val, 0, .unordered));

test/behavior/byteswap.zig+4-4

...	...	@@ -38,7 +38,7 @@ test "@byteSwap integers" {
38	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
39	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
40	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
41		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	41	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
42	42
43	43	const ByteSwapIntTest = struct {
44	44	fn run() !void {
...	...	@@ -97,7 +97,7 @@ test "@byteSwap vectors u8" {
97	97	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98	98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
99	99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
100		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
101	101	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
102	102
103	103	try comptime vector8();
...	...	@@ -117,7 +117,7 @@ test "@byteSwap vectors u16" {
117	117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
118	118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
119	119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	120	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
121	121	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
122	122
123	123	try comptime vector16();
...	...	@@ -137,7 +137,7 @@ test "@byteSwap vectors u24" {
137	137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
138	138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
139	139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
140		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	140	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
141	141	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
142	142
143	143	try comptime vector24();

test/behavior/byval_arg_var.zig+1-1

...	...	@@ -5,7 +5,7 @@ var result: []const u8 = "wrong";
5	5
6	6	test "pass string literal byvalue to a generic var param" {
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	9
10	10	start();
11	11	blowUpStack(10);

test/behavior/call.zig+10-10

...	...	@@ -24,7 +24,7 @@ test "basic invocations" {
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
28	28
29	29	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support tail call modifiers
30	30
...	...	@@ -63,7 +63,7 @@ test "tuple parameters" {
63	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
64	64	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
65	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	66	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
67	67
68	68	const add = struct {
69	69	fn add(a: i32, b: i32) i32 {
...	...	@@ -275,7 +275,7 @@ test "forced tail call" {
275	275	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
276	276	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
277	277	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
278		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	278	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
279	279	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
280	280
281	281	if (builtin.zig_backend == .stage2_llvm) {
...	...	@@ -310,7 +310,7 @@ test "inline call preserves tail call" {
310	310	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
311	311	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
312	312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	313	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
314	314	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
315	315
316	316	if (builtin.zig_backend == .stage2_llvm) {
...	...	@@ -344,7 +344,7 @@ test "inline call preserves tail call" {
344	344	test "inline call doesn't re-evaluate non generic struct" {
345	345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
346	346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
347		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	347	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
348	348
349	349	const S = struct {
350	350	fn foo(f: struct { a: u8, b: u8 }) !void {
...	...	@@ -496,7 +496,7 @@ test "argument to generic function has correct result type" {
496	496	}
497	497
498	498	test "call inline fn through pointer" {
499		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	499	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
500	500
501	501	const S = struct {
502	502	inline fn foo(x: u8) !void {
...	...	@@ -546,7 +546,7 @@ test "call function pointer in comptime field" {
546	546	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
547	547	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
548	548	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
549		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	549	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
550	550
551	551	const Auto = struct {
552	552	auto: [max_len]u8 = undefined,
...	...	@@ -645,7 +645,7 @@ test "function call with cast to anyopaque pointer" {
645	645	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
646	646	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
647	647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
648		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	648	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
649	649
650	650	const Foo = struct {
651	651	y: u8,
...	...	@@ -662,7 +662,7 @@ test "function call with cast to anyopaque pointer" {
662	662	test "arguments pointed to on stack into tailcall" {
663	663	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
664	664	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
665		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	665	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
666	666	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls
667	667
668	668	switch (builtin.cpu.arch) {
...	...	@@ -736,7 +736,7 @@ test "tail call function pointer" {
736	736	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
737	737	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
738	738	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	739	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
740	740	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
741	741
742	742	if (builtin.zig_backend == .stage2_llvm) {

test/behavior/cast.zig+84-84

...	...	@@ -68,7 +68,7 @@ test "implicit cast comptime_int to comptime_float" {
68	68	}
69	69
70	70	test "comptime_int @floatFromInt" {
71		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	71	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
72	72
73	73	{
74	74	const result = @as(f16, @floatFromInt(1234));
...	...	@@ -123,7 +123,7 @@ test "@floatFromInt(f80)" {
123	123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
124	124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
125	125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
126		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	126	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
127	127	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
128	128	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
129	129	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -160,7 +160,7 @@ test "@intFromFloat" {
160	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
161	161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	163	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
164	164
165	165	try testIntFromFloats();
166	166	try comptime testIntFromFloats();
...	...	@@ -183,7 +183,7 @@ fn expectIntFromFloat(comptime F: type, f: F, comptime I: type, i: I) !void {
183	183	test "implicitly cast indirect pointer to maybe-indirect pointer" {
184	184	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
185	185	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
186		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	186	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
187	187
188	188	const S = struct {
189	189	const Self = @This();
...	...	@@ -264,7 +264,7 @@ fn MakeType(comptime T: type) type {
264	264	test "implicit cast from [N]T to [c]T" {
265	265	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
266	266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
267		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	267	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
268	268
269	269	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
270	270	var y: [*c]u16 = &x;
...	...	@@ -327,7 +327,7 @@ test "const ?[]const T to [c]const [c]const T" {
327	327	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
328	328	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
329	329	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
330		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	330	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
331	331
332	332	var array = [_]u8{ 'o', 'k' };
333	333	const opt_array_ptr: ?[*]const u8 = &array;
...	...	@@ -340,7 +340,7 @@ test "const ?[]const T to [c]const [c]const T" {
340	340	test "array coercion to undefined at runtime" {
341	341	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
342	342	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
343		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	343	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
344	344
345	345	@setRuntimeSafety(true);
346	346
...	...	@@ -405,7 +405,7 @@ test "peer type unsigned int to signed" {
405	405	test "expected [c]const u8, found [:0]const u8" {
406	406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
407	407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
408		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	408	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
409	409
410	410	var a: [*:0]const u8 = "hello";
411	411	_ = &a;
...	...	@@ -418,7 +418,7 @@ test "explicit cast from integer to error type" {
418	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
419	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
420	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
421		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	421	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
422	422	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
423	423
424	424	try testCastIntToErr(error.ItBroke);
...	...	@@ -434,7 +434,7 @@ test "peer resolve array and const slice" {
434	434	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
435	435	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
436	436	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
437		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	437	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
438	438
439	439	try testPeerResolveArrayConstSlice(true);
440	440	try comptime testPeerResolveArrayConstSlice(true);
...	...	@@ -492,7 +492,7 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
492	492	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
493	493	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
494	494	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
495		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	495	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
496	496
497	497	const S = struct {
498	498	fn doTheTest() anyerror!void {
...	...	@@ -524,7 +524,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
524	524	test "implicit cast from *const [N]T to []const T" {
525	525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
526	526	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
527		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	527	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
528	528
529	529	try testCastConstArrayRefToConstSlice();
530	530	try comptime testCastConstArrayRefToConstSlice();
...	...	@@ -550,7 +550,7 @@ fn testCastConstArrayRefToConstSlice() !void {
550	550	test "peer type resolution: error and [N]T" {
551	551	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
552	552	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
553		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	553	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
554	554
555	555	try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
556	556	comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
...	...	@@ -575,7 +575,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
575	575	test "single-item pointer of array to slice to unknown length pointer" {
576	576	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
577	577	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
578		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	578	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
579	579
580	580	try testCastPtrOfArrayToSliceAndPtr();
581	581	try comptime testCastPtrOfArrayToSliceAndPtr();
...	...	@@ -605,7 +605,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
605	605	test "cast [1][]const u8 to []const ?[]const u8" {
606	606	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
607	607	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
608		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	608	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
609	609
610	610	const window_name = [1][*]const u8{"window name"};
611	611	const x: []const ?[]const u8 = &window_name;
...	...	@@ -618,7 +618,7 @@ test "@intCast on vector" {
618	618	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
619	619	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
620	620	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
621		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	621	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
622	622	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
623	623
624	624	const S = struct {
...	...	@@ -707,7 +707,7 @@ test "peer type resolution: error set supersets" {
707	707	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
708	708	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
709	709	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
710		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	710	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
711	711
712	712	const a: error{ One, Two } = undefined;
713	713	const b: error{One} = undefined;
...	...	@@ -737,7 +737,7 @@ test "peer type resolution: disjoint error sets" {
737	737	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
738	738	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
739	739	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
740		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	740	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
741	741
742	742	const a: error{ One, Two } = undefined;
743	743	const b: error{Three} = undefined;
...	...	@@ -767,7 +767,7 @@ test "peer type resolution: error union and error set" {
767	767	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
768	768	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
769	769	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
770		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	770	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
771	771
772	772	const a: error{Three} = undefined;
773	773	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -801,7 +801,7 @@ test "peer type resolution: error union after non-error" {
801	801	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
802	802	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
803	803	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
804		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	804	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
805	805
806	806	const a: u32 = undefined;
807	807	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -835,7 +835,7 @@ test "peer cast *[0]T to E![]const T" {
835	835	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
836	836	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
837	837	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
838		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	838	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
839	839
840	840	var buffer: [5]u8 = "abcde".*;
841	841	const buf: anyerror![]const u8 = buffer[0..];
...	...	@@ -851,7 +851,7 @@ test "peer cast *[0]T to []const T" {
851	851	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
852	852	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
853	853	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
854		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	854	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
855	855
856	856	var buffer: [5]u8 = "abcde".*;
857	857	const buf: []const u8 = buffer[0..];
...	...	@@ -875,7 +875,7 @@ test "peer resolution of string literals" {
875	875	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
876	876	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
877	877	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
878		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	878	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
879	879
880	880	const S = struct {
881	881	const E = enum { a, b, c, d };
...	...	@@ -897,7 +897,7 @@ test "peer resolution of string literals" {
897	897	test "peer cast [:x]T to []T" {
898	898	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
899	899	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
900		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	900	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
901	901
902	902	const S = struct {
903	903	fn doTheTest() !void {
...	...	@@ -914,7 +914,7 @@ test "peer cast [:x]T to []T" {
914	914	test "peer cast [N:x]T to [N]T" {
915	915	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
916	916	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
917		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	917	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
918	918
919	919	const S = struct {
920	920	fn doTheTest() !void {
...	...	@@ -931,7 +931,7 @@ test "peer cast [N:x]T to [N]T" {
931	931	test "peer cast [N:x]T to [N]T" {
932	932	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
933	933	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
934		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	934	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
935	935
936	936	const S = struct {
937	937	fn doTheTest() !void {
...	...	@@ -948,7 +948,7 @@ test "peer cast [:x]T to []T" {
948	948	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
949	949	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
950	950	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
951		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	951	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
952	952
953	953	const S = struct {
954	954	fn doTheTest() !void {
...	...	@@ -969,7 +969,7 @@ test "peer cast [:x]T to [*:x]T" {
969	969	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
970	970	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
971	971	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
972		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	972	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
973	973
974	974	const S = struct {
975	975	fn doTheTest() !void {
...	...	@@ -990,7 +990,7 @@ test "peer cast [:x]T to [*:x]T" {
990	990	test "peer type resolution implicit cast to return type" {
991	991	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
992	992	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
993		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	993	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
994	994
995	995	const S = struct {
996	996	fn doTheTest() !void {
...	...	@@ -1011,7 +1011,7 @@ test "peer type resolution implicit cast to return type" {
1011	1011	test "peer type resolution implicit cast to variable type" {
1012	1012	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1013	1013	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1014		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1014	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1015	1015
1016	1016	const S = struct {
1017	1017	fn doTheTest() !void {
...	...	@@ -1037,7 +1037,7 @@ test "variable initialization uses result locations properly with regards to the
1037	1037	test "cast between C pointer with different but compatible types" {
1038	1038	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1039	1039	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1040		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1040	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1041	1041
1042	1042	const S = struct {
1043	1043	fn foo(arg: [*]c_ushort) u16 {
...	...	@@ -1055,7 +1055,7 @@ test "cast between C pointer with different but compatible types" {
1055	1055	test "peer type resolve string lit with sentinel-terminated mutable slice" {
1056	1056	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1057	1057	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1058		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1058	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1059	1059
1060	1060	var array: [4:0]u8 = undefined;
1061	1061	array[4] = 0; // TODO remove this when #4372 is solved
...	...	@@ -1122,7 +1122,7 @@ test "implicit cast from []T to ?anyopaque" {
1122	1122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1123	1123	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1124	1124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1125		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1125	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1126	1126
1127	1127	var a = [_]u8{ 3, 2, 1 };
1128	1128	var runtime_zero: usize = 0;
...	...	@@ -1139,7 +1139,7 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
1139	1139	}
1140	1140
1141	1141	test "compile time int to ptr of function" {
1142		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1142	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1143	1143
1144	1144	try foobar(FUNCTION_CONSTANT);
1145	1145	}
...	...	@@ -1154,7 +1154,7 @@ fn foobar(func: PFN_void) !void {
1154	1154	}
1155	1155
1156	1156	test "cast function with an opaque parameter" {
1157		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1157	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1158	1158
1159	1159	if (builtin.zig_backend == .stage2_c) {
1160	1160	// https://github.com/ziglang/zig/issues/16845
...	...	@@ -1187,7 +1187,7 @@ test "implicit ptr to *anyopaque" {
1187	1187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1188	1188	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1189	1189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1190		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1190	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1191	1191
1192	1192	var a: u32 = 1;
1193	1193	const ptr: *align(@alignOf(u32)) anyopaque = &a;
...	...	@@ -1201,7 +1201,7 @@ test "implicit ptr to *anyopaque" {
1201	1201	test "return null from fn () anyerror!?&T" {
1202	1202	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1203	1203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1204		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1204	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1205	1205
1206	1206	const a = returnNullFromOptionalTypeErrorRef();
1207	1207	const b = returnNullLitFromOptionalTypeErrorRef();
...	...	@@ -1219,7 +1219,7 @@ test "peer type resolution: [0]u8 and []const u8" {
1219	1219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1220	1220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1221	1221	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1222		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1222	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1223	1223
1224	1224	try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
1225	1225	try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
...	...	@@ -1240,7 +1240,7 @@ test "implicitly cast from [N]T to ?[]const T" {
1240	1240	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1241	1241	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1242	1242	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1243		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1243	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1244	1244
1245	1245	try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
1246	1246	comptime assert(mem.eql(u8, castToOptionalSlice().?, "hi"));
...	...	@@ -1254,7 +1254,7 @@ test "cast u128 to f128 and back" {
1254	1254	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1255	1255	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1256	1256	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1257		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1257	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1258	1258	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1259	1259
1260	1260	try comptime testCast128();
...	...	@@ -1278,7 +1278,7 @@ test "implicit cast from [N]T to ?[]T" {
1278	1278	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1279	1279	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1280	1280	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1281		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1281	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1282	1282
1283	1283	var x: ?[*]u16 = null;
1284	1284	var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
...	...	@@ -1294,7 +1294,7 @@ test "implicit cast from T to ?anyopaque" {
1294	1294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1295	1295	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1296	1296	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1297		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1297	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1298	1298
1299	1299	var a: u8 = 1;
1300	1300	incrementVoidPtrValue(&a);
...	...	@@ -1316,13 +1316,13 @@ test "implicit cast *[0]T to E![]const u8" {
1316	1316
1317	1317	var global_array: [4]u8 = undefined;
1318	1318	test "cast from array reference to fn: comptime fn ptr" {
1319		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1319	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1320	1320
1321	1321	const f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
1322	1322	try expect(@intFromPtr(f) == @intFromPtr(&global_array));
1323	1323	}
1324	1324	test "cast from array reference to fn: runtime fn ptr" {
1325		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1325	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1326	1326
1327	1327	var f = @as(*align(1) const fn () callconv(.c) void, @ptrCast(&global_array));
1328	1328	_ = &f;
...	...	@@ -1333,7 +1333,7 @@ test "*const [N]null u8 to ?[]const u8" {
1333	1333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1334	1334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1335	1335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1336		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1336	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1337	1337
1338	1338	const S = struct {
1339	1339	fn doTheTest() !void {
...	...	@@ -1370,7 +1370,7 @@ test "assignment to optional pointer result loc" {
1370	1370	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1371	1371	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1372	1372	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1373		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1373	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1374	1374
1375	1375	var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
1376	1376	_ = &foo;
...	...	@@ -1378,7 +1378,7 @@ test "assignment to optional pointer result loc" {
1378	1378	}
1379	1379
1380	1380	test "cast between *[N]void and []void" {
1381		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1381	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1382	1382
1383	1383	var a: [4]void = undefined;
1384	1384	const b: []void = &a;
...	...	@@ -1388,7 +1388,7 @@ test "cast between *[N]void and []void" {
1388	1388	test "peer resolve arrays of different size to const slice" {
1389	1389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1390	1390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1391		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1391	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1392	1392
1393	1393	try expect(mem.eql(u8, boolToStr(true), "true"));
1394	1394	try expect(mem.eql(u8, boolToStr(false), "false"));
...	...	@@ -1403,7 +1403,7 @@ test "cast f16 to wider types" {
1403	1403	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1404	1404	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1405	1405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1406		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1406	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1407	1407	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1408	1408	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1409	1409	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -1425,7 +1425,7 @@ test "cast f128 to narrower types" {
1425	1425	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1426	1426	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1427	1427	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1428		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1428	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1429	1429	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1430	1430	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1431	1431
...	...	@@ -1446,7 +1446,7 @@ test "peer type resolution: unreachable, null, slice" {
1446	1446	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1447	1447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1448	1448	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1449		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1449	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1450	1450
1451	1451	const S = struct {
1452	1452	fn doTheTest(num: usize, word: []const u8) !void {
...	...	@@ -1487,7 +1487,7 @@ test "cast compatible optional types" {
1487	1487	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1488	1488	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1489	1489	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1490		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1490	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1491	1491
1492	1492	var a: ?[:0]const u8 = null;
1493	1493	_ = &a;
...	...	@@ -1519,7 +1519,7 @@ test "coerce between pointers of compatible differently-named floats" {
1519	1519	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1520	1520	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows and !builtin.link_libc) return error.SkipZigTest;
1521	1521	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1522		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1522	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1523	1523	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1524	1524	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1525	1525
...	...	@@ -1587,7 +1587,7 @@ test "cast typed undefined to int" {
1587	1587
1588	1588	test "bitcast packed struct with u0" {
1589	1589	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1590		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1590	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1591	1591
1592	1592	const S = packed struct(u2) { a: u0, b: u2 };
1593	1593	const s = @as(S, @bitCast(@as(u2, 2)));
...	...	@@ -1599,7 +1599,7 @@ test "bitcast packed struct with u0" {
1599	1599
1600	1600	test "optional pointer coerced to optional allowzero pointer" {
1601	1601	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1602		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1602	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1603	1603
1604	1604	var p: ?*u32 = undefined;
1605	1605	var q: ?*allowzero u32 = undefined;
...	...	@@ -1616,7 +1616,7 @@ test "optional slice coerced to allowzero many pointer" {
1616	1616	}
1617	1617
1618	1618	test "optional slice passed as parameter coerced to allowzero many pointer" {
1619		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1619	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1620	1620
1621	1621	const ns = struct {
1622	1622	const Color = struct {
...	...	@@ -1637,7 +1637,7 @@ test "optional slice passed as parameter coerced to allowzero many pointer" {
1637	1637	}
1638	1638
1639	1639	test "single item pointer to pointer to array to slice" {
1640		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1640	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1641	1641
1642	1642	var x: i32 = 1234;
1643	1643	try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234);
...	...	@@ -1647,7 +1647,7 @@ test "single item pointer to pointer to array to slice" {
1647	1647
1648	1648	test "peer type resolution forms error union" {
1649	1649	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1650		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1650	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1651	1651
1652	1652	var foo: i32 = 123;
1653	1653	_ = &foo;
...	...	@@ -1682,7 +1682,7 @@ test "@volatileCast without a result location" {
1682	1682	}
1683	1683
1684	1684	test "coercion from single-item pointer to @as to slice" {
1685		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1685	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1686	1686
1687	1687	var x: u32 = 1;
1688	1688
...	...	@@ -1696,7 +1696,7 @@ test "peer type resolution: const sentinel slice and mutable non-sentinel slice"
1696	1696	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1697	1697	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1698	1698	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1699		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1699	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1700	1700
1701	1701	const S = struct {
1702	1702	fn doTheTest(comptime T: type, comptime s: T) !void {
...	...	@@ -1749,7 +1749,7 @@ test "peer type resolution: same array type with sentinel" {
1749	1749	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1750	1750	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1751	1751	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1752		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1752	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1753	1753
1754	1754	var a: [2:0]u32 = .{ 0, 1 };
1755	1755	var b: [2:0]u32 = .{ 2, 3 };
...	...	@@ -1772,7 +1772,7 @@ test "peer type resolution: array with sentinel and array without sentinel" {
1772	1772	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1773	1773	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1774	1774	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1775		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1775	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1776	1776
1777	1777	var a: [2:0]u32 = .{ 0, 1 };
1778	1778	var b: [2]u32 = .{ 2, 3 };
...	...	@@ -1795,7 +1795,7 @@ test "peer type resolution: array and vector with same child type" {
1795	1795	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1796	1796	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1797	1797	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1798		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1798	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1799	1799
1800	1800	var arr: [2]u32 = .{ 0, 1 };
1801	1801	var vec: @Vector(2, u32) = .{ 2, 3 };
...	...	@@ -1842,7 +1842,7 @@ test "peer type resolution: error union and optional of same type" {
1842	1842	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1843	1843	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1844	1844	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1845		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1845	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1846	1846
1847	1847	const E = error{Foo};
1848	1848	var a: E!*u8 = error.Foo;
...	...	@@ -1866,7 +1866,7 @@ test "peer type resolution: C pointer and @TypeOf(null)" {
1866	1866	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1867	1867	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1868	1868	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1869		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1869	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1870	1870
1871	1871	var a: [*c]c_int = 0x1000;
1872	1872	_ = &a;
...	...	@@ -1889,7 +1889,7 @@ test "peer type resolution: three-way resolution combines error set and optional
1889	1889	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1890	1890	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1891	1891	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1892		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1892	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1893	1893
1894	1894	const E = error{Foo};
1895	1895	var a: E = error.Foo;
...	...	@@ -1933,7 +1933,7 @@ test "peer type resolution: vector and optional vector" {
1933	1933	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1934	1934	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1935	1935	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1936		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1936	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1937	1937
1938	1938	var a: ?@Vector(3, u32) = .{ 0, 1, 2 };
1939	1939	var b: @Vector(3, u32) = .{ 3, 4, 5 };
...	...	@@ -1978,7 +1978,7 @@ test "peer type resolution: array and tuple" {
1978	1978	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1979	1979	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1980	1980	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1981		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1981	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1982	1982
1983	1983	var arr: [3]i32 = .{ 1, 2, 3 };
1984	1984	_ = &arr;
...	...	@@ -2027,7 +2027,7 @@ test "peer type resolution: vector and array and tuple" {
2027	2027	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2028	2028	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2029	2029	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2030		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2030	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2031	2031
2032	2032	var vec: @Vector(2, i8) = .{ 10, 20 };
2033	2033	var arr: [2]i8 = .{ 30, 40 };
...	...	@@ -2070,7 +2070,7 @@ test "peer type resolution: empty tuple pointer and slice" {
2070	2070	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2071	2071	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2072	2072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2073		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2073	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2074	2074
2075	2075	var a: [:0]const u8 = "Hello";
2076	2076	var b = &.{};
...	...	@@ -2092,7 +2092,7 @@ test "peer type resolution: tuple pointer and slice" {
2092	2092	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2093	2093	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2094	2094	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2095		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2095	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2096	2096
2097	2097	var a: [:0]const u8 = "Hello";
2098	2098	var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
...	...	@@ -2115,7 +2115,7 @@ test "peer type resolution: tuple pointer and optional slice" {
2115	2115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2116	2116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2117	2117	// Miscompilation on Intel's OpenCL CPU runtime.
2118		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
	2118	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // flaky
2119	2119
2120	2120	var a: ?[:0]const u8 = null;
2121	2121	var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') };
...	...	@@ -2137,7 +2137,7 @@ test "peer type resolution: many compatible pointers" {
2137	2137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2138	2138	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2139	2139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2140		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2140	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2141	2141
2142	2142	var buf = "foo-3".*;
2143	2143
...	...	@@ -2204,7 +2204,7 @@ test "peer type resolution: tuples with comptime fields" {
2204	2204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2205	2205	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2206	2206	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2207		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	2207	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
2208	2208
2209	2209	const a = .{ 1, 2 };
2210	2210	const b = .{ @as(u32, 3), @as(i16, 4) };
...	...	@@ -2236,7 +2236,7 @@ test "peer type resolution: C pointer and many pointer" {
2236	2236	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2237	2237	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2238	2238	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2239		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2239	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2240	2240
2241	2241	var buf = "hello".*;
2242	2242
...	...	@@ -2260,7 +2260,7 @@ test "peer type resolution: pointer attributes are combined correctly" {
2260	2260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2261	2261	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2262	2262	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2263		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2263	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2264	2264
2265	2265	var buf_a align(4) = "foo".*;
2266	2266	var buf_b align(4) = "bar".*;
...	...	@@ -2342,7 +2342,7 @@ test "peer type resolution: arrays of compatible types" {
2342	2342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2343	2343	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2344	2344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2345		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2345	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2346	2346
2347	2347	var e0: u8 = 3;
2348	2348	var e1: u8 = 2;
...	...	@@ -2360,7 +2360,7 @@ test "cast builtins can wrap result in optional" {
2360	2360	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2361	2361	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2362	2362	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2363		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2363	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2364	2364
2365	2365	const S = struct {
2366	2366	const MyEnum = enum(u32) { _ };
...	...	@@ -2436,7 +2436,7 @@ test "cast builtins can wrap result in error union and optional" {
2436	2436	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2437	2437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2438	2438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2439		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2439	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2440	2440
2441	2441	const S = struct {
2442	2442	const MyEnum = enum(u32) { _ };
...	...	@@ -2519,7 +2519,7 @@ test "@ptrFromInt on vector" {
2519	2519	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2520	2520	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2521	2521	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2522		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2522	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2523	2523
2524	2524	const S = struct {
2525	2525	fn doTheTest() !void {
...	...	@@ -2544,7 +2544,7 @@ test "@intFromPtr on vector" {
2544	2544	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2545	2545	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2546	2546	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2547		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2547	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2548	2548
2549	2549	const S = struct {
2550	2550	fn doTheTest() !void {
...	...	@@ -2663,7 +2663,7 @@ test "result information is preserved through many nested structures" {
2663	2663	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2664	2664	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2665	2665	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2666		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2666	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2667	2667
2668	2668	const S = struct {
2669	2669	fn doTheTest() !void {
...	...	@@ -2690,7 +2690,7 @@ test "@intCast vector of signed integer" {
2690	2690	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2691	2691	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2692	2692	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2693		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2693	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2694	2694	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
2695	2695
2696	2696	var x: @Vector(4, i32) = .{ 1, 2, 3, 4 };
...	...	@@ -2721,7 +2721,7 @@ test "bitcast vector" {
2721	2721	}
2722	2722
2723	2723	test "peer type resolution: slice of sentinel-terminated array" {
2724		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2724	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2725	2725
2726	2726	var f: bool = undefined;
2727	2727	f = false;

test/behavior/cast_int.zig+3-3

...	...	@@ -8,7 +8,7 @@ test "@intCast i32 to u7" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13	13
14	14	var x: u128 = maxInt(u128);
...	...	@@ -165,7 +165,7 @@ const Piece = packed struct {
165	165
166	166	test "load non byte-sized optional value" {
167	167	// Originally reported at https://github.com/ziglang/zig/issues/14200
168		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	168	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
169	169
170	170	// note: this bug is triggered by the == operator, expectEqual will hide it
171	171	const opt: ?Piece = try Piece.charToPiece('p');
...	...	@@ -179,7 +179,7 @@ test "load non byte-sized optional value" {
179	179	}
180	180
181	181	test "load non byte-sized value in struct" {
182		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	182	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
183	183	if (builtin.cpu.arch.endian() != .little) return error.SkipZigTest; // packed struct TODO
184	184
185	185	// note: this bug is triggered by the == operator, expectEqual will hide it

test/behavior/const_slice_child.zig+1-1

...	...	@@ -11,7 +11,7 @@ test "const slice child" {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
14		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
15	15
16	16	const strs = [_][*]const u8{ "one", "two", "three" };
17	17	argv = &strs;

test/behavior/decl_literals.zig+2-2

...	...	@@ -36,7 +36,7 @@ test "call decl literal with optional" {
36	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
37	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	39	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40	40
41	41	const S = struct {
42	42	x: u32,
...	...	@@ -74,7 +74,7 @@ test "call decl literal" {
74	74	}
75	75
76	76	test "call decl literal with error union" {
77		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	77	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
78	78
79	79	const S = struct {
80	80	x: u32,

test/behavior/defer.zig+3-3

...	...	@@ -113,7 +113,7 @@ test "errdefer with payload" {
113	113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
114	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
115	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	116	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
117	117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
118	118
119	119	const S = struct {
...	...	@@ -135,7 +135,7 @@ test "reference to errdefer payload" {
135	135	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
136	136	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
137	137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	138	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
139	139	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
140	140
141	141	const S = struct {
...	...	@@ -159,7 +159,7 @@ test "reference to errdefer payload" {
159	159	test "simple else prong doesn't emit an error for unreachable else prong" {
160	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	162	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
163	163
164	164	const S = struct {
165	165	fn foo() error{Foo}!void {

test/behavior/destructure.zig+1-1

...	...	@@ -94,7 +94,7 @@ test "destructure from labeled block" {
94	94	}
95	95
96	96	test "destructure tuple value" {
97		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	97	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
98	98
99	99	const tup: struct { f32, u32, i64 } = .{ 10.0, 20, 30 };
100	100	const x, const y, const z = tup;

test/behavior/duplicated_test_names.zig+1-1

...	...	@@ -15,7 +15,7 @@ comptime {
15	15	test "thingy" {}
16	16
17	17	test thingy {
18		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20	20
21	21	if (thingy(1, 2) != 3) unreachable;

test/behavior/enum.zig+12-12

...	...	@@ -945,7 +945,7 @@ test "constant enum initialization with differing sizes" {
945	945	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
946	946	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
947	947	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
948		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	948	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
949	949
950	950	try test3_1(test3_foo);
951	951	try test3_2(test3_bar);
...	...	@@ -988,7 +988,7 @@ test "@tagName" {
988	988	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
989	989	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
990	990	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
991		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	991	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
992	992	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
993	993
994	994	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
...	...	@@ -1005,7 +1005,7 @@ test "@tagName non-exhaustive enum" {
1005	1005	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1006	1006	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1007	1007	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1008		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1008	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1009	1009	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1010	1010
1011	1011	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
...	...	@@ -1017,7 +1017,7 @@ test "@tagName is null-terminated" {
1017	1017	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1018	1018	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1019	1019	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1020		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1020	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1021	1021	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1022	1022
1023	1023	const S = struct {
...	...	@@ -1033,7 +1033,7 @@ test "tag name with assigned enum values" {
1033	1033	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1034	1034	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1035	1035	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1036		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1036	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1037	1037	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1038	1038
1039	1039	const LocalFoo = enum(u8) {
...	...	@@ -1048,7 +1048,7 @@ test "tag name with assigned enum values" {
1048	1048	test "@tagName on enum literals" {
1049	1049	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1050	1050	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1051		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1051	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1052	1052
1053	1053	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1054	1054	comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar"));
...	...	@@ -1058,7 +1058,7 @@ test "tag name with signed enum values" {
1058	1058	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1059	1059	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1060	1060	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1061		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1061	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1062	1062	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1063	1063
1064	1064	const LocalFoo = enum(isize) {
...	...	@@ -1076,7 +1076,7 @@ test "@tagName in callconv(.c) function" {
1076	1076	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1077	1077	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1078	1078	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1079		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1079	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1080	1080	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1081	1081
1082	1082	try expect(mem.orderZ(u8, testEnumTagNameCallconvC(), "Two") == .eq);
...	...	@@ -1120,7 +1120,7 @@ test "bit field access with enum fields" {
1120	1120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1121	1121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1122	1122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1123		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1123	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1124	1124
1125	1125	var data = bit_field_1;
1126	1126	try expect(getA(&data) == A.Two);
...	...	@@ -1160,7 +1160,7 @@ test "tag name functions are unique" {
1160	1160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1161	1161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1162	1162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1163		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1163	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1164	1164	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1165	1165
1166	1166	{
...	...	@@ -1238,7 +1238,7 @@ test "enum tag from a local variable" {
1238	1238	}
1239	1239
1240	1240	test "auto-numbered enum with signed tag type" {
1241		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1241	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1242	1242
1243	1243	const E = enum(i32) { a, b };
1244	1244
...	...	@@ -1294,7 +1294,7 @@ test "matching captures causes enum equivalence" {
1294	1294
1295	1295	test "large enum field values" {
1296	1296	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1297		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1297	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1298	1298
1299	1299	{
1300	1300	const E = enum(u64) { min = std.math.minInt(u64), max = std.math.maxInt(u64) };

test/behavior/error.zig+17-17

...	...	@@ -124,7 +124,7 @@ test "debug info for optional error set" {
124	124
125	125	test "implicit cast to optional to error union to return result loc" {
126	126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	127	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
128	128
129	129	const S = struct {
130	130	fn entry() !void {
...	...	@@ -150,7 +150,7 @@ test "fn returning empty error set can be passed as fn returning any error" {
150	150	}
151	151
152	152	test "fn returning empty error set can be passed as fn returning any error - pointer" {
153		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	153	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
154	154
155	155	entryPtr();
156	156	comptime entryPtr();
...	...	@@ -364,7 +364,7 @@ fn foo3(b: usize) Error!usize {
364	364
365	365	test "error: Infer error set from literals" {
366	366	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
367		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	367	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
368	368
369	369	_ = nullLiteral("n") catch \|err\| handleErrors(err);
370	370	_ = floatLiteral("n") catch \|err\| handleErrors(err);
...	...	@@ -507,7 +507,7 @@ test "nested catch" {
507	507
508	508	test "function pointer with return type that is error union with payload which is pointer of parent struct" {
509	509	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
510		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	510	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
511	511
512	512	const S = struct {
513	513	const Foo = struct {
...	...	@@ -593,7 +593,7 @@ test "@errorName" {
593	593	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
594	594	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595	595	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	596	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
597	597	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
598	598
599	599	try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
...	...	@@ -608,7 +608,7 @@ test "@errorName sentinel length matches slice length" {
608	608	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
609	609	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
610	610	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
611		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	611	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
612	612	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
613	613
614	614	const name = testBuiltinErrorName(error.FooBar);
...	...	@@ -703,7 +703,7 @@ test "error union payload is properly aligned" {
703	703	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
704	704	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
705	705	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
706		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	706	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
707	707	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
708	708
709	709	const S = struct {
...	...	@@ -763,7 +763,7 @@ test "pointer to error union payload" {
763	763	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
764	764	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
765	765	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
766		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	766	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
767	767	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
768	768
769	769	var err_union: anyerror!u8 = 15;
...	...	@@ -797,7 +797,7 @@ test "error union of noreturn used with if" {
797	797	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
798	798	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
799	799	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
800		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	800	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
801	801	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
802	802
803	803	NoReturn.a = 64;
...	...	@@ -812,7 +812,7 @@ test "error union of noreturn used with try" {
812	812	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
813	813	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
814	814	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
815		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	815	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
816	816	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
817	817
818	818	NoReturn.a = 64;
...	...	@@ -824,7 +824,7 @@ test "error union of noreturn used with catch" {
824	824	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
825	825	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
826	826	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
827		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	827	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
828	828	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
829	829
830	830	NoReturn.a = 64;
...	...	@@ -836,7 +836,7 @@ test "alignment of wrapping an error union payload" {
836	836	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
837	837	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
838	838	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
839		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	839	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
840	840	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
841	841
842	842	const S = struct {
...	...	@@ -890,7 +890,7 @@ test "error from comptime string" {
890	890	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
891	891	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
892	892	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
893		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	893	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
894	894	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
895	895
896	896	const name = "Weird error name!";
...	...	@@ -954,7 +954,7 @@ test "optional error set function parameter" {
954	954	test "returning an error union containing a type with no runtime bits" {
955	955	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
956	956	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
957		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	957	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
958	958
959	959	const ZeroByteType = struct {
960	960	foo: void,
...	...	@@ -971,7 +971,7 @@ test "returning an error union containing a type with no runtime bits" {
971	971	test "try used in recursive function with inferred error set" {
972	972	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
973	973	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
974		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	974	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
975	975
976	976	const Value = union(enum) {
977	977	values: []const @This(),
...	...	@@ -1086,7 +1086,7 @@ test "result location initialization of error union with OPV payload" {
1086	1086	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1087	1087	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1088	1088	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1089		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1089	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1090	1090
1091	1091	const S = struct {
1092	1092	x: u0,
...	...	@@ -1108,7 +1108,7 @@ test "result location initialization of error union with OPV payload" {
1108	1108
1109	1109	test "return error union with i65" {
1110	1110	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1111		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1111	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1112	1112
1113	1113	try expect(try add(1000, 234) == 1234);
1114	1114	}

test/behavior/eval.zig+23-23

...	...	@@ -143,7 +143,7 @@ test "a type constructed in a global expression" {
143	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
144	144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
145	145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
146		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	146	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
147	147
148	148	var l: List = undefined;
149	149	l.array[0] = 10;
...	...	@@ -446,7 +446,7 @@ test "binary math operator in partially inlined function" {
446	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
447	447	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
448	448	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
449		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	449	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
450	450
451	451	var s: [4]u32 = undefined;
452	452	var b: [16]u8 = undefined;
...	...	@@ -465,7 +465,7 @@ test "comptime shl" {
465	465	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
466	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
467	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
468		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	468	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
469	469
470	470	const a: u128 = 3;
471	471	const b: u7 = 63;
...	...	@@ -505,7 +505,7 @@ test "comptime shlWithOverflow" {
505	505	test "const ptr to variable data changes at runtime" {
506	506	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
507	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
508		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	508	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
509	509
510	510	try expect(foo_ref.name[0] == 'a');
511	511	foo_ref.name = "b";
...	...	@@ -524,7 +524,7 @@ test "runtime 128 bit integer division" {
524	524	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
525	525	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
526	526	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
527		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	527	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
528	528	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
529	529	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
530	530	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -539,7 +539,7 @@ test "runtime 128 bit integer division" {
539	539	test "@tagName of @typeInfo" {
540	540	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
541	541	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
542		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	542	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
543	543
544	544	const str = @tagName(@typeInfo(u8));
545	545	try expect(std.mem.eql(u8, str, "int"));
...	...	@@ -617,7 +617,7 @@ const hi1 = "hi";
617	617	const hi2 = hi1;
618	618	test "const global shares pointer with other same one" {
619	619	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
620		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	620	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
621	621
622	622	try assertEqualPtrs(&hi1[0], &hi2[0]);
623	623	comptime assert(&hi1[0] == &hi2[0]);
...	...	@@ -744,7 +744,7 @@ test "array concatenation of function calls" {
744	744	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
745	745	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
746	746	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
747		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	747	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
748	748
749	749	var a = oneItem(3) ++ oneItem(4);
750	750	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
...	...	@@ -754,7 +754,7 @@ test "array multiplication of function calls" {
754	754	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
755	755	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
756	756	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
757		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	757	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
758	758
759	759	var a = oneItem(3) ** scalar(2);
760	760	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
...	...	@@ -789,7 +789,7 @@ test "array concatenation peer resolves element types - pointer" {
789	789	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
790	790	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
791	791	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
792		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	792	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
793	793
794	794	var a = [2]u3{ 1, 7 };
795	795	var b = [3]u8{ 200, 225, 255 };
...	...	@@ -807,7 +807,7 @@ test "array concatenation sets the sentinel - value" {
807	807	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
808	808	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
809	809	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
810		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	810	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
811	811
812	812	var a = [2]u3{ 1, 7 };
813	813	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -827,7 +827,7 @@ test "array concatenation sets the sentinel - pointer" {
827	827	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
828	828	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
829	829	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
830		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	830	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
831	831
832	832	var a = [2]u3{ 1, 7 };
833	833	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -847,7 +847,7 @@ test "array multiplication sets the sentinel - value" {
847	847	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
848	848	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
849	849	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
850		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	850	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
851	851
852	852	var a = [2:7]u3{ 1, 6 };
853	853	_ = &a;
...	...	@@ -866,7 +866,7 @@ test "array multiplication sets the sentinel - pointer" {
866	866	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
867	867	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
868	868	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
869		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	869	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
870	870
871	871	var a = [2:7]u3{ 1, 6 };
872	872	const b = &a ** 2;
...	...	@@ -950,7 +950,7 @@ test "comptime pointer load through elem_ptr" {
950	950	}
951	951
952	952	test "debug variable type resolved through indirect zero-bit types" {
953		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	953	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
954	954
955	955	const T = struct { key: []void };
956	956	const slice: []const T = &[_]T{};
...	...	@@ -1112,7 +1112,7 @@ test "no dependency loop for alignment of self struct" {
1112	1112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1113	1113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1114	1114	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1115		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1115	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1116	1116
1117	1117	const S = struct {
1118	1118	fn doTheTest() !void {
...	...	@@ -1151,7 +1151,7 @@ test "no dependency loop for alignment of self bare union" {
1151	1151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1152	1152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1153	1153	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1154		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1154	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1155	1155
1156	1156	const S = struct {
1157	1157	fn doTheTest() !void {
...	...	@@ -1190,7 +1190,7 @@ test "no dependency loop for alignment of self tagged union" {
1190	1190	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1191	1191	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1192	1192	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1193		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1193	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1194	1194
1195	1195	const S = struct {
1196	1196	fn doTheTest() !void {
...	...	@@ -1234,7 +1234,7 @@ test "storing an array of type in a field" {
1234	1234	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1235	1235	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1236	1236	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1237		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1237	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1238	1238
1239	1239	const S = struct {
1240	1240	fn doTheTest() void {
...	...	@@ -1263,7 +1263,7 @@ test "storing an array of type in a field" {
1263	1263	test "pass pointer to field of comptime-only type as a runtime parameter" {
1264	1264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1265	1265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1266		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1266	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1267	1267
1268	1268	const S = struct {
1269	1269	const Mixed = struct {
...	...	@@ -1378,7 +1378,7 @@ test "lazy sizeof is resolved in division" {
1378	1378	}
1379	1379
1380	1380	test "lazy sizeof union tag size in compare" {
1381		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1381	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1382	1382
1383	1383	const A = union(enum) {
1384	1384	a: void,
...	...	@@ -1392,7 +1392,7 @@ test "lazy value is resolved as slice operand" {
1392	1392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1393	1393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1394	1394	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1395		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1395	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1396	1396
1397	1397	const A = struct { a: u32 };
1398	1398	var a: [512]u64 = undefined;
...	...	@@ -1646,7 +1646,7 @@ test "struct in comptime false branch is not evaluated" {
1646	1646	}
1647	1647
1648	1648	test "result of nested switch assigned to variable" {
1649		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1649	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1650	1650
1651	1651	var zds: u32 = 0;
1652	1652	zds = switch (zds) {

test/behavior/export_builtin.zig+1-1

...	...	@@ -59,7 +59,7 @@ test "exporting comptime-known value" {
59	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
60	60	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
61	61	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
62		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	62	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
63	63
64	64	if (builtin.cpu.arch.isWasm()) {
65	65	// https://github.com/ziglang/zig/issues/4866

test/behavior/export_keyword.zig+1-1

...	...	@@ -41,7 +41,7 @@ export fn testPackedStuff(a: const PackedStruct, b: const PackedUnion) void {
41	41
42	42	test "export function alias" {
43	43	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
44		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	44	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
45	45
46	46	_ = struct {
47	47	fn foo_internal() callconv(.c) u32 {

test/behavior/extern.zig+3-3

...	...	@@ -5,7 +5,7 @@ const expect = std.testing.expect;
5	5	test "anyopaque extern symbol" {
6	6	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
8		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	9
10	10	const a = @extern(*anyopaque, .{ .name = "a_mystery_symbol" });
11	11	const b: *i32 = @alignCast(@ptrCast(a));
...	...	@@ -17,7 +17,7 @@ export var a_mystery_symbol: i32 = 1234;
17	17	test "function extern symbol" {
18	18	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
20		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	20	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21	21
22	22	const a = @extern(*const fn () callconv(.c) i32, .{ .name = "a_mystery_function" });
23	23	try expect(a() == 4567);
...	...	@@ -30,7 +30,7 @@ export fn a_mystery_function() i32 {
30	30	test "function extern symbol matches extern decl" {
31	31	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34	34
35	35	const S = struct {
36	36	extern fn another_mystery_function() u32;

test/behavior/field_parent_ptr.zig+16-16

...	...	@@ -2,7 +2,7 @@ const expect = @import("std").testing.expect;
2	2	const builtin = @import("builtin");
3	3
4	4	test "@fieldParentPtr struct" {
5		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	5	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7	7
8	8	const C = struct {
...	...	@@ -139,7 +139,7 @@ test "@fieldParentPtr struct" {
139	139
140	140	test "@fieldParentPtr extern struct" {
141	141	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
142		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	142	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
143	143
144	144	const C = extern struct {
145	145	a: bool = true,
...	...	@@ -274,7 +274,7 @@ test "@fieldParentPtr extern struct" {
274	274	}
275	275
276	276	test "@fieldParentPtr extern struct first zero-bit field" {
277		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	277	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
278	278	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
279	279
280	280	const C = extern struct {
...	...	@@ -378,7 +378,7 @@ test "@fieldParentPtr extern struct first zero-bit field" {
378	378	}
379	379
380	380	test "@fieldParentPtr extern struct middle zero-bit field" {
381		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	381	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
382	382	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
383	383
384	384	const C = extern struct {
...	...	@@ -482,7 +482,7 @@ test "@fieldParentPtr extern struct middle zero-bit field" {
482	482	}
483	483
484	484	test "@fieldParentPtr extern struct last zero-bit field" {
485		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	485	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
486	486	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
487	487
488	488	const C = extern struct {
...	...	@@ -588,7 +588,7 @@ test "@fieldParentPtr extern struct last zero-bit field" {
588	588	test "@fieldParentPtr unaligned packed struct" {
589	589	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
590	590	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
591		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	591	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
592	592	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
593	593
594	594	const C = packed struct {
...	...	@@ -726,7 +726,7 @@ test "@fieldParentPtr unaligned packed struct" {
726	726	test "@fieldParentPtr aligned packed struct" {
727	727	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
728	728	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
729		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	729	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
730	730	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
731	731
732	732	const C = packed struct {
...	...	@@ -863,7 +863,7 @@ test "@fieldParentPtr aligned packed struct" {
863	863
864	864	test "@fieldParentPtr nested packed struct" {
865	865	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
866		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	866	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
867	867	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
868	868
869	869	{
...	...	@@ -1025,7 +1025,7 @@ test "@fieldParentPtr nested packed struct" {
1025	1025
1026	1026	test "@fieldParentPtr packed struct first zero-bit field" {
1027	1027	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1028		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1028	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1029	1029	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1030	1030
1031	1031	const C = packed struct {
...	...	@@ -1130,7 +1130,7 @@ test "@fieldParentPtr packed struct first zero-bit field" {
1130	1130
1131	1131	test "@fieldParentPtr packed struct middle zero-bit field" {
1132	1132	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1133		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1133	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1134	1134	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1135	1135
1136	1136	const C = packed struct {
...	...	@@ -1235,7 +1235,7 @@ test "@fieldParentPtr packed struct middle zero-bit field" {
1235	1235
1236	1236	test "@fieldParentPtr packed struct last zero-bit field" {
1237	1237	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1238		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1238	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1239	1239	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1240	1240
1241	1241	const C = packed struct {
...	...	@@ -1340,7 +1340,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {
1340	1340
1341	1341	test "@fieldParentPtr tagged union" {
1342	1342	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1343		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1343	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1344	1344
1345	1345	const C = union(enum) {
1346	1346	a: bool,
...	...	@@ -1475,7 +1475,7 @@ test "@fieldParentPtr tagged union" {
1475	1475	}
1476	1476
1477	1477	test "@fieldParentPtr untagged union" {
1478		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1478	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1479	1479	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1480	1480
1481	1481	const C = union {
...	...	@@ -1612,7 +1612,7 @@ test "@fieldParentPtr untagged union" {
1612	1612
1613	1613	test "@fieldParentPtr extern union" {
1614	1614	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1615		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1615	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1616	1616
1617	1617	const C = extern union {
1618	1618	a: bool,
...	...	@@ -1747,7 +1747,7 @@ test "@fieldParentPtr extern union" {
1747	1747	}
1748	1748
1749	1749	test "@fieldParentPtr packed union" {
1750		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1750	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1751	1751	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1752	1752	if (builtin.target.cpu.arch.endian() == .big) return error.SkipZigTest; // TODO
1753	1753
...	...	@@ -1886,7 +1886,7 @@ test "@fieldParentPtr packed union" {
1886	1886	test "@fieldParentPtr tagged union all zero-bit fields" {
1887	1887	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1888	1888	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1889		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1889	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1890	1890
1891	1891	const C = union(enum) {
1892	1892	a: u0,

test/behavior/floatop.zig+54-54

...	...	@@ -32,7 +32,7 @@ test "add f32/f64" {
32	32
33	33	test "add f80/f128/c_longdouble" {
34	34	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
35		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	35	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
36	36	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
37	37
38	38	try testAdd(f80);
...	...	@@ -68,7 +68,7 @@ test "sub f32/f64" {
68	68
69	69	test "sub f80/f128/c_longdouble" {
70	70	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
71		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	71	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
72	72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
73	73
74	74	try testSub(f80);
...	...	@@ -104,7 +104,7 @@ test "mul f32/f64" {
104	104
105	105	test "mul f80/f128/c_longdouble" {
106	106	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
107		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	107	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
108	108	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
109	109
110	110	try testMul(f80);
...	...	@@ -136,7 +136,7 @@ test "cmp f16" {
136	136	}
137	137
138	138	test "cmp f32" {
139		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	139	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
140	140	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
141	141	if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
142	142
...	...	@@ -145,7 +145,7 @@ test "cmp f32" {
145	145	}
146	146
147	147	test "cmp f64" {
148		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	148	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
149	149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
150	150	if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
151	151
...	...	@@ -157,7 +157,7 @@ test "cmp f128" {
157	157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
158	158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
159	159	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
160		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	160	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
161	161	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
162	162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
163	163
...	...	@@ -170,7 +170,7 @@ test "cmp f80/c_longdouble" {
170	170	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
171	171	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
172	172	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
173		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	173	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
174	174	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
175	175	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
176	176
...	...	@@ -249,7 +249,7 @@ test "vector cmp f16" {
249	249	}
250	250
251	251	test "vector cmp f32" {
252		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	252	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
253	253	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
254	254	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
255	255	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -280,7 +280,7 @@ test "vector cmp f128" {
280	280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
281	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
282	282	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
283		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	283	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
284	284	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
285	285	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
286	286	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
...	...	@@ -295,7 +295,7 @@ test "vector cmp f80/c_longdouble" {
295	295	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
296	296	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .powerpc64le) return error.SkipZigTest;
297	297	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
298		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	298	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
299	299	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
300	300	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
301	301
...	...	@@ -380,7 +380,7 @@ fn testDifferentSizedFloatComparisons() !void {
380	380	test "negative f128 intFromFloat at compile-time" {
381	381	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
382	382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
383		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	383	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
384	384
385	385	const a: f128 = -2;
386	386	var b: i64 = @intFromFloat(a);
...	...	@@ -393,7 +393,7 @@ test "@sqrt f16" {
393	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
394	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395	395	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
396		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	396	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
397	397
398	398	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
399	399	!comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest;
...	...	@@ -406,7 +406,7 @@ test "@sqrt f32/f64" {
406	406	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
407	407	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
408	408	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
409		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	409	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
410	410
411	411	try testSqrt(f32);
412	412	try comptime testSqrt(f32);
...	...	@@ -420,7 +420,7 @@ test "@sqrt f80/f128/c_longdouble" {
420	420	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
421	421	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
422	422	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
423		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	423	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
424	424
425	425	if (builtin.os.tag == .freebsd) {
426	426	// TODO https://github.com/ziglang/zig/issues/10875
...	...	@@ -507,7 +507,7 @@ test "@sqrt with vectors" {
507	507	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
508	508	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
509	509	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
510		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	510	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
511	511
512	512	try testSqrtWithVectors();
513	513	try comptime testSqrtWithVectors();
...	...	@@ -529,7 +529,7 @@ test "@sin f16" {
529	529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
530	530	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
531	531	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
532		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	532	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
533	533
534	534	try testSin(f16);
535	535	try comptime testSin(f16);
...	...	@@ -541,7 +541,7 @@ test "@sin f32/f64" {
541	541	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
542	542	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
543	543	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
544		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	544	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
545	545
546	546	try testSin(f32);
547	547	comptime try testSin(f32);
...	...	@@ -555,7 +555,7 @@ test "@sin f80/f128/c_longdouble" {
555	555	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
556	556	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
557	557	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
558		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	558	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
559	559
560	560	try testSin(f80);
561	561	comptime try testSin(f80);
...	...	@@ -583,7 +583,7 @@ test "@sin with vectors" {
583	583	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
584	584	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
585	585	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
586		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	586	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
587	587
588	588	try testSinWithVectors();
589	589	try comptime testSinWithVectors();
...	...	@@ -605,7 +605,7 @@ test "@cos f16" {
605	605	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
606	606	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
607	607	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
608		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	608	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
609	609
610	610	try testCos(f16);
611	611	try comptime testCos(f16);
...	...	@@ -617,7 +617,7 @@ test "@cos f32/f64" {
617	617	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
618	618	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
619	619	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
620		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	620	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
621	621
622	622	try testCos(f32);
623	623	try comptime testCos(f32);
...	...	@@ -631,7 +631,7 @@ test "@cos f80/f128/c_longdouble" {
631	631	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
632	632	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
633	633	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
634		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	634	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
635	635
636	636	try testCos(f80);
637	637	try comptime testCos(f80);
...	...	@@ -659,7 +659,7 @@ test "@cos with vectors" {
659	659	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
660	660	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
661	661	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
662		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	662	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
663	663
664	664	try testCosWithVectors();
665	665	try comptime testCosWithVectors();
...	...	@@ -681,7 +681,7 @@ test "@tan f16" {
681	681	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
682	682	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
683	683	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
684		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	684	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
685	685
686	686	try testTan(f16);
687	687	try comptime testTan(f16);
...	...	@@ -693,7 +693,7 @@ test "@tan f32/f64" {
693	693	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
694	694	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
695	695	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
696		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	696	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
697	697
698	698	try testTan(f32);
699	699	try comptime testTan(f32);
...	...	@@ -707,7 +707,7 @@ test "@tan f80/f128/c_longdouble" {
707	707	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
708	708	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
709	709	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
710		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	710	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
711	711
712	712	try testTan(f80);
713	713	try comptime testTan(f80);
...	...	@@ -735,7 +735,7 @@ test "@tan with vectors" {
735	735	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
736	736	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
737	737	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
738		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	738	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
739	739
740	740	try testTanWithVectors();
741	741	try comptime testTanWithVectors();
...	...	@@ -757,7 +757,7 @@ test "@exp f16" {
757	757	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
758	758	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
759	759	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
760		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	760	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
761	761
762	762	try testExp(f16);
763	763	try comptime testExp(f16);
...	...	@@ -769,7 +769,7 @@ test "@exp f32/f64" {
769	769	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
770	770	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
771	771	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
772		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	772	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
773	773
774	774	try testExp(f32);
775	775	try comptime testExp(f32);
...	...	@@ -783,7 +783,7 @@ test "@exp f80/f128/c_longdouble" {
783	783	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
784	784	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
785	785	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
786		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	786	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
787	787
788	788	try testExp(f80);
789	789	try comptime testExp(f80);
...	...	@@ -815,7 +815,7 @@ test "@exp with vectors" {
815	815	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
816	816	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
817	817	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
818		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	818	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
819	819
820	820	try testExpWithVectors();
821	821	try comptime testExpWithVectors();
...	...	@@ -837,7 +837,7 @@ test "@exp2 f16" {
837	837	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
838	838	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
839	839	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
840		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	840	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
841	841
842	842	try testExp2(f16);
843	843	try comptime testExp2(f16);
...	...	@@ -849,7 +849,7 @@ test "@exp2 f32/f64" {
849	849	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
850	850	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
851	851	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
852		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	852	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
853	853
854	854	try testExp2(f32);
855	855	try comptime testExp2(f32);
...	...	@@ -863,7 +863,7 @@ test "@exp2 f80/f128/c_longdouble" {
863	863	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
864	864	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
865	865	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
866		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	866	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
867	867
868	868	try testExp2(f80);
869	869	try comptime testExp2(f80);
...	...	@@ -890,7 +890,7 @@ test "@exp2 with @vectors" {
890	890	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
891	891	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
892	892	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
893		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	893	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
894	894
895	895	try testExp2WithVectors();
896	896	try comptime testExp2WithVectors();
...	...	@@ -912,7 +912,7 @@ test "@log f16" {
912	912	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
913	913	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
914	914	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
915		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	915	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
916	916
917	917	try testLog(f16);
918	918	try comptime testLog(f16);
...	...	@@ -924,7 +924,7 @@ test "@log f32/f64" {
924	924	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
925	925	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
926	926	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
927		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	927	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
928	928
929	929	try testLog(f32);
930	930	try comptime testLog(f32);
...	...	@@ -938,7 +938,7 @@ test "@log f80/f128/c_longdouble" {
938	938	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
939	939	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
940	940	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
941		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	941	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
942	942
943	943	try testLog(f80);
944	944	try comptime testLog(f80);
...	...	@@ -966,7 +966,7 @@ test "@log with @vectors" {
966	966	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
967	967	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
968	968	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
969		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	969	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
970	970
971	971	{
972	972	var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
...	...	@@ -985,7 +985,7 @@ test "@log2 f16" {
985	985	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
986	986	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
987	987	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
988		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	988	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
989	989
990	990	try testLog2(f16);
991	991	try comptime testLog2(f16);
...	...	@@ -997,7 +997,7 @@ test "@log2 f32/f64" {
997	997	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
998	998	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
999	999	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1000		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1000	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1001	1001
1002	1002	try testLog2(f32);
1003	1003	try comptime testLog2(f32);
...	...	@@ -1011,7 +1011,7 @@ test "@log2 f80/f128/c_longdouble" {
1011	1011	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1012	1012	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1013	1013	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1014		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1014	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1015	1015
1016	1016	try testLog2(f80);
1017	1017	try comptime testLog2(f80);
...	...	@@ -1037,7 +1037,7 @@ test "@log2 with vectors" {
1037	1037	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1038	1038	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1039	1039	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1040		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1040	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1041	1041	// https://github.com/ziglang/zig/issues/13681
1042	1042	if (builtin.zig_backend == .stage2_llvm and
1043	1043	builtin.cpu.arch == .aarch64 and
...	...	@@ -1064,7 +1064,7 @@ test "@log10 f16" {
1064	1064	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1065	1065	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1066	1066	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1067		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1067	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1068	1068
1069	1069	try testLog10(f16);
1070	1070	try comptime testLog10(f16);
...	...	@@ -1076,7 +1076,7 @@ test "@log10 f32/f64" {
1076	1076	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1077	1077	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1078	1078	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1079		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1079	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1080	1080
1081	1081	try testLog10(f32);
1082	1082	try comptime testLog10(f32);
...	...	@@ -1090,7 +1090,7 @@ test "@log10 f80/f128/c_longdouble" {
1090	1090	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1091	1091	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1092	1092	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1093		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1093	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1094	1094
1095	1095	try testLog10(f80);
1096	1096	try comptime testLog10(f80);
...	...	@@ -1117,7 +1117,7 @@ test "@log10 with vectors" {
1117	1117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1118	1118	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1119	1119	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1120		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1120	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1121	1121
1122	1122	try testLog10WithVectors();
1123	1123	try comptime testLog10WithVectors();
...	...	@@ -1163,7 +1163,7 @@ test "@abs f80/f128/c_longdouble" {
1163	1163	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1164	1164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1165	1165	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1166		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1166	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1167	1167	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1168	1168
1169	1169	try testFabs(f80);
...	...	@@ -1290,7 +1290,7 @@ test "@floor f80/f128/c_longdouble" {
1290	1290	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1291	1291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1292	1292	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1293		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1293	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1294	1294	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1295	1295
1296	1296	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
...	...	@@ -1391,7 +1391,7 @@ test "@ceil f80/f128/c_longdouble" {
1391	1391	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1392	1392	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1393	1393	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1394		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1394	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1395	1395	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1396	1396
1397	1397	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
...	...	@@ -1492,7 +1492,7 @@ test "@trunc f80/f128/c_longdouble" {
1492	1492	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1493	1493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1494	1494	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1495		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1495	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1496	1496	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1497	1497
1498	1498	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
...	...	@@ -1595,7 +1595,7 @@ test "neg f80/f128/c_longdouble" {
1595	1595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1596	1596	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1597	1597	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1598		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1598	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1599	1599	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1600	1600	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1601	1601	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -1703,7 +1703,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
1703	1703	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1704	1704	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1705	1705	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1706		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1706	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1707	1707	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1708	1708	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1709	1709
...	...	@@ -1716,7 +1716,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
1716	1716	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1717	1717	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1718	1718	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1719		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1719	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1720	1720
1721	1721	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
1722	1722	const pos = @as(F, 1) / @as(F, 0);

test/behavior/fn.zig+10-10

...	...	@@ -70,7 +70,7 @@ fn outer(y: u32) *const fn (u32) u32 {
70	70	}
71	71
72	72	test "return inner function which references comptime variable of outer function" {
73		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	73	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
74	74
75	75	const func = outer(10);
76	76	try expect(func(3) == 7);
...	...	@@ -103,7 +103,7 @@ test "inline function call that calls optional function pointer, return pointer
103	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
104	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	106	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
107	107
108	108	const S = struct {
109	109	field: u32,
...	...	@@ -150,7 +150,7 @@ fn fnWithUnreachable() noreturn {
150	150	test "extern struct with stdcallcc fn pointer" {
151	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
152	152	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch == .x86) return error.SkipZigTest;
153		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	153	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
154	154
155	155	const S = extern struct {
156	156	ptr: *const fn () callconv(if (builtin.target.cpu.arch == .x86) .Stdcall else .c) i32,
...	...	@@ -257,7 +257,7 @@ test "implicit cast fn call result to optional in field result" {
257	257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
258	258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259	259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	260	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
261	261
262	262	const S = struct {
263	263	fn entry() !void {
...	...	@@ -309,7 +309,7 @@ test "function pointers" {
309	309	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
310	310	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
311	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
312		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	312	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
313	313
314	314	const fns = [_]*const @TypeOf(fn1){
315	315	&fn1,
...	...	@@ -428,7 +428,7 @@ test "implicit cast function to function ptr" {
428	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
429	429	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
430	430	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
431		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	431	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
432	432
433	433	const S1 = struct {
434	434	export fn someFunctionThatReturnsAValue() c_int {
...	...	@@ -468,7 +468,7 @@ test "method call with optional and error union first param" {
468	468	test "method call with optional pointer first param" {
469	469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
470	470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
471		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	471	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
472	472
473	473	const S = struct {
474	474	x: i32 = 1234,
...	...	@@ -487,7 +487,7 @@ test "using @ptrCast on function pointers" {
487	487	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488	488	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
489	489	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
490		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	490	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
491	491
492	492	const S = struct {
493	493	const A = struct { data: [4]u8 };
...	...	@@ -583,7 +583,7 @@ test "pass and return comptime-only types" {
583	583	test "pointer to alias behaves same as pointer to function" {
584	584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
585	585	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
586		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	586	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
587	587
588	588	const S = struct {
589	589	fn foo() u32 {
...	...	@@ -620,7 +620,7 @@ test "inline function with comptime-known comptime-only return type called at ru
620	620	}
621	621
622	622	test "address of function parameter is consistent" {
623		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	623	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
624	624
625	625	const S = struct {
626	626	fn paramAddrMatch(x: u8) bool {

test/behavior/fn_in_struct_in_comptime.zig+1-1

...	...	@@ -12,7 +12,7 @@ fn get_foo() fn (*u8) usize {
12	12	}
13	13
14	14	test "define a function in an anonymous struct in comptime" {
15		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
16	16
17	17	const foo = get_foo();
18	18	try expect(foo(@as(*u8, @ptrFromInt(12345))) == 12345);

test/behavior/for.zig+11-11

...	...	@@ -69,7 +69,7 @@ test "basic for loop" {
69	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	72	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
73	73
74	74	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
75	75
...	...	@@ -113,7 +113,7 @@ test "for with null and T peer types and inferred result location type" {
113	113	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
114	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	116	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
117	117
118	118	const S = struct {
119	119	fn doTheTest(slice: []const u8) !void {
...	...	@@ -155,7 +155,7 @@ test "for loop with pointer elem var" {
155	155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
156	156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
157	157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
158		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	158	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
159	159
160	160	const source = "abcdefg";
161	161	var target: [source.len]u8 = undefined;
...	...	@@ -201,7 +201,7 @@ test "for on slice with allowzero ptr" {
201	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
202	202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
203	203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
204		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	204	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
205	205
206	206	const S = struct {
207	207	fn doTheTest(slice: []const u8) !void {
...	...	@@ -217,7 +217,7 @@ test "for on slice with allowzero ptr" {
217	217	test "else continue outer for" {
218	218	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
219	219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
220		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	220	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
221	221
222	222	var i: usize = 6;
223	223	var buf: [5]u8 = undefined;
...	...	@@ -313,7 +313,7 @@ test "slice and two counters, one is offset and one is runtime" {
313	313	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
314	314	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315	315	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
316		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	316	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
317	317
318	318	const slice: []const u8 = "blah";
319	319	var start: usize = 0;
...	...	@@ -343,7 +343,7 @@ test "two slices, one captured by-ref" {
343	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
344	344	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345	345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
346		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	346	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
347	347
348	348	var buf: [10]u8 = undefined;
349	349	const slice1: []const u8 = "blah";
...	...	@@ -363,7 +363,7 @@ test "raw pointer and slice" {
363	363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
364	364	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
365	365	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
366		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	366	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
367	367
368	368	var buf: [10]u8 = undefined;
369	369	const slice: []const u8 = "blah";
...	...	@@ -383,7 +383,7 @@ test "raw pointer and counter" {
383	383	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
384	384	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
385	385	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
386		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	386	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
387	387
388	388	var buf: [10]u8 = undefined;
389	389	const ptr: [*]u8 = &buf;
...	...	@@ -433,7 +433,7 @@ test "inline for with counter as the comptime-known" {
433	433	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
434	434	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
435	435	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
436		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	436	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
437	437
438	438	var runtime_slice = "hello";
439	439	var runtime_i: usize = 3;
...	...	@@ -465,7 +465,7 @@ test "inline for on tuple pointer" {
465	465	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
466	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
467	467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
468		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	468	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
469	469
470	470	const S = struct { u32, u32, u32 };
471	471	var s: S = .{ 100, 200, 300 };

test/behavior/generics.zig+12-12

...	...	@@ -90,7 +90,7 @@ test "type constructed by comptime function call" {
90	90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
91	91	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
92	92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
93		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	93	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
94	94
95	95	var l: SimpleList(10) = undefined;
96	96	l.array[0] = 10;
...	...	@@ -156,7 +156,7 @@ test "generic fn with implicit cast" {
156	156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
157	157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
158	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
159		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	159	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
160	160
161	161	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
162	162	try expect(getFirstByte(u16, &[_]u16{
...	...	@@ -210,7 +210,7 @@ fn foo2(arg: anytype) bool {
210	210
211	211	test "generic struct" {
212	212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
213		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	213	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
214	214
215	215	var a1 = GenNode(i32){
216	216	.value = 13,
...	...	@@ -252,7 +252,7 @@ test "generic function instantiation turns into comptime call" {
252	252	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
253	253	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
254	254	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
255		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	255	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
256	256
257	257	const S = struct {
258	258	fn doTheTest() !void {
...	...	@@ -320,7 +320,7 @@ test "generic function instantiation non-duplicates" {
320	320	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
321	321	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
322	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
323		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	323	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
324	324
325	325	if (builtin.os.tag == .wasi) return error.SkipZigTest;
326	326
...	...	@@ -358,7 +358,7 @@ test "generic instantiation of tagged union with only one field" {
358	358	}
359	359
360	360	test "nested generic function" {
361		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	361	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
362	362
363	363	const S = struct {
364	364	fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
...	...	@@ -411,7 +411,7 @@ test "generic struct as parameter type" {
411	411	}
412	412
413	413	test "slice as parameter type" {
414		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	414	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
415	415
416	416	const S = struct {
417	417	fn internComptimeString(comptime str: []const u8) *const []const u8 {
...	...	@@ -427,7 +427,7 @@ test "slice as parameter type" {
427	427	}
428	428
429	429	test "null sentinel pointer passed as generic argument" {
430		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	430	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
431	431
432	432	const S = struct {
433	433	fn doTheTest(a: anytype) !void {
...	...	@@ -451,7 +451,7 @@ test "generic function passed as comptime argument" {
451	451
452	452	test "return type of generic function is function pointer" {
453	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
454		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	454	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
455	455
456	456	const S = struct {
457	457	fn b(comptime T: type) ?*const fn () error{}!T {
...	...	@@ -513,7 +513,7 @@ test "union in struct captures argument" {
513	513	test "function argument tuple used as struct field" {
514	514	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
515	515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
516		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	516	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
517	517
518	518	const S = struct {
519	519	fn DeleagateWithContext(comptime Function: type) type {
...	...	@@ -589,7 +589,7 @@ fn StructCapture(comptime T: type) type {
589	589	test "call generic function that uses capture from function declaration's scope" {
590	590	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
591	591	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
592		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	592	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
593	593
594	594	const S = StructCapture(f64);
595	595	const s = S.foo(123);
...	...	@@ -603,7 +603,7 @@ comptime {
603	603	}
604	604
605	605	test "generic parameter resolves to comptime-only type but is not marked comptime" {
606		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	606	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
607	607
608	608	const S = struct {
609	609	fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {

test/behavior/globals.zig+7-7

...	...	@@ -28,7 +28,7 @@ test "slices pointing at the same address as global array." {
28	28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
29	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	31	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32	32
33	33	const S = struct {
34	34	const a = [_]u8{ 1, 2, 3 };
...	...	@@ -69,7 +69,7 @@ test "global loads can affect liveness" {
69	69	}
70	70
71	71	test "global const can be self-referential" {
72		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	72	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
73	73
74	74	const S = struct {
75	75	self: *const @This(),
...	...	@@ -86,7 +86,7 @@ test "global const can be self-referential" {
86	86	}
87	87
88	88	test "global var can be self-referential" {
89		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	89	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
90	90
91	91	const S = struct {
92	92	self: *@This(),
...	...	@@ -115,7 +115,7 @@ test "global var can be self-referential" {
115	115	}
116	116
117	117	test "global const can be indirectly self-referential" {
118		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	118	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
119	119
120	120	const S = struct {
121	121	other: *const @This(),
...	...	@@ -141,7 +141,7 @@ test "global const can be indirectly self-referential" {
141	141	}
142	142
143	143	test "global var can be indirectly self-referential" {
144		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	144	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
145	145
146	146	const S = struct {
147	147	other: *@This(),
...	...	@@ -180,7 +180,7 @@ var callbacks: Callbacks = undefined;
180	180	var callbacks_loaded: bool = false;
181	181
182	182	test "function pointer field call on global extern struct, conditional on global" {
183		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	183	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
184	184
185	185	if (callbacks_loaded) {
186	186	try std.testing.expectEqual(42, callbacks.key_callback(42));
...	...	@@ -188,7 +188,7 @@ test "function pointer field call on global extern struct, conditional on global
188	188	}
189	189
190	190	test "function pointer field call on global extern struct" {
191		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	191	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
192	192
193	193	const S = struct {
194	194	fn keyCallback(key: i32) callconv(.c) i32 {

test/behavior/hasdecl.zig+2-2

...	...	@@ -13,7 +13,7 @@ const Bar = struct {
13	13
14	14	test "@hasDecl" {
15	15	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
16		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
17	17
18	18	try expect(@hasDecl(Foo, "public_thing"));
19	19	try expect(!@hasDecl(Foo, "private_thing"));
...	...	@@ -26,7 +26,7 @@ test "@hasDecl" {
26	26
27	27	test "@hasDecl using a sliced string literal" {
28	28	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
29		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	29	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
30	30
31	31	try expect(@hasDecl(@This(), "std") == true);
32	32	try expect(@hasDecl(@This(), "std"[0..0]) == false);

test/behavior/if.zig+1-1

...	...	@@ -118,7 +118,7 @@ test "if peer expressions inferred optional type" {
118	118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119	119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
120	120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
121		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	121	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
122	122
123	123	var self: []const u8 = "abcdef";
124	124	var index: usize = 0;

test/behavior/import.zig+4-4

...	...	@@ -5,21 +5,21 @@ const expectEqual = std.testing.expectEqual;
5	5	const a_namespace = @import("import/a_namespace.zig");
6	6
7	7	test "call fn via namespace lookup" {
8		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10	10
11	11	try expect(@as(i32, 1234) == a_namespace.foo());
12	12	}
13	13
14	14	test "importing the same thing gives the same import" {
15		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
17	17
18	18	try expect(@import("std") == @import("std"));
19	19	}
20	20
21	21	test "import in non-toplevel scope" {
22		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	22	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24	24
25	25	const S = struct {
...	...	@@ -29,7 +29,7 @@ test "import in non-toplevel scope" {
29	29	}
30	30
31	31	test "import empty file" {
32		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	32	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33	33	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
34	34
35	35	_ = @import("import/empty.zig");

test/behavior/import_c_keywords.zig+1-1

...	...	@@ -30,7 +30,7 @@ test "import c keywords" {
30	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34	34	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
35	35	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest;
36	36	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

test/behavior/inline_switch.zig+1-1

...	...	@@ -113,7 +113,7 @@ test "inline else enum" {
113	113	test "inline else int with gaps" {
114	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
115	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	116	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
117	117
118	118	var a: u8 = 0;
119	119	_ = &a;

test/behavior/int128.zig+5-5

...	...	@@ -8,7 +8,7 @@ test "uint128" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13	13
14	14	var buff: u128 = maxInt(u128);
...	...	@@ -28,7 +28,7 @@ test "undefined 128 bit int" {
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
30	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	31	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
33	33
34	34	@setRuntimeSafety(true);
...	...	@@ -48,7 +48,7 @@ test "int128" {
48	48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
49	49	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
50	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	51	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
52	52	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
53	53
54	54	var buff: i128 = -1;
...	...	@@ -71,7 +71,7 @@ test "truncate int128" {
71	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
72	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
73	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
74		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	74	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75	75	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
76	76
77	77	{
...	...	@@ -95,7 +95,7 @@ test "shift int128" {
95	95	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
96	96	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97	97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	98	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
99	99	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
100	100
101	101	const types = .{ u128, i128 };

test/behavior/int_comparison_elision.zig+1-1

...	...	@@ -17,7 +17,7 @@ test "int comparison elision" {
17	17	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	20	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21	21
22	22	// TODO: panic: integer overflow with int types > 65528 bits wide
23	23	// TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide

test/behavior/lower_strlit_to_vector.zig+1-1

...	...	@@ -6,7 +6,7 @@ test "strlit to vector" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10	10
11	11	const strlit = "0123456789abcdef0123456789ABCDEF";
12	12	const vec_from_strlit: @Vector(32, u8) = strlit.*;

test/behavior/math.zig+42-42

...	...	@@ -66,7 +66,7 @@ test "@clz" {
66	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68	68	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
69		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	69	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
70	70
71	71	try testClz();
72	72	try comptime testClz();
...	...	@@ -84,7 +84,7 @@ test "@clz big ints" {
84	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
85	85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
86	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	87	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
88	88	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
89	89
90	90	try testClzBigInts();
...	...	@@ -105,7 +105,7 @@ test "@clz vectors" {
105	105	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
106	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
107	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	108	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
109	109	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
110	110
111	111	try testClzVectors();
...	...	@@ -151,7 +151,7 @@ test "@ctz" {
151	151	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
152	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
153	153	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
154		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	154	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
155	155
156	156	try testCtz();
157	157	try comptime testCtz();
...	...	@@ -174,7 +174,7 @@ test "@ctz 128-bit integers" {
174	174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
175	175	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
176	176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	177	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
178	178	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
179	179
180	180	try testCtz128();
...	...	@@ -194,7 +194,7 @@ test "@ctz vectors" {
194	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196	196	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
197		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	197	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
198	198
199	199	try testCtzVectors();
200	200	try comptime testCtzVectors();
...	...	@@ -394,7 +394,7 @@ fn not(comptime T: type, a: T) T {
394	394
395	395	test "binary not" {
396	396	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
397		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	397	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
398	398
399	399	try expect(not(u0, 0) == 0);
400	400	try expect(not(u1, 0) == 1);
...	...	@@ -437,7 +437,7 @@ test "binary not big int <= 128 bits" {
437	437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
438	438	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
439	439	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
440		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	440	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
441	441	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
442	442
443	443	try expect(not(u65, 1) == 0x1_FFFFFFFF_FFFFFFFE);
...	...	@@ -472,7 +472,7 @@ test "division" {
472	472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
473	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
474	474	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
475		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	475	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
476	476
477	477	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
478	478	!comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest;
...	...	@@ -594,7 +594,7 @@ test "large integer division" {
594	594	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
595	595	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
596	596	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
597		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	597	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
598	598	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
599	599
600	600	{
...	...	@@ -678,7 +678,7 @@ fn testSignedWrappingEval(x: i32) !void {
678	678	}
679	679
680	680	test "signed negation wrapping" {
681		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	681	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
682	682
683	683	try testSignedNegationWrappingEval(minInt(i16));
684	684	try comptime testSignedNegationWrappingEval(minInt(i16));
...	...	@@ -756,7 +756,7 @@ test "f128" {
756	756	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
757	757	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
758	758	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
759		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	759	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
760	760	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
761	761	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
762	762
...	...	@@ -784,7 +784,7 @@ fn should_not_be_zero(x: f128) !void {
784	784
785	785	test "umax wrapped squaring" {
786	786	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
787		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	787	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
788	788
789	789	{
790	790	var x: u4 = maxInt(u4);
...	...	@@ -842,7 +842,7 @@ test "128-bit multiplication" {
842	842	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
843	843	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
844	844	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
845		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	845	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
846	846	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
847	847	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
848	848	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -897,7 +897,7 @@ test "@addWithOverflow > 64 bits" {
897	897	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
898	898	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
899	899	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
900		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	900	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
901	901
902	902	try testAddWithOverflow(u65, 4, 105, 109, 0);
903	903	try testAddWithOverflow(u65, 1000, 100, 1100, 0);
...	...	@@ -978,7 +978,7 @@ test "extensive @mulWithOverflow" {
978	978	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
979	979	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
980	980	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
981		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	981	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
982	982
983	983	try testMulWithOverflow(u5, 3, 10, 30, 0);
984	984	try testMulWithOverflow(u5, 3, 11, 1, 1);
...	...	@@ -1051,7 +1051,7 @@ test "@mulWithOverflow bitsize 128 bits" {
1051	1051	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1052	1052	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1053	1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1054		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1054	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1055	1055	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1056	1056
1057	1057	try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
...	...	@@ -1076,7 +1076,7 @@ test "@mulWithOverflow bitsize 128 bits" {
1076	1076	test "@mulWithOverflow bitsize 256 bits" {
1077	1077	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1078	1078	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1079		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1079	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1080	1080	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1081	1081	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1082	1082
...	...	@@ -1142,7 +1142,7 @@ test "@subWithOverflow > 64 bits" {
1142	1142	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1143	1143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1144	1144	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1145		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1145	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1146	1146
1147	1147	try testSubWithOverflow(u65, 4, 105, maxInt(u65) - 100, 1);
1148	1148	try testSubWithOverflow(u65, 1000, 100, 900, 0);
...	...	@@ -1188,7 +1188,7 @@ fn testShlWithOverflow(comptime T: type, a: T, b: math.Log2Int(T), shl: T, bit:
1188	1188	test "@shlWithOverflow" {
1189	1189	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1190	1190	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1191		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1191	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1192	1192	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1193	1193
1194	1194	try testShlWithOverflow(u4, 2, 1, 4, 0);
...	...	@@ -1207,7 +1207,7 @@ test "@shlWithOverflow" {
1207	1207	test "@shlWithOverflow > 64 bits" {
1208	1208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1209	1209	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1210		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1210	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1211	1211	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1212	1212
1213	1213	try testShlWithOverflow(u65, 0x0_0100_0000_0000_0000, 7, 0x0_8000_0000_0000_0000, 0);
...	...	@@ -1232,7 +1232,7 @@ test "@shlWithOverflow > 64 bits" {
1232	1232	}
1233	1233
1234	1234	test "overflow arithmetic with u0 values" {
1235		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1235	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1236	1236
1237	1237	{
1238	1238	var a: u0 = 0;
...	...	@@ -1277,7 +1277,7 @@ test "quad hex float literal parsing accurate" {
1277	1277	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1278	1278	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1279	1279	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1280		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1280	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1281	1281	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1282	1282
1283	1283	const a: f128 = 0x1.1111222233334444555566667777p+0;
...	...	@@ -1435,7 +1435,7 @@ test "remainder division" {
1435	1435	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1436	1436	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1437	1437	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1438		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1438	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1439	1439	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1440	1440	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1441	1441	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -1474,7 +1474,7 @@ test "float remainder division using @rem" {
1474	1474	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1475	1475	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1476	1476	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1477		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1477	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1478	1478	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1479	1479	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1480	1480
...	...	@@ -1517,7 +1517,7 @@ test "float modulo division using @mod" {
1517	1517	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1518	1518	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1519	1519	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1520		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1520	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1521	1521	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1522	1522	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1523	1523
...	...	@@ -1589,7 +1589,7 @@ test "@round f80" {
1589	1589	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1590	1590	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1591	1591	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1592		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1592	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1593	1593	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1594	1594	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1595	1595	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -1602,7 +1602,7 @@ test "@round f128" {
1602	1602	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1603	1603	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1604	1604	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1605		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1605	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1606	1606	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
1607	1607	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1608	1608	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -1623,7 +1623,7 @@ test "vector integer addition" {
1623	1623	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1624	1624	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1625	1625	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1626		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1626	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1627	1627	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1628	1628
1629	1629	const S = struct {
...	...	@@ -1645,7 +1645,7 @@ test "NaN comparison" {
1645	1645	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1646	1646	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1647	1647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1648		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1648	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1649	1649	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1650	1650	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1651	1651	if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
...	...	@@ -1664,7 +1664,7 @@ test "NaN comparison f80" {
1664	1664	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1665	1665	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1666	1666	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1667		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1667	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1668	1668	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1669	1669	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1670	1670
...	...	@@ -1690,7 +1690,7 @@ test "vector comparison" {
1690	1690	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1691	1691	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1692	1692	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1693		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1693	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1694	1694
1695	1695	const S = struct {
1696	1696	fn doTheTest() !void {
...	...	@@ -1720,7 +1720,7 @@ test "signed zeros are represented properly" {
1720	1720	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1721	1721	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1722	1722	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1723		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1723	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1724	1724	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1725	1725	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1726	1726
...	...	@@ -1785,7 +1785,7 @@ test "@clz works on both vector and scalar inputs" {
1785	1785	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1786	1786	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1787	1787	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1788		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1788	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1789	1789
1790	1790	var x: u32 = 0x1;
1791	1791	_ = &x;
...	...	@@ -1801,7 +1801,7 @@ test "runtime comparison to NaN is comptime-known" {
1801	1801	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1802	1802	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1803	1803	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1804		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1804	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1805	1805	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1806	1806	if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
1807	1807
...	...	@@ -1831,7 +1831,7 @@ test "runtime int comparison to inf is comptime-known" {
1831	1831	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1832	1832	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1833	1833	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1834		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1834	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1835	1835	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1836	1836	if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
1837	1837
...	...	@@ -1863,7 +1863,7 @@ test "float divide by zero" {
1863	1863	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1864	1864	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1865	1865	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1866		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1866	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1867	1867	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1868	1868
1869	1869	const S = struct {
...	...	@@ -1898,7 +1898,7 @@ test "partially-runtime integer vector division would be illegal if vector eleme
1898	1898	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1899	1899	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1900	1900	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1901		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1901	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1902	1902	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1903	1903	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1904	1904
...	...	@@ -1928,7 +1928,7 @@ test "float vector division of comptime zero by runtime nan is nan" {
1928	1928	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1929	1929	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1930	1930	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1931		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1931	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1932	1932
1933	1933	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
1934	1934	!comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest;
...	...	@@ -1949,7 +1949,7 @@ test "float vector multiplication of comptime zero by runtime nan is nan" {
1949	1949	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1950	1950	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1951	1951	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1952		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1952	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1953	1953
1954	1954	const ct_zero: @Vector(1, f32) = .{0};
1955	1955	var rt_nan: @Vector(1, f32) = .{math.nan(f32)};
...	...	@@ -1966,7 +1966,7 @@ test "comptime float vector division of zero by nan is nan" {
1966	1966	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1967	1967	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1968	1968	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1969		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1969	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1970	1970
1971	1971	const ct_zero: @Vector(1, f32) = .{0};
1972	1972	const ct_nan: @Vector(1, f32) = .{math.nan(f32)};
...	...	@@ -1982,7 +1982,7 @@ test "comptime float vector multiplication of zero by nan is nan" {
1982	1982	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1983	1983	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1984	1984	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1985		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1985	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1986	1986
1987	1987	const ct_zero: @Vector(1, f32) = .{0};
1988	1988	const ct_nan: @Vector(1, f32) = .{math.nan(f32)};

test/behavior/maximum_minimum.zig+4-4

...	...	@@ -33,7 +33,7 @@ test "@max on vectors" {
33	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
34	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35	35	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
36		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	36	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
37	37
38	38	const S = struct {
39	39	fn doTheTest() !void {
...	...	@@ -88,7 +88,7 @@ test "@min for vectors" {
88	88	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
90	90	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
91		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	91	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
92	92
93	93	const S = struct {
94	94	fn doTheTest() !void {
...	...	@@ -119,7 +119,7 @@ test "@min/max for floats" {
119	119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
120	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
121	121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
122		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	122	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
123	123	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
124	124	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
125	125	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
...	...	@@ -317,7 +317,7 @@ test "@min/@max notices bounds from vector types when element of comptime-known
317	317	}
318	318
319	319	test "@min/@max of signed and unsigned runtime integers" {
320		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	320	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
321	321
322	322	var x: i32 = -1;
323	323	var y: u31 = 1;

test/behavior/member_func.zig+2-2

...	...	@@ -30,7 +30,7 @@ test "standard field calls" {
30	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34	34
35	35	try expect(HasFuncs.one(0) == 1);
36	36	try expect(HasFuncs.two(0) == 2);
...	...	@@ -74,7 +74,7 @@ test "@field field calls" {
74	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
75	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
76	76	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
77		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	77	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
78	78
79	79	try expect(@field(HasFuncs, "one")(0) == 1);
80	80	try expect(@field(HasFuncs, "two")(0) == 2);

test/behavior/memcpy.zig+8-8

...	...	@@ -7,7 +7,7 @@ test "memcpy and memset intrinsics" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	try testMemcpyMemset();
13	13	try comptime testMemcpyMemset();
...	...	@@ -29,7 +29,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
29	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
32		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	32	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
33	33
34	34	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
35	35	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
...	...	@@ -50,7 +50,7 @@ test "@memcpy dest many pointer" {
50	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
51	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
52	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
53		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	53	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
54	54
55	55	try testMemcpyDestManyPtr();
56	56	try comptime testMemcpyDestManyPtr();
...	...	@@ -73,7 +73,7 @@ test "@memcpy C pointer" {
73	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
74	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
75	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
76		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	76	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
77	77
78	78	try testMemcpyCPointer();
79	79	try comptime testMemcpyCPointer();
...	...	@@ -94,7 +94,7 @@ test "@memcpy slice" {
94	94	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
95	95	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
96	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
97		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	97	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
98	98
99	99	try testMemcpySlice();
100	100	try comptime testMemcpySlice();
...	...	@@ -137,7 +137,7 @@ test "@memcpy comptime-only type" {
137	137	}
138	138
139	139	test "@memcpy zero-bit type with aliasing" {
140		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	140	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
141	141
142	142	const S = struct {
143	143	fn doTheTest() void {
...	...	@@ -156,7 +156,7 @@ test "@memcpy zero-bit type with aliasing" {
156	156	}
157	157
158	158	test "@memcpy with sentinel" {
159		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	159	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
160	160
161	161	const S = struct {
162	162	fn doTheTest() void {
...	...	@@ -171,7 +171,7 @@ test "@memcpy with sentinel" {
171	171	}
172	172
173	173	test "@memcpy no sentinel source into sentinel destination" {
174		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	174	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
175	175
176	176	const S = struct {
177	177	fn doTheTest() void {

test/behavior/memmove.zig+4-4

...	...	@@ -6,7 +6,7 @@ test "memmove and memset intrinsics" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
...	...	@@ -36,7 +36,7 @@ test "@memmove with both operands single-ptr-to-array, one is null-terminated" {
36	36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
37	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
39		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	39	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40	40	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
41	41	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
42	42	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
...	...	@@ -82,7 +82,7 @@ test "@memmove dest many pointer" {
82	82	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
83	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
84	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
85		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	85	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
86	86	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
87	87	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
88	88	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
...	...	@@ -126,7 +126,7 @@ test "@memmove slice" {
126	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127	127	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128	128	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
129		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	129	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
130	130	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
131	131	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
132	132	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;

test/behavior/memset.zig+9-9

...	...	@@ -6,7 +6,7 @@ test "@memset on array pointers" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10	10
11	11	try testMemsetArray();
12	12	try comptime testMemsetArray();
...	...	@@ -35,7 +35,7 @@ test "@memset on slices" {
35	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
36	36	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
37	37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
38		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	38	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
39	39	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
40	40
41	41	try testMemsetSlice();
...	...	@@ -71,7 +71,7 @@ test "memset with bool element" {
71	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
72	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
73	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
74		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	74	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
75	75
76	76	var buf: [5]bool = undefined;
77	77	@memset(&buf, true);
...	...	@@ -83,7 +83,7 @@ test "memset with 1-byte struct element" {
83	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
84	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
85	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
86		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	86	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
87	87	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
88	88
89	89	const S = struct { x: bool };
...	...	@@ -97,7 +97,7 @@ test "memset with 1-byte array element" {
97	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98	98	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
99	99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
100		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
101	101	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
102	102
103	103	const A = [1]bool;
...	...	@@ -111,7 +111,7 @@ test "memset with large array element, runtime known" {
111	111	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
112	112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
113	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
114		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	114	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
115	115	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
116	116
117	117	const A = [128]u64;
...	...	@@ -130,7 +130,7 @@ test "memset with large array element, comptime known" {
130	130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
131	131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
132	132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
133		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	133	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
134	134	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
135	135
136	136	const A = [128]u64;
...	...	@@ -148,7 +148,7 @@ test "@memset provides result type" {
148	148	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
149	149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
150	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
151		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	151	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
152	152	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
153	153
154	154	const S = struct { x: u32 };
...	...	@@ -167,7 +167,7 @@ test "zero keys with @memset" {
167	167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
168	168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
169	169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
170		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	170	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
171	171
172	172	const Keys = struct {
173	173	up: bool,

test/behavior/muladd.zig+9-9

...	...	@@ -7,7 +7,7 @@ test "@mulAdd" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
13	13	!comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest;
...	...	@@ -39,7 +39,7 @@ test "@mulAdd f16" {
39	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
40	40	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
41	41	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
42		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	42	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
43	43
44	44	try comptime testMulAdd16();
45	45	try testMulAdd16();
...	...	@@ -57,7 +57,7 @@ test "@mulAdd f80" {
57	57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
59	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
60		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	60	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
61	61	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
62	62	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
63	63	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -78,7 +78,7 @@ test "@mulAdd f128" {
78	78	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
79	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
80	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	81	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
82	82	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
83	83	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
84	84	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -115,7 +115,7 @@ test "vector f16" {
115	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116	116	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
117	117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
118		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	118	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
119	119
120	120	try comptime vector16();
121	121	try vector16();
...	...	@@ -140,7 +140,7 @@ test "vector f32" {
140	140	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
141	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
142	142	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
143		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	143	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
144	144
145	145	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
146	146	!comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest;
...	...	@@ -168,7 +168,7 @@ test "vector f64" {
168	168	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
169	169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
170	170	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
171		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	171	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
172	172
173	173	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
174	174	!comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest;
...	...	@@ -194,7 +194,7 @@ test "vector f80" {
194	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195	195	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
196	196	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
197		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	197	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
198	198	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
199	199	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
200	200	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -221,7 +221,7 @@ test "vector f128" {
221	221	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
222	222	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
223	223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	224	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
225	225	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
226	226	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
227	227	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

test/behavior/multiple_externs_with_conflicting_types.zig+1-1

...	...	@@ -14,7 +14,7 @@ test "call extern function defined with conflicting type" {
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
18	18	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
20	20

test/behavior/namespace_depends_on_compile_var.zig+1-1

...	...	@@ -3,7 +3,7 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4
5	5	test "namespace depends on compile var" {
6		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8	8
9	9	if (some_namespace.a_bool) {

test/behavior/nan.zig+1-1

...	...	@@ -25,7 +25,7 @@ test "nan memory equality" {
25	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
26	26	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
27	27	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
28		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
29	29
30	30	// signaled
31	31	try testing.expect(mem.eql(u8, mem.asBytes(&snan_u16), mem.asBytes(&snan_f16)));

test/behavior/null.zig+1-1

...	...	@@ -131,7 +131,7 @@ test "null with default unwrap" {
131	131
132	132	test "optional pointer to 0 bit type null value at runtime" {
133	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
134		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	134	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
135	135
136	136	const EmptyStruct = struct {};
137	137	var x: ?*EmptyStruct = null;

test/behavior/optional.zig+15-15

...	...	@@ -28,7 +28,7 @@ pub const EmptyStruct = struct {};
28	28
29	29	test "optional pointer to size zero struct" {
30	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	31	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
32	32
33	33	var e = EmptyStruct{};
34	34	const o: ?*EmptyStruct = &e;
...	...	@@ -36,7 +36,7 @@ test "optional pointer to size zero struct" {
36	36	}
37	37
38	38	test "equality compare optional pointers" {
39		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	39	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40	40
41	41	try testNullPtrsEql();
42	42	try comptime testNullPtrsEql();
...	...	@@ -60,7 +60,7 @@ fn testNullPtrsEql() !void {
60	60
61	61	test "optional with zero-bit type" {
62	62	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
63		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	63	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
64	64
65	65	const S = struct {
66	66	fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {
...	...	@@ -114,7 +114,7 @@ test "address of unwrap optional" {
114	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
115	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
116	116	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
117		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	117	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
118	118
119	119	const S = struct {
120	120	const Foo = struct {
...	...	@@ -238,7 +238,7 @@ test "compare optionals with modified payloads" {
238	238
239	239	test "unwrap function call with optional pointer return value" {
240	240	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
241		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	241	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
242	242	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243	243
244	244	const S = struct {
...	...	@@ -287,7 +287,7 @@ test "nested orelse" {
287	287	test "self-referential struct through a slice of optional" {
288	288	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
289	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	290	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
291	291
292	292	const S = struct {
293	293	const Node = struct {
...	...	@@ -323,7 +323,7 @@ test "coerce an anon struct literal to optional struct" {
323	323	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
324	324	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
325	325	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
326		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	326	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
327	327
328	328	const S = struct {
329	329	const Struct = struct {
...	...	@@ -367,7 +367,7 @@ test "0-bit child type coerced to optional return ptr result location" {
367	367
368	368	test "0-bit child type coerced to optional" {
369	369	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
370		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	370	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
371	371
372	372	const S = struct {
373	373	fn doTheTest() !void {
...	...	@@ -395,7 +395,7 @@ test "array of optional unaligned types" {
395	395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
396	396	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
397	397	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
398		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	398	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
399	399
400	400	const Enum = enum { one, two, three };
401	401
...	...	@@ -451,7 +451,7 @@ test "optional pointer to zero bit error union payload" {
451	451	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
452	452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
453	453	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
454		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	454	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
455	455	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
456	456
457	457	const B = struct {
...	...	@@ -528,7 +528,7 @@ test "alignment of wrapping an optional payload" {
528	528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
529	529	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
530	530	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
531		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	531	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
532	532	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
533	533
534	534	const S = struct {
...	...	@@ -547,7 +547,7 @@ test "Optional slice size is optimized" {
547	547	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
548	548	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
549	549	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
550		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	550	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
551	551
552	552	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
553	553	var a: ?[]const u8 = null;
...	...	@@ -560,7 +560,7 @@ test "Optional slice passed to function" {
560	560	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
561	561	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
562	562	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
563		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	563	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
564	564
565	565	const S = struct {
566	566	fn foo(a: ?[]const u8) !void {
...	...	@@ -603,7 +603,7 @@ test "peer type resolution in nested if expressions" {
603	603	test "cast slice to const slice nested in error union and optional" {
604	604	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
605	605	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
606		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	606	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
607	607	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
608	608
609	609	const S = struct {
...	...	@@ -641,7 +641,7 @@ test "result location initialization of optional with OPV payload" {
641	641	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
642	642	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
643	643	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
644		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	644	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
645	645
646	646	const S = struct {
647	647	x: u0,

test/behavior/packed-struct.zig+27-27

...	...	@@ -235,7 +235,7 @@ test "regular in irregular packed struct" {
235	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
236	236	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
237	237	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	238	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239	239
240	240	const Irregular = packed struct {
241	241	bar: Regular = Regular{},
...	...	@@ -326,7 +326,7 @@ test "byte-aligned field pointer offsets" {
326	326	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
327	327	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
328	328	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
329		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	329	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
330	330
331	331	const S = struct {
332	332	const A = packed struct {
...	...	@@ -427,7 +427,7 @@ test "nested packed struct field pointers" {
427	427	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
428	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
429	429	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
430		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	430	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
431	431	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // ubsan unaligned pointer access
432	432	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
433	433
...	...	@@ -465,7 +465,7 @@ test "load pointer from packed struct" {
465	465	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
466	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
467	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
468		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	468	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
469	469	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
470	470
471	471	const A = struct {
...	...	@@ -486,7 +486,7 @@ test "@intFromPtr on a packed struct field" {
486	486	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
487	487	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
488	488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
489		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	489	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
490	490	if (native_endian != .little) return error.SkipZigTest;
491	491
492	492	const S = struct {
...	...	@@ -509,7 +509,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {
509	509	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
510	510	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
511	511	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
512		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	512	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
513	513	if (native_endian != .little) return error.SkipZigTest; // Byte aligned packed struct field pointers have not been implemented yet
514	514
515	515	const S1 = packed struct {
...	...	@@ -619,7 +619,7 @@ test "packed struct fields modification" {
619	619	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
620	620
621	621	// Originally reported at https://github.com/ziglang/zig/issues/16615
622		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	622	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
623	623
624	624	const Small = packed struct {
625	625	val: u8 = 0,
...	...	@@ -645,7 +645,7 @@ test "optional pointer in packed struct" {
645	645	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
646	646	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647	647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
648		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	648	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
649	649	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
650	650
651	651	const T = packed struct { ptr: ?*const u8 };
...	...	@@ -660,7 +660,7 @@ test "nested packed struct field access test" {
660	660	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
661	661	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
662	662	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
663		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	663	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
664	664	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
665	665	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
666	666
...	...	@@ -778,7 +778,7 @@ test "nested packed struct field access test" {
778	778
779	779	test "nested packed struct at non-zero offset" {
780	780	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
781		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	781	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
782	782
783	783	const Pair = packed struct(u24) {
784	784	a: u16 = 0,
...	...	@@ -809,7 +809,7 @@ test "nested packed struct at non-zero offset 2" {
809	809	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
810	810	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
811	811	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
812		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	812	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
813	813	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO packed structs larger than 64 bits
814	814	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
815	815	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...	...	@@ -876,7 +876,7 @@ test "runtime init of unnamed packed struct type" {
876	876	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
877	877	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
878	878	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
879		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	879	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
880	880
881	881	var z: u8 = 123;
882	882	_ = &z;
...	...	@@ -918,7 +918,7 @@ test "overaligned pointer to packed struct" {
918	918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
919	919	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
920	920	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
921		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	921	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
922	922
923	923	const S = packed struct { a: u32, b: u32 };
924	924	var foo: S align(4) = .{ .a = 123, .b = 456 };
...	...	@@ -953,7 +953,7 @@ test "pointer to container level packed struct field" {
953	953	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
954	954	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
955	955	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
956		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	956	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
957	957
958	958	const S = packed struct(u32) {
959	959	test_bit: bool,
...	...	@@ -997,7 +997,7 @@ test "bitcast back and forth" {
997	997
998	998	test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
999	999	// Originally reported at https://github.com/ziglang/zig/issues/14200
1000		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1000	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1001	1001
1002	1002	const S = struct {
1003	1003	ps: packed struct { x: i2, y: i2 },
...	...	@@ -1018,7 +1018,7 @@ test "modify nested packed struct aligned field" {
1018	1018	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1019	1019	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1020	1020	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1021		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1021	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1022	1022
1023	1023	const Options = packed struct {
1024	1024	foo: bool = false,
...	...	@@ -1047,7 +1047,7 @@ test "assigning packed struct inside another packed struct" {
1047	1047	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1048	1048
1049	1049	// Originally reported at https://github.com/ziglang/zig/issues/9674
1050		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1050	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1051	1051
1052	1052	const S = struct {
1053	1053	const Inner = packed struct {
...	...	@@ -1079,7 +1079,7 @@ test "packed struct used as part of anon decl name" {
1079	1079	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1080	1080	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1081	1081	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1082		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1082	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1083	1083
1084	1084	const S = packed struct { a: u0 = 0 };
1085	1085	var a: u8 = 0;
...	...	@@ -1133,7 +1133,7 @@ test "pointer loaded correctly from packed struct" {
1133	1133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1134	1134	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1135	1135	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1136		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1136	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1137	1137
1138	1138	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // crashes MSVC
1139	1139
...	...	@@ -1146,7 +1146,7 @@ test "pointer loaded correctly from packed struct" {
1146	1146	test "assignment to non-byte-aligned field in packed struct" {
1147	1147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1148	1148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1149		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1149	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1150	1150
1151	1151	const Frame = packed struct {
1152	1152	num: u20,
...	...	@@ -1167,7 +1167,7 @@ test "packed struct field pointer aligned properly" {
1167	1167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1168	1168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1169	1169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1170		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1170	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1171	1171
1172	1172	const Foo = packed struct {
1173	1173	a: i32,
...	...	@@ -1186,7 +1186,7 @@ test "load flag from packed struct in union" {
1186	1186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1187	1187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1188	1188	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1189		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1189	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1190	1190	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1191	1191
1192	1192	const A = packed struct {
...	...	@@ -1255,7 +1255,7 @@ test "2-byte packed struct argument in C calling convention" {
1255	1255	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1256	1256	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
1257	1257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1258		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1258	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1259	1259
1260	1260	const S = packed struct(u16) {
1261	1261	x: u15 = 0,
...	...	@@ -1309,7 +1309,7 @@ test "packed struct equality" {
1309	1309
1310	1310	test "packed struct equality ignores padding bits" {
1311	1311	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1312		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1312	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1313	1313
1314	1314	const S = packed struct { b: bool };
1315	1315	var s: S = undefined;
...	...	@@ -1331,7 +1331,7 @@ test "packed struct with signed field" {
1331	1331	test "assign packed struct initialized with RLS to packed struct literal field" {
1332	1332	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isWasm()) return error.SkipZigTest;
1333	1333	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1334		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1334	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1335	1335
1336	1336	const Inner = packed struct { x: u17 };
1337	1337	const Outer = packed struct { inner: Inner, x: u15 };
...	...	@@ -1348,7 +1348,7 @@ test "assign packed struct initialized with RLS to packed struct literal field"
1348	1348	test "byte-aligned packed relocation" {
1349	1349	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1350	1350	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1351		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1351	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1352	1352	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1353	1353
1354	1354	const S = struct {
...	...	@@ -1360,7 +1360,7 @@ test "byte-aligned packed relocation" {
1360	1360	}
1361	1361
1362	1362	test "packed struct store of comparison result" {
1363		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1363	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1364	1364
1365	1365	const S1 = packed struct {
1366	1366	val1: u3,

test/behavior/packed-union.zig+3-3

...	...	@@ -7,7 +7,7 @@ test "flags in packed union" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	try testFlagsInPackedUnion();
13	13	try comptime testFlagsInPackedUnion();
...	...	@@ -49,7 +49,7 @@ test "flags in packed union at offset" {
49	49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
50	50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
51	51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
52		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	52	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
53	53
54	54	try testFlagsInPackedUnionAtOffset();
55	55	try comptime testFlagsInPackedUnionAtOffset();
...	...	@@ -101,7 +101,7 @@ test "packed union in packed struct" {
101	101	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
102	102
103	103	// Originally reported at https://github.com/ziglang/zig/issues/16581
104		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	104	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
105	105
106	106	try testPackedUnionInPackedStruct();
107	107	try comptime testPackedUnionInPackedStruct();

test/behavior/pointers.zig+26-26

...	...	@@ -21,7 +21,7 @@ test "pointer-integer arithmetic" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	24	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
25	25
26	26	var ptr: [*]const u8 = "abcd";
27	27
...	...	@@ -46,7 +46,7 @@ test "pointer-integer arithmetic" {
46	46
47	47	test "pointer subtraction" {
48	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
50	50
51	51	{
52	52	const a: *u8 = @ptrFromInt(100);
...	...	@@ -101,7 +101,7 @@ test "pointer subtraction" {
101	101	}
102	102
103	103	test "pointer arithmetic with non-trivial RHS" {
104		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	104	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
105	105
106	106	var t: bool = undefined;
107	107	t = true;
...	...	@@ -127,7 +127,7 @@ fn PtrOf(comptime T: type) type {
127	127
128	128	test "implicit cast single item pointer to C pointer and back" {
129	129	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
130		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	130	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
131	131
132	132	var y: u8 = 11;
133	133	const x: [*c]u8 = &y;
...	...	@@ -144,7 +144,7 @@ test "initialize const optional C pointer to null" {
144	144
145	145	test "assigning integer to C pointer" {
146	146	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
147		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	147	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
148	148
149	149	var x: i32 = 0;
150	150	var y: i32 = 1;
...	...	@@ -162,7 +162,7 @@ test "assigning integer to C pointer" {
162	162
163	163	test "C pointer comparison and arithmetic" {
164	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
165		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	165	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
166	166
167	167	const S = struct {
168	168	fn doTheTest() !void {
...	...	@@ -206,7 +206,7 @@ fn testDerefPtrOneVal() !void {
206	206	}
207	207
208	208	test "peer type resolution with C pointers" {
209		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	209	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
210	210
211	211	const ptr_one: *u8 = undefined;
212	212	const ptr_many: [*]u8 = undefined;
...	...	@@ -235,7 +235,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
235	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
236	236	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
237	237	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
238		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	238	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239	239
240	240	var slice: []const u8 = "aoeu";
241	241	_ = &slice;
...	...	@@ -251,7 +251,7 @@ test "implicit cast error unions with non-optional to optional pointer" {
251	251	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
252	252	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
253	253	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
254		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	254	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
255	255	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
256	256
257	257	const S = struct {
...	...	@@ -280,7 +280,7 @@ test "allowzero pointer and slice" {
280	280	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
281	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
282	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	283	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
284	284
285	285	var ptr: [*]allowzero i32 = @ptrFromInt(0);
286	286	const opt_ptr: ?[*]allowzero i32 = ptr;
...	...	@@ -300,7 +300,7 @@ test "assign null directly to C pointer and test null equality" {
300	300	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
301	301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
302	302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
303		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	303	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
304	304
305	305	var x: [*c]i32 = null;
306	306	_ = &x;
...	...	@@ -368,7 +368,7 @@ test "array initialization types" {
368	368	test "null terminated pointer" {
369	369	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
370	370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
371		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	371	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
372	372
373	373	const S = struct {
374	374	fn doTheTest() !void {
...	...	@@ -387,7 +387,7 @@ test "allow any sentinel" {
387	387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
388	388	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
389	389	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
390		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	390	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
391	391
392	392	const S = struct {
393	393	fn doTheTest() !void {
...	...	@@ -404,7 +404,7 @@ test "pointer sentinel with enums" {
404	404	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
405	405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
406	406	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
407		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	407	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
408	408
409	409	const S = struct {
410	410	const Number = enum {
...	...	@@ -428,7 +428,7 @@ test "pointer sentinel with optional element" {
428	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
429	429	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
430	430	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
431		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	431	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
432	432
433	433	const S = struct {
434	434	fn doTheTest() !void {
...	...	@@ -446,7 +446,7 @@ test "pointer sentinel with +inf" {
446	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
447	447	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
448	448	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
449		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	449	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
450	450
451	451	const S = struct {
452	452	fn doTheTest() !void {
...	...	@@ -468,7 +468,7 @@ test "pointer to array at fixed address" {
468	468	}
469	469
470	470	test "pointer-integer arithmetic affects the alignment" {
471		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	471	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
472	472
473	473	{
474	474	var ptr: [*]align(8) u32 = undefined;
...	...	@@ -518,7 +518,7 @@ test "indexing array with sentinel returns correct type" {
518	518	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
519	519	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
520	520	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
521		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	521	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
522	522
523	523	var s: [:0]const u8 = "abc";
524	524	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
...	...	@@ -527,7 +527,7 @@ test "indexing array with sentinel returns correct type" {
527	527	test "element pointer to slice" {
528	528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
529	529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
530		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	530	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
531	531
532	532	const S = struct {
533	533	fn doTheTest() !void {
...	...	@@ -550,7 +550,7 @@ test "element pointer to slice" {
550	550	test "element pointer arithmetic to slice" {
551	551	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
552	552	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
553		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	553	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
554	554
555	555	const S = struct {
556	556	fn doTheTest() !void {
...	...	@@ -575,7 +575,7 @@ test "element pointer arithmetic to slice" {
575	575
576	576	test "array slicing to slice" {
577	577	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
578		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	578	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
579	579
580	580	const S = struct {
581	581	fn doTheTest() !void {
...	...	@@ -606,7 +606,7 @@ test "ptrCast comptime known slice to C pointer" {
606	606	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
607	607	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
608	608	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
609		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	609	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
610	610
611	611	const s: [:0]const u8 = "foo";
612	612	var p: [*c]const u8 = @ptrCast(s);
...	...	@@ -626,7 +626,7 @@ test "pointer alignment and element type include call expression" {
626	626
627	627	test "pointer to array has explicit alignment" {
628	628	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
629		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	629	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
630	630
631	631	const S = struct {
632	632	const Base = extern struct { a: u8 };
...	...	@@ -703,7 +703,7 @@ fn constant() !void {
703	703
704	704	test "pointer-to-array constness for zero-size elements, var" {
705	705	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
706		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	706	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
707	707
708	708	try mutable();
709	709	try comptime mutable();
...	...	@@ -762,7 +762,7 @@ test "comptime pointer equality through distinct elements with well-defined layo
762	762	}
763	763
764	764	test "pointers to elements of slice of zero-bit type" {
765		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	765	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
766	766
767	767	var slice: []const u0 = undefined;
768	768	slice = &.{ 0, 0 };
...	...	@@ -774,7 +774,7 @@ test "pointers to elements of slice of zero-bit type" {
774	774	}
775	775
776	776	test "pointers to elements of many-ptr to zero-bit type" {
777		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	777	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
778	778
779	779	var many_ptr: [*]const u0 = undefined;
780	780	many_ptr = &.{ 0, 0 };

test/behavior/popcount.zig+3-3

...	...	@@ -7,7 +7,7 @@ test "@popCount integers" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	try comptime testPopCountIntegers();
13	13	try testPopCountIntegers();
...	...	@@ -17,7 +17,7 @@ test "@popCount 128bit integer" {
17	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	20	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
21	21	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
22	22
23	23	comptime {
...	...	@@ -80,7 +80,7 @@ test "@popCount vectors" {
80	80	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
81	81	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
82	82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
83		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	83	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
84	84	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
85	85
86	86	try comptime testPopCountVectors();

test/behavior/prefetch.zig+1-1

...	...	@@ -2,7 +2,7 @@ const builtin = @import("builtin");
2	2	const std = @import("std");
3	3
4	4	test "@prefetch()" {
5		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	5	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/134624
7	7
8	8	var a: [2]u32 = .{ 42, 42 };

test/behavior/ptrcast.zig+16-16

...	...	@@ -24,7 +24,7 @@ test "reinterpret an array over multiple elements, with no well-defined layout"
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	27	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
28	28
29	29	try testReinterpretWithOffsetAndNoWellDefinedLayout();
30	30	try comptime testReinterpretWithOffsetAndNoWellDefinedLayout();
...	...	@@ -58,7 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
58	58	test "reinterpret bytes of an array into an extern struct" {
59	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
60	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
61		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	61	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
62	62
63	63	try testReinterpretBytesAsExternStruct();
64	64	try comptime testReinterpretBytesAsExternStruct();
...	...	@@ -175,7 +175,7 @@ test "lower reinterpreted comptime field ptr" {
175	175	test "reinterpret struct field at comptime" {
176	176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177	177	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
178		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	178	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
179	179
180	180	const numNative = comptime Bytes.init(0x12345678);
181	181	if (native_endian != .little) {
...	...	@@ -233,7 +233,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
233	233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
234	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
236		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	236	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
237	237
238	238	var buf: [4]u8 = "aoeu".*;
239	239	const x: ?[*]u8 = &buf;
...	...	@@ -246,7 +246,7 @@ test "@ptrCast slice to slice" {
246	246	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
247	247	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
248	248	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
249		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	249	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
250	250
251	251	const S = struct {
252	252	fn foo(slice: []u32) []i32 {
...	...	@@ -356,7 +356,7 @@ test "@ptrCast slice multiplying length" {
356	356	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
357	357	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
358	358	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
359		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	359	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
360	360
361	361	const S = struct {
362	362	fn doTheTest(zero: u32) !void {
...	...	@@ -374,7 +374,7 @@ test "@ptrCast array pointer to slice multiplying length" {
374	374	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
375	375	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
376	376	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
377		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	377	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
378	378
379	379	const S = struct {
380	380	fn doTheTest(zero: u32) !void {
...	...	@@ -392,7 +392,7 @@ test "@ptrCast slice dividing length" {
392	392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
393	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
394	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	395	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
396	396
397	397	const S = struct {
398	398	fn doTheTest(zero: u8) !void {
...	...	@@ -410,7 +410,7 @@ test "@ptrCast array pointer to slice dividing length" {
410	410	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
411	411	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
412	412	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
413		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	413	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
414	414
415	415	const S = struct {
416	416	fn doTheTest(zero: u8) !void {
...	...	@@ -428,7 +428,7 @@ test "@ptrCast slice with complex length increase" {
428	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
429	429	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
430	430	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
431		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	431	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
432	432
433	433	const TwoBytes = [2]u8;
434	434	const ThreeBytes = [3]u8;
...	...	@@ -449,7 +449,7 @@ test "@ptrCast array pointer to slice with complex length increase" {
449	449	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
450	450	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
451	451	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
452		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	452	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
453	453
454	454	const TwoBytes = [2]u8;
455	455	const ThreeBytes = [3]u8;
...	...	@@ -470,7 +470,7 @@ test "@ptrCast slice with complex length decrease" {
470	470	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
471	471	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
472	472	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
473		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	473	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
474	474
475	475	const TwoBytes = [2]u8;
476	476	const ThreeBytes = [3]u8;
...	...	@@ -491,7 +491,7 @@ test "@ptrCast array pointer to slice with complex length decrease" {
491	491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
492	492	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
493	493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
494		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	494	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
495	495
496	496	const TwoBytes = [2]u8;
497	497	const ThreeBytes = [3]u8;
...	...	@@ -512,7 +512,7 @@ test "@ptrCast slice of zero-bit type to different slice" {
512	512	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
513	513	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
514	514	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
515		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	515	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
516	516
517	517	const S = struct {
518	518	fn doTheTest(comptime T: type, zero_bits: []const T) !void {
...	...	@@ -532,7 +532,7 @@ test "@ptrCast single-item pointer to slice with length 1" {
532	532	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
533	533	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
534	534	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
535		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	535	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
536	536	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
537	537
538	538	const S = struct {
...	...	@@ -554,7 +554,7 @@ test "@ptrCast single-item pointer to slice of bytes" {
554	554	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
555	555	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
556	556	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
557		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	557	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
558	558	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
559	559
560	560	const S = struct {

test/behavior/ptrfromint.zig+3-3

...	...	@@ -3,7 +3,7 @@ const builtin = @import("builtin");
3	3	const expectEqual = std.testing.expectEqual;
4	4
5	5	test "casting integer address to function pointer" {
6		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7	7
8	8	addressToFunction();
9	9	comptime addressToFunction();
...	...	@@ -19,7 +19,7 @@ test "mutate through ptr initialized with constant ptrFromInt value" {
19	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
20	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	22	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
23	23
24	24	forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
25	25	}
...	...	@@ -37,7 +37,7 @@ test "@ptrFromInt creates null pointer" {
37	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
40		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	40	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
41	41
42	42	const ptr = @as(?*u32, @ptrFromInt(0));
43	43	try expectEqual(@as(?*u32, null), ptr);

test/behavior/pub_enum.zig+2-2

...	...	@@ -3,7 +3,7 @@ const other = @import("pub_enum/other.zig");
3	3	const expect = @import("std").testing.expect;
4	4
5	5	test "pub enum" {
6		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	6	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
8	8
9	9	try pubEnumTest(other.APubEnum.Two);
...	...	@@ -13,7 +13,7 @@ fn pubEnumTest(foo: other.APubEnum) !void {
13	13	}
14	14
15	15	test "cast with imported symbol" {
16		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
18	18
19	19	try expect(@as(other.size_t, 42) == 42);

test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1-1

...	...	@@ -8,7 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12	12
13	13	try foo(true, Num.Two, false, "aoeu");
14	14	try expect(!ok);

test/behavior/return_address.zig+1-1

...	...	@@ -9,7 +9,7 @@ test "return address" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13	13
14	14	_ = retAddr();
15	15	// TODO: #14938

test/behavior/saturating_arithmetic.zig+10-10

...	...	@@ -8,7 +8,7 @@ test "saturating add" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
13	13
14	14	const S = struct {
...	...	@@ -56,7 +56,7 @@ test "saturating add 128bit" {
56	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57	57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	59	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
60	60	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
61	61	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
62	62
...	...	@@ -83,7 +83,7 @@ test "saturating subtraction" {
83	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
84	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
85	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
86		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	86	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
87	87	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
88	88
89	89	const S = struct {
...	...	@@ -130,7 +130,7 @@ test "saturating subtraction 128bit" {
130	130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
131	131	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
132	132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	133	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
134	134	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
135	135	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
136	136
...	...	@@ -163,7 +163,7 @@ test "saturating multiplication <= 32 bits" {
163	163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
164	164	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
165	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
166		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	166	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
167	167	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
168	168	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
169	169
...	...	@@ -232,7 +232,7 @@ test "saturating multiplication <= 32 bits" {
232	232
233	233	test "saturating mul i64, i128" {
234	234	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
235		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	235	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
236	236	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
237	237
238	238	try testSatMul(i64, 0, maxInt(i64), 0);
...	...	@@ -263,7 +263,7 @@ test "saturating multiplication" {
263	263	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
264	264	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
265	265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	266	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
267	267	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
268	268	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
269	269	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
...	...	@@ -302,7 +302,7 @@ test "saturating shift-left" {
302	302	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
303	303	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
304	304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
305		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	305	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
306	306	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
307	307	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
308	308
...	...	@@ -347,7 +347,7 @@ test "saturating shift-left" {
347	347	test "saturating shift-left large rhs" {
348	348	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
349	349	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
350		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	350	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
351	351	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
352	352	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
353	353
...	...	@@ -366,7 +366,7 @@ test "saturating shl uses the LHS type" {
366	366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
367	367	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
368	368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
369		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	369	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
370	370	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
371	371	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
372	372

test/behavior/select.zig+2-2

...	...	@@ -9,7 +9,7 @@ test "@select vectors" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13	13
14	14	try comptime selectVectors();
15	15	try selectVectors();
...	...	@@ -40,7 +40,7 @@ test "@select arrays" {
40	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
41	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42	42	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
43		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	43	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
44	44
45	45	try comptime selectArrays();
46	46	try selectArrays();

test/behavior/shuffle.zig+4-4

...	...	@@ -9,7 +9,7 @@ test "@shuffle int" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13	13
14	14	const S = struct {
15	15	fn doTheTest() !void {
...	...	@@ -55,7 +55,7 @@ test "@shuffle int strange sizes" {
55	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57	57	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
58		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	58	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
59	59
60	60	try comptime testShuffle(2, 2, 2);
61	61	try testShuffle(2, 2, 2);
...	...	@@ -137,7 +137,7 @@ test "@shuffle bool 1" {
137	137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
138	138	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
139	139	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
140		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	140	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
141	141
142	142	const S = struct {
143	143	fn doTheTest() !void {
...	...	@@ -160,7 +160,7 @@ test "@shuffle bool 2" {
160	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
161	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
163		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	163	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
164	164
165	165	const S = struct {
166	166	fn doTheTest() !void {

test/behavior/sizeof_and_typeof.zig+4-4

...	...	@@ -80,7 +80,7 @@ const P = packed struct {
80	80
81	81	test "@offsetOf" {
82	82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
83		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	83	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
84	84
85	85	// Packed structs have fixed memory layout
86	86	try expect(@offsetOf(P, "a") == 0);
...	...	@@ -233,7 +233,7 @@ test "@sizeOf comparison against zero" {
233	233	}
234	234
235	235	test "hardcoded address in typeof expression" {
236		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	236	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
237	237
238	238	const S = struct {
239	239	fn func() @TypeOf(@as([]u8, @ptrFromInt(0x10)).[0]) {
...	...	@@ -328,7 +328,7 @@ test "lazy abi size used in comparison" {
328	328	test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
329	329	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
330	330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
331		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	331	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
332	332
333	333	const T = struct {
334	334	next: @TypeOf(null, @as(*const @This(), undefined)),
...	...	@@ -386,7 +386,7 @@ comptime {
386	386	}
387	387
388	388	test "Extern function calls in @TypeOf" {
389		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	389	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
390	390
391	391	const S = extern struct {
392	392	state: c_short,

test/behavior/slice.zig+34-34

...	...	@@ -30,7 +30,7 @@ comptime {
30	30
31	31	test "slicing" {
32	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34	34
35	35	var array: [20]i32 = undefined;
36	36
...	...	@@ -78,7 +78,7 @@ fn assertLenIsZero(msg: []const u8) !void {
78	78
79	79	test "access len index of sentinel-terminated slice" {
80	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	81	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
82	82
83	83	const S = struct {
84	84	fn doTheTest() !void {
...	...	@@ -102,7 +102,7 @@ test "comptime slice of slice preserves comptime var" {
102	102
103	103	test "open slice of open slice with sentinel" {
104	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	105	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
106	106
107	107	var slice: [:0]const u8 = "hello";
108	108	_ = &slice;
...	...	@@ -120,7 +120,7 @@ test "open slice of open slice with sentinel" {
120	120
121	121	test "open slice with sentinel of slice with end index" {
122	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
123		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	123	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
124	124
125	125	var slice: [:0]const u8 = "hello";
126	126	_ = &slice;
...	...	@@ -173,7 +173,7 @@ fn memFree(comptime T: type, memory: []T) void {
173	173	}
174	174
175	175	test "slice of hardcoded address to pointer" {
176		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	176	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
177	177
178	178	const S = struct {
179	179	fn doTheTest() !void {
...	...	@@ -213,7 +213,7 @@ test "comptime pointer cast array and then slice" {
213	213	test "slicing zero length array" {
214	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
215	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	216	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
217	217
218	218	const s1 = ""[0..];
219	219	const s2 = ([_]u32{})[0..];
...	...	@@ -224,7 +224,7 @@ test "slicing zero length array" {
224	224	}
225	225
226	226	test "slicing pointer by length" {
227		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	227	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
228	228
229	229	const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
230	230	const ptr: []const u8 = @as([]const u8, @ptrCast(&array));
...	...	@@ -247,7 +247,7 @@ test "compile time slice of pointer to hard coded address" {
247	247	}
248	248
249	249	test "slice string literal has correct type" {
250		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	250	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
251	251
252	252	comptime {
253	253	try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
...	...	@@ -276,7 +276,7 @@ test "runtime safety lets us slice from len..len" {
276	276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277	277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
278	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
279		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	279	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
280	280
281	281	var an_array = [_]u8{ 1, 2, 3 };
282	282	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
...	...	@@ -289,7 +289,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
289	289	test "C pointer" {
290	290	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
291	291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
292		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	292	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
293	293
294	294	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
295	295	var len: u32 = 10;
...	...	@@ -302,7 +302,7 @@ test "C pointer slice access" {
302	302	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
303	303	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
304	304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
305		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	305	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
306	306
307	307	var buf: [10]u32 = [1]u32{42} ** 10;
308	308	const c_ptr = @as([*c]const u32, @ptrCast(&buf));
...	...	@@ -333,7 +333,7 @@ fn sliceSum(comptime q: []const u8) i32 {
333	333	test "slice type with custom alignment" {
334	334	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
335	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
336		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	336	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
337	337
338	338	const LazilyResolvedType = struct {
339	339	anything: i32,
...	...	@@ -347,7 +347,7 @@ test "slice type with custom alignment" {
347	347
348	348	test "obtaining a null terminated slice" {
349	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	350	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
351	351
352	352	// here we have a normal array
353	353	var buf: [50]u8 = undefined;
...	...	@@ -392,7 +392,7 @@ test "empty array to slice" {
392	392	test "@ptrCast slice to pointer" {
393	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
394	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	395	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
396	396
397	397	const S = struct {
398	398	fn doTheTest() !void {
...	...	@@ -409,7 +409,7 @@ test "@ptrCast slice to pointer" {
409	409
410	410	test "slice multi-pointer without end" {
411	411	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
412		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	412	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
413	413
414	414	const S = struct {
415	415	fn doTheTest() !void {
...	...	@@ -448,7 +448,7 @@ test "slice syntax resulting in pointer-to-array" {
448	448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
449	449	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
450	450	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
451		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	451	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
452	452
453	453	const S = struct {
454	454	fn doTheTest() !void {
...	...	@@ -667,7 +667,7 @@ test "slice syntax resulting in pointer-to-array" {
667	667	test "slice pointer-to-array null terminated" {
668	668	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
669	669	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
670		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	670	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
671	671
672	672	comptime {
673	673	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
...	...	@@ -686,7 +686,7 @@ test "slice pointer-to-array null terminated" {
686	686
687	687	test "slice pointer-to-array zero length" {
688	688	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
689		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	689	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
690	690
691	691	comptime {
692	692	{
...	...	@@ -721,7 +721,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
721	721	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
722	722	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
723	723	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
724		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	724	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
725	725
726	726	const S = struct {
727	727	const U = union {
...	...	@@ -778,7 +778,7 @@ test "array mult of slice gives ptr to array" {
778	778
779	779	test "slice bounds in comptime concatenation" {
780	780	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
781		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	781	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
782	782
783	783	const bs = comptime blk: {
784	784	const b = "........1........";
...	...	@@ -814,7 +814,7 @@ test "slice sentinel access at comptime" {
814	814	test "slicing array with sentinel as end index" {
815	815	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
816	816	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
817		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	817	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
818	818
819	819	const S = struct {
820	820	fn do() !void {
...	...	@@ -833,7 +833,7 @@ test "slicing array with sentinel as end index" {
833	833	test "slicing slice with sentinel as end index" {
834	834	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
835	835	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
836		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	836	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
837	837
838	838	const S = struct {
839	839	fn do() !void {
...	...	@@ -891,7 +891,7 @@ test "global slice field access" {
891	891	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
892	892	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
893	893	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
894		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	894	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
895	895
896	896	const S = struct {
897	897	var slice: []const u8 = undefined;
...	...	@@ -903,7 +903,7 @@ test "global slice field access" {
903	903	}
904	904
905	905	test "slice of void" {
906		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	906	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
907	907
908	908	var n: usize = 10;
909	909	_ = &n;
...	...	@@ -913,7 +913,7 @@ test "slice of void" {
913	913	}
914	914
915	915	test "slice with dereferenced value" {
916		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	916	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
917	917
918	918	var a: usize = 0;
919	919	const idx: *usize = &a;
...	...	@@ -930,7 +930,7 @@ test "slice with dereferenced value" {
930	930
931	931	test "empty slice ptr is non null" {
932	932	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO
933		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test assumes `undefined` is non-zero
	933	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // Test assumes `undefined` is non-zero
934	934
935	935	{
936	936	const empty_slice: []u8 = &[_]u8{};
...	...	@@ -949,7 +949,7 @@ test "empty slice ptr is non null" {
949	949	test "slice decays to many pointer" {
950	950	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
951	951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
952		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	952	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
953	953
954	954	var buf: [8]u8 = "abcdefg\x00".*;
955	955	const p: [*:0]const u8 = buf[0..7 :0];
...	...	@@ -960,7 +960,7 @@ test "write through pointer to optional slice arg" {
960	960	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
961	961	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
962	962	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
963		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	963	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
964	964
965	965	const S = struct {
966	966	fn bar(foo: *?[]const u8) !void {
...	...	@@ -980,7 +980,7 @@ test "modify slice length at comptime" {
980	980	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
981	981	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
982	982	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
983		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	983	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
984	984
985	985	const arr: [2]u8 = .{ 10, 20 };
986	986	comptime var s: []const u8 = arr[0..0];
...	...	@@ -996,7 +996,7 @@ test "modify slice length at comptime" {
996	996	test "slicing zero length array field of struct" {
997	997	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
998	998	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
999		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	999	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1000	1000	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1001	1001
1002	1002	const S = struct {
...	...	@@ -1012,7 +1012,7 @@ test "slicing zero length array field of struct" {
1012	1012	test "slicing slices gives correct result" {
1013	1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1014	1014	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1015		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1015	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1016	1016
1017	1017	const foo = "1234";
1018	1018	const bar = foo[0..4];
...	...	@@ -1026,7 +1026,7 @@ test "slicing slices gives correct result" {
1026	1026	test "get address of element of zero-sized slice" {
1027	1027	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1028	1028	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1029		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1029	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1030	1030
1031	1031	const S = struct {
1032	1032	fn destroy(_: *void) void {}
...	...	@@ -1039,7 +1039,7 @@ test "get address of element of zero-sized slice" {
1039	1039	test "sentinel-terminated 0-length slices" {
1040	1040	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1041	1041	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1042		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1042	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1043	1043
1044	1044	const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
1045	1045
...	...	@@ -1058,7 +1058,7 @@ test "sentinel-terminated 0-length slices" {
1058	1058	}
1059	1059
1060	1060	test "peer slices keep abi alignment with empty struct" {
1061		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1061	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1062	1062
1063	1063	var cond: bool = undefined;
1064	1064	cond = false;

test/behavior/src.zig+1-1

...	...	@@ -19,7 +19,7 @@ test "@src" {
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21	21	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	22	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
23	23
24	24	try doTheTest();
25	25	}

test/behavior/string_literals.zig+6-6

...	...	@@ -8,7 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
8	8	test "@tagName() returns a string literal" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
12	12
13	13	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
14	14	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
...	...	@@ -22,7 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
22	22	test "@errorName() returns a string literal" {
23	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	25	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
26	26
27	27	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
28	28	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
...	...	@@ -36,7 +36,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
36	36	test "@typeName() returns a string literal" {
37	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
38	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
39		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	39	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40	40
41	41	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
42	42	try std.testing.expect(std.mem.eql(u8, "behavior.string_literals.TestType", type_name));
...	...	@@ -51,7 +51,7 @@ test "@embedFile() returns a string literal" {
51	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53	53	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
54		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	54	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
55	55
56	56	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
57	57	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
...	...	@@ -66,7 +66,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
66	66	test "@src() returns a struct containing 0-terminated string slices" {
67	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
68	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	69	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
70	70
71	71	const src = testFnForSrc();
72	72	try std.testing.expect([:0]const u8 == @TypeOf(src.file));
...	...	@@ -104,7 +104,7 @@ test "Peer type resolution with string literals and unknown length u8 pointers"
104	104	}
105	105
106	106	test "including the sentinel when dereferencing a string literal" {
107		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	107	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
108	108
109	109	var var_str = "abc";
110	110	const var_derefed = var_str[0 .. var_str.len + 1].*;

test/behavior/struct.zig+39-39

...	...	@@ -90,7 +90,7 @@ test "structs" {
90	90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
91	91	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
92	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
93		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	93	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
94	94
95	95	var foo: StructFoo = undefined;
96	96	@memset(@as([*]u8, @ptrCast(&foo))[0..@sizeOf(StructFoo)], 0);
...	...	@@ -293,7 +293,7 @@ const Val = struct {
293	293	test "struct point to self" {
294	294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
295	295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
296		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	296	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
297	297
298	298	var root: Node = undefined;
299	299	root.val.x = 1;
...	...	@@ -337,7 +337,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
337	337
338	338	test "pass slice of empty struct to fn" {
339	339	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
340		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	340	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
341	341
342	342	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
343	343	}
...	...	@@ -349,7 +349,7 @@ test "self-referencing struct via array member" {
349	349	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
350	350	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
351	351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
352		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	352	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
353	353
354	354	const T = struct {
355	355	children: [1]*@This(),
...	...	@@ -373,7 +373,7 @@ const EmptyStruct = struct {
373	373	test "align 1 field before self referential align 8 field as slice return type" {
374	374	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
375	375	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
376		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	376	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
377	377
378	378	const result = alloc(Expr);
379	379	try expect(result.len == 0);
...	...	@@ -397,7 +397,7 @@ test "packed struct" {
397	397	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
398	398	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
399	399	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
400		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	400	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
401	401
402	402	var foo = APackedStruct{
403	403	.x = 1,
...	...	@@ -420,7 +420,7 @@ const Foo96Bits = packed struct {
420	420
421	421	test "packed struct 24bits" {
422	422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
423		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	423	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
424	424	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
425	425	if (builtin.cpu.arch.isArm()) return error.SkipZigTest; // TODO
426	426	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -465,7 +465,7 @@ test "runtime struct initialization of bitfield" {
465	465	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
466	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
467	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
468		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	468	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
469	469	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
470	470
471	471	const s1 = Nibbles{
...	...	@@ -505,7 +505,7 @@ test "packed struct fields are ordered from LSB to MSB" {
505	505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
506	506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
507	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
508		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	508	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
509	509
510	510	var all: u64 = 0x7765443322221111;
511	511	var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined;
...	...	@@ -525,7 +525,7 @@ test "implicit cast packed struct field to const ptr" {
525	525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
526	526	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
527	527	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
528		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	528	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
529	529
530	530	const LevelUpMove = packed struct {
531	531	move_id: u9,
...	...	@@ -559,7 +559,7 @@ test "packed struct with non-ABI-aligned field" {
559	559	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
560	560	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
561	561	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
562		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	562	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
563	563	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
564	564	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
565	565
...	...	@@ -590,7 +590,7 @@ test "bit field access" {
590	590	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
591	591	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
592	592	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
593		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	593	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
594	594
595	595	var data = bit_field_1;
596	596	try expect(getA(&data) == 1);
...	...	@@ -646,7 +646,7 @@ test "packed array 24bits" {
646	646	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647	647	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
648	648	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
649		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	649	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
650	650
651	651	comptime {
652	652	try expect(@sizeOf([9]Foo32Bits) == 9 * 4);
...	...	@@ -713,7 +713,7 @@ test "pointer to packed struct member in a stack variable" {
713	713	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
714	714	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
715	715	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
716		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	716	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
717	717
718	718	const S = packed struct {
719	719	a: u2,
...	...	@@ -764,7 +764,7 @@ test "packed struct with fp fields" {
764	764	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
765	765	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
766	766	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
767		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	767	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
768	768	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
769	769
770	770	const S = packed struct {
...	...	@@ -818,7 +818,7 @@ test "non-packed struct with u128 entry in union" {
818	818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
819	819	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
820	820	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
821		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	821	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
822	822	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
823	823	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
824	824
...	...	@@ -845,7 +845,7 @@ test "packed struct field passed to generic function" {
845	845	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
846	846	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
847	847	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
848		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	848	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
849	849
850	850	const S = struct {
851	851	const P = packed struct {
...	...	@@ -957,7 +957,7 @@ test "comptime struct field" {
957	957	}
958	958
959	959	test "tuple element initialized with fn call" {
960		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	960	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
961	961	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
962	962	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
963	963	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -976,7 +976,7 @@ test "tuple element initialized with fn call" {
976	976	}
977	977
978	978	test "struct with union field" {
979		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	979	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
980	980	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
981	981	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
982	982	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -1047,7 +1047,7 @@ test "packed struct with undefined initializers" {
1047	1047	}
1048	1048
1049	1049	test "for loop over pointers to struct, getting field from struct pointer" {
1050		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1050	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1051	1051	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1052	1052	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1053	1053
...	...	@@ -1089,7 +1089,7 @@ test "anon init through error unions and optionals" {
1089	1089	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1090	1090	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1091	1091	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1092		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1092	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1093	1093
1094	1094	const S = struct {
1095	1095	a: u32,
...	...	@@ -1116,7 +1116,7 @@ test "anon init through optional" {
1116	1116	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1117	1117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1118	1118	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1119		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1119	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1120	1120
1121	1121	const S = struct {
1122	1122	a: u32,
...	...	@@ -1136,7 +1136,7 @@ test "anon init through error union" {
1136	1136	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1137	1137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1138	1138	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1139		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1139	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1140	1140
1141	1141	const S = struct {
1142	1142	a: u32,
...	...	@@ -1237,7 +1237,7 @@ test "packed struct field access via pointer" {
1237	1237	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1238	1238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1239	1239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1240		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1240	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1241	1241
1242	1242	const S = struct {
1243	1243	fn doTheTest() !void {
...	...	@@ -1293,7 +1293,7 @@ test "under-aligned struct field" {
1293	1293	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1294	1294	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1295	1295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1296		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1296	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1297	1297	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1298	1298
1299	1299	const U = extern union {
...	...	@@ -1316,7 +1316,7 @@ test "under-aligned struct field" {
1316	1316	test "fieldParentPtr of a zero-bit field" {
1317	1317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1318	1318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1319		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1319	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1320	1320	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1321	1321
1322	1322	const S = struct {
...	...	@@ -1364,7 +1364,7 @@ test "fieldParentPtr of a zero-bit field" {
1364	1364	}
1365	1365
1366	1366	test "struct field has a pointer to an aligned version of itself" {
1367		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1367	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1368	1368	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1369	1369
1370	1370	const E = struct {
...	...	@@ -1425,7 +1425,7 @@ test "struct has only one reference" {
1425	1425	test "no dependency loop on pointer to optional struct" {
1426	1426	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1427	1427	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1428		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1428	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1429	1429
1430	1430	const S = struct {
1431	1431	const A = struct { b: B };
...	...	@@ -1446,7 +1446,7 @@ test "discarded struct initialization works as expected" {
1446	1446
1447	1447	test "function pointer in struct returns the struct" {
1448	1448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1449		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1449	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1450	1450
1451	1451	const A = struct {
1452	1452	const A = @This();
...	...	@@ -1462,7 +1462,7 @@ test "function pointer in struct returns the struct" {
1462	1462	}
1463	1463
1464	1464	test "no dependency loop on optional field wrapped in generic function" {
1465		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1465	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1466	1466	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1467	1467
1468	1468	const S = struct {
...	...	@@ -1524,7 +1524,7 @@ test "optional generic function label struct field" {
1524	1524	}
1525	1525
1526	1526	test "struct fields get automatically reordered" {
1527		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1527	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1528	1528	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1529	1529
1530	1530	const S1 = struct {
...	...	@@ -1543,7 +1543,7 @@ test "struct fields get automatically reordered" {
1543	1543	}
1544	1544
1545	1545	test "directly initiating tuple like struct" {
1546		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1546	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1547	1547
1548	1548	const a = struct { u8 }{8};
1549	1549	try expect(a[0] == 8);
...	...	@@ -1706,7 +1706,7 @@ test "runtime side-effects in comptime-known struct init" {
1706	1706	}
1707	1707
1708	1708	test "pointer to struct initialized through reference to anonymous initializer provides result types" {
1709		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1709	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1710	1710
1711	1711	const S = struct { a: u8, b: u16, c: *const anyopaque };
1712	1712	var my_u16: u16 = 0xABCD;
...	...	@@ -1765,7 +1765,7 @@ test "initializer uses own size" {
1765	1765	}
1766	1766
1767	1767	test "initializer takes a pointer to a variable inside its struct" {
1768		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1768	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1769	1769
1770	1770	const namespace = struct {
1771	1771	const S = struct {
...	...	@@ -1785,7 +1785,7 @@ test "initializer takes a pointer to a variable inside its struct" {
1785	1785	}
1786	1786
1787	1787	test "circular dependency through pointer field of a struct" {
1788		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1788	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1789	1789
1790	1790	const S = struct {
1791	1791	const StructInner = extern struct {
...	...	@@ -1855,7 +1855,7 @@ test "assign to slice.len of global variable" {
1855	1855	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1856	1856	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1857	1857	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1858		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1858	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1859	1859	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1860	1860
1861	1861	const S = struct {
...	...	@@ -1906,7 +1906,7 @@ test "array of structs inside struct initialized with undefined" {
1906	1906	test "runtime call in nested initializer" {
1907	1907	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1908	1908	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1909		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1909	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1910	1910
1911	1911	const Holder = struct {
1912	1912	array: []const u8,
...	...	@@ -1994,7 +1994,7 @@ test "struct field default value is a call" {
1994	1994	}
1995	1995
1996	1996	test "aggregate initializers should allow initializing comptime fields, verifying equality" {
1997		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1997	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1998	1998
1999	1999	var x: u32 = 15;
2000	2000	_ = &x;
...	...	@@ -2057,7 +2057,7 @@ test "initiate global variable with runtime value" {
2057	2057
2058	2058	test "struct containing optional pointer to array of @This()" {
2059	2059	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
2060		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2060	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2061	2061
2062	2062	const S = struct {
2063	2063	x: ?*const [1]@This(),

test/behavior/struct_contains_null_ptr_itself.zig+1-1

...	...	@@ -5,7 +5,7 @@ const builtin = @import("builtin");
5	5	test "struct contains null pointer which contains original struct" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	9
10	10	var x: ?*NodeLineComment = null;
11	11	_ = &x;

test/behavior/struct_contains_slice_of_itself.zig+2-2

...	...	@@ -13,7 +13,7 @@ const NodeAligned = struct {
13	13
14	14	test "struct contains slice of itself" {
15	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	16	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
17	17
18	18	var other_nodes = [_]Node{
19	19	Node{
...	...	@@ -54,7 +54,7 @@ test "struct contains slice of itself" {
54	54	test "struct contains aligned slice of itself" {
55	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	57	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58	58
59	59	var other_nodes = [_]NodeAligned{
60	60	NodeAligned{

test/behavior/switch.zig+18-18

...	...	@@ -9,7 +9,7 @@ const maxInt = std.math.maxInt;
9	9
10	10	test "switch with numbers" {
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13	13
14	14	try testSwitchWithNumbers(13);
15	15	}
...	...	@@ -25,7 +25,7 @@ fn testSwitchWithNumbers(x: u32) !void {
25	25
26	26	test "switch with all ranges" {
27	27	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
28		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	28	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
29	29
30	30	try expect(testSwitchWithAllRanges(50, 3) == 1);
31	31	try expect(testSwitchWithAllRanges(101, 0) == 2);
...	...	@@ -46,7 +46,7 @@ test "switch arbitrary int size" {
46	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
47	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
48	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
50	50	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
51	51
52	52	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
...	...	@@ -216,7 +216,7 @@ test "undefined.u0" {
216	216
217	217	test "switch with disjoint range" {
218	218	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
219		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	219	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
220	220
221	221	var q: u8 = 0;
222	222	_ = &q;
...	...	@@ -228,7 +228,7 @@ test "switch with disjoint range" {
228	228	}
229	229
230	230	test "switch variable for range and multiple prongs" {
231		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	231	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
232	232
233	233	const S = struct {
234	234	fn doTheTest() !void {
...	...	@@ -321,7 +321,7 @@ fn testSwitchEnumPtrCapture() !void {
321	321
322	322	test "switch handles all cases of number" {
323	323	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
324		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	324	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
325	325
326	326	try testSwitchHandleAllCases();
327	327	try comptime testSwitchHandleAllCases();
...	...	@@ -472,7 +472,7 @@ test "else prong of switch on error set excludes other cases" {
472	472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
473	473	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
474	474	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
475		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	475	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
476	476	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
477	477
478	478	const S = struct {
...	...	@@ -508,7 +508,7 @@ test "switch prongs with error set cases make a new error set type for capture v
508	508	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
509	509	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
510	510	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
511		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	511	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
512	512	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
513	513
514	514	const S = struct {
...	...	@@ -544,7 +544,7 @@ test "switch prongs with error set cases make a new error set type for capture v
544	544
545	545	test "return result loc and then switch with range implicit casted to error union" {
546	546	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
547		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	547	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
548	548
549	549	const S = struct {
550	550	fn doTheTest() !void {
...	...	@@ -691,7 +691,7 @@ test "switch prong pointer capture alignment" {
691	691	test "switch on pointer type" {
692	692	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
693	693	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
694		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	694	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
695	695
696	696	const S = struct {
697	697	const X = struct {
...	...	@@ -740,7 +740,7 @@ test "switch capture copies its payload" {
740	740	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
741	741	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
742	742	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
743		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	743	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
744	744
745	745	const S = struct {
746	746	fn doTheTest() !void {
...	...	@@ -764,7 +764,7 @@ test "switch capture copies its payload" {
764	764
765	765	test "capture of integer forwards the switch condition directly" {
766	766	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
767		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	767	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
768	768
769	769	const S = struct {
770	770	fn foo(x: u8) !void {
...	...	@@ -831,7 +831,7 @@ test "comptime inline switch" {
831	831	}
832	832
833	833	test "switch capture peer type resolution" {
834		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	834	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
835	835
836	836	const U = union(enum) {
837	837	a: u32,
...	...	@@ -905,7 +905,7 @@ test "inline switch range that includes the maximum value of the switched type"
905	905
906	906	test "nested break ignores switch conditions and breaks instead" {
907	907	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
908		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	908	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
909	909
910	910	const S = struct {
911	911	fn register_to_address(ident: []const u8) !u8 {
...	...	@@ -926,7 +926,7 @@ test "nested break ignores switch conditions and breaks instead" {
926	926	}
927	927
928	928	test "peer type resolution on switch captures ignores unused payload bits" {
929		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	929	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
930	930	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
931	931
932	932	const Foo = union(enum) {
...	...	@@ -953,7 +953,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
953	953	test "switch prong captures range" {
954	954	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
955	955	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
956		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	956	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
957	957
958	958	const S = struct {
959	959	fn a(b: []u3, c: u3) void {
...	...	@@ -1016,7 +1016,7 @@ test "block error return trace index is reset between prongs" {
1016	1016	}
1017	1017
1018	1018	test "labeled switch with break" {
1019		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1019	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1020	1020
1021	1021	var six: u32 = undefined;
1022	1022	six = 6;
...	...	@@ -1045,7 +1045,7 @@ test "unlabeled break ignores switch" {
1045	1045	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1046	1046	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1047	1047	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1048		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1048	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1049	1049
1050	1050	const result = while (true) {
1051	1051	_ = s: switch (@as(u32, 1)) {

test/behavior/switch_loop.zig+7-7

...	...	@@ -6,7 +6,7 @@ test "simple switch loop" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
10	10
11	11	const S = struct {
12	12	fn doTheTest() !void {
...	...	@@ -30,7 +30,7 @@ test "switch loop with ranges" {
30	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
31	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
32	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
34	34
35	35	const S = struct {
36	36	fn doTheTest() !void {
...	...	@@ -51,7 +51,7 @@ test "switch loop on enum" {
51	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	52	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53	53	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
54		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	54	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
55	55
56	56	const S = struct {
57	57	const E = enum { a, b, c };
...	...	@@ -75,7 +75,7 @@ test "switch loop with error set" {
75	75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
76	76	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
77	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
78		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	78	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
79	79
80	80	const S = struct {
81	81	const E = error{ Foo, Bar, Baz };
...	...	@@ -99,7 +99,7 @@ test "switch loop on tagged union" {
99	99	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
100	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
102		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	102	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
103	103	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
104	104
105	105	const S = struct {
...	...	@@ -132,7 +132,7 @@ test "switch loop dispatching instructions" {
132	132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
133	133	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
134	134	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
135		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	135	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
136	136
137	137	const S = struct {
138	138	const Inst = union(enum) {
...	...	@@ -182,7 +182,7 @@ test "switch loop with pointer capture" {
182	182	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
183	183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
184	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
185		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	185	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
186	186
187	187	const S = struct {
188	188	const U = union(enum) {

test/behavior/switch_on_captured_error.zig+2-2

...	...	@@ -6,7 +6,7 @@ const expectEqual = std.testing.expectEqual;
6	6	const builtin = @import("builtin");
7	7
8	8	test "switch on error union catch capture" {
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
11	11
12	12	const S = struct {
...	...	@@ -300,7 +300,7 @@ test "switch on error union catch capture" {
300	300	}
301	301
302	302	test "switch on error union if else capture" {
303		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	303	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
304	304	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
305	305
306	306	const S = struct {

test/behavior/this.zig+1-1

...	...	@@ -50,7 +50,7 @@ test "this used as optional function parameter" {
50	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
51	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
52	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	53	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
54	54
55	55	var global: State = undefined;
56	56	global.enter = prev;

test/behavior/threadlocal.zig+3-3

...	...	@@ -7,7 +7,7 @@ test "thread local variable" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; // TODO
12	12
13	13	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .macos) {
...	...	@@ -27,7 +27,7 @@ test "pointer to thread local array" {
27	27	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
28	28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	30	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; // TODO
32	32
33	33	const s = "Hello world";
...	...	@@ -42,7 +42,7 @@ test "reference a global threadlocal variable" {
42	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
43	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
45		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	45	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
46	46	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; // TODO
47	47
48	48	_ = nrfx_uart_rx(&g_uart0);

test/behavior/truncate.zig+1-1

...	...	@@ -70,7 +70,7 @@ test "truncate on vectors" {
70	70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
71	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72	72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
73		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	73	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
74	74
75	75	const S = struct {
76	76	fn doTheTest() !void {

test/behavior/try.zig+1-1

...	...	@@ -49,7 +49,7 @@ test "try then not executed with assignment" {
49	49	test "`try`ing an if/else expression" {
50	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
51	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
52		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	52	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
53	53	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
54	54
55	55	const S = struct {

test/behavior/tuple.zig+18-18

...	...	@@ -54,7 +54,7 @@ test "more tuple concatenation" {
54	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	57	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58	58
59	59	const T = struct {
60	60	fn consume_tuple(tuple: anytype, len: usize) !void {
...	...	@@ -131,7 +131,7 @@ test "tuple initializer for var" {
131	131	test "array-like initializer for tuple types" {
132	132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
133	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
134		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	134	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
135	135
136	136	const T = @Type(.{
137	137	.@"struct" = .{
...	...	@@ -220,7 +220,7 @@ test "fieldParentPtr of tuple" {
220	220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222	222	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
223		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	223	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
224	224
225	225	var x: u32 = 0;
226	226	_ = &x;
...	...	@@ -233,7 +233,7 @@ test "fieldParentPtr of anon struct" {
233	233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
234	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	235	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
236		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	236	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
237	237
238	238	var x: u32 = 0;
239	239	_ = &x;
...	...	@@ -257,7 +257,7 @@ test "offsetOf anon struct" {
257	257
258	258	test "initializing tuple with mixed comptime-runtime fields" {
259	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
260		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	260	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
261	261
262	262	var x: u32 = 15;
263	263	_ = &x;
...	...	@@ -269,7 +269,7 @@ test "initializing tuple with mixed comptime-runtime fields" {
269	269
270	270	test "initializing anon struct with mixed comptime-runtime fields" {
271	271	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
272		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	272	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
273	273
274	274	var x: u32 = 15;
275	275	_ = &x;
...	...	@@ -283,7 +283,7 @@ test "tuple in tuple passed to generic function" {
283	283	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
284	284	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
285	285	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
286		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	286	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
287	287
288	288	const S = struct {
289	289	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {
...	...	@@ -303,7 +303,7 @@ test "coerce tuple to tuple" {
303	303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
304	304	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
305	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
306		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	306	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
307	307
308	308	const T = std.meta.Tuple(&.{u8});
309	309	const S = struct {
...	...	@@ -318,7 +318,7 @@ test "tuple type with void field" {
318	318	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
319	319	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
320	320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
321		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	321	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
322	322
323	323	const T = std.meta.Tuple(&[_]type{void});
324	324	const x = T{{}};
...	...	@@ -355,7 +355,7 @@ test "zero sized struct in tuple handled correctly" {
355	355	test "tuple type with void field and a runtime field" {
356	356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
357	357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
358		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	358	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
359	359
360	360	const T = std.meta.Tuple(&[_]type{ usize, void });
361	361	var t: T = .{ 5, {} };
...	...	@@ -383,7 +383,7 @@ test "tuple initialized with a runtime known value" {
383	383	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
384	384	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
385	385	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
386		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	386	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
387	387
388	388	const E = union(enum) { e: []const u8 };
389	389	const W = union(enum) { w: E };
...	...	@@ -399,7 +399,7 @@ test "tuple of struct concatenation and coercion to array" {
399	399	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
400	400	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
401	401	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
402		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	402	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
403	403
404	404	const StructWithDefault = struct { value: f32 = 42 };
405	405	const SomeStruct = struct { array: [4]StructWithDefault };
...	...	@@ -414,7 +414,7 @@ test "nested runtime conditionals in tuple initializer" {
414	414	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
415	415	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
416	416	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
417		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	417	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
418	418
419	419	var data: u8 = 0;
420	420	_ = &data;
...	...	@@ -450,7 +450,7 @@ test "tuple pointer is indexable" {
450	450	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
451	451	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
452	452	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
453		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	453	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
454	454
455	455	const S = struct { u32, bool };
456	456
...	...	@@ -508,7 +508,7 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
508	508	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
509	509	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
510	510	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
511		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	511	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
512	512
513	513	const S = struct {
514	514	fn f(a: [:null]const ?u8) !void {
...	...	@@ -581,7 +581,7 @@ test "empty struct in tuple" {
581	581	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
582	582	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
583	583	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
584		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	584	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
585	585
586	586	const T = struct { struct {} };
587	587	const info = @typeInfo(T);
...	...	@@ -594,7 +594,7 @@ test "empty union in tuple" {
594	594	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
595	595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
596	596	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
597		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	597	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
598	598
599	599	const T = struct { union {} };
600	600	const info = @typeInfo(T);
...	...	@@ -604,7 +604,7 @@ test "empty union in tuple" {
604	604	}
605	605
606	606	test "field pointer of underaligned tuple" {
607		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	607	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
608	608	const S = struct {
609	609	fn doTheTest() !void {
610	610	const T = struct { u8, u32 };

test/behavior/tuple_declarations.zig+2-2

...	...	@@ -7,7 +7,7 @@ const expectEqualStrings = testing.expectEqualStrings;
7	7	test "tuple declaration type info" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11
12	12	{
13	13	const T = struct { comptime u32 = 1, []const u8 };
...	...	@@ -36,7 +36,7 @@ test "tuple declaration type info" {
36	36	test "tuple declaration usage" {
37	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
38	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
39		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	39	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
40	40
41	41	const T = struct { u32, []const u8 };
42	42	var t: T = .{ 1, "foo" };

test/behavior/type.zig+4-4

...	...	@@ -203,7 +203,7 @@ test "Type.Opaque" {
203	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
204	204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
205	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
206		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	206	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
207	207
208	208	const Opaque = @Type(.{
209	209	.@"opaque" = .{
...	...	@@ -261,7 +261,7 @@ test "Type.Struct" {
261	261	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
262	262	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
263	263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
264		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	264	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
265	265
266	266	const A = @Type(@typeInfo(struct { x: u8, y: u32 }));
267	267	const infoA = @typeInfo(A).@"struct";
...	...	@@ -349,7 +349,7 @@ test "Type.Struct" {
349	349	test "Type.Enum" {
350	350	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
351	351	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
352		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	352	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
353	353
354	354	const Foo = @Type(.{
355	355	.@"enum" = .{
...	...	@@ -411,7 +411,7 @@ test "Type.Enum" {
411	411	test "Type.Union" {
412	412	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
413	413	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
414		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	414	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
415	415
416	416	const Untagged = @Type(.{
417	417	.@"union" = .{

test/behavior/type_info.zig+11-11

...	...	@@ -161,7 +161,7 @@ test "type info: error set, error union info, anyerror" {
161	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162	162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
164		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	164	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
165	165
166	166	try testErrorSet();
167	167	try comptime testErrorSet();
...	...	@@ -193,7 +193,7 @@ test "type info: error set single value" {
193	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
194	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	196	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
197	197
198	198	const TestSet = error.One;
199	199
...	...	@@ -207,7 +207,7 @@ test "type info: error set merged" {
207	207	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
208	208	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
209	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
210		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	210	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
211	211
212	212	const TestSet = error{ One, Two } \|\| error{Three};
213	213
...	...	@@ -223,7 +223,7 @@ test "type info: enum info" {
223	223	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
224	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
225	225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
226		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	226	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
227	227
228	228	try testEnum();
229	229	try comptime testEnum();
...	...	@@ -286,7 +286,7 @@ fn testUnion() !void {
286	286
287	287	test "type info: struct info" {
288	288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
289		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	289	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
290	290
291	291	try testStruct();
292	292	try comptime testStruct();
...	...	@@ -354,7 +354,7 @@ fn testOpaque() !void {
354	354	}
355	355
356	356	test "type info: function type info" {
357		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	357	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
358	358	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
359	359
360	360	try testFunction();
...	...	@@ -556,7 +556,7 @@ test "type info for async frames" {
556	556
557	557	test "Declarations are returned in declaration order" {
558	558	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
559		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	559	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
560	560
561	561	const S = struct {
562	562	pub const a = 1;
...	...	@@ -578,7 +578,7 @@ test "Struct.is_tuple for anon list literal" {
578	578	}
579	579
580	580	test "Struct.is_tuple for anon struct literal" {
581		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	581	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
582	582
583	583	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
584	584
...	...	@@ -594,7 +594,7 @@ test "StructField.is_comptime" {
594	594	}
595	595
596	596	test "typeInfo resolves usingnamespace declarations" {
597		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	597	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
598	598
599	599	const A = struct {
600	600	pub const f1 = 42;
...	...	@@ -621,7 +621,7 @@ test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {
621	621	test "@typeInfo decls and usingnamespace" {
622	622	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
623	623	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
624		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	624	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
625	625
626	626	const A = struct {
627	627	pub const x = 5;
...	...	@@ -662,7 +662,7 @@ test "type info of tuple of string literal default value" {
662	662	}
663	663
664	664	test "@typeInfo only contains pub decls" {
665		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	665	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
666	666
667	667	const other = struct {
668	668	const std = @import("std");

test/behavior/typename.zig+8-8

...	...	@@ -15,7 +15,7 @@ test "anon fn param" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	18	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
19	19
20	20	// https://github.com/ziglang/zig/issues/9339
21	21	try expectEqualStringsIgnoreDigits(
...	...	@@ -41,7 +41,7 @@ test "anon field init" {
41	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
42	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
43	43	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
44		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	44	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
45	45
46	46	const Foo = .{
47	47	.T1 = struct {},
...	...	@@ -67,7 +67,7 @@ test "basic" {
67	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
68	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
69	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
70		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	70	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
71	71
72	72	try expectEqualStrings("i64", @typeName(i64));
73	73	try expectEqualStrings("usize", @typeName(usize));
...	...	@@ -89,7 +89,7 @@ test "top level decl" {
89	89	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
90	90	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
91	91	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
92		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	92	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
93	93
94	94	try expectEqualStrings(
95	95	"behavior.typename.A_Struct",
...	...	@@ -139,7 +139,7 @@ test "fn param" {
139	139	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
140	140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
141	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
142		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	142	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
143	143
144	144	// https://github.com/ziglang/zig/issues/675
145	145	try expectEqualStrings(
...	...	@@ -219,7 +219,7 @@ test "local variable" {
219	219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
220	220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
221	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	222	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
223	223
224	224	const Foo = struct { a: u32 };
225	225	const Bar = union { a: u32 };
...	...	@@ -238,7 +238,7 @@ test "comptime parameters not converted to anytype in function type" {
238	238	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
239	239	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
240	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
241		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	241	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
242	242
243	243	const T = fn (comptime fn (comptime type) void, void) void;
244	244	try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));
...	...	@@ -248,7 +248,7 @@ test "anon name strategy used in sub expression" {
248	248	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
249	249	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
250	250	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
251		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	251	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
252	252
253	253	const S = struct {
254	254	fn getTheName() []const u8 {

test/behavior/undefined.zig+3-3

...	...	@@ -79,7 +79,7 @@ test "assign undefined to struct with method" {
79	79	}
80	80
81	81	test "type name of undefined" {
82		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84	84
85	85	const x = undefined;
...	...	@@ -91,7 +91,7 @@ var buf: []u8 = undefined;
91	91	test "reslice of undefined global var slice" {
92	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
93	93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
94		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	94	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
95	95
96	96	var stack_buf: [100]u8 = [_]u8{0} ** 100;
97	97	buf = &stack_buf;
...	...	@@ -102,7 +102,7 @@ test "reslice of undefined global var slice" {
102	102	test "returned undef is 0xaa bytes when runtime safety is enabled" {
103	103	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
104	104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
105		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	105	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
106	106	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
107	107
108	108	const Rect = struct {

test/behavior/union.zig+36-36

...	...	@@ -16,7 +16,7 @@ test "basic unions with floats" {
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
19		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	19	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
20	20
21	21	var foo = FooWithFloats{ .int = 1 };
22	22	try expect(foo.int == 1);
...	...	@@ -44,7 +44,7 @@ test "basic unions" {
44	44	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
45	45	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
46	46	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	47	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
48	48
49	49	var foo = Foo{ .int = 1 };
50	50	try expect(foo.int == 1);
...	...	@@ -64,7 +64,7 @@ test "init union with runtime value" {
64	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
65	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66	66	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
67		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	67	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
68	68
69	69	var foo: Foo = undefined;
70	70
...	...	@@ -103,7 +103,7 @@ const FooExtern = extern union {
103	103	test "basic extern unions" {
104	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	106	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
107	107
108	108	var foo = FooExtern{ .int = 1 };
109	109	try expect(foo.int == 1);
...	...	@@ -214,7 +214,7 @@ test "union with specified enum tag" {
214	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
215	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
216	216	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
217		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	217	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
218	218
219	219	try doTest();
220	220	try comptime doTest();
...	...	@@ -224,7 +224,7 @@ test "packed union generates correctly aligned type" {
224	224	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
225	225	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
226	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
227		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	227	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
228	228	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
229	229
230	230	const U = packed union {
...	...	@@ -266,7 +266,7 @@ test "comparison between union and enum literal" {
266	266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
267	267	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
268	268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
269		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	269	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
270	270
271	271	try testComparison();
272	272	try comptime testComparison();
...	...	@@ -341,7 +341,7 @@ test "constant packed union" {
341	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
342	342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
343	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
344		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	344	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
345	345
346	346	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
347	347	}
...	...	@@ -491,7 +491,7 @@ test "initialize global array of union" {
491	491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
492	492	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
493	493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
494		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	494	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
495	495
496	496	glbl_array[1] = FooUnion{ .U1 = 2 };
497	497	glbl_array[0] = FooUnion{ .U0 = 1 };
...	...	@@ -531,7 +531,7 @@ test "union initializer generates padding only if needed" {
531	531	test "runtime tag name with single field" {
532	532	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
533	533	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
534		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	534	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
535	535
536	536	const U = union(enum) {
537	537	A: i32,
...	...	@@ -609,7 +609,7 @@ test "tagged union as return value" {
609	609	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
610	610	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
611	611	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
612		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	612	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
613	613
614	614	switch (returnAnInt(13)) {
615	615	TaggedFoo.One => \|value\| try expect(value == 13),
...	...	@@ -653,7 +653,7 @@ test "union(enum(u32)) with specified and unspecified tag values" {
653	653	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
654	654	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
655	655	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
656		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	656	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
657	657
658	658	comptime assert(Tag(Tag(MultipleChoice2)) == u32);
659	659	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
...	...	@@ -903,7 +903,7 @@ test "union no tag with struct member" {
903	903	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
904	904	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
905	905	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
906		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	906	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
907	907
908	908	const Struct = struct {};
909	909	const Union = union {
...	...	@@ -940,7 +940,7 @@ test "anonymous union literal syntax" {
940	940	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
941	941	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
942	942	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
943		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	943	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
944	944
945	945	const S = struct {
946	946	const Number = union {
...	...	@@ -1110,7 +1110,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1110	1110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1111	1111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1112	1112	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1113		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1113	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1114	1114
1115	1115	const T = struct {
1116	1116	const U = union(enum) {
...	...	@@ -1210,7 +1210,7 @@ test "extern union most-aligned field is smaller" {
1210	1210	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1211	1211	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1212	1212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1213		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1213	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1214	1214
1215	1215	const U = extern union {
1216	1216	in6: extern struct {
...	...	@@ -1343,7 +1343,7 @@ test "union field ptr - zero sized payload" {
1343	1343	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1344	1344	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1345	1345	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1346		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1346	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1347	1347
1348	1348	const U = union {
1349	1349	foo: void,
...	...	@@ -1358,7 +1358,7 @@ test "union field ptr - zero sized field" {
1358	1358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1359	1359	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1360	1360	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1361		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1361	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1362	1362
1363	1363	const U = union {
1364	1364	foo: void,
...	...	@@ -1423,7 +1423,7 @@ test "union int tag type is properly managed" {
1423	1423	test "no dependency loop when function pointer in union returns the union" {
1424	1424	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1425	1425	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1426		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1426	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1427	1427	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1428	1428
1429	1429	const U = union(enum) {
...	...	@@ -1594,7 +1594,7 @@ test "packed union field pointer has correct alignment" {
1594	1594	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1595	1595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1596	1596	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1597		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1597	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1598	1598
1599	1599	const U = packed union { x: u20 };
1600	1600	const S = packed struct(u24) { a: u2, u: U, b: u2 };
...	...	@@ -1625,7 +1625,7 @@ test "packed union field pointer has correct alignment" {
1625	1625	}
1626	1626
1627	1627	test "union with 128 bit integer" {
1628		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1628	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1629	1629
1630	1630	const ValueTag = enum { int, other };
1631	1631
...	...	@@ -1648,7 +1648,7 @@ test "union with 128 bit integer" {
1648	1648	}
1649	1649
1650	1650	test "memset extern union" {
1651		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1651	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1652	1652
1653	1653	const U = extern union {
1654	1654	foo: u8,
...	...	@@ -1669,7 +1669,7 @@ test "memset extern union" {
1669	1669	}
1670	1670
1671	1671	test "memset packed union" {
1672		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1672	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1673	1673
1674	1674	const U = packed union {
1675	1675	a: u32,
...	...	@@ -1769,7 +1769,7 @@ test "reinterpret extern union" {
1769	1769	}
1770	1770
1771	1771	test "reinterpret packed union" {
1772		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1772	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1773	1773
1774	1774	const U = packed union {
1775	1775	foo: u8,
...	...	@@ -1841,7 +1841,7 @@ test "reinterpret packed union" {
1841	1841	}
1842	1842
1843	1843	test "reinterpret packed union inside packed struct" {
1844		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1844	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1845	1845
1846	1846	const U = packed union {
1847	1847	a: u7,
...	...	@@ -1926,7 +1926,7 @@ test "inner struct initializer uses packed union layout" {
1926	1926	}
1927	1927
1928	1928	test "extern union initialized via reintepreted struct field initializer" {
1929		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1929	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1930	1930
1931	1931	const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
1932	1932
...	...	@@ -1963,7 +1963,7 @@ test "packed union initialized via reintepreted struct field initializer" {
1963	1963	}
1964	1964
1965	1965	test "store of comptime reinterpreted memory to extern union" {
1966		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1966	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1967	1967
1968	1968	const bytes = [_]u8{ 0xaa, 0xbb, 0xcc, 0xdd };
1969	1969
...	...	@@ -2007,7 +2007,7 @@ test "store of comptime reinterpreted memory to packed union" {
2007	2007	test "union field is a pointer to an aligned version of itself" {
2008	2008	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2009	2009	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2010		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2010	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2011	2011
2012	2012	const E = union {
2013	2013	next: *align(1) @This(),
...	...	@@ -2020,7 +2020,7 @@ test "union field is a pointer to an aligned version of itself" {
2020	2020
2021	2021	test "pass register-sized field as non-register-sized union" {
2022	2022	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2023		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2023	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2024	2024
2025	2025	const S = struct {
2026	2026	fn taggedUnion(u: union(enum) { x: usize, y: [2]usize }) !void {
...	...	@@ -2044,7 +2044,7 @@ test "pass register-sized field as non-register-sized union" {
2044	2044	}
2045	2045
2046	2046	test "circular dependency through pointer field of a union" {
2047		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2047	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2048	2048
2049	2049	const S = struct {
2050	2050	const UnionInner = extern struct {
...	...	@@ -2068,7 +2068,7 @@ test "circular dependency through pointer field of a union" {
2068	2068
2069	2069	test "pass nested union with rls" {
2070	2070	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2071		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2071	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2072	2072
2073	2073	const Union = union(enum) {
2074	2074	a: u32,
...	...	@@ -2091,7 +2091,7 @@ test "runtime union init, most-aligned field != largest" {
2091	2091	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2092	2092	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2093	2093	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2094		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2094	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2095	2095	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2096	2096
2097	2097	const U = union(enum) {
...	...	@@ -2117,7 +2117,7 @@ test "copied union field doesn't alias source" {
2117	2117	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2118	2118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2119	2119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2120		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2120	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2121	2121
2122	2122	const U = union(enum) {
2123	2123	array: [10]u32,
...	...	@@ -2136,7 +2136,7 @@ test "copied union field doesn't alias source" {
2136	2136	test "create union(enum) from other union(enum)" {
2137	2137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2138	2138	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2139		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2139	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2140	2140	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2141	2141
2142	2142	const string = "hello world";
...	...	@@ -2260,7 +2260,7 @@ test "matching captures causes union equivalence" {
2260	2260	test "signed enum tag with negative value" {
2261	2261	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2262	2262	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2263		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2263	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2264	2264	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
2265	2265	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
2266	2266
...	...	@@ -2316,7 +2316,7 @@ test "extern union @FieldType" {
2316	2316	}
2317	2317
2318	2318	test "assign global tagged union" {
2319		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	2319	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
2320	2320
2321	2321	const U = union(enum) {
2322	2322	a: u16,

test/behavior/union_with_members.zig+1-1

...	...	@@ -20,7 +20,7 @@ test "enum with members" {
20	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	23	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
24	24
25	25	const a = ET{ .SINT = -42 };
26	26	const b = ET{ .UINT = 42 };

test/behavior/usingnamespace.zig+8-8

...	...	@@ -12,7 +12,7 @@ const C = struct {
12	12
13	13	test "basic usingnamespace" {
14	14	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
15		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	15	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
16	16
17	17	try std.testing.expect(C.B == bool);
18	18	}
...	...	@@ -25,7 +25,7 @@ fn Foo(comptime T: type) type {
25	25
26	26	test "usingnamespace inside a generic struct" {
27	27	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
28		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	28	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
29	29
30	30	const std2 = Foo(std);
31	31	const testing2 = Foo(std.testing);
...	...	@@ -39,7 +39,7 @@ usingnamespace struct {
39	39
40	40	test "usingnamespace does not redeclare an imported variable" {
41	41	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
42		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	42	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
43	43
44	44	try comptime std.testing.expect(@This().foo == 42);
45	45	}
...	...	@@ -49,7 +49,7 @@ test "usingnamespace omits mixing in private functions" {
49	49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
50	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51	51	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
52		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	52	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
53	53
54	54	try expect(@This().privateFunction());
55	55	try expect(!@This().printText());
...	...	@@ -60,7 +60,7 @@ fn privateFunction() bool {
60	60
61	61	test {
62	62	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
63		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	63	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
64	64
65	65	_ = @import("usingnamespace/import_segregation.zig");
66	66	}
...	...	@@ -70,7 +70,7 @@ test "two files usingnamespace import each other" {
70	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
72	72	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
73		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	73	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
74	74
75	75	try expect(@This().ok());
76	76	}
...	...	@@ -79,7 +79,7 @@ test {
79	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
80	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81	81	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
82		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	83
84	84	const AA = struct {
85	85	x: i32,
...	...	@@ -109,7 +109,7 @@ const Mixin = struct {
109	109
110	110	test "container member access usingnamespace decls" {
111	111	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
112		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	112	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
113	113
114	114	var foo = Bar{};
115	115	foo.two();

test/behavior/var_args.zig+5-5

...	...	@@ -98,7 +98,7 @@ test "simple variadic function" {
98	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
99	99	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
100	100	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
101		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	101	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
102	102	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
103	103	if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
104	104	// https://github.com/ziglang/zig/issues/14096
...	...	@@ -160,7 +160,7 @@ test "coerce reference to var arg" {
160	160	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
161	161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
163		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	163	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
164	164	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
165	165	if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
166	166	// https://github.com/ziglang/zig/issues/14096
...	...	@@ -194,7 +194,7 @@ test "variadic functions" {
194	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195	195	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
196	196	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
197		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	197	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
198	198	if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
199	199	// https://github.com/ziglang/zig/issues/14096
200	200	return error.SkipZigTest;
...	...	@@ -239,7 +239,7 @@ test "copy VaList" {
239	239	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
240	240	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
241	241	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
242		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	242	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
243	243	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
244	244	if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
245	245	// https://github.com/ziglang/zig/issues/14096
...	...	@@ -274,7 +274,7 @@ test "unused VaList arg" {
274	274	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
275	275	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
276	276	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
277		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	277	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
278	278	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
279	279	if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
280	280	// https://github.com/ziglang/zig/issues/14096

test/behavior/vector.zig+30-30

...	...	@@ -11,7 +11,7 @@ test "implicit cast vector to array - bool" {
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	14	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
15	15
16	16	const S = struct {
17	17	fn doTheTest() !void {
...	...	@@ -30,7 +30,7 @@ test "vector wrap operators" {
30	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
33		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
34	34
35	35	const S = struct {
36	36	fn doTheTest() !void {
...	...	@@ -54,7 +54,7 @@ test "vector bin compares with mem.eql" {
54	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
55	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	56	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
57		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	57	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
58	58
59	59	const S = struct {
60	60	fn doTheTest() !void {
...	...	@@ -79,7 +79,7 @@ test "vector int operators" {
79	79	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
80	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81	81	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
82		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	83	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
84	84
85	85	const S = struct {
...	...	@@ -102,7 +102,7 @@ test "vector float operators" {
102	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	105	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
106	106	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
107	107	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
108	108
...	...	@@ -148,7 +148,7 @@ test "vector bit operators" {
148	148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
149	149	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
150	150	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
151		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	151	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
152	152
153	153	const S = struct {
154	154	fn doTheTest() !void {
...	...	@@ -179,7 +179,7 @@ test "implicit cast vector to array" {
179	179	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
180	180	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
181	181	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
182		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	182	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
183	183
184	184	const S = struct {
185	185	fn doTheTest() !void {
...	...	@@ -198,7 +198,7 @@ test "array to vector" {
198	198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199	199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	201	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
202	202
203	203	const S = struct {
204	204	fn doTheTest() !void {
...	...	@@ -257,7 +257,7 @@ test "array to vector with element type coercion" {
257	257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
258	258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
259	259	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
260		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	260	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
261	261	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
262	262
263	263	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and
...	...	@@ -325,7 +325,7 @@ test "vector casts of sizes not divisible by 8" {
325	325	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
326	326	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
327	327	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
328		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	328	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
329	329
330	330	const S = struct {
331	331	fn doTheTest() !void {
...	...	@@ -364,7 +364,7 @@ test "vector @splat" {
364	364	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
365	365	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
366	366	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
367		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	367	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
368	368	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
369	369
370	370	const S = struct {
...	...	@@ -520,7 +520,7 @@ test "vector comparison operators" {
520	520	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
521	521	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
522	522	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
523		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	523	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
524	524
525	525	const S = struct {
526	526	fn doTheTest() !void {
...	...	@@ -566,7 +566,7 @@ test "vector division operators" {
566	566	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
567	567	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
568	568	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
569		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	569	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
570	570	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
571	571
572	572	const S = struct {
...	...	@@ -655,7 +655,7 @@ test "vector division operators" {
655	655
656	656	test "vector bitwise not operator" {
657	657	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
658		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	658	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
659	659	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
660	660	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
661	661	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -689,7 +689,7 @@ test "vector bitwise not operator" {
689	689
690	690	test "vector boolean not operator" {
691	691	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
692		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	692	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
693	693	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
694	694	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
695	695	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	...	@@ -717,7 +717,7 @@ test "vector shift operators" {
717	717	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
718	718	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
719	719	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
720		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	720	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
721	721	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
722	722
723	723	const S = struct {
...	...	@@ -788,7 +788,7 @@ test "vector reduce operation" {
788	788	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
789	789	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
790	790	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
791		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	791	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
792	792	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
793	793	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
794	794	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21091
...	...	@@ -959,7 +959,7 @@ test "saturating add" {
959	959	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
960	960	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
961	961	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
962		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	962	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
963	963	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
964	964
965	965	const S = struct {
...	...	@@ -993,7 +993,7 @@ test "saturating subtraction" {
993	993	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
994	994	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
995	995	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
996		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	996	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
997	997	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
998	998
999	999	const S = struct {
...	...	@@ -1017,7 +1017,7 @@ test "saturating multiplication" {
1017	1017	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1018	1018	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1019	1019	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1020		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1020	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1021	1021	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1022	1022
1023	1023	// TODO: once #9660 has been solved, remove this line
...	...	@@ -1045,7 +1045,7 @@ test "saturating shift-left" {
1045	1045	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1046	1046	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1047	1047	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1048		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1048	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1049	1049	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1050	1050	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1051	1051
...	...	@@ -1071,7 +1071,7 @@ test "multiplication-assignment operator with an array operand" {
1071	1071	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1072	1072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1073	1073	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1074		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1074	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1075	1075	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1076	1076
1077	1077	const S = struct {
...	...	@@ -1093,7 +1093,7 @@ test "@addWithOverflow" {
1093	1093	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1094	1094	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1095	1095	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1096		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1096	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1097	1097	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1098	1098
1099	1099	const S = struct {
...	...	@@ -1143,7 +1143,7 @@ test "@subWithOverflow" {
1143	1143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1144	1144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1145	1145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1146		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1146	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1147	1147	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1148	1148
1149	1149	const S = struct {
...	...	@@ -1244,7 +1244,7 @@ test "loading the second vector from a slice of vectors" {
1244	1244	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1245	1245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1246	1246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1247		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1247	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1248	1248
1249	1249	@setRuntimeSafety(false);
1250	1250	var small_bases = [2]@Vector(2, u8){
...	...	@@ -1261,7 +1261,7 @@ test "array of vectors is copied" {
1261	1261	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1262	1262	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1263	1263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1264		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1264	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1265	1265
1266	1266	const Vec3 = @Vector(3, i32);
1267	1267	var points = [_]Vec3{
...	...	@@ -1425,7 +1425,7 @@ test "store to vector in slice" {
1425	1425	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1426	1426	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1427	1427	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1428		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1428	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1429	1429	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1430	1430
1431	1431	var v = [_]@Vector(3, f32){
...	...	@@ -1444,7 +1444,7 @@ test "store vector with memset" {
1444	1444	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1445	1445	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1446	1446	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1447		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
	1447	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO
1448	1448	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1449	1449	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1450	1450	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
...	...	@@ -1538,7 +1538,7 @@ test "bitcast to vector with different child type" {
1538	1538	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1539	1539	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1540	1540	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1541		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1541	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1542	1542
1543	1543	const S = struct {
1544	1544	fn doTheTest() !void {
...	...	@@ -1594,7 +1594,7 @@ test "@reduce on bool vector" {
1594	1594	test "bitcast vector to array of smaller vectors" {
1595	1595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1596	1596	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1597		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1597	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1598	1598
1599	1599	const u8x32 = @Vector(32, u8);
1600	1600	const u8x64 = @Vector(64, u8);

test/behavior/void.zig+1-1

...	...	@@ -21,7 +21,7 @@ test "compare void with void compile time known" {
21	21	test "iterate over a void slice" {
22	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
24		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	24	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
25	25
26	26	var j: usize = 0;
27	27	for (times(10), 0..) \|_, i\| {

test/behavior/while.zig+4-4

...	...	@@ -38,7 +38,7 @@ fn staticWhileLoop2() i32 {
38	38	}
39	39
40	40	test "while with continue expression" {
41		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	41	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
42	42
43	43	var sum: i32 = 0;
44	44	{
...	...	@@ -160,7 +160,7 @@ test "while with optional as condition with else" {
160	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
163		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	163	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
164	164
165	165	numbers_left = 10;
166	166	var sum: i32 = 0;
...	...	@@ -178,7 +178,7 @@ test "while with optional as condition with else" {
178	178	test "while with error union condition" {
179	179	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180	180	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
181		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	181	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
182	182
183	183	numbers_left = 10;
184	184	var sum: i32 = 0;
...	...	@@ -350,7 +350,7 @@ test "else continue outer while" {
350	350	test "try terminating an infinite loop" {
351	351	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
352	352	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
353		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	353	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
354	354
355	355	// Test coverage for https://github.com/ziglang/zig/issues/13546
356	356	const Foo = struct {

test/behavior/widening.zig+5-5

...	...	@@ -7,7 +7,7 @@ test "integer widening" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
12	12
13	13	var a: u8 = 250;
...	...	@@ -31,7 +31,7 @@ test "integer widening u0 to u8" {
31	31	test "implicit unsigned integer to signed integer" {
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
33	33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
34		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	34	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
35	35
36	36	var a: u8 = 250;
37	37	var b: i16 = a;
...	...	@@ -43,7 +43,7 @@ test "float widening" {
43	43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
44	44	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
45	45	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	46	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
47	47	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
48	48	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
49	49
...	...	@@ -64,7 +64,7 @@ test "float widening f16 to f128" {
64	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
65	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
66	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	67	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
68	68	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
69	69	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
70	70
...	...	@@ -78,7 +78,7 @@ test "cast small unsigned to larger signed" {
78	78	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
79	79	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
80	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	81	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
82	82
83	83	try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
84	84	try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));

test/behavior/wrapping_arithmetic.zig+3-3

...	...	@@ -5,7 +5,7 @@ const maxInt = std.math.maxInt;
5	5	const expect = std.testing.expect;
6	6
7	7	test "wrapping add" {
8		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
10	10
11	11	const S = struct {
...	...	@@ -43,7 +43,7 @@ test "wrapping add" {
43	43	}
44	44
45	45	test "wrapping subtraction" {
46		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	46	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
47	47	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
48	48
49	49	const S = struct {
...	...	@@ -79,7 +79,7 @@ test "wrapping subtraction" {
79	79	}
80	80
81	81	test "wrapping multiplication" {
82		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	82	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
83	83	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
84	84
85	85	// TODO: once #9660 has been solved, remove this line

test/c_import/c_char_signedness.zig+1-1

...	...	@@ -6,7 +6,7 @@ const c = @cImport({
6	6	});
7	7
8	8	test "c_char signedness" {
9		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
10	10
11	11	try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char));
12	12	try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char));

test/c_import/macros.zig+17-17

...	...	@@ -9,7 +9,7 @@ const latin1 = @cImport(@cInclude("macros_not_utf8.h"));
9	9
10	10	test "casting to void with a macro" {
11	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	12	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
13	13
14	14	h.IGNORE_ME_1(42);
15	15	h.IGNORE_ME_2(42);
...	...	@@ -27,7 +27,7 @@ test "initializer list expression" {
27	27	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
29	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	30	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
31	31
32	32	try expectEqual(h.Color{
33	33	.r = 200,
...	...	@@ -40,7 +40,7 @@ test "initializer list expression" {
40	40	test "sizeof in macros" {
41	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
42	42	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
43		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	43	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
44	44
45	45	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
46	46	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
...	...	@@ -48,7 +48,7 @@ test "sizeof in macros" {
48	48
49	49	test "reference to a struct type" {
50	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	51	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
52	52
53	53	try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
54	54	}
...	...	@@ -57,7 +57,7 @@ test "cast negative integer to pointer" {
57	57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
59	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
60		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	60	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
61	61
62	62	try expectEqual(@as(?*anyopaque, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1))))), h.MAP_FAILED);
63	63	}
...	...	@@ -66,7 +66,7 @@ test "casting to union with a macro" {
66	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
68	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	69	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
70	70
71	71	const l: c_long = 42;
72	72	const d: f64 = 2.0;
...	...	@@ -82,7 +82,7 @@ test "casting or calling a value with a paren-surrounded macro" {
82	82	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
83	83	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
84	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	85	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
86	86
87	87	const l: c_long = 42;
88	88	const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
...	...	@@ -101,7 +101,7 @@ test "nested comma operator" {
101	101	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
102	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
103	103	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
104		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	104	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
105	105
106	106	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
107	107	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
...	...	@@ -111,7 +111,7 @@ test "cast functions" {
111	111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
112	112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
113	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
114		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	114	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
115	115
116	116	const S = struct {
117	117	fn foo() void {}
...	...	@@ -125,7 +125,7 @@ test "large integer macro" {
125	125	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
126	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
127	127	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	128	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
129	129
130	130	try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
131	131	}
...	...	@@ -134,7 +134,7 @@ test "string literal macro with embedded tab character" {
134	134	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
135	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
136	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	137	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
138	138
139	139	try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
140	140	}
...	...	@@ -143,7 +143,7 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
143	143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
144	144	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
145	145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	146	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
147	147
148	148	try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
149	149	try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
...	...	@@ -154,7 +154,7 @@ test "Macro that uses division operator. Issue #13162" {
154	154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
156	156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	157	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
158	158	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
159	159
160	160	try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
...	...	@@ -198,7 +198,7 @@ test "Macro that uses remainder operator. Issue #13346" {
198	198	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
199	199	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
200	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
201		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	201	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
202	202
203	203	try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
204	204	try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));
...	...	@@ -229,20 +229,20 @@ test "Macro that uses remainder operator. Issue #13346" {
229	229	}
230	230
231	231	test "@typeInfo on @cImport result" {
232		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	232	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
233	233
234	234	try expect(@typeInfo(h).@"struct".decls.len > 1);
235	235	}
236	236
237	237	test "Macro that uses Long type concatenation casting" {
238		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	238	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
239	239
240	240	try expect((@TypeOf(h.X)) == c_long);
241	241	try expectEqual(h.X, @as(c_long, 10));
242	242	}
243	243
244	244	test "Blank macros" {
245		if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	245	if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
246	246
247	247	try expectEqual(h.BLANK_MACRO, "");
248	248	try expectEqual(h.BLANK_CHILD_MACRO, "");

test/cases/compile_errors/spirv_merge_logical_pointers.zig+1-1

...	...	@@ -16,4 +16,4 @@ export fn a() void {
16	16	//
17	17	// :9:13: error: value with non-mergable pointer type '*i32' depends on runtime control flow
18	18	// :9:17: note: runtime control flow here
19		// :9:13: note: pointers with address space 'generic' cannot be returned from a branch on target spirv-vulkan by compiler backend stage2_spirv64
	19	// :9:13: note: pointers with address space 'generic' cannot be returned from a branch on target spirv-vulkan by compiler backend stage2_spirv