Commit aec0f9b3e7790c2e3b66d519e4d8e438208b5406 | zig

author	Ali Chraghi <alichraghi@proton.me> 2025-02-19 00:07:07+03:30
committer	Robin Voetter <robin@voetter.nl> 2025-02-24 19:39:42+01:00
log	aec0f9b3e7790c2e3b66d519e4d8e438208b5406
tree	1e96f489e6738b43351a2207d5dfe90c9ab65376
parent	94af47d28c83efa3dc26ee0b47b224b823c9b333
signature	Signed by SSH key SHA256:ZS52FNyUv2WUXvO4njmVaFVO46RHojFuOrxRc4LuKzg

test: skip failing tests with spirv-vulkan

66 files changed, 554 insertions(+), 52 deletions(-)

test
- behavior.zig
- behavior

test/behavior.zig+3-3

...	@@ -112,11 +112,11 @@ test {	...	@@ -112,11 +112,11 @@ test {
112		112
113	_ = @import("behavior/x86_64.zig");	113	_ = @import("behavior/x86_64.zig");
114		114
115	if (builtin.cpu.arch == .wasm32) {	115	if (builtin.zig_backend != .stage2_spirv64 and builtin.cpu.arch == .wasm32) {
116	_ = @import("behavior/wasm.zig");	116	_ = @import("behavior/wasm.zig");
117	}	117	}
118		118
119	if (builtin.os.tag != .wasi) {	119	if (builtin.zig_backend != .stage2_spirv64 and builtin.os.tag != .wasi) {
120	_ = @import("behavior/asm.zig");	120	_ = @import("behavior/asm.zig");
121	}	121	}
122		122
...	@@ -127,7 +127,7 @@ test {	...	@@ -127,7 +127,7 @@ test {
127	_ = @import("behavior/export_keyword.zig");	127	_ = @import("behavior/export_keyword.zig");
128	}	128	}
129		129
130	if (!builtin.cpu.arch.isWasm()) {	130	if (builtin.zig_backend != .stage2_spirv64 and !builtin.cpu.arch.isWasm()) {
131	// Due to lack of import/export of global support	131	// Due to lack of import/export of global support
132	// (https://github.com/ziglang/zig/issues/4866), these tests correctly	132	// (https://github.com/ziglang/zig/issues/4866), these tests correctly
133	// cause linker errors, since a data symbol cannot be exported when	133	// cause linker errors, since a data symbol cannot be exported when

test/behavior/abs.zig+3

test/behavior/addrspace_and_linksection.zig+2

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

test/behavior/align.zig+11

test/behavior/alignof.zig+2

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

test/behavior/array.zig+40

test/behavior/atomics.zig+2

...	@@ -107,6 +107,7 @@ test "cmpxchg with ignored result" {	...	@@ -107,6 +107,7 @@ test "cmpxchg with ignored result" {
107	}	107	}
108		108
109	test "128-bit cmpxchg" {	109	test "128-bit cmpxchg" {
		110	// TODO: this must appear first
110	if (!supports_128_bit_atomics) return error.SkipZigTest;	111	if (!supports_128_bit_atomics) return error.SkipZigTest;
111		112
112	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	113	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
...	@@ -284,6 +285,7 @@ fn testAtomicRmwInt(comptime signedness: std.builtin.Signedness, comptime N: usi	...	@@ -284,6 +285,7 @@ fn testAtomicRmwInt(comptime signedness: std.builtin.Signedness, comptime N: usi
284	}	285	}
285		286
286	test "atomicrmw with 128-bit ints" {	287	test "atomicrmw with 128-bit ints" {
		288	// TODO: this must appear first
287	if (!supports_128_bit_atomics) return error.SkipZigTest;	289	if (!supports_128_bit_atomics) return error.SkipZigTest;
288		290
289	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO

test/behavior/basic.zig+33

test/behavior/bitcast.zig+4-2

test/behavior/bool.zig+1

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

test/behavior/call.zig+5

...	@@ -344,6 +344,7 @@ test "inline call preserves tail call" {	...	@@ -344,6 +344,7 @@ test "inline call preserves tail call" {
344	test "inline call doesn't re-evaluate non generic struct" {	344	test "inline call doesn't re-evaluate non generic struct" {
345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	346	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		347	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
347		348
348	const S = struct {	349	const S = struct {
349	fn foo(f: struct { a: u8, b: u8 }) !void {	350	fn foo(f: struct { a: u8, b: u8 }) !void {
...	@@ -497,6 +498,8 @@ test "argument to generic function has correct result type" {	...	@@ -497,6 +498,8 @@ test "argument to generic function has correct result type" {
497	}	498	}
498		499
499	test "call inline fn through pointer" {	500	test "call inline fn through pointer" {
		501	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		502
500	const S = struct {	503	const S = struct {
501	inline fn foo(x: u8) !void {	504	inline fn foo(x: u8) !void {
502	try expect(x == 123);	505	try expect(x == 123);
...	@@ -644,6 +647,8 @@ test "function call with cast to anyopaque pointer" {	...	@@ -644,6 +647,8 @@ test "function call with cast to anyopaque pointer" {
644	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	647	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
645	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	648	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
646	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	649	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		650	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		651
647	const Foo = struct {	652	const Foo = struct {
648	y: u8,	653	y: u8,
649	var foo: @This() = undefined;	654	var foo: @This() = undefined;

test/behavior/cast.zig+85-10

test/behavior/cast_int.zig+4-1

...	@@ -22,6 +22,7 @@ test "coerce i8 to i32 and @intCast back" {	...	@@ -22,6 +22,7 @@ test "coerce i8 to i32 and @intCast back" {
22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25		26
26	var x: i8 = -5;	27	var x: i8 = -5;
27	var y: i32 = -5;	28	var y: i32 = -5;
...	@@ -35,6 +36,8 @@ test "coerce i8 to i32 and @intCast back" {	...	@@ -35,6 +36,8 @@ test "coerce i8 to i32 and @intCast back" {
35	}	36	}
36		37
37	test "coerce non byte-sized integers accross 32bits boundary" {	38	test "coerce non byte-sized integers accross 32bits boundary" {
		39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		40
38	{	41	{
39	var v: u21 = 6417;	42	var v: u21 = 6417;
40	_ = &v;	43	_ = &v;
...	@@ -179,8 +182,8 @@ test "load non byte-sized optional value" {	...	@@ -179,8 +182,8 @@ test "load non byte-sized optional value" {
179	}	182	}
180		183
181	test "load non byte-sized value in struct" {	184	test "load non byte-sized value in struct" {
182	if (builtin.cpu.arch.endian() != .little) return error.SkipZigTest; // packed struct TODO
183	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	185	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		186	if (builtin.cpu.arch.endian() != .little) return error.SkipZigTest; // packed struct TODO
184		187
185	// note: this bug is triggered by the == operator, expectEqual will hide it	188	// note: this bug is triggered by the == operator, expectEqual will hide it
186	// using ptrCast not to depend on unitialised memory state	189	// using ptrCast not to depend on unitialised memory state

test/behavior/const_slice_child.zig+1

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

test/behavior/decl_literals.zig+5-4

...	@@ -33,10 +33,11 @@ test "decl literal with pointer" {	...	@@ -33,10 +33,11 @@ test "decl literal with pointer" {
33	}	33	}
34		34
35	test "call decl literal with optional" {	35	test "call decl literal with optional" {
36	if (builtin.zig_backend == .stage2_sparc64 or	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
37	builtin.zig_backend == .stage2_arm or	37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	builtin.zig_backend == .stage2_aarch64 or	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		40
40	const S = struct {	41	const S = struct {
41	x: u32,	42	x: u32,
42	fn init() ?@This() {	43	fn init() ?@This() {

test/behavior/defer.zig+1

...	@@ -160,6 +160,7 @@ test "reference to errdefer payload" {	...	@@ -160,6 +160,7 @@ test "reference to errdefer payload" {
160	test "simple else prong doesn't emit an error for unreachable else prong" {	160	test "simple else prong doesn't emit an error for unreachable else prong" {
161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
163		164
164	const S = struct {	165	const S = struct {
165	fn foo() error{Foo}!void {	166	fn foo() error{Foo}!void {

test/behavior/destructure.zig+2

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

test/behavior/enum.zig+4

test/behavior/error.zig+2

...	@@ -124,6 +124,7 @@ test "debug info for optional error set" {	...	@@ -124,6 +124,7 @@ test "debug info for optional error set" {
124		124
125	test "implicit cast to optional to error union to return result loc" {	125	test "implicit cast to optional to error union to return result loc" {
126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		127	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
127		128
128	const S = struct {	129	const S = struct {
129	fn entry() !void {	130	fn entry() !void {
...	@@ -150,6 +151,7 @@ test "fn returning empty error set can be passed as fn returning any error" {	...	@@ -150,6 +151,7 @@ test "fn returning empty error set can be passed as fn returning any error" {
150		151
151	test "fn returning empty error set can be passed as fn returning any error - pointer" {	152	test "fn returning empty error set can be passed as fn returning any error - pointer" {
152	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	153	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		154
153	entryPtr();	155	entryPtr();
154	comptime entryPtr();	156	comptime entryPtr();
155	}	157	}

test/behavior/eval.zig+20

test/behavior/export_keyword.zig+1

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

test/behavior/field_parent_ptr.zig+6

...	@@ -2,6 +2,7 @@ const expect = @import("std").testing.expect;	...	@@ -2,6 +2,7 @@ const expect = @import("std").testing.expect;
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	test "@fieldParentPtr struct" {	4	test "@fieldParentPtr struct" {
		5	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	6	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
6		7
7	const C = struct {	8	const C = struct {
...	@@ -138,6 +139,7 @@ test "@fieldParentPtr struct" {	...	@@ -138,6 +139,7 @@ test "@fieldParentPtr struct" {
138		139
139	test "@fieldParentPtr extern struct" {	140	test "@fieldParentPtr extern struct" {
140	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	141	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		142	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
141		143
142	const C = extern struct {	144	const C = extern struct {
143	a: bool = true,	145	a: bool = true,
...	@@ -1344,6 +1346,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {	...	@@ -1344,6 +1346,7 @@ test "@fieldParentPtr packed struct last zero-bit field" {
1344		1346
1345	test "@fieldParentPtr tagged union" {	1347	test "@fieldParentPtr tagged union" {
1346	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1348	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1349	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1347		1350
1348	const C = union(enum) {	1351	const C = union(enum) {
1349	a: bool,	1352	a: bool,
...	@@ -1478,6 +1481,7 @@ test "@fieldParentPtr tagged union" {	...	@@ -1478,6 +1481,7 @@ test "@fieldParentPtr tagged union" {
1478	}	1481	}
1479		1482
1480	test "@fieldParentPtr untagged union" {	1483	test "@fieldParentPtr untagged union" {
		1484	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1481	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1485	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1482		1486
1483	const C = union {	1487	const C = union {
...	@@ -1614,6 +1618,7 @@ test "@fieldParentPtr untagged union" {	...	@@ -1614,6 +1618,7 @@ test "@fieldParentPtr untagged union" {
1614		1618
1615	test "@fieldParentPtr extern union" {	1619	test "@fieldParentPtr extern union" {
1616	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1620	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1621	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1617		1622
1618	const C = extern union {	1623	const C = extern union {
1619	a: bool,	1624	a: bool,
...	@@ -1889,6 +1894,7 @@ test "@fieldParentPtr tagged union all zero-bit fields" {	...	@@ -1889,6 +1894,7 @@ test "@fieldParentPtr tagged union all zero-bit fields" {
1889	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1894	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1890	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1895	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1891	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1896	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1897	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1892		1898
1893	const C = union(enum) {	1899	const C = union(enum) {
1894	a: u0,	1900	a: u0,

test/behavior/floatop.zig+36-10

test/behavior/fn.zig+4

...	@@ -257,6 +257,7 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -257,6 +257,7 @@ test "implicit cast fn call result to optional in field result" {
257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
260		261
261	const S = struct {	262	const S = struct {
262	fn entry() !void {	263	fn entry() !void {
...	@@ -468,6 +469,7 @@ test "method call with optional and error union first param" {	...	@@ -468,6 +469,7 @@ test "method call with optional and error union first param" {
468	test "method call with optional pointer first param" {	469	test "method call with optional pointer first param" {
469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	470	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	471	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		472	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
471		473
472	const S = struct {	474	const S = struct {
473	x: i32 = 1234,	475	x: i32 = 1234,
...	@@ -619,6 +621,8 @@ test "inline function with comptime-known comptime-only return type called at ru	...	@@ -619,6 +621,8 @@ test "inline function with comptime-known comptime-only return type called at ru
619	}	621	}
620		622
621	test "address of function parameter is consistent" {	623	test "address of function parameter is consistent" {
		624	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		625
622	const S = struct {	626	const S = struct {
623	fn paramAddrMatch(x: u8) bool {	627	fn paramAddrMatch(x: u8) bool {
624	return &x == &x;	628	return &x == &x;

test/behavior/fn_in_struct_in_comptime.zig+2

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

test/behavior/for.zig+10

test/behavior/generics.zig+16-2

test/behavior/globals.zig+5

...	@@ -28,6 +28,7 @@ test "slices pointing at the same address as global array." {	...	@@ -28,6 +28,7 @@ test "slices pointing at the same address as global array." {
28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	28	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
31		32
32	const S = struct {	33	const S = struct {
33	const a = [_]u8{ 1, 2, 3 };	34	const a = [_]u8{ 1, 2, 3 };
...	@@ -83,6 +84,8 @@ test "global const can be self-referential" {	...	@@ -83,6 +84,8 @@ test "global const can be self-referential" {
83	}	84	}
84		85
85	test "global var can be self-referential" {	86	test "global var can be self-referential" {
		87	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		88
86	const S = struct {	89	const S = struct {
87	self: *@This(),	90	self: *@This(),
88	x: u32,	91	x: u32,
...	@@ -134,6 +137,8 @@ test "global const can be indirectly self-referential" {	...	@@ -134,6 +137,8 @@ test "global const can be indirectly self-referential" {
134	}	137	}
135		138
136	test "global var can be indirectly self-referential" {	139	test "global var can be indirectly self-referential" {
		140	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		141
137	const S = struct {	142	const S = struct {
138	other: *@This(),	143	other: *@This(),
139	x: u32,	144	x: u32,

test/behavior/if.zig+1

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

test/behavior/lower_strlit_to_vector.zig+1

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

test/behavior/math.zig+13-1

test/behavior/maximum_minimum.zig+4

test/behavior/memcpy.zig+5

test/behavior/muladd.zig+5

...	@@ -8,6 +8,7 @@ test "@mulAdd" {	...	@@ -8,6 +8,7 @@ test "@mulAdd" {
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11		12
12	try comptime testMulAdd();	13	try comptime testMulAdd();
13	try testMulAdd();	14	try testMulAdd();
...	@@ -36,6 +37,7 @@ test "@mulAdd f16" {	...	@@ -36,6 +37,7 @@ test "@mulAdd f16" {
36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	38	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
38	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	39	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		40	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
39		41
40	try comptime testMulAdd16();	42	try comptime testMulAdd16();
41	try testMulAdd16();	43	try testMulAdd16();
...	@@ -111,6 +113,7 @@ test "vector f16" {	...	@@ -111,6 +113,7 @@ test "vector f16" {
111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
112	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	114	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
113	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	115	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		116	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
114		117
115	try comptime vector16();	118	try comptime vector16();
116	try vector16();	119	try vector16();
...	@@ -136,6 +139,7 @@ test "vector f32" {	...	@@ -136,6 +139,7 @@ test "vector f32" {
136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	140	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
138	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	141	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		142	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
139		143
140	try comptime vector32();	144	try comptime vector32();
141	try vector32();	145	try vector32();
...	@@ -161,6 +165,7 @@ test "vector f64" {	...	@@ -161,6 +165,7 @@ test "vector f64" {
161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	165	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	166	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
163	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	167	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		168	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
164		169
165	try comptime vector64();	170	try comptime vector64();
166	try vector64();	171	try vector64();

test/behavior/null.zig+1

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

test/behavior/optional.zig+8-1

test/behavior/packed-struct.zig+5

...	@@ -1299,6 +1299,8 @@ test "packed struct contains optional pointer" {	...	@@ -1299,6 +1299,8 @@ test "packed struct contains optional pointer" {
1299	}	1299	}
1300		1300
1301	test "packed struct equality" {	1301	test "packed struct equality" {
		1302	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1303
1302	const Foo = packed struct {	1304	const Foo = packed struct {
1303	a: u4,	1305	a: u4,
1304	b: u4,	1306	b: u4,
...	@@ -1319,6 +1321,8 @@ test "packed struct equality" {	...	@@ -1319,6 +1321,8 @@ test "packed struct equality" {
1319	}	1321	}
1320		1322
1321	test "packed struct with signed field" {	1323	test "packed struct with signed field" {
		1324	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1325
1322	var s: packed struct {	1326	var s: packed struct {
1323	a: i2,	1327	a: i2,
1324	b: u6,	1328	b: u6,
...	@@ -1332,6 +1336,7 @@ test "assign packed struct initialized with RLS to packed struct literal field"	...	@@ -1332,6 +1336,7 @@ test "assign packed struct initialized with RLS to packed struct literal field"
1332	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isWasm()) return error.SkipZigTest;	1336	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isWasm()) return error.SkipZigTest;
1333	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1337	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1334	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;	1338	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
		1339	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1335		1340
1336	const Inner = packed struct { x: u17 };	1341	const Inner = packed struct { x: u17 };
1337	const Outer = packed struct { inner: Inner, x: u15 };	1342	const Outer = packed struct { inner: Inner, x: u15 };

test/behavior/pointers.zig+25

test/behavior/ptrcast.zig+3

test/behavior/ptrfromint.zig+2

...	@@ -17,6 +17,7 @@ test "mutate through ptr initialized with constant ptrFromInt value" {	...	@@ -17,6 +17,7 @@ test "mutate through ptr initialized with constant ptrFromInt value" {
17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20		21
21	forceCompilerAnalyzeBranchHardCodedPtrDereference(false);	22	forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
22	}	23	}
...	@@ -34,6 +35,7 @@ test "@ptrFromInt creates null pointer" {	...	@@ -34,6 +35,7 @@ test "@ptrFromInt creates null pointer" {
34	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		38	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37		39
38	const ptr = @as(?*u32, @ptrFromInt(0));	40	const ptr = @as(?*u32, @ptrFromInt(0));
39	try expectEqual(@as(?*u32, null), ptr);	41	try expectEqual(@as(?*u32, null), ptr);

test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1

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

test/behavior/select.zig+2

...	@@ -9,6 +9,7 @@ test "@select vectors" {	...	@@ -9,6 +9,7 @@ test "@select vectors" {
9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		12	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
12		13
13	try comptime selectVectors();	14	try comptime selectVectors();
14	try selectVectors();	15	try selectVectors();
...	@@ -39,6 +40,7 @@ test "@select arrays" {	...	@@ -39,6 +40,7 @@ test "@select arrays" {
39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	42	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
42	if (builtin.zig_backend == .stage2_x86_64 and	44	if (builtin.zig_backend == .stage2_x86_64 and
43	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;	45	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;
44		46

test/behavior/shuffle.zig+4

test/behavior/sizeof_and_typeof.zig+1-3

test/behavior/slice.zig+33

test/behavior/src.zig+1

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

test/behavior/string_literals.zig+5

test/behavior/struct.zig+19-1

test/behavior/struct_contains_null_ptr_itself.zig+1

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

test/behavior/struct_contains_slice_of_itself.zig+2

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

test/behavior/switch.zig+6-8

 @@ -9,13 +9,12 @@ const maxInt = std.math.maxInt;
 test "switch with numbers" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try testSwitchWithNumbers(13);
 }
 fn testSwitchWithNumbers(x: u32) !void {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
     const result = switch (x) {
         1, 2, 3, 4...8 => false,
         13 => true,
 @@ -323,14 +322,13 @@ fn testSwitchEnumPtrCapture() !void {
 test "switch handles all cases of number" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try testSwitchHandleAllCases();
     try comptime testSwitchHandleAllCases();
 }
 fn testSwitchHandleAllCases() !void {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
     try expect(testSwitchHandleAllCasesExhaustive(0) == 3);
     try expect(testSwitchHandleAllCasesExhaustive(1) == 2);
     try expect(testSwitchHandleAllCasesExhaustive(2) == 1);
 @@ -694,6 +692,7 @@ test "switch prong pointer capture alignment" {
 test "switch on pointer type" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const S = struct {
         const X = struct {
 @@ -742,6 +741,7 @@ test "switch capture copies its payload" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const S = struct {
         fn doTheTest() !void {
 @@ -832,6 +832,8 @@ test "comptime inline switch" {
 }
 test "switch capture peer type resolution" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const U = union(enum) {
         a: u32,
         b: u64,
 @@ -867,8 +869,6 @@ test "switch capture peer type resolution for in-memory coercible payloads" {
 }
 test "switch pointer capture peer type resolution" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const T1 = c_int;
     const T2 = @Type(@typeInfo(T1));
 @@ -989,8 +989,6 @@ test "prong with inline call to unreachable" {
 }
 test "block error return trace index is reset between prongs" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
     const S = struct {
         fn returnError() error{TestFailed} {
             return error.TestFailed;

test/behavior/threadlocal.zig+2

...	@@ -25,6 +25,7 @@ test "pointer to thread local array" {	...	@@ -25,6 +25,7 @@ test "pointer to thread local array" {
25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
26	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	26	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
27	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	27	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		28	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
28		29
29	const s = "Hello world";	30	const s = "Hello world";
30	@memcpy(buffer[0..s.len], s);	31	@memcpy(buffer[0..s.len], s);
...	@@ -38,6 +39,7 @@ test "reference a global threadlocal variable" {	...	@@ -38,6 +39,7 @@ test "reference a global threadlocal variable" {
38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		42	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41		43
42	_ = nrfx_uart_rx(&g_uart0);	44	_ = nrfx_uart_rx(&g_uart0);
43	}	45	}

test/behavior/truncate.zig+1

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

test/behavior/try.zig-1

...	@@ -72,7 +72,6 @@ test "'return try' of empty error set in function returning non-error" {	...	@@ -72,7 +72,6 @@ test "'return try' of empty error set in function returning non-error" {
72	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	72	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
76	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	75	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
77		76
78	const S = struct {	77	const S = struct {

test/behavior/tuple.zig+14-2

test/behavior/tuple_declarations.zig+2

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

test/behavior/type.zig+3

test/behavior/type_info.zig+13

...	@@ -161,6 +161,7 @@ test "type info: error set, error union info, anyerror" {	...	@@ -161,6 +161,7 @@ test "type info: error set, error union info, anyerror" {
161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
164		165
165	try testErrorSet();	166	try testErrorSet();
166	try comptime testErrorSet();	167	try comptime testErrorSet();
...	@@ -192,6 +193,7 @@ test "type info: error set single value" {	...	@@ -192,6 +193,7 @@ test "type info: error set single value" {
192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
193	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		196	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
195		197
196	const TestSet = error.One;	198	const TestSet = error.One;
197		199
...	@@ -205,6 +207,7 @@ test "type info: error set merged" {	...	@@ -205,6 +207,7 @@ test "type info: error set merged" {
205	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	207	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
206	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	208	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
207	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		210	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
208		211
209	const TestSet = error{ One, Two } \|\| error{Three};	212	const TestSet = error{ One, Two } \|\| error{Three};
210		213
...	@@ -220,6 +223,7 @@ test "type info: enum info" {	...	@@ -220,6 +223,7 @@ test "type info: enum info" {
220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	223	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		226	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
223		227
224	try testEnum();	228	try testEnum();
225	try comptime testEnum();	229	try comptime testEnum();
...	@@ -282,6 +286,7 @@ fn testUnion() !void {	...	@@ -282,6 +286,7 @@ fn testUnion() !void {
282		286
283	test "type info: struct info" {	287	test "type info: struct info" {
284	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		289	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
285		290
286	try testStruct();	291	try testStruct();
287	try comptime testStruct();	292	try comptime testStruct();
...	@@ -551,6 +556,7 @@ test "type info for async frames" {	...	@@ -551,6 +556,7 @@ test "type info for async frames" {
551		556
552	test "Declarations are returned in declaration order" {	557	test "Declarations are returned in declaration order" {
553	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	558	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		559	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
554		560
555	const S = struct {	561	const S = struct {
556	pub const a = 1;	562	pub const a = 1;
...	@@ -572,6 +578,8 @@ test "Struct.is_tuple for anon list literal" {	...	@@ -572,6 +578,8 @@ test "Struct.is_tuple for anon list literal" {
572	}	578	}
573		579
574	test "Struct.is_tuple for anon struct literal" {	580	test "Struct.is_tuple for anon struct literal" {
		581	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		582
575	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	583	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
576		584
577	const info = @typeInfo(@TypeOf(.{ .a = 0 }));	585	const info = @typeInfo(@TypeOf(.{ .a = 0 }));
...	@@ -586,6 +594,8 @@ test "StructField.is_comptime" {	...	@@ -586,6 +594,8 @@ test "StructField.is_comptime" {
586	}	594	}
587		595
588	test "typeInfo resolves usingnamespace declarations" {	596	test "typeInfo resolves usingnamespace declarations" {
		597	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		598
589	const A = struct {	599	const A = struct {
590	pub const f1 = 42;	600	pub const f1 = 42;
591	};	601	};
...	@@ -611,6 +621,7 @@ test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {	...	@@ -611,6 +621,7 @@ test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {
611	test "@typeInfo decls and usingnamespace" {	621	test "@typeInfo decls and usingnamespace" {
612	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	622	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
613	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	623	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		624	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
614		625
615	const A = struct {	626	const A = struct {
616	pub const x = 5;	627	pub const x = 5;
...	@@ -651,6 +662,8 @@ test "type info of tuple of string literal default value" {	...	@@ -651,6 +662,8 @@ test "type info of tuple of string literal default value" {
651	}	662	}
652		663
653	test "@typeInfo only contains pub decls" {	664	test "@typeInfo only contains pub decls" {
		665	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		666
654	const other = struct {	667	const other = struct {
655	const std = @import("std");	668	const std = @import("std");
656		669

test/behavior/typename.zig+2

...	@@ -67,6 +67,7 @@ test "basic" {	...	@@ -67,6 +67,7 @@ test "basic" {
67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		70	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
70		71
71	try expectEqualStrings("i64", @typeName(i64));	72	try expectEqualStrings("i64", @typeName(i64));
72	try expectEqualStrings("usize", @typeName(usize));	73	try expectEqualStrings("usize", @typeName(usize));
...	@@ -237,6 +238,7 @@ test "comptime parameters not converted to anytype in function type" {	...	@@ -237,6 +238,7 @@ test "comptime parameters not converted to anytype in function type" {
237	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	238	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	239	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		241	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
240		242
241	const T = fn (comptime fn (comptime type) void, void) void;	243	const T = fn (comptime fn (comptime type) void, void) void;
242	try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));	244	try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));

test/behavior/undefined.zig+2

...	@@ -79,6 +79,7 @@ test "assign undefined to struct with method" {	...	@@ -79,6 +79,7 @@ test "assign undefined to struct with method" {
79	}	79	}
80		80
81	test "type name of undefined" {	81	test "type name of undefined" {
		82	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
82	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
83		84
84	const x = undefined;	85	const x = undefined;
...	@@ -91,6 +92,7 @@ test "reslice of undefined global var slice" {	...	@@ -91,6 +92,7 @@ test "reslice of undefined global var slice" {
91	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	92	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		95	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
94		96
95	var stack_buf: [100]u8 = [_]u8{0} ** 100;	97	var stack_buf: [100]u8 = [_]u8{0} ** 100;
96	buf = &stack_buf;	98	buf = &stack_buf;

test/behavior/union.zig+21-1

test/behavior/usingnamespace.zig+8

test/behavior/var_args.zig+1-1

 @@ -192,8 +192,8 @@ test "variadic functions" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.os.tag != .macos and builtin.cpu.arch.isAARCH64()) {
         // https://github.com/ziglang/zig/issues/14096
         return error.SkipZigTest;

test/behavior/vector.zig+22-1

test/behavior/void.zig+1

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

test/behavior/while.zig+4

...	@@ -38,6 +38,8 @@ fn staticWhileLoop2() i32 {	...	@@ -38,6 +38,8 @@ fn staticWhileLoop2() i32 {
38	}	38	}
39		39
40	test "while with continue expression" {	40	test "while with continue expression" {
		41	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		42
41	var sum: i32 = 0;	43	var sum: i32 = 0;
42	{	44	{
43	var i: i32 = 0;	45	var i: i32 = 0;
...	@@ -158,6 +160,7 @@ test "while with optional as condition with else" {	...	@@ -158,6 +160,7 @@ test "while with optional as condition with else" {
158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
160	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	162	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
161		164
162	numbers_left = 10;	165	numbers_left = 10;
163	var sum: i32 = 0;	166	var sum: i32 = 0;
...	@@ -175,6 +178,7 @@ test "while with optional as condition with else" {	...	@@ -175,6 +178,7 @@ test "while with optional as condition with else" {
175	test "while with error union condition" {	178	test "while with error union condition" {
176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	179	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	180	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		181	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
178		182
179	numbers_left = 10;	183	numbers_left = 10;
180	var sum: i32 = 0;	184	var sum: i32 = 0;

...	@@ -7,6 +7,7 @@ test "@abs integers" {	...	@@ -7,6 +7,7 @@ test "@abs integers" {
7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	9	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10		11
11	try comptime testAbsIntegers();	12	try comptime testAbsIntegers();
12	try testAbsIntegers();	13	try testAbsIntegers();
...	@@ -215,6 +216,7 @@ test "@abs int vectors" {	...	@@ -215,6 +216,7 @@ test "@abs int vectors" {
215	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	216	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
216	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	218	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		219	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
218		220
219	try comptime testAbsIntVectors(1);	221	try comptime testAbsIntVectors(1);
220	try testAbsIntVectors(1);	222	try testAbsIntVectors(1);
...	@@ -281,6 +283,7 @@ test "@abs unsigned int vectors" {	...	@@ -281,6 +283,7 @@ test "@abs unsigned int vectors" {
281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	283	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	284	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	285	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		286	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
284		287
285	try comptime testAbsUnsignedIntVectors(1);	288	try comptime testAbsUnsignedIntVectors(1);
286	try testAbsUnsignedIntVectors(1);	289	try testAbsUnsignedIntVectors(1);

...	@@ -52,6 +52,8 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {	...	@@ -52,6 +52,8 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {
52	}	52	}
53		53
54	test "@alignCast pointers" {	54	test "@alignCast pointers" {
		55	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		56
55	var x: u32 align(4) = 1;	57	var x: u32 align(4) = 1;
56	expectsOnly1(&x);	58	expectsOnly1(&x);
57	try expect(x == 2);	59	try expect(x == 2);
...	@@ -199,6 +201,7 @@ test "alignment and size of structs with 128-bit fields" {	...	@@ -199,6 +201,7 @@ test "alignment and size of structs with 128-bit fields" {
199	test "implicitly decreasing slice alignment" {	201	test "implicitly decreasing slice alignment" {
200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	202	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
201	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
202		205
203	const a: u32 align(4) = 3;	206	const a: u32 align(4) = 3;
204	const b: u32 align(8) = 4;	207	const b: u32 align(8) = 4;
...	@@ -211,6 +214,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {	...	@@ -211,6 +214,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
211	test "specifying alignment allows pointer cast" {	214	test "specifying alignment allows pointer cast" {
212	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	215	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	216	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		217	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
214		218
215	try testBytesAlign(0x33);	219	try testBytesAlign(0x33);
216	}	220	}
...	@@ -276,6 +280,7 @@ test "function alignment" {	...	@@ -276,6 +280,7 @@ test "function alignment" {
276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		283	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
279		284
280	// function alignment is a compile error on wasm	285	// function alignment is a compile error on wasm
281	if (native_arch.isWasm()) return error.SkipZigTest;	286	if (native_arch.isWasm()) return error.SkipZigTest;
...	@@ -349,6 +354,7 @@ fn simple4() align(4) i32 {	...	@@ -349,6 +354,7 @@ fn simple4() align(4) i32 {
349		354
350	test "runtime-known array index has best alignment possible" {	355	test "runtime-known array index has best alignment possible" {
351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	356	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		357	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
352		358
353	// take full advantage of over-alignment	359	// take full advantage of over-alignment
354	var array align(4) = [_]u8{ 1, 2, 3, 4 };	360	var array align(4) = [_]u8{ 1, 2, 3, 4 };
...	@@ -485,6 +491,7 @@ test "align(N) on functions" {	...	@@ -485,6 +491,7 @@ test "align(N) on functions" {
485	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	491	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	492	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	493	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		494	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
488		495
489	if (builtin.zig_backend == .stage2_c) {	496	if (builtin.zig_backend == .stage2_c) {
490	// https://github.com/ziglang/zig/issues/16845	497	// https://github.com/ziglang/zig/issues/16845
...	@@ -525,6 +532,7 @@ test "comptime alloc alignment" {	...	@@ -525,6 +532,7 @@ test "comptime alloc alignment" {
525	test "@alignCast null" {	532	test "@alignCast null" {
526	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	533	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
527	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	534	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		535	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
528		536
529	var ptr: ?*anyopaque = null;	537	var ptr: ?*anyopaque = null;
530	_ = &ptr;	538	_ = &ptr;
...	@@ -541,6 +549,7 @@ test "sub-aligned pointer field access" {	...	@@ -541,6 +549,7 @@ test "sub-aligned pointer field access" {
541	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	549	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
542	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
543	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	551	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		552	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
544		553
545	// Originally reported at https://github.com/ziglang/zig/issues/14904	554	// Originally reported at https://github.com/ziglang/zig/issues/14904
546		555
...	@@ -615,6 +624,8 @@ test "zero-bit fields in extern struct pad fields appropriately" {	...	@@ -615,6 +624,8 @@ test "zero-bit fields in extern struct pad fields appropriately" {
615	}	624	}
616		625
617	test "function pointer @intFromPtr/@ptrFromInt roundtrip" {	626	test "function pointer @intFromPtr/@ptrFromInt roundtrip" {
		627	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		628
618	// This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`	629	// This only succeeds on Thumb if we handle the Thumb bit correctly; if not, the `@ptrFromInt`
619	// will incorrectly trip an alignment safety check.	630	// will incorrectly trip an alignment safety check.
620		631

...	@@ -24,6 +24,7 @@ fn testTruncate(x: u32) u8 {	...	@@ -24,6 +24,7 @@ fn testTruncate(x: u32) u8 {
24	}	24	}
25		25
26	test "truncate to non-power-of-two integers" {	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_sparc64) return error.SkipZigTest; // TODO	28	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
28		29
29	try testTrunc(u32, u1, 0b10101, 0b1);	30	try testTrunc(u32, u1, 0b10101, 0b1);
...	@@ -208,12 +209,14 @@ fn first4KeysOfHomeRow() []const u8 {	...	@@ -208,12 +209,14 @@ fn first4KeysOfHomeRow() []const u8 {
208	}	209	}
209		210
210	test "return string from function" {	211	test "return string from function" {
		212	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212		214
213	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));	215	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
214	}	216	}
215		217
216	test "hex escape" {	218	test "hex escape" {
		219	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
218		221
219	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));	222	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
...	@@ -221,6 +224,7 @@ test "hex escape" {	...	@@ -221,6 +224,7 @@ test "hex escape" {
221		224
222	test "multiline string" {	225	test "multiline string" {
223	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	226	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		227	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
224		228
225	const s1 =	229	const s1 =
226	\\one	230	\\one
...	@@ -233,6 +237,7 @@ test "multiline string" {	...	@@ -233,6 +237,7 @@ test "multiline string" {
233		237
234	test "multiline string comments at start" {	238	test "multiline string comments at start" {
235	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		240	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
236		241
237	const s1 =	242	const s1 =
238	//\\one	243	//\\one
...	@@ -245,6 +250,7 @@ test "multiline string comments at start" {	...	@@ -245,6 +250,7 @@ test "multiline string comments at start" {
245		250
246	test "multiline string comments at end" {	251	test "multiline string comments at end" {
247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		253	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
248		254
249	const s1 =	255	const s1 =
250	\\one	256	\\one
...	@@ -257,6 +263,7 @@ test "multiline string comments at end" {	...	@@ -257,6 +263,7 @@ test "multiline string comments at end" {
257		263
258	test "multiline string comments in middle" {	264	test "multiline string comments in middle" {
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		266	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
260		267
261	const s1 =	268	const s1 =
262	\\one	269	\\one
...	@@ -269,6 +276,7 @@ test "multiline string comments in middle" {	...	@@ -269,6 +276,7 @@ test "multiline string comments in middle" {
269		276
270	test "multiline string comments at multiple places" {	277	test "multiline string comments at multiple places" {
271	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		279	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
272		280
273	const s1 =	281	const s1 =
274	\\one	282	\\one
...	@@ -282,11 +290,14 @@ test "multiline string comments at multiple places" {	...	@@ -282,11 +290,14 @@ test "multiline string comments at multiple places" {
282	}	290	}
283		291
284	test "string concatenation simple" {	292	test "string concatenation simple" {
		293	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		294
285	try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));	295	try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
286	}	296	}
287		297
288	test "array mult operator" {	298	test "array mult operator" {
289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		300	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
290		301
291	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));	302	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
292	}	303	}
...	@@ -308,6 +319,8 @@ const global_a: i32 = 1234;	...	@@ -308,6 +319,8 @@ const global_a: i32 = 1234;
308	const global_b: *const i32 = &global_a;	319	const global_b: *const i32 = &global_a;
309	const global_c: const f32 = @as(const f32, @ptrCast(global_b));	320	const global_c: const f32 = @as(const f32, @ptrCast(global_b));
310	test "compile time global reinterpret" {	321	test "compile time global reinterpret" {
		322	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		323
311	const d = @as(*const i32, @ptrCast(global_c));	324	const d = @as(*const i32, @ptrCast(global_c));
312	try expect(d.* == 1234);	325	try expect(d.* == 1234);
313	}	326	}
...	@@ -435,6 +448,8 @@ fn f2(x: bool) []const u8 {	...	@@ -435,6 +448,8 @@ fn f2(x: bool) []const u8 {
435	}	448	}
436		449
437	test "variable is allowed to be a pointer to an opaque type" {	450	test "variable is allowed to be a pointer to an opaque type" {
		451	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		452
438	var x: i32 = 1234;	453	var x: i32 = 1234;
439	_ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));	454	_ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));
440	}	455	}
...	@@ -457,6 +472,8 @@ fn testTakeAddressOfParameter(f: f32) !void {	...	@@ -457,6 +472,8 @@ fn testTakeAddressOfParameter(f: f32) !void {
457	}	472	}
458		473
459	test "pointer to void return type" {	474	test "pointer to void return type" {
		475	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		476
460	try testPointerToVoidReturnType();	477	try testPointerToVoidReturnType();
461	}	478	}
462	fn testPointerToVoidReturnType() anyerror!void {	479	fn testPointerToVoidReturnType() anyerror!void {
...	@@ -472,6 +489,7 @@ test "array 2D const double ptr" {	...	@@ -472,6 +489,7 @@ test "array 2D const double ptr" {
472	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	489	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	490	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
474	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	491	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		492	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
475		493
476	const rect_2d_vertexes = [_][1]f32{	494	const rect_2d_vertexes = [_][1]f32{
477	[_]f32{1.0},	495	[_]f32{1.0},
...	@@ -484,6 +502,7 @@ test "array 2D const double ptr with offset" {	...	@@ -484,6 +502,7 @@ test "array 2D const double ptr with offset" {
484	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	502	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
485	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	503	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		505	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
487		506
488	const rect_2d_vertexes = [_][2]f32{	507	const rect_2d_vertexes = [_][2]f32{
489	[_]f32{ 3.0, 4.239 },	508	[_]f32{ 3.0, 4.239 },
...	@@ -496,6 +515,7 @@ test "array 3D const double ptr with offset" {	...	@@ -496,6 +515,7 @@ test "array 3D const double ptr with offset" {
496	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
497	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
498	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	517	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		518	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
499		519
500	const rect_3d_vertexes = [_][2][2]f32{	520	const rect_3d_vertexes = [_][2][2]f32{
501	[_][2]f32{	521	[_][2]f32{
...	@@ -551,6 +571,8 @@ fn testStructInFn() !void {	...	@@ -551,6 +571,8 @@ fn testStructInFn() !void {
551		571
552	test "fn call returning scalar optional in equality expression" {	572	test "fn call returning scalar optional in equality expression" {
553	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	573	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		574	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		575
554	try expect(getNull() == null);	576	try expect(getNull() == null);
555	}	577	}
556		578
...	@@ -561,6 +583,7 @@ fn getNull() ?*i32 {	...	@@ -561,6 +583,7 @@ fn getNull() ?*i32 {
561	test "global variable assignment with optional unwrapping with var initialized to undefined" {	583	test "global variable assignment with optional unwrapping with var initialized to undefined" {
562	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
563	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	585	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		586	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
564		587
565	const S = struct {	588	const S = struct {
566	var data: i32 = 1234;	589	var data: i32 = 1234;
...	@@ -676,6 +699,7 @@ test "self reference through fn ptr field" {	...	@@ -676,6 +699,7 @@ test "self reference through fn ptr field" {
676		699
677	test "global variable initialized to global variable array element" {	700	test "global variable initialized to global variable array element" {
678	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	701	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		702	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
679		703
680	try expect(global_ptr == &gdt[0]);	704	try expect(global_ptr == &gdt[0]);
681	}	705	}
...	@@ -708,6 +732,7 @@ test "global constant is loaded with a runtime-known index" {	...	@@ -708,6 +732,7 @@ test "global constant is loaded with a runtime-known index" {
708		732
709	test "multiline string literal is null terminated" {	733	test "multiline string literal is null terminated" {
710	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	734	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		735	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
711		736
712	const s1 =	737	const s1 =
713	\\one	738	\\one
...	@@ -722,6 +747,7 @@ test "string escapes" {	...	@@ -722,6 +747,7 @@ test "string escapes" {
722	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	747	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
723	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	748	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
724	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	749	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		750	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
725		751
726	try expectEqualStrings("\"", "\x22");	752	try expectEqualStrings("\"", "\x22");
727	try expectEqualStrings("\'", "\x27");	753	try expectEqualStrings("\'", "\x27");
...	@@ -739,6 +765,8 @@ test "explicit cast optional pointers" {	...	@@ -739,6 +765,8 @@ test "explicit cast optional pointers" {
739	}	765	}
740		766
741	test "pointer comparison" {	767	test "pointer comparison" {
		768	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		769
742	const a = @as([]const u8, "a");	770	const a = @as([]const u8, "a");
743	const b = &a;	771	const b = &a;
744	try expect(ptrEql(b, b));	772	try expect(ptrEql(b, b));
...	@@ -789,6 +817,7 @@ fn maybe(x: bool) anyerror!?u32 {	...	@@ -789,6 +817,7 @@ fn maybe(x: bool) anyerror!?u32 {
789	test "auto created variables have correct alignment" {	817	test "auto created variables have correct alignment" {
790	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
791	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	819	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		820	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
792		821
793	const S = struct {	822	const S = struct {
794	fn foo(str: [*]const u8) u32 {	823	fn foo(str: [*]const u8) u32 {
...	@@ -1152,6 +1181,8 @@ test "orelse coercion as function argument" {	...	@@ -1152,6 +1181,8 @@ test "orelse coercion as function argument" {
1152	}	1181	}
1153		1182
1154	test "runtime-known globals initialized with undefined" {	1183	test "runtime-known globals initialized with undefined" {
		1184	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1185
1155	const S = struct {	1186	const S = struct {
1156	var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };	1187	var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
1157	var vp: [*]u32 = undefined;	1188	var vp: [*]u32 = undefined;
...	@@ -1244,6 +1275,8 @@ fn testUnsignedCmp(comptime T: type) !void {	...	@@ -1244,6 +1275,8 @@ fn testUnsignedCmp(comptime T: type) !void {
1244	}	1275	}
1245		1276
1246	test "integer compare <= 64 bits" {	1277	test "integer compare <= 64 bits" {
		1278	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1279
1247	inline for (.{ u8, u16, u32, u64, usize, u10, u20, u30, u60 }) \|T\| {	1280	inline for (.{ u8, u16, u32, u64, usize, u10, u20, u30, u60 }) \|T\| {
1248	try testUnsignedCmp(T);	1281	try testUnsignedCmp(T);
1249	try comptime testUnsignedCmp(T);	1282	try comptime testUnsignedCmp(T);

...	@@ -23,8 +23,8 @@ test "@bitCast iX -> uX (8, 16, 128)" {	...	@@ -23,8 +23,8 @@ test "@bitCast iX -> uX (8, 16, 128)" {
23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
27	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	26	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
28		28
29	const bit_values = [_]usize{ 8, 16, 128 };	29	const bit_values = [_]usize{ 8, 16, 128 };
30		30
...	@@ -153,6 +153,8 @@ test "bitcast literal [4]u8 param to u32" {	...	@@ -153,6 +153,8 @@ test "bitcast literal [4]u8 param to u32" {
153	}	153	}
154		154
155	test "bitcast generates a temporary value" {	155	test "bitcast generates a temporary value" {
		156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		157
156	var y: u16 = 0x55AA;	158	var y: u16 = 0x55AA;
157	_ = &y;	159	_ = &y;
158	const x: u16 = @bitCast(@as([2]u8, @bitCast(y)));	160	const x: u16 = @bitCast(@as([2]u8, @bitCast(y)));
...	@@ -190,6 +192,7 @@ test "@bitCast packed structs at runtime and comptime" {	...	@@ -190,6 +192,7 @@ test "@bitCast packed structs at runtime and comptime" {
190	test "@bitCast extern structs at runtime and comptime" {	192	test "@bitCast extern structs at runtime and comptime" {
191	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		195	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
193		196
194	const Full = extern struct {	197	const Full = extern struct {
195	number: u16,	198	number: u16,
...	@@ -383,7 +386,6 @@ test "comptime bitcast with fields following f80" {	...	@@ -383,7 +386,6 @@ test "comptime bitcast with fields following f80" {
383	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	386	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
384	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	387	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
385	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	388	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
386	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
387	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	389	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
388		390
389	const FloatT = extern struct { f: f80, x: u128 align(16) };	391	const FloatT = extern struct { f: f80, x: u128 align(16) };

...	@@ -945,6 +945,7 @@ test "constant enum initialization with differing sizes" {	...	@@ -945,6 +945,7 @@ test "constant enum initialization with differing sizes" {
945	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	945	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
946	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	946	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
947	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	947	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		948	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
948		949
949	try test3_1(test3_foo);	950	try test3_1(test3_foo);
950	try test3_2(test3_bar);	951	try test3_2(test3_bar);
...	@@ -1047,6 +1048,7 @@ test "tag name with assigned enum values" {	...	@@ -1047,6 +1048,7 @@ test "tag name with assigned enum values" {
1047	test "@tagName on enum literals" {	1048	test "@tagName on enum literals" {
1048	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1049	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1049	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1050	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1051	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1050		1052
1051	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));	1053	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1052	comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar"));	1054	comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar"));
...	@@ -1236,6 +1238,8 @@ test "enum tag from a local variable" {	...	@@ -1236,6 +1238,8 @@ test "enum tag from a local variable" {
1236	}	1238	}
1237		1239
1238	test "auto-numbered enum with signed tag type" {	1240	test "auto-numbered enum with signed tag type" {
		1241	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1242
1239	const E = enum(i32) { a, b };	1243	const E = enum(i32) { a, b };
1240		1244
1241	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));	1245	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));

...	@@ -143,6 +143,7 @@ test "a type constructed in a global expression" {	...	@@ -143,6 +143,7 @@ test "a type constructed in a global expression" {
143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	145	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		146	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
146		147
147	var l: List = undefined;	148	var l: List = undefined;
148	l.array[0] = 10;	149	l.array[0] = 10;
...	@@ -445,6 +446,7 @@ test "binary math operator in partially inlined function" {	...	@@ -445,6 +446,7 @@ test "binary math operator in partially inlined function" {
445	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
446	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
447	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	448	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		449	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
448		450
449	var s: [4]u32 = undefined;	451	var s: [4]u32 = undefined;
450	var b: [16]u8 = undefined;	452	var b: [16]u8 = undefined;
...	@@ -503,6 +505,7 @@ test "comptime shlWithOverflow" {	...	@@ -503,6 +505,7 @@ test "comptime shlWithOverflow" {
503	test "const ptr to variable data changes at runtime" {	505	test "const ptr to variable data changes at runtime" {
504	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	506	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
505	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		508	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
506		509
507	try expect(foo_ref.name[0] == 'a');	510	try expect(foo_ref.name[0] == 'a');
508	foo_ref.name = "b";	511	foo_ref.name = "b";
...	@@ -536,6 +539,7 @@ test "runtime 128 bit integer division" {	...	@@ -536,6 +539,7 @@ test "runtime 128 bit integer division" {
536	test "@tagName of @typeInfo" {	539	test "@tagName of @typeInfo" {
537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	540	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	541	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		542	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
539		543
540	const str = @tagName(@typeInfo(u8));	544	const str = @tagName(@typeInfo(u8));
541	try expect(std.mem.eql(u8, str, "int"));	545	try expect(std.mem.eql(u8, str, "int"));
...	@@ -613,6 +617,7 @@ const hi1 = "hi";	...	@@ -613,6 +617,7 @@ const hi1 = "hi";
613	const hi2 = hi1;	617	const hi2 = hi1;
614	test "const global shares pointer with other same one" {	618	test "const global shares pointer with other same one" {
615	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	619	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		620	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
616		621
617	try assertEqualPtrs(&hi1[0], &hi2[0]);	622	try assertEqualPtrs(&hi1[0], &hi2[0]);
618	comptime assert(&hi1[0] == &hi2[0]);	623	comptime assert(&hi1[0] == &hi2[0]);
...	@@ -739,6 +744,7 @@ test "array concatenation of function calls" {	...	@@ -739,6 +744,7 @@ test "array concatenation of function calls" {
739	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	744	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
740	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	745	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
741	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	746	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		747	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
742		748
743	var a = oneItem(3) ++ oneItem(4);	749	var a = oneItem(3) ++ oneItem(4);
744	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));	750	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
...	@@ -748,6 +754,7 @@ test "array multiplication of function calls" {	...	@@ -748,6 +754,7 @@ test "array multiplication of function calls" {
748	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	754	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
749	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	755	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
750	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	756	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		757	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
751		758
752	var a = oneItem(3) ** scalar(2);	759	var a = oneItem(3) ** scalar(2);
753	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));	760	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
...	@@ -782,6 +789,7 @@ test "array concatenation peer resolves element types - pointer" {	...	@@ -782,6 +789,7 @@ test "array concatenation peer resolves element types - pointer" {
782	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	789	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
783	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	790	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
784	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	791	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		792	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
785		793
786	var a = [2]u3{ 1, 7 };	794	var a = [2]u3{ 1, 7 };
787	var b = [3]u8{ 200, 225, 255 };	795	var b = [3]u8{ 200, 225, 255 };
...	@@ -799,6 +807,7 @@ test "array concatenation sets the sentinel - value" {	...	@@ -799,6 +807,7 @@ test "array concatenation sets the sentinel - value" {
799	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	807	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
800	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	808	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
801	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	809	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		810	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
802		811
803	var a = [2]u3{ 1, 7 };	812	var a = [2]u3{ 1, 7 };
804	var b = [3:69]u8{ 200, 225, 255 };	813	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -818,6 +827,7 @@ test "array concatenation sets the sentinel - pointer" {	...	@@ -818,6 +827,7 @@ test "array concatenation sets the sentinel - pointer" {
818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	827	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
819	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	828	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
820	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	829	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		830	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
821		831
822	var a = [2]u3{ 1, 7 };	832	var a = [2]u3{ 1, 7 };
823	var b = [3:69]u8{ 200, 225, 255 };	833	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -837,6 +847,7 @@ test "array multiplication sets the sentinel - value" {	...	@@ -837,6 +847,7 @@ test "array multiplication sets the sentinel - value" {
837	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	847	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
838	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	848	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
839	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	849	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		850	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
840		851
841	var a = [2:7]u3{ 1, 6 };	852	var a = [2:7]u3{ 1, 6 };
842	_ = &a;	853	_ = &a;
...	@@ -855,6 +866,7 @@ test "array multiplication sets the sentinel - pointer" {	...	@@ -855,6 +866,7 @@ test "array multiplication sets the sentinel - pointer" {
855	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	866	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
856	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	867	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
857	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	868	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		869	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
858		870
859	var a = [2:7]u3{ 1, 6 };	871	var a = [2:7]u3{ 1, 6 };
860	const b = &a ** 2;	872	const b = &a ** 2;
...	@@ -938,6 +950,8 @@ test "comptime pointer load through elem_ptr" {	...	@@ -938,6 +950,8 @@ test "comptime pointer load through elem_ptr" {
938	}	950	}
939		951
940	test "debug variable type resolved through indirect zero-bit types" {	952	test "debug variable type resolved through indirect zero-bit types" {
		953	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		954
941	const T = struct { key: []void };	955	const T = struct { key: []void };
942	const slice: []const T = &[_]T{};	956	const slice: []const T = &[_]T{};
943	_ = slice;	957	_ = slice;
...	@@ -1098,6 +1112,7 @@ test "no dependency loop for alignment of self struct" {	...	@@ -1098,6 +1112,7 @@ test "no dependency loop for alignment of self struct" {
1098	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1099	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1100	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1114	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1115	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1101		1116
1102	const S = struct {	1117	const S = struct {
1103	fn doTheTest() !void {	1118	fn doTheTest() !void {
...	@@ -1136,6 +1151,7 @@ test "no dependency loop for alignment of self bare union" {	...	@@ -1136,6 +1151,7 @@ test "no dependency loop for alignment of self bare union" {
1136	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1138	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1153	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1154	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1139		1155
1140	const S = struct {	1156	const S = struct {
1141	fn doTheTest() !void {	1157	fn doTheTest() !void {
...	@@ -1174,6 +1190,7 @@ test "no dependency loop for alignment of self tagged union" {	...	@@ -1174,6 +1190,7 @@ test "no dependency loop for alignment of self tagged union" {
1174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1190	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1191	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1176	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1192	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1193	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1177		1194
1178	const S = struct {	1195	const S = struct {
1179	fn doTheTest() !void {	1196	fn doTheTest() !void {
...	@@ -1361,6 +1378,8 @@ test "lazy sizeof is resolved in division" {	...	@@ -1361,6 +1378,8 @@ test "lazy sizeof is resolved in division" {
1361	}	1378	}
1362		1379
1363	test "lazy sizeof union tag size in compare" {	1380	test "lazy sizeof union tag size in compare" {
		1381	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1382
1364	const A = union(enum) {	1383	const A = union(enum) {
1365	a: void,	1384	a: void,
1366	b: void,	1385	b: void,
...	@@ -1373,6 +1392,7 @@ test "lazy value is resolved as slice operand" {	...	@@ -1373,6 +1392,7 @@ test "lazy value is resolved as slice operand" {
1373	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1374	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1375	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1394	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1395	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1376		1396
1377	const A = struct { a: u32 };	1397	const A = struct { a: u32 };
1378	var a: [512]u64 = undefined;	1398	var a: [512]u64 = undefined;

...	@@ -69,6 +69,7 @@ test "basic for loop" {	...	@@ -69,6 +69,7 @@ test "basic for loop" {
69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		72	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
72		73
73	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;	74	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
74		75
...	@@ -112,6 +113,7 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -112,6 +113,7 @@ test "for with null and T peer types and inferred result location type" {
112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	113	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
114	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	115	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		116	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
115		117
116	const S = struct {	118	const S = struct {
117	fn doTheTest(slice: []const u8) !void {	119	fn doTheTest(slice: []const u8) !void {
...	@@ -153,6 +155,7 @@ test "for loop with pointer elem var" {	...	@@ -153,6 +155,7 @@ test "for loop with pointer elem var" {
153	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		158	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156		159
157	const source = "abcdefg";	160	const source = "abcdefg";
158	var target: [source.len]u8 = undefined;	161	var target: [source.len]u8 = undefined;
...	@@ -198,6 +201,7 @@ test "for on slice with allowzero ptr" {	...	@@ -198,6 +201,7 @@ test "for on slice with allowzero ptr" {
198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		204	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
201		205
202	const S = struct {	206	const S = struct {
203	fn doTheTest(slice: []const u8) !void {	207	fn doTheTest(slice: []const u8) !void {
...	@@ -213,6 +217,7 @@ test "for on slice with allowzero ptr" {	...	@@ -213,6 +217,7 @@ test "for on slice with allowzero ptr" {
213	test "else continue outer for" {	217	test "else continue outer for" {
214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	218	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		220	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
216		221
217	var i: usize = 6;	222	var i: usize = 6;
218	var buf: [5]u8 = undefined;	223	var buf: [5]u8 = undefined;
...	@@ -308,6 +313,7 @@ test "slice and two counters, one is offset and one is runtime" {	...	@@ -308,6 +313,7 @@ test "slice and two counters, one is offset and one is runtime" {
308	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	313	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
309	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	314	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	315	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		316	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
311		317
312	const slice: []const u8 = "blah";	318	const slice: []const u8 = "blah";
313	var start: usize = 0;	319	var start: usize = 0;
...	@@ -337,6 +343,7 @@ test "two slices, one captured by-ref" {	...	@@ -337,6 +343,7 @@ test "two slices, one captured by-ref" {
337	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
338	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	344	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	345	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		346	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
340		347
341	var buf: [10]u8 = undefined;	348	var buf: [10]u8 = undefined;
342	const slice1: []const u8 = "blah";	349	const slice1: []const u8 = "blah";
...	@@ -356,6 +363,7 @@ test "raw pointer and slice" {	...	@@ -356,6 +363,7 @@ test "raw pointer and slice" {
356	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	364	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	365	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		366	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
359		367
360	var buf: [10]u8 = undefined;	368	var buf: [10]u8 = undefined;
361	const slice: []const u8 = "blah";	369	const slice: []const u8 = "blah";
...	@@ -375,6 +383,7 @@ test "raw pointer and counter" {	...	@@ -375,6 +383,7 @@ test "raw pointer and counter" {
375	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	383	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
376	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	384	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
377	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	385	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		386	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
378		387
379	var buf: [10]u8 = undefined;	388	var buf: [10]u8 = undefined;
380	const ptr: [*]u8 = &buf;	389	const ptr: [*]u8 = &buf;
...	@@ -424,6 +433,7 @@ test "inline for with counter as the comptime-known" {	...	@@ -424,6 +433,7 @@ test "inline for with counter as the comptime-known" {
424	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	433	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	434	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
426	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	435	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
427		437
428	var runtime_slice = "hello";	438	var runtime_slice = "hello";
429	var runtime_i: usize = 3;	439	var runtime_i: usize = 3;

...	@@ -90,6 +90,7 @@ test "type constructed by comptime function call" {	...	@@ -90,6 +90,7 @@ test "type constructed by comptime function call" {
90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	90	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
91	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	91	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	92	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
93		94
94	var l: SimpleList(10) = undefined;	95	var l: SimpleList(10) = undefined;
95	l.array[0] = 10;	96	l.array[0] = 10;
...	@@ -155,6 +156,7 @@ test "generic fn with implicit cast" {	...	@@ -155,6 +156,7 @@ test "generic fn with implicit cast" {
155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		159	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
158		160
159	try expect(getFirstByte(u8, &[_]u8{13}) == 13);	161	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
160	try expect(getFirstByte(u16, &[_]u16{	162	try expect(getFirstByte(u16, &[_]u16{
...	@@ -208,6 +210,7 @@ fn foo2(arg: anytype) bool {	...	@@ -208,6 +210,7 @@ fn foo2(arg: anytype) bool {
208		210
209	test "generic struct" {	211	test "generic struct" {
210	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		213	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
211		214
212	var a1 = GenNode(i32){	215	var a1 = GenNode(i32){
213	.value = 13,	216	.value = 13,
...	@@ -249,6 +252,7 @@ test "generic function instantiation turns into comptime call" {	...	@@ -249,6 +252,7 @@ test "generic function instantiation turns into comptime call" {
249	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
250	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	253	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
251	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	254	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		255	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
252		256
253	const S = struct {	257	const S = struct {
254	fn doTheTest() !void {	258	fn doTheTest() !void {
...	@@ -316,6 +320,8 @@ test "generic function instantiation non-duplicates" {	...	@@ -316,6 +320,8 @@ test "generic function instantiation non-duplicates" {
316	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	320	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	321	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
318	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		323	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		324
319	if (builtin.os.tag == .wasi) return error.SkipZigTest;	325	if (builtin.os.tag == .wasi) return error.SkipZigTest;
320		326
321	const S = struct {	327	const S = struct {
...	@@ -334,6 +340,7 @@ test "generic function instantiation non-duplicates" {	...	@@ -334,6 +340,7 @@ test "generic function instantiation non-duplicates" {
334	test "generic instantiation of tagged union with only one field" {	340	test "generic instantiation of tagged union with only one field" {
335	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
336	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		343
337	if (builtin.os.tag == .wasi) return error.SkipZigTest;	344	if (builtin.os.tag == .wasi) return error.SkipZigTest;
338		345
339	const S = struct {	346	const S = struct {
...	@@ -368,8 +375,6 @@ test "nested generic function" {	...	@@ -368,8 +375,6 @@ test "nested generic function" {
368	}	375	}
369		376
370	test "extern function used as generic parameter" {	377	test "extern function used as generic parameter" {
371	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
372
373	const S = struct {	378	const S = struct {
374	extern fn usedAsGenericParameterFoo() void;	379	extern fn usedAsGenericParameterFoo() void;
375	extern fn usedAsGenericParameterBar() void;	380	extern fn usedAsGenericParameterBar() void;
...	@@ -406,6 +411,8 @@ test "generic struct as parameter type" {	...	@@ -406,6 +411,8 @@ test "generic struct as parameter type" {
406	}	411	}
407		412
408	test "slice as parameter type" {	413	test "slice as parameter type" {
		414	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		415
409	const S = struct {	416	const S = struct {
410	fn internComptimeString(comptime str: []const u8) *const []const u8 {	417	fn internComptimeString(comptime str: []const u8) *const []const u8 {
411	return &struct {	418	return &struct {
...	@@ -420,6 +427,8 @@ test "slice as parameter type" {	...	@@ -420,6 +427,8 @@ test "slice as parameter type" {
420	}	427	}
421		428
422	test "null sentinel pointer passed as generic argument" {	429	test "null sentinel pointer passed as generic argument" {
		430	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		431
423	const S = struct {	432	const S = struct {
424	fn doTheTest(a: anytype) !void {	433	fn doTheTest(a: anytype) !void {
425	try std.testing.expect(@intFromPtr(a) == 8);	434	try std.testing.expect(@intFromPtr(a) == 8);
...	@@ -442,6 +451,7 @@ test "generic function passed as comptime argument" {	...	@@ -442,6 +451,7 @@ test "generic function passed as comptime argument" {
442		451
443	test "return type of generic function is function pointer" {	452	test "return type of generic function is function pointer" {
444	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		454	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
445		455
446	const S = struct {	456	const S = struct {
447	fn b(comptime T: type) ?*const fn () error{}!T {	457	fn b(comptime T: type) ?*const fn () error{}!T {
...	@@ -503,6 +513,7 @@ test "union in struct captures argument" {	...	@@ -503,6 +513,7 @@ test "union in struct captures argument" {
503	test "function argument tuple used as struct field" {	513	test "function argument tuple used as struct field" {
504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	514	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		516	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
506		517
507	const S = struct {	518	const S = struct {
508	fn DeleagateWithContext(comptime Function: type) type {	519	fn DeleagateWithContext(comptime Function: type) type {
...	@@ -578,6 +589,7 @@ fn StructCapture(comptime T: type) type {	...	@@ -578,6 +589,7 @@ fn StructCapture(comptime T: type) type {
578	test "call generic function that uses capture from function declaration's scope" {	589	test "call generic function that uses capture from function declaration's scope" {
579	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	590	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
580	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	591	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		592	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
581		593
582	const S = StructCapture(f64);	594	const S = StructCapture(f64);
583	const s = S.foo(123);	595	const s = S.foo(123);
...	@@ -591,6 +603,8 @@ comptime {	...	@@ -591,6 +603,8 @@ comptime {
591	}	603	}
592		604
593	test "generic parameter resolves to comptime-only type but is not marked comptime" {	605	test "generic parameter resolves to comptime-only type but is not marked comptime" {
		606	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		607
594	const S = struct {	608	const S = struct {
595	fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {	609	fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {
596	if (rt_false) _ = foo(T, rt_false, func);	610	if (rt_false) _ = foo(T, rt_false, func);

...	@@ -67,6 +67,7 @@ test "@clz" {	...	@@ -67,6 +67,7 @@ test "@clz" {
67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	68	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
69	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_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
		70	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
70		71
71	try testClz();	72	try testClz();
72	try comptime testClz();	73	try comptime testClz();
...	@@ -153,6 +154,7 @@ test "@ctz" {	...	@@ -153,6 +154,7 @@ test "@ctz" {
153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
155	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	156	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		157	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156		158
157	try testCtz();	159	try testCtz();
158	try comptime testCtz();	160	try comptime testCtz();
...	@@ -197,6 +199,7 @@ test "@ctz vectors" {	...	@@ -197,6 +199,7 @@ test "@ctz vectors" {
197	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
198	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
199	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	201	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		202	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
200		203
201	try testCtzVectors();	204	try testCtzVectors();
202	try comptime testCtzVectors();	205	try comptime testCtzVectors();
...	@@ -396,6 +399,7 @@ fn not(comptime T: type, a: T) T {	...	@@ -396,6 +399,7 @@ fn not(comptime T: type, a: T) T {
396		399
397	test "binary not" {	400	test "binary not" {
398	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	401	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		402	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
399		403
400	try expect(not(u0, 0) == 0);	404	try expect(not(u0, 0) == 0);
401	try expect(not(u1, 0) == 1);	405	try expect(not(u1, 0) == 1);
...	@@ -474,6 +478,7 @@ test "division" {	...	@@ -474,6 +478,7 @@ test "division" {
474	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	478	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
475	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	479	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
476	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	480	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		481	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
477		482
478	try testIntDivision();	483	try testIntDivision();
479	try comptime testIntDivision();	484	try comptime testIntDivision();
...	@@ -676,6 +681,8 @@ fn testSignedWrappingEval(x: i32) !void {	...	@@ -676,6 +681,8 @@ fn testSignedWrappingEval(x: i32) !void {
676	}	681	}
677		682
678	test "signed negation wrapping" {	683	test "signed negation wrapping" {
		684	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		685
679	try testSignedNegationWrappingEval(minInt(i16));	686	try testSignedNegationWrappingEval(minInt(i16));
680	try comptime testSignedNegationWrappingEval(minInt(i16));	687	try comptime testSignedNegationWrappingEval(minInt(i16));
681	}	688	}
...	@@ -781,6 +788,7 @@ fn should_not_be_zero(x: f128) !void {	...	@@ -781,6 +788,7 @@ fn should_not_be_zero(x: f128) !void {
781	test "umax wrapped squaring" {	788	test "umax wrapped squaring" {
782	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	789	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
783	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	790	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
		791	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
784		792
785	{	793	{
786	var x: u4 = maxInt(u4);	794	var x: u4 = maxInt(u4);
...	@@ -894,7 +902,6 @@ test "@addWithOverflow > 64 bits" {	...	@@ -894,7 +902,6 @@ test "@addWithOverflow > 64 bits" {
894	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	902	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
895	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	903	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
896	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO	904	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
897	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
898		905
899	try testAddWithOverflow(u65, 4, 105, 109, 0);	906	try testAddWithOverflow(u65, 4, 105, 109, 0);
900	try testAddWithOverflow(u65, 1000, 100, 1100, 0);	907	try testAddWithOverflow(u65, 1000, 100, 1100, 0);
...	@@ -975,6 +982,7 @@ test "extensive @mulWithOverflow" {	...	@@ -975,6 +982,7 @@ test "extensive @mulWithOverflow" {
975	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	982	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
976	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	983	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
977	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	984	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		985	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
978		986
979	try testMulWithOverflow(u5, 3, 10, 30, 0);	987	try testMulWithOverflow(u5, 3, 10, 30, 0);
980	try testMulWithOverflow(u5, 3, 11, 1, 1);	988	try testMulWithOverflow(u5, 3, 11, 1, 1);
...	@@ -1616,6 +1624,7 @@ test "vector integer addition" {	...	@@ -1616,6 +1624,7 @@ test "vector integer addition" {
1616	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	1624	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1617	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1625	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1618	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1626	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1627	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1619		1628
1620	const S = struct {	1629	const S = struct {
1621	fn doTheTest() !void {	1630	fn doTheTest() !void {
...	@@ -1681,6 +1690,8 @@ test "vector comparison" {	...	@@ -1681,6 +1690,8 @@ test "vector comparison" {
1681	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1690	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1682	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1691	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1683	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1692	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1693	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1694
1684	if (builtin.zig_backend == .stage2_x86_64 and	1695	if (builtin.zig_backend == .stage2_x86_64 and
1685	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;	1696	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .avx2)) return error.SkipZigTest;
1686		1697
...	@@ -1777,6 +1788,7 @@ test "@clz works on both vector and scalar inputs" {	...	@@ -1777,6 +1788,7 @@ test "@clz works on both vector and scalar inputs" {
1777	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1788	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1778	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1789	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1779	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1790	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1791	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1780		1792
1781	var x: u32 = 0x1;	1793	var x: u32 = 0x1;
1782	_ = &x;	1794	_ = &x;

...	@@ -33,6 +33,7 @@ test "@max on vectors" {	...	@@ -33,6 +33,7 @@ test "@max on vectors" {
33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	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_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
37		38
38	const S = struct {	39	const S = struct {
...	@@ -88,6 +89,7 @@ test "@min for vectors" {	...	@@ -88,6 +89,7 @@ test "@min for vectors" {
88	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	89	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	90	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
90	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	91	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		92	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
91	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	93	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
92		94
93	const S = struct {	95	const S = struct {
...	@@ -320,6 +322,8 @@ test "@min/@max notices bounds from vector types when element of comptime-known	...	@@ -320,6 +322,8 @@ test "@min/@max notices bounds from vector types when element of comptime-known
320	}	322	}
321		323
322	test "@min/@max of signed and unsigned runtime integers" {	324	test "@min/@max of signed and unsigned runtime integers" {
		325	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		326
323	var x: i32 = -1;	327	var x: i32 = -1;
324	var y: u31 = 1;	328	var y: u31 = 1;
325	_ = .{ &x, &y };	329	_ = .{ &x, &y };

...	@@ -29,6 +29,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {	...	@@ -29,6 +29,7 @@ test "@memcpy with both operands single-ptr-to-array, one is null-terminated" {
29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32		33
33	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();	34	try testMemcpyBothSinglePtrArrayOneIsNullTerminated();
34	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();	35	try comptime testMemcpyBothSinglePtrArrayOneIsNullTerminated();
...	@@ -49,6 +50,7 @@ test "@memcpy dest many pointer" {	...	@@ -49,6 +50,7 @@ test "@memcpy dest many pointer" {
49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
51	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52		54
53	try testMemcpyDestManyPtr();	55	try testMemcpyDestManyPtr();
54	try comptime testMemcpyDestManyPtr();	56	try comptime testMemcpyDestManyPtr();
...	@@ -71,6 +73,7 @@ test "@memcpy slice" {	...	@@ -71,6 +73,7 @@ test "@memcpy slice" {
71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		76	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74		77
75	try testMemcpySlice();	78	try testMemcpySlice();
76	try comptime testMemcpySlice();	79	try comptime testMemcpySlice();
...	@@ -113,6 +116,8 @@ test "@memcpy comptime-only type" {	...	@@ -113,6 +116,8 @@ test "@memcpy comptime-only type" {
113	}	116	}
114		117
115	test "@memcpy zero-bit type with aliasing" {	118	test "@memcpy zero-bit type with aliasing" {
		119	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		120
116	const S = struct {	121	const S = struct {
117	fn doTheTest() void {	122	fn doTheTest() void {
118	var buf: [3]void = @splat({});	123	var buf: [3]void = @splat({});

...	@@ -28,6 +28,7 @@ pub const EmptyStruct = struct {};	...	@@ -28,6 +28,7 @@ pub const EmptyStruct = struct {};
28		28
29	test "optional pointer to size zero struct" {	29	test "optional pointer to size zero struct" {
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		31	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
31		32
32	var e = EmptyStruct{};	33	var e = EmptyStruct{};
33	const o: ?*EmptyStruct = &e;	34	const o: ?*EmptyStruct = &e;
...	@@ -35,6 +36,8 @@ test "optional pointer to size zero struct" {	...	@@ -35,6 +36,8 @@ test "optional pointer to size zero struct" {
35	}	36	}
36		37
37	test "equality compare optional pointers" {	38	test "equality compare optional pointers" {
		39	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		40
38	try testNullPtrsEql();	41	try testNullPtrsEql();
39	try comptime testNullPtrsEql();	42	try comptime testNullPtrsEql();
40	}	43	}
...	@@ -112,6 +115,7 @@ test "address of unwrap optional" {	...	@@ -112,6 +115,7 @@ test "address of unwrap optional" {
112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
114	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	117	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		118	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
115		119
116	const S = struct {	120	const S = struct {
117	const Foo = struct {	121	const Foo = struct {
...	@@ -236,6 +240,7 @@ test "compare optionals with modified payloads" {	...	@@ -236,6 +240,7 @@ test "compare optionals with modified payloads" {
236		240
237	test "unwrap function call with optional pointer return value" {	241	test "unwrap function call with optional pointer return value" {
238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		243	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	244	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240		245
241	const S = struct {	246	const S = struct {
...	@@ -284,6 +289,7 @@ test "nested orelse" {	...	@@ -284,6 +289,7 @@ test "nested orelse" {
284	test "self-referential struct through a slice of optional" {	289	test "self-referential struct through a slice of optional" {
285	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
286	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		292	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
287		293
288	const S = struct {	294	const S = struct {
289	const Node = struct {	295	const Node = struct {
...	@@ -391,6 +397,7 @@ test "array of optional unaligned types" {	...	@@ -391,6 +397,7 @@ test "array of optional unaligned types" {
391	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	397	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	398	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
393	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	399	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		400	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394		401
395	const Enum = enum { one, two, three };	402	const Enum = enum { one, two, three };
396		403
...	@@ -513,7 +520,6 @@ test "mutable optional of noreturn" {	...	@@ -513,7 +520,6 @@ test "mutable optional of noreturn" {
513	}	520	}
514		521
515	test "orelse on C pointer" {	522	test "orelse on C pointer" {
516
517	// TODO https://github.com/ziglang/zig/issues/6597	523	// TODO https://github.com/ziglang/zig/issues/6597
518	const foo: [*c]const u8 = "hey";	524	const foo: [*c]const u8 = "hey";
519	const d = foo orelse @compileError("bad");	525	const d = foo orelse @compileError("bad");
...	@@ -543,6 +549,7 @@ test "Optional slice size is optimized" {	...	@@ -543,6 +549,7 @@ test "Optional slice size is optimized" {
543	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	549	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
544	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
545	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	551	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		552	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
546		553
547	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));	554	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
548	var a: ?[]const u8 = null;	555	var a: ?[]const u8 = null;

...	@@ -21,6 +21,7 @@ test "pointer-integer arithmetic" {	...	@@ -21,6 +21,7 @@ test "pointer-integer arithmetic" {
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	23	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24		25
25	var ptr: [*]const u8 = "abcd";	26	var ptr: [*]const u8 = "abcd";
26		27
...	@@ -100,6 +101,8 @@ test "pointer subtraction" {	...	@@ -100,6 +101,8 @@ test "pointer subtraction" {
100	}	101	}
101		102
102	test "pointer arithmetic with non-trivial RHS" {	103	test "pointer arithmetic with non-trivial RHS" {
		104	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		105
103	var t: bool = undefined;	106	var t: bool = undefined;
104	t = true;	107	t = true;
105		108
...	@@ -124,6 +127,7 @@ fn PtrOf(comptime T: type) type {	...	@@ -124,6 +127,7 @@ fn PtrOf(comptime T: type) type {
124		127
125	test "implicit cast single item pointer to C pointer and back" {	128	test "implicit cast single item pointer to C pointer and back" {
126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	129	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		130	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
127		131
128	var y: u8 = 11;	132	var y: u8 = 11;
129	const x: [*c]u8 = &y;	133	const x: [*c]u8 = &y;
...	@@ -140,6 +144,7 @@ test "initialize const optional C pointer to null" {	...	@@ -140,6 +144,7 @@ test "initialize const optional C pointer to null" {
140		144
141	test "assigning integer to C pointer" {	145	test "assigning integer to C pointer" {
142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	146	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		147	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
143		148
144	var x: i32 = 0;	149	var x: i32 = 0;
145	var y: i32 = 1;	150	var y: i32 = 1;
...	@@ -157,6 +162,7 @@ test "assigning integer to C pointer" {	...	@@ -157,6 +162,7 @@ test "assigning integer to C pointer" {
157		162
158	test "C pointer comparison and arithmetic" {	163	test "C pointer comparison and arithmetic" {
159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		165	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
160		166
161	const S = struct {	167	const S = struct {
162	fn doTheTest() !void {	168	fn doTheTest() !void {
...	@@ -200,6 +206,8 @@ fn testDerefPtrOneVal() !void {	...	@@ -200,6 +206,8 @@ fn testDerefPtrOneVal() !void {
200	}	206	}
201		207
202	test "peer type resolution with C pointers" {	208	test "peer type resolution with C pointers" {
		209	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		210
203	const ptr_one: *u8 = undefined;	211	const ptr_one: *u8 = undefined;
204	const ptr_many: [*]u8 = undefined;	212	const ptr_many: [*]u8 = undefined;
205	const ptr_c: [*c]u8 = undefined;	213	const ptr_c: [*c]u8 = undefined;
...	@@ -227,6 +235,7 @@ test "implicit casting between C pointer and optional non-C pointer" {	...	@@ -227,6 +235,7 @@ test "implicit casting between C pointer and optional non-C pointer" {
227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	236	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
229	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	237	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		238	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
230		239
231	var slice: []const u8 = "aoeu";	240	var slice: []const u8 = "aoeu";
232	_ = &slice;	241	_ = &slice;
...	@@ -271,6 +280,7 @@ test "allowzero pointer and slice" {	...	@@ -271,6 +280,7 @@ test "allowzero pointer and slice" {
271	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	280	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
272	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
273	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		283	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
274		284
275	var ptr: [*]allowzero i32 = @ptrFromInt(0);	285	var ptr: [*]allowzero i32 = @ptrFromInt(0);
276	const opt_ptr: ?[*]allowzero i32 = ptr;	286	const opt_ptr: ?[*]allowzero i32 = ptr;
...	@@ -290,6 +300,7 @@ test "assign null directly to C pointer and test null equality" {	...	@@ -290,6 +300,7 @@ test "assign null directly to C pointer and test null equality" {
290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	300	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	302	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		303	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
293		304
294	var x: [*c]i32 = null;	305	var x: [*c]i32 = null;
295	_ = &x;	306	_ = &x;
...	@@ -357,6 +368,7 @@ test "array initialization types" {	...	@@ -357,6 +368,7 @@ test "array initialization types" {
357	test "null terminated pointer" {	368	test "null terminated pointer" {
358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	369	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
359	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		371	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
360		372
361	const S = struct {	373	const S = struct {
362	fn doTheTest() !void {	374	fn doTheTest() !void {
...	@@ -375,6 +387,7 @@ test "allow any sentinel" {	...	@@ -375,6 +387,7 @@ test "allow any sentinel" {
375	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	387	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
376	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	388	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
377	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	389	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		390	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
378		391
379	const S = struct {	392	const S = struct {
380	fn doTheTest() !void {	393	fn doTheTest() !void {
...	@@ -391,6 +404,7 @@ test "pointer sentinel with enums" {	...	@@ -391,6 +404,7 @@ test "pointer sentinel with enums" {
391	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	404	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
392	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
393	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	406	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		407	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394		408
395	const S = struct {	409	const S = struct {
396	const Number = enum {	410	const Number = enum {
...	@@ -414,6 +428,7 @@ test "pointer sentinel with optional element" {	...	@@ -414,6 +428,7 @@ test "pointer sentinel with optional element" {
414	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
415	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	429	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
416	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	430	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		431	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
417		432
418	const S = struct {	433	const S = struct {
419	fn doTheTest() !void {	434	fn doTheTest() !void {
...	@@ -431,6 +446,7 @@ test "pointer sentinel with +inf" {	...	@@ -431,6 +446,7 @@ test "pointer sentinel with +inf" {
431	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
433	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	448	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		449	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
434		450
435	const S = struct {	451	const S = struct {
436	fn doTheTest() !void {	452	fn doTheTest() !void {
...	@@ -452,6 +468,8 @@ test "pointer to array at fixed address" {	...	@@ -452,6 +468,8 @@ test "pointer to array at fixed address" {
452	}	468	}
453		469
454	test "pointer-integer arithmetic affects the alignment" {	470	test "pointer-integer arithmetic affects the alignment" {
		471	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		472
455	{	473	{
456	var ptr: [*]align(8) u32 = undefined;	474	var ptr: [*]align(8) u32 = undefined;
457	var x: usize = 1;	475	var x: usize = 1;
...	@@ -500,6 +518,7 @@ test "indexing array with sentinel returns correct type" {	...	@@ -500,6 +518,7 @@ test "indexing array with sentinel returns correct type" {
500	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	518	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
501	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	519	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
502	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	520	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		521	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
503		522
504	var s: [:0]const u8 = "abc";	523	var s: [:0]const u8 = "abc";
505	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));	524	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
...	@@ -508,6 +527,7 @@ test "indexing array with sentinel returns correct type" {	...	@@ -508,6 +527,7 @@ test "indexing array with sentinel returns correct type" {
508	test "element pointer to slice" {	527	test "element pointer to slice" {
509	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	528	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
510	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		530	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
511		531
512	const S = struct {	532	const S = struct {
513	fn doTheTest() !void {	533	fn doTheTest() !void {
...	@@ -530,6 +550,7 @@ test "element pointer to slice" {	...	@@ -530,6 +550,7 @@ test "element pointer to slice" {
530	test "element pointer arithmetic to slice" {	550	test "element pointer arithmetic to slice" {
531	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	551	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	552	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		553	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
533		554
534	const S = struct {	555	const S = struct {
535	fn doTheTest() !void {	556	fn doTheTest() !void {
...	@@ -554,6 +575,7 @@ test "element pointer arithmetic to slice" {	...	@@ -554,6 +575,7 @@ test "element pointer arithmetic to slice" {
554		575
555	test "array slicing to slice" {	576	test "array slicing to slice" {
556	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	577	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		578	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
557		579
558	const S = struct {	580	const S = struct {
559	fn doTheTest() !void {	581	fn doTheTest() !void {
...	@@ -584,6 +606,7 @@ test "ptrCast comptime known slice to C pointer" {	...	@@ -584,6 +606,7 @@ test "ptrCast comptime known slice to C pointer" {
584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	606	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
585	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	607	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
586	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	608	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		609	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
587		610
588	const s: [:0]const u8 = "foo";	611	const s: [:0]const u8 = "foo";
589	var p: [*c]const u8 = @ptrCast(s);	612	var p: [*c]const u8 = @ptrCast(s);
...	@@ -603,6 +626,7 @@ test "pointer alignment and element type include call expression" {	...	@@ -603,6 +626,7 @@ test "pointer alignment and element type include call expression" {
603		626
604	test "pointer to array has explicit alignment" {	627	test "pointer to array has explicit alignment" {
605	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	628	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		629	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
606		630
607	const S = struct {	631	const S = struct {
608	const Base = extern struct { a: u8 };	632	const Base = extern struct { a: u8 };
...	@@ -679,6 +703,7 @@ fn constant() !void {	...	@@ -679,6 +703,7 @@ fn constant() !void {
679		703
680	test "pointer-to-array constness for zero-size elements, var" {	704	test "pointer-to-array constness for zero-size elements, var" {
681	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	705	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		706	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
682		707
683	try mutable();	708	try mutable();
684	try comptime mutable();	709	try comptime mutable();

...	@@ -58,6 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {	...	@@ -58,6 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
58	test "reinterpret bytes of an array into an extern struct" {	58	test "reinterpret bytes of an array into an extern struct" {
59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	59	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
61		62
62	try testReinterpretBytesAsExternStruct();	63	try testReinterpretBytesAsExternStruct();
63	try comptime testReinterpretBytesAsExternStruct();	64	try comptime testReinterpretBytesAsExternStruct();
...	@@ -232,6 +233,7 @@ test "implicit optional pointer to optional anyopaque pointer" {	...	@@ -232,6 +233,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
234	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		236	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
235		237
236	var buf: [4]u8 = "aoeu".*;	238	var buf: [4]u8 = "aoeu".*;
237	const x: ?[*]u8 = &buf;	239	const x: ?[*]u8 = &buf;
...	@@ -244,6 +246,7 @@ test "@ptrCast slice to slice" {	...	@@ -244,6 +246,7 @@ test "@ptrCast slice to slice" {
244	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	246	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
245	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	247	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	248	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		249	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
247		250
248	const S = struct {	251	const S = struct {
249	fn foo(slice: []u32) []i32 {	252	fn foo(slice: []u32) []i32 {

...	@@ -9,6 +9,7 @@ test "@shuffle int" {	...	@@ -9,6 +9,7 @@ test "@shuffle int" {
9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	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_x86_64 and	13	if (builtin.zig_backend == .stage2_x86_64 and
13	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .ssse3)) return error.SkipZigTest;	14	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .ssse3)) return error.SkipZigTest;
14		15
...	@@ -57,6 +58,7 @@ test "@shuffle int strange sizes" {	...	@@ -57,6 +58,7 @@ test "@shuffle int strange sizes" {
57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	60	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		61	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
60		62
61	try comptime testShuffle(2, 2, 2);	63	try comptime testShuffle(2, 2, 2);
62	try testShuffle(2, 2, 2);	64	try testShuffle(2, 2, 2);
...	@@ -139,6 +141,7 @@ test "@shuffle bool 1" {	...	@@ -139,6 +141,7 @@ test "@shuffle bool 1" {
139	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
140	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
141	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	143	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		144	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
142		145
143	const S = struct {	146	const S = struct {
144	fn doTheTest() !void {	147	fn doTheTest() !void {
...	@@ -162,6 +165,7 @@ test "@shuffle bool 2" {	...	@@ -162,6 +165,7 @@ test "@shuffle bool 2" {
162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
164	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	167	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		168	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
165		169
166	const S = struct {	170	const S = struct {
167	fn doTheTest() !void {	171	fn doTheTest() !void {

...	@@ -327,6 +327,7 @@ test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {	...	@@ -327,6 +327,7 @@ test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
327	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	327	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
328	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	328	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
329	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	329	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		330	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
330		331
331	const T = struct {	332	const T = struct {
332	next: @TypeOf(null, @as(*const @This(), undefined)),	333	next: @TypeOf(null, @as(*const @This(), undefined)),
...	@@ -420,8 +421,6 @@ test "Extern function calls in @TypeOf" {	...	@@ -420,8 +421,6 @@ test "Extern function calls in @TypeOf" {
420	}	421	}
421		422
422	test "Peer resolution of extern function calls in @TypeOf" {	423	test "Peer resolution of extern function calls in @TypeOf" {
423	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
424
425	const Test = struct {	424	const Test = struct {
426	fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) {	425	fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) {
427	return 0;	426	return 0;
...	@@ -439,7 +438,6 @@ test "Peer resolution of extern function calls in @TypeOf" {	...	@@ -439,7 +438,6 @@ test "Peer resolution of extern function calls in @TypeOf" {
439	test "Extern function calls, dereferences and field access in @TypeOf" {	438	test "Extern function calls, dereferences and field access in @TypeOf" {
440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	439	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
441	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	440	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
442	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
443		441
444	const Test = struct {	442	const Test = struct {
445	fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {	443	fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {

...	@@ -30,6 +30,7 @@ comptime {	...	@@ -30,6 +30,7 @@ comptime {
30		30
31	test "slicing" {	31	test "slicing" {
32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33		34
34	var array: [20]i32 = undefined;	35	var array: [20]i32 = undefined;
35		36
...	@@ -77,6 +78,7 @@ fn assertLenIsZero(msg: []const u8) !void {	...	@@ -77,6 +78,7 @@ fn assertLenIsZero(msg: []const u8) !void {
77		78
78	test "access len index of sentinel-terminated slice" {	79	test "access len index of sentinel-terminated slice" {
79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		81	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
80		82
81	const S = struct {	83	const S = struct {
82	fn doTheTest() !void {	84	fn doTheTest() !void {
...	@@ -100,6 +102,7 @@ test "comptime slice of slice preserves comptime var" {	...	@@ -100,6 +102,7 @@ test "comptime slice of slice preserves comptime var" {
100		102
101	test "open slice of open slice with sentinel" {	103	test "open slice of open slice with sentinel" {
102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	104	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		105	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103		106
104	var slice: [:0]const u8 = "hello";	107	var slice: [:0]const u8 = "hello";
105	_ = &slice;	108	_ = &slice;
...	@@ -117,6 +120,7 @@ test "open slice of open slice with sentinel" {	...	@@ -117,6 +120,7 @@ test "open slice of open slice with sentinel" {
117		120
118	test "open slice with sentinel of slice with end index" {	121	test "open slice with sentinel of slice with end index" {
119	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
120		124
121	var slice: [:0]const u8 = "hello";	125	var slice: [:0]const u8 = "hello";
122	_ = &slice;	126	_ = &slice;
...	@@ -169,6 +173,8 @@ fn memFree(comptime T: type, memory: []T) void {	...	@@ -169,6 +173,8 @@ fn memFree(comptime T: type, memory: []T) void {
169	}	173	}
170		174
171	test "slice of hardcoded address to pointer" {	175	test "slice of hardcoded address to pointer" {
		176	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		177
172	const S = struct {	178	const S = struct {
173	fn doTheTest() !void {	179	fn doTheTest() !void {
174	const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2];	180	const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2];
...	@@ -207,6 +213,7 @@ test "comptime pointer cast array and then slice" {	...	@@ -207,6 +213,7 @@ test "comptime pointer cast array and then slice" {
207	test "slicing zero length array" {	213	test "slicing zero length array" {
208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		216	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
210		217
211	const s1 = ""[0..];	218	const s1 = ""[0..];
212	const s2 = ([_]u32{})[0..];	219	const s2 = ([_]u32{})[0..];
...	@@ -217,6 +224,8 @@ test "slicing zero length array" {	...	@@ -217,6 +224,8 @@ test "slicing zero length array" {
217	}	224	}
218		225
219	test "slicing pointer by length" {	226	test "slicing pointer by length" {
		227	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		228
220	const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };	229	const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
221	const ptr: []const u8 = @as([]const u8, @ptrCast(&array));	230	const ptr: []const u8 = @as([]const u8, @ptrCast(&array));
222	const slice = ptr[1..][0..5];	231	const slice = ptr[1..][0..5];
...	@@ -238,6 +247,8 @@ test "compile time slice of pointer to hard coded address" {	...	@@ -238,6 +247,8 @@ test "compile time slice of pointer to hard coded address" {
238	}	247	}
239		248
240	test "slice string literal has correct type" {	249	test "slice string literal has correct type" {
		250	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		251
241	comptime {	252	comptime {
242	try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);	253	try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
243	const array = [_]i32{ 1, 2, 3, 4 };	254	const array = [_]i32{ 1, 2, 3, 4 };
...	@@ -265,6 +276,7 @@ test "runtime safety lets us slice from len..len" {	...	@@ -265,6 +276,7 @@ test "runtime safety lets us slice from len..len" {
265	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
267	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		279	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
268		280
269	var an_array = [_]u8{ 1, 2, 3 };	281	var an_array = [_]u8{ 1, 2, 3 };
270	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));	282	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
...	@@ -277,6 +289,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {	...	@@ -277,6 +289,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
277	test "C pointer" {	289	test "C pointer" {
278	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	290	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
279	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		292	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
280		293
281	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";	294	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
282	var len: u32 = 10;	295	var len: u32 = 10;
...	@@ -289,6 +302,7 @@ test "C pointer slice access" {	...	@@ -289,6 +302,7 @@ test "C pointer slice access" {
289	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	302	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	303	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		305	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
292		306
293	var buf: [10]u32 = [1]u32{42} ** 10;	307	var buf: [10]u32 = [1]u32{42} ** 10;
294	const c_ptr = @as([*c]const u32, @ptrCast(&buf));	308	const c_ptr = @as([*c]const u32, @ptrCast(&buf));
...	@@ -319,6 +333,7 @@ fn sliceSum(comptime q: []const u8) i32 {	...	@@ -319,6 +333,7 @@ fn sliceSum(comptime q: []const u8) i32 {
319	test "slice type with custom alignment" {	333	test "slice type with custom alignment" {
320	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	334	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
321	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		336	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
322		337
323	const LazilyResolvedType = struct {	338	const LazilyResolvedType = struct {
324	anything: i32,	339	anything: i32,
...	@@ -332,6 +347,7 @@ test "slice type with custom alignment" {	...	@@ -332,6 +347,7 @@ test "slice type with custom alignment" {
332		347
333	test "obtaining a null terminated slice" {	348	test "obtaining a null terminated slice" {
334	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		350	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
335		351
336	// here we have a normal array	352	// here we have a normal array
337	var buf: [50]u8 = undefined;	353	var buf: [50]u8 = undefined;
...	@@ -376,6 +392,7 @@ test "empty array to slice" {	...	@@ -376,6 +392,7 @@ test "empty array to slice" {
376	test "@ptrCast slice to pointer" {	392	test "@ptrCast slice to pointer" {
377	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
378	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		395	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
379		396
380	const S = struct {	397	const S = struct {
381	fn doTheTest() !void {	398	fn doTheTest() !void {
...	@@ -392,6 +409,7 @@ test "@ptrCast slice to pointer" {	...	@@ -392,6 +409,7 @@ test "@ptrCast slice to pointer" {
392		409
393	test "slice multi-pointer without end" {	410	test "slice multi-pointer without end" {
394	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	411	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		412	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
395		413
396	const S = struct {	414	const S = struct {
397	fn doTheTest() !void {	415	fn doTheTest() !void {
...	@@ -649,6 +667,7 @@ test "slice syntax resulting in pointer-to-array" {	...	@@ -649,6 +667,7 @@ test "slice syntax resulting in pointer-to-array" {
649	test "slice pointer-to-array null terminated" {	667	test "slice pointer-to-array null terminated" {
650	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	668	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
651	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	669	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		670	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
652		671
653	comptime {	672	comptime {
654	var array = [5:0]u8{ 1, 2, 3, 4, 5 };	673	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
...	@@ -667,6 +686,7 @@ test "slice pointer-to-array null terminated" {	...	@@ -667,6 +686,7 @@ test "slice pointer-to-array null terminated" {
667		686
668	test "slice pointer-to-array zero length" {	687	test "slice pointer-to-array zero length" {
669	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	688	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		689	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
670		690
671	comptime {	691	comptime {
672	{	692	{
...	@@ -701,6 +721,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {	...	@@ -701,6 +721,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
701	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	721	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
702	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	722	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
703	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	723	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		724	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
704		725
705	const S = struct {	726	const S = struct {
706	const U = union {	727	const U = union {
...	@@ -757,6 +778,7 @@ test "array mult of slice gives ptr to array" {	...	@@ -757,6 +778,7 @@ test "array mult of slice gives ptr to array" {
757		778
758	test "slice bounds in comptime concatenation" {	779	test "slice bounds in comptime concatenation" {
759	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	780	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		781	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
760		782
761	const bs = comptime blk: {	783	const bs = comptime blk: {
762	const b = "........1........";	784	const b = "........1........";
...	@@ -792,6 +814,7 @@ test "slice sentinel access at comptime" {	...	@@ -792,6 +814,7 @@ test "slice sentinel access at comptime" {
792	test "slicing array with sentinel as end index" {	814	test "slicing array with sentinel as end index" {
793	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	815	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
794	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	816	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		817	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
795		818
796	const S = struct {	819	const S = struct {
797	fn do() !void {	820	fn do() !void {
...	@@ -810,6 +833,7 @@ test "slicing array with sentinel as end index" {	...	@@ -810,6 +833,7 @@ test "slicing array with sentinel as end index" {
810	test "slicing slice with sentinel as end index" {	833	test "slicing slice with sentinel as end index" {
811	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	834	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
812	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	835	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		836	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
813		837
814	const S = struct {	838	const S = struct {
815	fn do() !void {	839	fn do() !void {
...	@@ -889,6 +913,8 @@ test "slice of void" {	...	@@ -889,6 +913,8 @@ test "slice of void" {
889	}	913	}
890		914
891	test "slice with dereferenced value" {	915	test "slice with dereferenced value" {
		916	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		917
892	var a: usize = 0;	918	var a: usize = 0;
893	const idx: *usize = &a;	919	const idx: *usize = &a;
894	_ = blk: {	920	_ = blk: {
...	@@ -923,6 +949,7 @@ test "empty slice ptr is non null" {	...	@@ -923,6 +949,7 @@ test "empty slice ptr is non null" {
923	test "slice decays to many pointer" {	949	test "slice decays to many pointer" {
924	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	950	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
925	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
		952	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
926		953
927	var buf: [8]u8 = "abcdefg\x00".*;	954	var buf: [8]u8 = "abcdefg\x00".*;
928	const p: [*:0]const u8 = buf[0..7 :0];	955	const p: [*:0]const u8 = buf[0..7 :0];
...	@@ -933,6 +960,7 @@ test "write through pointer to optional slice arg" {	...	@@ -933,6 +960,7 @@ test "write through pointer to optional slice arg" {
933	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	960	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
934	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	961	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
935	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	962	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		963	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
936		964
937	const S = struct {	965	const S = struct {
938	fn bar(foo: *?[]const u8) !void {	966	fn bar(foo: *?[]const u8) !void {
...	@@ -952,6 +980,7 @@ test "modify slice length at comptime" {	...	@@ -952,6 +980,7 @@ test "modify slice length at comptime" {
952	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	980	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
953	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	981	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
954	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	982	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
		983	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
955		984
956	const arr: [2]u8 = .{ 10, 20 };	985	const arr: [2]u8 = .{ 10, 20 };
957	comptime var s: []const u8 = arr[0..0];	986	comptime var s: []const u8 = arr[0..0];
...	@@ -985,6 +1014,7 @@ test "slicing slices gives correct result" {	...	@@ -985,6 +1014,7 @@ test "slicing slices gives correct result" {
985	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	1014	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
986	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1015	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
987	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1016	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1017	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
988		1018
989	const foo = "1234";	1019	const foo = "1234";
990	const bar = foo[0..4];	1020	const bar = foo[0..4];
...	@@ -1013,6 +1043,7 @@ test "sentinel-terminated 0-length slices" {	...	@@ -1013,6 +1043,7 @@ test "sentinel-terminated 0-length slices" {
1013	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	1043	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1014	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1044	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1015	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1045	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1046	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1016		1047
1017	const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };	1048	const u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
1018		1049
...	@@ -1031,6 +1062,8 @@ test "sentinel-terminated 0-length slices" {	...	@@ -1031,6 +1062,8 @@ test "sentinel-terminated 0-length slices" {
1031	}	1062	}
1032		1063
1033	test "peer slices keep abi alignment with empty struct" {	1064	test "peer slices keep abi alignment with empty struct" {
		1065	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1066
1034	var cond: bool = undefined;	1067	var cond: bool = undefined;
1035	cond = false;	1068	cond = false;
1036	const slice = if (cond) &[1]u32{42} else &.{};	1069	const slice = if (cond) &[1]u32{42} else &.{};

...	@@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;	...	@@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
8	test "@tagName() returns a string literal" {	8	test "@tagName() returns a string literal" {
9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		11	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11		12
12	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));	13	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
13	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));	14	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
...	@@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;	...	@@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
21	test "@errorName() returns a string literal" {	22	test "@errorName() returns a string literal" {
22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24		26
25	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));	27	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
26	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));	28	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
...	@@ -64,6 +66,7 @@ fn testFnForSrc() std.builtin.SourceLocation {	...	@@ -64,6 +66,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
64	test "@src() returns a struct containing 0-terminated string slices" {	66	test "@src() returns a struct containing 0-terminated string slices" {
65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		69	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67		70
68	const src = testFnForSrc();	71	const src = testFnForSrc();
69	try std.testing.expect([:0]const u8 == @TypeOf(src.file));	72	try std.testing.expect([:0]const u8 == @TypeOf(src.file));
...	@@ -101,6 +104,8 @@ test "Peer type resolution with string literals and unknown length u8 pointers"	...	@@ -101,6 +104,8 @@ test "Peer type resolution with string literals and unknown length u8 pointers"
101	}	104	}
102		105
103	test "including the sentinel when dereferencing a string literal" {	106	test "including the sentinel when dereferencing a string literal" {
		107	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		108
104	var var_str = "abc";	109	var var_str = "abc";
105	const var_derefed = var_str[0 .. var_str.len + 1].*;	110	const var_derefed = var_str[0 .. var_str.len + 1].*;
106		111

...	@@ -293,6 +293,7 @@ const Val = struct {	...	@@ -293,6 +293,7 @@ const Val = struct {
293	test "struct point to self" {	293	test "struct point to self" {
294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	295	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		296	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
296		297
297	var root: Node = undefined;	298	var root: Node = undefined;
298	root.val.x = 1;	299	root.val.x = 1;
...	@@ -336,6 +337,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {	...	@@ -336,6 +337,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
336		337
337	test "pass slice of empty struct to fn" {	338	test "pass slice of empty struct to fn" {
338	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	339	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		340	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
339		341
340	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);	342	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
341	}	343	}
...	@@ -347,6 +349,7 @@ test "self-referencing struct via array member" {	...	@@ -347,6 +349,7 @@ test "self-referencing struct via array member" {
347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	349	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	350	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		352	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
350		353
351	const T = struct {	354	const T = struct {
352	children: [1]*@This(),	355	children: [1]*@This(),
...	@@ -370,6 +373,7 @@ const EmptyStruct = struct {	...	@@ -370,6 +373,7 @@ const EmptyStruct = struct {
370	test "align 1 field before self referential align 8 field as slice return type" {	373	test "align 1 field before self referential align 8 field as slice return type" {
371	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	374	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
372	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	375	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		376	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
373		377
374	const result = alloc(Expr);	378	const result = alloc(Expr);
375	try expect(result.len == 0);	379	try expect(result.len == 0);
...	@@ -416,12 +420,12 @@ const Foo96Bits = packed struct {	...	@@ -416,12 +420,12 @@ const Foo96Bits = packed struct {
416		420
417	test "packed struct 24bits" {	421	test "packed struct 24bits" {
418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		423	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
419	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	424	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
420	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	425	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
421	if (builtin.cpu.arch.isWasm()) return error.SkipZigTest; // TODO	426	if (builtin.cpu.arch.isWasm()) return error.SkipZigTest; // TODO
422	if (builtin.cpu.arch.isArm()) return error.SkipZigTest; // TODO	427	if (builtin.cpu.arch.isArm()) return error.SkipZigTest; // TODO
423	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	428	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
424	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
425		429
426	comptime {	430	comptime {
427	std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24));	431	std.debug.assert(@sizeOf(Foo24Bits) == @sizeOf(u24));
...	@@ -956,6 +960,7 @@ test "comptime struct field" {	...	@@ -956,6 +960,7 @@ test "comptime struct field" {
956	}	960	}
957		961
958	test "tuple element initialized with fn call" {	962	test "tuple element initialized with fn call" {
		963	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
959	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	964	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
960	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	965	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
961	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	966	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -974,6 +979,7 @@ test "tuple element initialized with fn call" {	...	@@ -974,6 +979,7 @@ test "tuple element initialized with fn call" {
974	}	979	}
975		980
976	test "struct with union field" {	981	test "struct with union field" {
		982	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
977	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	983	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
978	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	984	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
979	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	985	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -1045,6 +1051,7 @@ test "packed struct with undefined initializers" {	...	@@ -1045,6 +1051,7 @@ test "packed struct with undefined initializers" {
1045	}	1051	}
1046		1052
1047	test "for loop over pointers to struct, getting field from struct pointer" {	1053	test "for loop over pointers to struct, getting field from struct pointer" {
		1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1048	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1055	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1049	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1056	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1050		1057
...	@@ -1362,6 +1369,7 @@ test "fieldParentPtr of a zero-bit field" {	...	@@ -1362,6 +1369,7 @@ test "fieldParentPtr of a zero-bit field" {
1362	}	1369	}
1363		1370
1364	test "struct field has a pointer to an aligned version of itself" {	1371	test "struct field has a pointer to an aligned version of itself" {
		1372	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1365	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1373	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1366		1374
1367	const E = struct {	1375	const E = struct {
...	@@ -1459,6 +1467,7 @@ test "function pointer in struct returns the struct" {	...	@@ -1459,6 +1467,7 @@ test "function pointer in struct returns the struct" {
1459	}	1467	}
1460		1468
1461	test "no dependency loop on optional field wrapped in generic function" {	1469	test "no dependency loop on optional field wrapped in generic function" {
		1470	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	1471	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1463		1472
1464	const S = struct {	1473	const S = struct {
...	@@ -1538,6 +1547,8 @@ test "struct fields get automatically reordered" {	...	@@ -1538,6 +1547,8 @@ test "struct fields get automatically reordered" {
1538	}	1547	}
1539		1548
1540	test "directly initiating tuple like struct" {	1549	test "directly initiating tuple like struct" {
		1550	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1551
1541	const a = struct { u8 }{8};	1552	const a = struct { u8 }{8};
1542	try expect(a[0] == 8);	1553	try expect(a[0] == 8);
1543	}	1554	}
...	@@ -1699,6 +1710,8 @@ test "runtime side-effects in comptime-known struct init" {	...	@@ -1699,6 +1710,8 @@ test "runtime side-effects in comptime-known struct init" {
1699	}	1710	}
1700		1711
1701	test "pointer to struct initialized through reference to anonymous initializer provides result types" {	1712	test "pointer to struct initialized through reference to anonymous initializer provides result types" {
		1713	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1714
1702	const S = struct { a: u8, b: u16, c: *const anyopaque };	1715	const S = struct { a: u8, b: u16, c: *const anyopaque };
1703	var my_u16: u16 = 0xABCD;	1716	var my_u16: u16 = 0xABCD;
1704	_ = &my_u16;	1717	_ = &my_u16;
...	@@ -1756,6 +1769,8 @@ test "initializer uses own size" {	...	@@ -1756,6 +1769,8 @@ test "initializer uses own size" {
1756	}	1769	}
1757		1770
1758	test "initializer takes a pointer to a variable inside its struct" {	1771	test "initializer takes a pointer to a variable inside its struct" {
		1772	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1773
1759	const namespace = struct {	1774	const namespace = struct {
1760	const S = struct {	1775	const S = struct {
1761	s: *S = &S.instance,	1776	s: *S = &S.instance,
...	@@ -1774,6 +1789,8 @@ test "initializer takes a pointer to a variable inside its struct" {	...	@@ -1774,6 +1789,8 @@ test "initializer takes a pointer to a variable inside its struct" {
1774	}	1789	}
1775		1790
1776	test "circular dependency through pointer field of a struct" {	1791	test "circular dependency through pointer field of a struct" {
		1792	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1793
1777	const S = struct {	1794	const S = struct {
1778	const StructInner = extern struct {	1795	const StructInner = extern struct {
1779	outer: StructOuter = std.mem.zeroes(StructOuter),	1796	outer: StructOuter = std.mem.zeroes(StructOuter),
...	@@ -1895,6 +1912,7 @@ test "runtime call in nested initializer" {	...	@@ -1895,6 +1912,7 @@ test "runtime call in nested initializer" {
1895	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	1912	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1896	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1913	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1897	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1914	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1915	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1898		1916
1899	const Holder = struct {	1917	const Holder = struct {
1900	array: []const u8,	1918	array: []const u8,

...	@@ -131,6 +131,7 @@ test "tuple initializer for var" {	...	@@ -131,6 +131,7 @@ test "tuple initializer for var" {
131	test "array-like initializer for tuple types" {	131	test "array-like initializer for tuple types" {
132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134		135
135	const T = @Type(.{	136	const T = @Type(.{
136	.@"struct" = .{	137	.@"struct" = .{
...	@@ -219,6 +220,7 @@ test "fieldParentPtr of tuple" {	...	@@ -219,6 +220,7 @@ test "fieldParentPtr of tuple" {
219	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
221	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	222	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
222		224
223	var x: u32 = 0;	225	var x: u32 = 0;
224	_ = &x;	226	_ = &x;
...	@@ -231,6 +233,7 @@ test "fieldParentPtr of anon struct" {	...	@@ -231,6 +233,7 @@ test "fieldParentPtr of anon struct" {
231	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
232	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
233	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	235	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		236	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
234		237
235	var x: u32 = 0;	238	var x: u32 = 0;
236	_ = &x;	239	_ = &x;
...	@@ -280,6 +283,7 @@ test "tuple in tuple passed to generic function" {	...	@@ -280,6 +283,7 @@ test "tuple in tuple passed to generic function" {
280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	283	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	284	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	285	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		286	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
283		287
284	const S = struct {	288	const S = struct {
285	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {	289	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {
...	@@ -299,6 +303,7 @@ test "coerce tuple to tuple" {	...	@@ -299,6 +303,7 @@ test "coerce tuple to tuple" {
299	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
300	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	304	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
301	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		306	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
302		307
303	const T = std.meta.Tuple(&.{u8});	308	const T = std.meta.Tuple(&.{u8});
304	const S = struct {	309	const S = struct {
...	@@ -313,6 +318,7 @@ test "tuple type with void field" {	...	@@ -313,6 +318,7 @@ test "tuple type with void field" {
313	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	318	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
314	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	319	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		321	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
316		322
317	const T = std.meta.Tuple(&[_]type{void});	323	const T = std.meta.Tuple(&[_]type{void});
318	const x = T{{}};	324	const x = T{{}};
...	@@ -349,6 +355,7 @@ test "zero sized struct in tuple handled correctly" {	...	@@ -349,6 +355,7 @@ test "zero sized struct in tuple handled correctly" {
349	test "tuple type with void field and a runtime field" {	355	test "tuple type with void field and a runtime field" {
350	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
351	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		358	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
352		359
353	const T = std.meta.Tuple(&[_]type{ usize, void });	360	const T = std.meta.Tuple(&[_]type{ usize, void });
354	var t: T = .{ 5, {} };	361	var t: T = .{ 5, {} };
...	@@ -376,6 +383,7 @@ test "tuple initialized with a runtime known value" {	...	@@ -376,6 +383,7 @@ test "tuple initialized with a runtime known value" {
376	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	383	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
377	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	384	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
378	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	385	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		386	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
379		387
380	const E = union(enum) { e: []const u8 };	388	const E = union(enum) { e: []const u8 };
381	const W = union(enum) { w: E };	389	const W = union(enum) { w: E };
...	@@ -391,6 +399,7 @@ test "tuple of struct concatenation and coercion to array" {	...	@@ -391,6 +399,7 @@ test "tuple of struct concatenation and coercion to array" {
391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	399	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
392	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	400	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
393	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	401	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		402	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394		403
395	const StructWithDefault = struct { value: f32 = 42 };	404	const StructWithDefault = struct { value: f32 = 42 };
396	const SomeStruct = struct { array: [4]StructWithDefault };	405	const SomeStruct = struct { array: [4]StructWithDefault };
...	@@ -405,6 +414,7 @@ test "nested runtime conditionals in tuple initializer" {	...	@@ -405,6 +414,7 @@ test "nested runtime conditionals in tuple initializer" {
405	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	414	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
406	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	415	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	416	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		417	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
408		418
409	var data: u8 = 0;	419	var data: u8 = 0;
410	_ = &data;	420	_ = &data;
...	@@ -440,6 +450,7 @@ test "tuple pointer is indexable" {	...	@@ -440,6 +450,7 @@ test "tuple pointer is indexable" {
440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	450	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	451	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
442	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	452	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		453	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
443		454
444	const S = struct { u32, bool };	455	const S = struct { u32, bool };
445		456
...	@@ -498,6 +509,7 @@ test "tuple with runtime value coerced into a slice with a sentinel" {	...	@@ -498,6 +509,7 @@ test "tuple with runtime value coerced into a slice with a sentinel" {
498	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	509	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
499	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	510	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
500	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	511	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		512	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
501		513
502	const S = struct {	514	const S = struct {
503	fn f(a: [:null]const ?u8) !void {	515	fn f(a: [:null]const ?u8) !void {
...	@@ -569,8 +581,8 @@ test "comptime fields in tuple can be initialized" {	...	@@ -569,8 +581,8 @@ test "comptime fields in tuple can be initialized" {
569	test "empty struct in tuple" {	581	test "empty struct in tuple" {
570	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	582	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
571	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	583	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
572	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
573	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	584	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		585	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
574		586
575	const T = struct { struct {} };	587	const T = struct { struct {} };
576	const info = @typeInfo(T);	588	const info = @typeInfo(T);
...	@@ -582,8 +594,8 @@ test "empty struct in tuple" {	...	@@ -582,8 +594,8 @@ test "empty struct in tuple" {
582	test "empty union in tuple" {	594	test "empty union in tuple" {
583	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	595	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
584	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	596	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
585	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
586	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	597	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		598	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
587		599
588	const T = struct { union {} };	600	const T = struct { union {} };
589	const info = @typeInfo(T);	601	const info = @typeInfo(T);

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

...	@@ -16,6 +16,7 @@ test "basic unions with floats" {	...	@@ -16,6 +16,7 @@ test "basic unions with floats" {
16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19		20
20	var foo = FooWithFloats{ .int = 1 };	21	var foo = FooWithFloats{ .int = 1 };
21	try expect(foo.int == 1);	22	try expect(foo.int == 1);
...	@@ -43,6 +44,7 @@ test "basic unions" {	...	@@ -43,6 +44,7 @@ test "basic unions" {
43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	44	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
44	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	45	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
45	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	46	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		47	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
46		48
47	var foo = Foo{ .int = 1 };	49	var foo = Foo{ .int = 1 };
48	try expect(foo.int == 1);	50	try expect(foo.int == 1);
...	@@ -62,6 +64,7 @@ test "init union with runtime value" {	...	@@ -62,6 +64,7 @@ test "init union with runtime value" {
62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
63	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	66	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
65		68
66	var foo: Foo = undefined;	69	var foo: Foo = undefined;
67		70
...	@@ -100,6 +103,7 @@ const FooExtern = extern union {	...	@@ -100,6 +103,7 @@ const FooExtern = extern union {
100	test "basic extern unions" {	103	test "basic extern unions" {
101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		106	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
103		107
104	var foo = FooExtern{ .int = 1 };	108	var foo = FooExtern{ .int = 1 };
105	try expect(foo.int == 1);	109	try expect(foo.int == 1);
...	@@ -210,6 +214,7 @@ test "union with specified enum tag" {	...	@@ -210,6 +214,7 @@ test "union with specified enum tag" {
210	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	216	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		217	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
213		218
214	try doTest();	219	try doTest();
215	try comptime doTest();	220	try comptime doTest();
...	@@ -261,6 +266,7 @@ test "comparison between union and enum literal" {	...	@@ -261,6 +266,7 @@ test "comparison between union and enum literal" {
261	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
262	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	267	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		269	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
264		270
265	try testComparison();	271	try testComparison();
266	try comptime testComparison();	272	try comptime testComparison();
...	@@ -334,6 +340,7 @@ test "constant packed union" {	...	@@ -334,6 +340,7 @@ test "constant packed union" {
334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	340	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
335	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	341	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
336	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	342	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		343	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
337		344
338	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});	345	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
339	}	346	}
...	@@ -483,6 +490,7 @@ test "initialize global array of union" {	...	@@ -483,6 +490,7 @@ test "initialize global array of union" {
483	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	490	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
484	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	491	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
485	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	492	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		493	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
486		494
487	glbl_array[1] = FooUnion{ .U1 = 2 };	495	glbl_array[1] = FooUnion{ .U1 = 2 };
488	glbl_array[0] = FooUnion{ .U0 = 1 };	496	glbl_array[0] = FooUnion{ .U0 = 1 };
...	@@ -522,6 +530,7 @@ test "union initializer generates padding only if needed" {	...	@@ -522,6 +530,7 @@ test "union initializer generates padding only if needed" {
522	test "runtime tag name with single field" {	530	test "runtime tag name with single field" {
523	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	531	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
524	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		533	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
525		534
526	const U = union(enum) {	535	const U = union(enum) {
527	A: i32,	536	A: i32,
...	@@ -599,6 +608,7 @@ test "tagged union as return value" {	...	@@ -599,6 +608,7 @@ test "tagged union as return value" {
599	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	608	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
600	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	609	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
601	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	610	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		611	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
602		612
603	switch (returnAnInt(13)) {	613	switch (returnAnInt(13)) {
604	TaggedFoo.One => \|value\| try expect(value == 13),	614	TaggedFoo.One => \|value\| try expect(value == 13),
...	@@ -642,6 +652,7 @@ test "union(enum(u32)) with specified and unspecified tag values" {	...	@@ -642,6 +652,7 @@ test "union(enum(u32)) with specified and unspecified tag values" {
642	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	652	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
643	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	653	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
644	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	654	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		655	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
645		656
646	comptime assert(Tag(Tag(MultipleChoice2)) == u32);	657	comptime assert(Tag(Tag(MultipleChoice2)) == u32);
647	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });	658	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
...	@@ -928,6 +939,7 @@ test "anonymous union literal syntax" {	...	@@ -928,6 +939,7 @@ test "anonymous union literal syntax" {
928	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	939	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
929	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	940	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
930	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	941	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		942	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
931		943
932	const S = struct {	944	const S = struct {
933	const Number = union {	945	const Number = union {
...	@@ -1048,7 +1060,6 @@ test "@unionInit on union with tag but no fields" {	...	@@ -1048,7 +1060,6 @@ test "@unionInit on union with tag but no fields" {
1048	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1060	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1049	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1061	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1050	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1062	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1051	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1052		1063
1053	const S = struct {	1064	const S = struct {
1054	const Type = enum(u8) { no_op = 105 };	1065	const Type = enum(u8) { no_op = 105 };
...	@@ -1098,6 +1109,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel	...	@@ -1098,6 +1109,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1098	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1109	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1099	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1101		1113
1102	const T = struct {	1114	const T = struct {
1103	const U = union(enum) {	1115	const U = union(enum) {
...	@@ -1330,6 +1342,7 @@ test "union field ptr - zero sized payload" {	...	@@ -1330,6 +1342,7 @@ test "union field ptr - zero sized payload" {
1330	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1331	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1343	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1332	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1345	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1333		1346
1334	const U = union {	1347	const U = union {
1335	foo: void,	1348	foo: void,
...	@@ -1344,6 +1357,7 @@ test "union field ptr - zero sized field" {	...	@@ -1344,6 +1357,7 @@ test "union field ptr - zero sized field" {
1344	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1357	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1345	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1358	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1346	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1359	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1360	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1347		1361
1348	const U = union {	1362	const U = union {
1349	foo: void,	1363	foo: void,
...	@@ -1998,6 +2012,7 @@ test "store of comptime reinterpreted memory to packed union" {	...	@@ -1998,6 +2012,7 @@ test "store of comptime reinterpreted memory to packed union" {
1998	test "union field is a pointer to an aligned version of itself" {	2012	test "union field is a pointer to an aligned version of itself" {
1999	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2000	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2014	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		2015	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2001		2016
2002	const E = union {	2017	const E = union {
2003	next: *align(1) @This(),	2018	next: *align(1) @This(),
...	@@ -2010,6 +2025,7 @@ test "union field is a pointer to an aligned version of itself" {	...	@@ -2010,6 +2025,7 @@ test "union field is a pointer to an aligned version of itself" {
2010		2025
2011	test "pass register-sized field as non-register-sized union" {	2026	test "pass register-sized field as non-register-sized union" {
2012	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2027	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		2028	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2013		2029
2014	const S = struct {	2030	const S = struct {
2015	fn taggedUnion(u: union(enum) { x: usize, y: [2]usize }) !void {	2031	fn taggedUnion(u: union(enum) { x: usize, y: [2]usize }) !void {
...	@@ -2057,6 +2073,7 @@ test "circular dependency through pointer field of a union" {	...	@@ -2057,6 +2073,7 @@ test "circular dependency through pointer field of a union" {
2057		2073
2058	test "pass nested union with rls" {	2074	test "pass nested union with rls" {
2059	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	2075	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		2076	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2060		2077
2061	const Union = union(enum) {	2078	const Union = union(enum) {
2062	a: u32,	2079	a: u32,
...	@@ -2105,6 +2122,7 @@ test "copied union field doesn't alias source" {	...	@@ -2105,6 +2122,7 @@ test "copied union field doesn't alias source" {
2105	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2122	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	2124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		2125	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2108		2126
2109	const U = union(enum) {	2127	const U = union(enum) {
2110	array: [10]u32,	2128	array: [10]u32,
...	@@ -2305,6 +2323,8 @@ test "extern union @FieldType" {	...	@@ -2305,6 +2323,8 @@ test "extern union @FieldType" {
2305	}	2323	}
2306		2324
2307	test "assign global tagged union" {	2325	test "assign global tagged union" {
		2326	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		2327
2308	const U = union(enum) {	2328	const U = union(enum) {
2309	a: u16,	2329	a: u16,
2310	b: u32,	2330	b: u32,

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

...	@@ -11,6 +11,7 @@ test "implicit cast vector to array - bool" {	...	@@ -11,6 +11,7 @@ test "implicit cast vector to array - bool" {
11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		14	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14		15
15	const S = struct {	16	const S = struct {
16	fn doTheTest() !void {	17	fn doTheTest() !void {
...	@@ -29,6 +30,7 @@ test "vector wrap operators" {	...	@@ -29,6 +30,7 @@ test "vector wrap operators" {
29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	32	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		33	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32	if (builtin.zig_backend == .stage2_x86_64 and	34	if (builtin.zig_backend == .stage2_x86_64 and
33	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;	35	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;
34		36
...	@@ -54,6 +56,7 @@ test "vector bin compares with mem.eql" {	...	@@ -54,6 +56,7 @@ test "vector bin compares with mem.eql" {
54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	56	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	58	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		59	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
57		60
58	const S = struct {	61	const S = struct {
59	fn doTheTest() !void {	62	fn doTheTest() !void {
...	@@ -79,6 +82,7 @@ test "vector int operators" {	...	@@ -79,6 +82,7 @@ test "vector int operators" {
79	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	82	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
80	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	84	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		85	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
82		86
83	const S = struct {	87	const S = struct {
84	fn doTheTest() !void {	88	fn doTheTest() !void {
...	@@ -149,6 +153,7 @@ test "vector bit operators" {	...	@@ -149,6 +153,7 @@ test "vector bit operators" {
149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
151	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	155	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
152		157
153	const S = struct {	158	const S = struct {
154	fn doTheTest() !void {	159	fn doTheTest() !void {
...	@@ -169,6 +174,7 @@ test "implicit cast vector to array" {	...	@@ -169,6 +174,7 @@ test "implicit cast vector to array" {
169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	174	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
171	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	176	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		177	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
172		178
173	const S = struct {	179	const S = struct {
174	fn doTheTest() !void {	180	fn doTheTest() !void {
...	@@ -187,6 +193,7 @@ test "array to vector" {	...	@@ -187,6 +193,7 @@ test "array to vector" {
187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
188	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	194	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		196	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
190		197
191	const S = struct {	198	const S = struct {
192	fn doTheTest() !void {	199	fn doTheTest() !void {
...	@@ -245,6 +252,7 @@ test "array to vector with element type coercion" {	...	@@ -245,6 +252,7 @@ test "array to vector with element type coercion" {
245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	253	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
247	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	254	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		255	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
248	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	256	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
249	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	257	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
250		258
...	@@ -287,7 +295,6 @@ test "tuple to vector" {	...	@@ -287,7 +295,6 @@ test "tuple to vector" {
287	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	295	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	296	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
289	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	297	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
290	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
291		298
292	const S = struct {	299	const S = struct {
293	fn doTheTest() !void {	300	fn doTheTest() !void {
...	@@ -311,6 +318,7 @@ test "vector casts of sizes not divisible by 8" {	...	@@ -311,6 +318,7 @@ test "vector casts of sizes not divisible by 8" {
311	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	319	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	320	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		321	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
314		322
315	const S = struct {	323	const S = struct {
316	fn doTheTest() !void {	324	fn doTheTest() !void {
...	@@ -350,6 +358,7 @@ test "vector @splat" {	...	@@ -350,6 +358,7 @@ test "vector @splat" {
350	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	358	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
351	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	359	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
352	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	360	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		361	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
353		362
354	if (builtin.zig_backend == .stage2_llvm and	363	if (builtin.zig_backend == .stage2_llvm and
355	builtin.os.tag == .macos)	364	builtin.os.tag == .macos)
...	@@ -511,6 +520,7 @@ test "vector comparison operators" {	...	@@ -511,6 +520,7 @@ test "vector comparison operators" {
511	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	520	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
512	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	521	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
513	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	522	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		523	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
514		524
515	const S = struct {	525	const S = struct {
516	fn doTheTest() !void {	526	fn doTheTest() !void {
...	@@ -557,6 +567,7 @@ test "vector division operators" {	...	@@ -557,6 +567,7 @@ test "vector division operators" {
557	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
558	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
559	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	569	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		570	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
560		571
561	const S = struct {	572	const S = struct {
562	fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {	573	fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
...	@@ -644,6 +655,7 @@ test "vector division operators" {	...	@@ -644,6 +655,7 @@ test "vector division operators" {
644		655
645	test "vector bitwise not operator" {	656	test "vector bitwise not operator" {
646	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	657	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		658	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
647	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	659	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
648	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	660	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
649	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	661	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	@@ -681,6 +693,7 @@ test "vector shift operators" {	...	@@ -681,6 +693,7 @@ test "vector shift operators" {
681	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	693	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
682	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	694	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
683	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	695	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		696	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
684		697
685	const S = struct {	698	const S = struct {
686	fn doTheTestShift(x: anytype, y: anytype) !void {	699	fn doTheTestShift(x: anytype, y: anytype) !void {
...	@@ -1038,6 +1051,7 @@ test "multiplication-assignment operator with an array operand" {	...	@@ -1038,6 +1051,7 @@ test "multiplication-assignment operator with an array operand" {
1038	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1051	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1039	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1052	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1040	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1053	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1054	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1041		1055
1042	const S = struct {	1056	const S = struct {
1043	fn doTheTest() !void {	1057	fn doTheTest() !void {
...	@@ -1059,6 +1073,7 @@ test "@addWithOverflow" {	...	@@ -1059,6 +1073,7 @@ test "@addWithOverflow" {
1059	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1073	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1060	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1074	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1061	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1075	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1076	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1062	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1077	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1063		1078
1064	const S = struct {	1079	const S = struct {
...	@@ -1109,6 +1124,7 @@ test "@subWithOverflow" {	...	@@ -1109,6 +1124,7 @@ test "@subWithOverflow" {
1109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1110	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1111	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1126	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1127	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1112	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;	1128	if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1113		1129
1114	const S = struct {	1130	const S = struct {
...	@@ -1211,6 +1227,7 @@ test "loading the second vector from a slice of vectors" {	...	@@ -1211,6 +1227,7 @@ test "loading the second vector from a slice of vectors" {
1211	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1212	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1228	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1229	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1230	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1214		1231
1215	@setRuntimeSafety(false);	1232	@setRuntimeSafety(false);
1216	var small_bases = [2]@Vector(2, u8){	1233	var small_bases = [2]@Vector(2, u8){
...	@@ -1227,6 +1244,7 @@ test "array of vectors is copied" {	...	@@ -1227,6 +1244,7 @@ test "array of vectors is copied" {
1227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1244	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1228	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1229	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1246	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1247	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1230		1248
1231	const Vec3 = @Vector(3, i32);	1249	const Vec3 = @Vector(3, i32);
1232	var points = [_]Vec3{	1250	var points = [_]Vec3{
...	@@ -1392,6 +1410,7 @@ test "store to vector in slice" {	...	@@ -1392,6 +1410,7 @@ test "store to vector in slice" {
1392	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1410	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1393	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1411	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1412	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1413	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1395	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;	1414	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
1396		1415
1397	var v = [_]@Vector(3, f32){	1416	var v = [_]@Vector(3, f32){
...	@@ -1508,6 +1527,7 @@ test "bitcast to vector with different child type" {	...	@@ -1508,6 +1527,7 @@ test "bitcast to vector with different child type" {
1508	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1527	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1509	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1528	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1510	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	1529	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
		1530	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1511		1531
1512	const S = struct {	1532	const S = struct {
1513	fn doTheTest() !void {	1533	fn doTheTest() !void {
...	@@ -1565,6 +1585,7 @@ test "@reduce on bool vector" {	...	@@ -1565,6 +1585,7 @@ test "@reduce on bool vector" {
1565	test "bitcast vector to array of smaller vectors" {	1585	test "bitcast vector to array of smaller vectors" {
1566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1586	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1587	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		1588	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1568		1589
1569	const u8x32 = @Vector(32, u8);	1590	const u8x32 = @Vector(32, u8);
1570	const u8x64 = @Vector(64, u8);	1591	const u8x64 = @Vector(64, u8);