Commit fd6b3db34252f2a548630c0e57fe80f32202aa12 | zig

.github/CODEOWNERS+4-1

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	# Autodoc	1	# Autodoc
2	/src/Autodoc.zig @kristoff-it	2	/src/Autodoc.zig @kristoff-it
3	/src/autodoc/* @kristoff-it	3	/src/autodoc/* @kristoff-it
4	/lib/docs/* @kristoff-it	4	/lib/docs/* @kristoff-it
...	@@ -11,3 +11,6 @@	...	@@ -11,3 +11,6 @@
11		11
12	# resinator	12	# resinator
13	/src/resinator/* @squeek502	13	/src/resinator/* @squeek502
		14
		15	# SPIR-V selfhosted backend
		16	/src/codegen/spirv* @Snektron

lib/std/testing.zig+12-4

 @@ -21,11 +21,15 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
 /// TODO https://github.com/ziglang/zig/issues/5738
 pub var log_level = std.log.Level.warn;
-fn print(comptime fmt: []const u8, args: anytype) void {
+// Disable printing in tests for simple backends.
-    // Disable printing in tests for simple backends.
+pub const backend_can_print = builtin.zig_backend != .stage2_spirv64;
-    if (builtin.zig_backend == .stage2_spirv64) return;
-    std.debug.print(fmt, args);
+fn print(comptime fmt: []const u8, args: anytype) void {
+    if (@inComptime()) {
+        @compileError(std.fmt.comptimePrint(fmt, args));
+    } else if (backend_can_print) {
+        std.debug.print(fmt, args);
+    }
 }
 /// This function is intended to be used only in tests. It prints diagnostics to stderr
 @@ -300,6 +304,10 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
         break :diff_index if (expected.len == actual.len) return else shortest;
     };
+    if (!backend_can_print) {
+        return error.TestExpectedEqual;
+    }
     print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
     // TODO: Should this be configurable by the caller?

src/InternPool.zig+10-5

 @@ -1556,10 +1556,10 @@ pub const Key = union(enum) {
                     // These are strange: we'll sometimes represent them as f128, even if the
                     // underlying type is smaller. f80 is an exception: see float_c_longdouble_f80.
                     const a_val = switch (a_info.storage) {
-                        inline else => |val| @as(f128, @floatCast(val)),
+                        inline else => |val| @as(u128, @bitCast(@as(f128, @floatCast(val)))),
                     };
                     const b_val = switch (b_info.storage) {
-                        inline else => |val| @as(f128, @floatCast(val)),
+                        inline else => |val| @as(u128, @bitCast(@as(f128, @floatCast(val)))),
                     };
                     return a_val == b_val;
                 }
 @@ -1567,9 +1567,14 @@ pub const Key = union(enum) {
                 const StorageTag = @typeInfo(Key.Float.Storage).Union.tag_type.?;
                 assert(@as(StorageTag, a_info.storage) == @as(StorageTag, b_info.storage));
-                return switch (a_info.storage) {
+                switch (a_info.storage) {
-                    inline else => |val, tag| val == @field(b_info.storage, @tagName(tag)),
+                    inline else => |val, tag| {
-                };
+                        const Bits = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(val)));
+                        const a_bits: Bits = @bitCast(val);
+                        const b_bits: Bits = @bitCast(@field(b_info.storage, @tagName(tag)));
+                        return a_bits == b_bits;
+                    },
+                }
             },
             .opaque_type => |a_info| {

src/arch/wasm/CodeGen.zig+21-7

 @@ -6253,8 +6253,10 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     func.finishAir(inst, result_ptr, &.{ extra.lhs, extra.rhs });
 }
-fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: enum { max, min }) InnerError!void {
+fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
+    assert(op == .max or op == .min);
     const mod = func.bin_file.base.options.module.?;
+    const target = mod.getTarget();
     const bin_op = func.air.instructions.items(.data)[inst].bin_op;
     const ty = func.typeOfIndex(inst);
 @@ -6269,13 +6271,25 @@ fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: enum { max, min }) InnerE
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
-    // operands to select from
+    if (ty.zigTypeTag(mod) == .Float) {
-    try func.lowerToStack(lhs);
+        var fn_name_buf: [64]u8 = undefined;
-    try func.lowerToStack(rhs);
+        const float_bits = ty.floatBits(target);
-    _ = try func.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
+        const fn_name = std.fmt.bufPrint(&fn_name_buf, "{s}f{s}{s}", .{
+            target_util.libcFloatPrefix(float_bits),
+            @tagName(op),
+            target_util.libcFloatSuffix(float_bits),
+        }) catch unreachable;
+        const result = try func.callIntrinsic(fn_name, &.{ ty.ip_index, ty.ip_index }, ty, &.{ lhs, rhs });
+        try func.lowerToStack(result);
+    } else {
+        // operands to select from
+        try func.lowerToStack(lhs);
+        try func.lowerToStack(rhs);
+        _ = try func.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
-    // based on the result from comparison, return operand 0 or 1.
+        // based on the result from comparison, return operand 0 or 1.
-    try func.addTag(.select);
+        try func.addTag(.select);
+    }
     // store result in local
     const result_ty = if (isByRef(ty, mod)) Type.u32 else ty;

src/codegen/llvm.zig+1

...	@@ -3050,6 +3050,7 @@ pub const Object = struct {	...	@@ -3050,6 +3050,7 @@ pub const Object = struct {
3050	decl_val: InternPool.Index,	3050	decl_val: InternPool.Index,
3051	llvm_addr_space: Builder.AddrSpace,	3051	llvm_addr_space: Builder.AddrSpace,
3052	) Error!Builder.Variable.Index {	3052	) Error!Builder.Variable.Index {
		3053	// TODO: Add address space to the anon_decl_map
3053	const gop = try o.anon_decl_map.getOrPut(o.gpa, decl_val);	3054	const gop = try o.anon_decl_map.getOrPut(o.gpa, decl_val);
3054	if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.variable;	3055	if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.variable;
3055	errdefer assert(o.anon_decl_map.remove(decl_val));	3056	errdefer assert(o.anon_decl_map.remove(decl_val));

src/codegen/spirv.zig+953-310

...	@@ -52,18 +52,136 @@ const Block = struct {	...	@@ -52,18 +52,136 @@ const Block = struct {
52		52
53	const BlockMap = std.AutoHashMapUnmanaged(Air.Inst.Index, *Block);	53	const BlockMap = std.AutoHashMapUnmanaged(Air.Inst.Index, *Block);
54		54
55	/// Maps Zig decl indices to linking SPIR-V linking information.	55	/// This structure holds information that is relevant to the entire compilation,
56	pub const DeclLinkMap = std.AutoHashMap(Module.Decl.Index, SpvModule.Decl.Index);	56	/// in contrast to `DeclGen`, which only holds relevant information about a
		57	/// single decl.
		58	pub const Object = struct {
		59	/// A general-purpose allocator that can be used for any allocation for this Object.
		60	gpa: Allocator,
		61
		62	/// the SPIR-V module that represents the final binary.
		63	spv: SpvModule,
		64
		65	/// The Zig module that this object file is generated for.
		66	/// A map of Zig decl indices to SPIR-V decl indices.
		67	decl_link: std.AutoHashMapUnmanaged(Decl.Index, SpvModule.Decl.Index) = .{},
		68
		69	/// A map of Zig InternPool indices for anonymous decls to SPIR-V decl indices.
		70	anon_decl_link: std.AutoHashMapUnmanaged(struct { InternPool.Index, StorageClass }, SpvModule.Decl.Index) = .{},
		71
		72	/// A map that maps AIR intern pool indices to SPIR-V cache references (which
		73	/// is basically the same thing except for SPIR-V).
		74	/// This map is typically only used for structures that are deemed heavy enough
		75	/// that it is worth to store them here. The SPIR-V module also interns types,
		76	/// and so the main purpose of this map is to avoid recomputation and to
		77	/// cache extra information about the type rather than to aid in validity
		78	/// of the SPIR-V module.
		79	type_map: TypeMap = .{},
		80
		81	pub fn init(gpa: Allocator) Object {
		82	return .{
		83	.gpa = gpa,
		84	.spv = SpvModule.init(gpa),
		85	};
		86	}
		87
		88	pub fn deinit(self: *Object) void {
		89	self.spv.deinit();
		90	self.decl_link.deinit(self.gpa);
		91	self.anon_decl_link.deinit(self.gpa);
		92	self.type_map.deinit(self.gpa);
		93	}
		94
		95	fn genDecl(
		96	self: *Object,
		97	mod: *Module,
		98	decl_index: Decl.Index,
		99	air: Air,
		100	liveness: Liveness,
		101	) !void {
		102	var decl_gen = DeclGen{
		103	.gpa = self.gpa,
		104	.object = self,
		105	.module = mod,
		106	.spv = &self.spv,
		107	.decl_index = decl_index,
		108	.air = air,
		109	.liveness = liveness,
		110	.type_map = &self.type_map,
		111	.current_block_label_id = undefined,
		112	};
		113	defer decl_gen.deinit();
		114
		115	decl_gen.genDecl() catch \|err\| switch (err) {
		116	error.CodegenFail => {
		117	try mod.failed_decls.put(mod.gpa, decl_index, decl_gen.error_msg.?);
		118	},
		119	else => \|other\| {
		120	// There might be an error that happened after self.error_msg
		121	// was already allocated, so be sure to free it.
		122	if (decl_gen.error_msg) \|error_msg\| {
		123	error_msg.deinit(mod.gpa);
		124	}
		125
		126	return other;
		127	},
		128	};
		129	}
		130
		131	pub fn updateFunc(
		132	self: *Object,
		133	mod: *Module,
		134	func_index: InternPool.Index,
		135	air: Air,
		136	liveness: Liveness,
		137	) !void {
		138	const decl_index = mod.funcInfo(func_index).owner_decl;
		139	// TODO: Separate types for generating decls and functions?
		140	try self.genDecl(mod, decl_index, air, liveness);
		141	}
		142
		143	pub fn updateDecl(
		144	self: *Object,
		145	mod: *Module,
		146	decl_index: Decl.Index,
		147	) !void {
		148	try self.genDecl(mod, decl_index, undefined, undefined);
		149	}
		150
		151	/// Fetch or allocate a result id for decl index. This function also marks the decl as alive.
		152	/// Note: Function does not actually generate the decl, it just allocates an index.
		153	pub fn resolveDecl(self: Object, mod: Module, decl_index: Decl.Index) !SpvModule.Decl.Index {
		154	const decl = mod.declPtr(decl_index);
		155	try mod.markDeclAlive(decl);
		156
		157	const entry = try self.decl_link.getOrPut(self.gpa, decl_index);
		158	if (!entry.found_existing) {
		159	// TODO: Extern fn?
		160	const kind: SpvModule.DeclKind = if (decl.val.isFuncBody(mod))
		161	.func
		162	else
		163	.global;
		164
		165	entry.value_ptr.* = try self.spv.allocDecl(kind);
		166	}
		167
		168	return entry.value_ptr.*;
		169	}
		170	};
57		171
58	/// This structure is used to compile a declaration, and contains all relevant meta-information to deal with that.	172	/// This structure is used to compile a declaration, and contains all relevant meta-information to deal with that.
59	pub const DeclGen = struct {	173	const DeclGen = struct {
60	/// A general-purpose allocator that can be used for any allocations for this DeclGen.	174	/// A general-purpose allocator that can be used for any allocations for this DeclGen.
61	gpa: Allocator,	175	gpa: Allocator,
62		176
		177	/// The object that this decl is generated into.
		178	object: *Object,
		179
63	/// The Zig module that we are generating decls for.	180	/// The Zig module that we are generating decls for.
64	module: *Module,	181	module: *Module,
65		182
66	/// The SPIR-V module that instructions should be emitted into.	183	/// The SPIR-V module that instructions should be emitted into.
		184	/// This is the same as `self.object.spv`, repeated here for brevity.
67	spv: *SpvModule,	185	spv: *SpvModule,
68		186
69	/// The decl we are currently generating code for.	187	/// The decl we are currently generating code for.
...	@@ -77,27 +195,19 @@ pub const DeclGen = struct {	...	@@ -77,27 +195,19 @@ pub const DeclGen = struct {
77	/// Note: If the declaration is not a function, this value will be undefined!	195	/// Note: If the declaration is not a function, this value will be undefined!
78	liveness: Liveness,	196	liveness: Liveness,
79		197
80	/// Maps Zig Decl indices to SPIR-V globals.
81	decl_link: *DeclLinkMap,
82
83	/// An array of function argument result-ids. Each index corresponds with the	198	/// An array of function argument result-ids. Each index corresponds with the
84	/// function argument of the same index.	199	/// function argument of the same index.
85	args: std.ArrayListUnmanaged(IdRef) = .{},	200	args: std.ArrayListUnmanaged(IdRef) = .{},
86		201
87	/// A counter to keep track of how many `arg` instructions we've seen yet.	202	/// A counter to keep track of how many `arg` instructions we've seen yet.
88	next_arg_index: u32,	203	next_arg_index: u32 = 0,
89		204
90	/// A map keeping track of which instruction generated which result-id.	205	/// A map keeping track of which instruction generated which result-id.
91	inst_results: InstMap = .{},	206	inst_results: InstMap = .{},
92		207
93	/// A map that maps AIR intern pool indices to SPIR-V cache references (which	208	/// A map that maps AIR intern pool indices to SPIR-V cache references.
94	/// is basically the same thing except for SPIR-V).	209	/// See Object.type_map
95	/// This map is typically only used for structures that are deemed heavy enough	210	type_map: *TypeMap,
96	/// that it is worth to store them here. The SPIR-V module also interns types,
97	/// and so the main purpose of this map is to avoid recomputation and to
98	/// cache extra information about the type rather than to aid in validity
99	/// of the SPIR-V module.
100	type_map: TypeMap = .{},
101		211
102	/// We need to keep track of result ids for block labels, as well as the 'incoming'	212	/// We need to keep track of result ids for block labels, as well as the 'incoming'
103	/// blocks for a block.	213	/// blocks for a block.
...	@@ -115,7 +225,7 @@ pub const DeclGen = struct {	...	@@ -115,7 +225,7 @@ pub const DeclGen = struct {
115		225
116	/// If `gen` returned `Error.CodegenFail`, this contains an explanatory message.	226	/// If `gen` returned `Error.CodegenFail`, this contains an explanatory message.
117	/// Memory is owned by `module.gpa`.	227	/// Memory is owned by `module.gpa`.
118	error_msg: ?*Module.ErrorMsg,	228	error_msg: ?*Module.ErrorMsg = null,
119		229
120	/// Possible errors the `genDecl` function may return.	230	/// Possible errors the `genDecl` function may return.
121	const Error = error{ CodegenFail, OutOfMemory };	231	const Error = error{ CodegenFail, OutOfMemory };
...	@@ -154,6 +264,12 @@ pub const DeclGen = struct {	...	@@ -154,6 +264,12 @@ pub const DeclGen = struct {
154	/// This is the actual number of bits of the type, not the size of the backing integer.	264	/// This is the actual number of bits of the type, not the size of the backing integer.
155	bits: u16,	265	bits: u16,
156		266
		267	/// The number of bits required to store the type.
		268	/// For `integer` and `float`, this is equal to `bits`.
		269	/// For `strange_integer` and `bool` this is the size of the backing integer.
		270	/// For `composite_integer` this is 0 (TODO)
		271	backing_bits: u16,
		272
157	/// Whether the type is a vector.	273	/// Whether the type is a vector.
158	is_vector: bool,	274	is_vector: bool,
159		275
...	@@ -175,65 +291,10 @@ pub const DeclGen = struct {	...	@@ -175,65 +291,10 @@ pub const DeclGen = struct {
175	indirect,	291	indirect,
176	};	292	};
177		293
178	/// Initialize the common resources of a DeclGen. Some fields are left uninitialized,
179	/// only set when `gen` is called.
180	pub fn init(
181	allocator: Allocator,
182	module: *Module,
183	spv: *SpvModule,
184	decl_link: *DeclLinkMap,
185	) DeclGen {
186	return .{
187	.gpa = allocator,
188	.module = module,
189	.spv = spv,
190	.decl_index = undefined,
191	.air = undefined,
192	.liveness = undefined,
193	.decl_link = decl_link,
194	.next_arg_index = undefined,
195	.current_block_label_id = undefined,
196	.error_msg = undefined,
197	};
198	}
199
200	/// Generate the code for `decl`. If a reportable error occurred during code generation,
201	/// a message is returned by this function. Callee owns the memory. If this function
202	/// returns such a reportable error, it is valid to be called again for a different decl.
203	pub fn gen(self: DeclGen, decl_index: Decl.Index, air: Air, liveness: Liveness) !?Module.ErrorMsg {
204	// Reset internal resources, we don't want to re-allocate these.
205	self.decl_index = decl_index;
206	self.air = air;
207	self.liveness = liveness;
208	self.args.items.len = 0;
209	self.next_arg_index = 0;
210	self.inst_results.clearRetainingCapacity();
211	self.blocks.clearRetainingCapacity();
212	self.current_block_label_id = undefined;
213	self.func.reset();
214	self.base_line_stack.items.len = 0;
215	self.error_msg = null;
216
217	self.genDecl() catch \|err\| switch (err) {
218	error.CodegenFail => return self.error_msg,
219	else => \|others\| {
220	// There might be an error that happened after self.error_msg
221	// was already allocated, so be sure to free it.
222	if (self.error_msg) \|error_msg\| {
223	error_msg.deinit(self.module.gpa);
224	}
225	return others;
226	},
227	};
228
229	return null;
230	}
231
232	/// Free resources owned by the DeclGen.	294	/// Free resources owned by the DeclGen.
233	pub fn deinit(self: *DeclGen) void {	295	pub fn deinit(self: *DeclGen) void {
234	self.args.deinit(self.gpa);	296	self.args.deinit(self.gpa);
235	self.inst_results.deinit(self.gpa);	297	self.inst_results.deinit(self.gpa);
236	self.type_map.deinit(self.gpa);
237	self.blocks.deinit(self.gpa);	298	self.blocks.deinit(self.gpa);
238	self.func.deinit(self.gpa);	299	self.func.deinit(self.gpa);
239	self.base_line_stack.deinit(self.gpa);	300	self.base_line_stack.deinit(self.gpa);
...	@@ -269,7 +330,7 @@ pub const DeclGen = struct {	...	@@ -269,7 +330,7 @@ pub const DeclGen = struct {
269	.func => \|func\| func.owner_decl,	330	.func => \|func\| func.owner_decl,
270	else => unreachable,	331	else => unreachable,
271	};	332	};
272	const spv_decl_index = try self.resolveDecl(fn_decl_index);	333	const spv_decl_index = try self.object.resolveDecl(mod, fn_decl_index);
273	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});	334	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
274	return self.spv.declPtr(spv_decl_index).result_id;	335	return self.spv.declPtr(spv_decl_index).result_id;
275	}	336	}
...	@@ -280,25 +341,87 @@ pub const DeclGen = struct {	...	@@ -280,25 +341,87 @@ pub const DeclGen = struct {
280	return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage.	341	return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage.
281	}	342	}
282		343
283	/// Fetch or allocate a result id for decl index. This function also marks the decl as alive.	344	fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index, storage_class: StorageClass) !IdRef {
284	/// Note: Function does not actually generate the decl.	345	// TODO: This cannot be a function at this point, but it should probably be handled anyway.
285	fn resolveDecl(self: *DeclGen, decl_index: Module.Decl.Index) !SpvModule.Decl.Index {	346	const spv_decl_index = blk: {
		347	const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, storage_class });
		348	if (entry.found_existing) {
		349	try self.func.decl_deps.put(self.spv.gpa, entry.value_ptr.*, {});
		350	return self.spv.declPtr(entry.value_ptr.*).result_id;
		351	}
		352
		353	const spv_decl_index = try self.spv.allocDecl(.global);
		354	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
		355	entry.value_ptr.* = spv_decl_index;
		356	break :blk spv_decl_index;
		357	};
		358
286	const mod = self.module;	359	const mod = self.module;
287	const decl = mod.declPtr(decl_index);	360	const ty = mod.intern_pool.typeOf(val).toType();
288	try mod.markDeclAlive(decl);	361	const ty_ref = try self.resolveType(ty, .indirect);
		362	const ptr_ty_ref = try self.spv.ptrType(ty_ref, storage_class);
289		363
290	const entry = try self.decl_link.getOrPut(decl_index);	364	const var_id = self.spv.declPtr(spv_decl_index).result_id;
291	if (!entry.found_existing) {
292	// TODO: Extern fn?
293	const kind: SpvModule.DeclKind = if (decl.val.isFuncBody(mod))
294	.func
295	else
296	.global;
297		365
298	entry.value_ptr.* = try self.spv.allocDecl(kind);	366	const section = &self.spv.sections.types_globals_constants;
299	}	367	try section.emit(self.spv.gpa, .OpVariable, .{
		368	.id_result_type = self.typeId(ptr_ty_ref),
		369	.id_result = var_id,
		370	.storage_class = storage_class,
		371	});
300		372
301	return entry.value_ptr.*;	373	// TODO: At some point we will be able to generate this all constant here, but then all of
		374	// constant() will need to be implemented such that it doesn't generate any at-runtime code.
		375	// NOTE: Because this is a global, we really only want to initialize it once. Therefore the
		376	// constant lowering of this value will need to be deferred to some other function, which
		377	// is then added to the list of initializers using endGlobal().
		378
		379	// Save the current state so that we can temporarily generate into a different function.
		380	// TODO: This should probably be made a little more robust.
		381	const func = self.func;
		382	defer self.func = func;
		383	const block_label_id = self.current_block_label_id;
		384	defer self.current_block_label_id = block_label_id;
		385
		386	self.func = .{};
		387
		388	// TODO: Merge this with genDecl?
		389	const begin = self.spv.beginGlobal();
		390
		391	const void_ty_ref = try self.resolveType(Type.void, .direct);
		392	const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
		393	.return_type = void_ty_ref,
		394	.parameters = &.{},
		395	} });
		396
		397	const initializer_id = self.spv.allocId();
		398	try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{
		399	.id_result_type = self.typeId(void_ty_ref),
		400	.id_result = initializer_id,
		401	.function_control = .{},
		402	.function_type = self.typeId(initializer_proto_ty_ref),
		403	});
		404	const root_block_id = self.spv.allocId();
		405	try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{
		406	.id_result = root_block_id,
		407	});
		408	self.current_block_label_id = root_block_id;
		409
		410	const val_id = try self.constant(ty, val.toValue(), .indirect);
		411	try self.func.body.emit(self.spv.gpa, .OpStore, .{
		412	.pointer = var_id,
		413	.object = val_id,
		414	});
		415
		416	self.spv.endGlobal(spv_decl_index, begin, var_id, initializer_id);
		417	try self.func.body.emit(self.spv.gpa, .OpReturn, {});
		418	try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});
		419	try self.spv.addFunction(spv_decl_index, self.func);
		420
		421	try self.spv.debugNameFmt(var_id, "__anon_{d}", .{@intFromEnum(val)});
		422	try self.spv.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@intFromEnum(val)});
		423
		424	return var_id;
302	}	425	}
303		426
304	/// Start a new SPIR-V block, Emits the label of the new block, and stores which	427	/// Start a new SPIR-V block, Emits the label of the new block, and stores which
...	@@ -376,12 +499,14 @@ pub const DeclGen = struct {	...	@@ -376,12 +499,14 @@ pub const DeclGen = struct {
376	return switch (ty.zigTypeTag(mod)) {	499	return switch (ty.zigTypeTag(mod)) {
377	.Bool => ArithmeticTypeInfo{	500	.Bool => ArithmeticTypeInfo{
378	.bits = 1, // Doesn't matter for this class.	501	.bits = 1, // Doesn't matter for this class.
		502	.backing_bits = self.backingIntBits(1).?,
379	.is_vector = false,	503	.is_vector = false,
380	.signedness = .unsigned, // Technically, but doesn't matter for this class.	504	.signedness = .unsigned, // Technically, but doesn't matter for this class.
381	.class = .bool,	505	.class = .bool,
382	},	506	},
383	.Float => ArithmeticTypeInfo{	507	.Float => ArithmeticTypeInfo{
384	.bits = ty.floatBits(target),	508	.bits = ty.floatBits(target),
		509	.backing_bits = ty.floatBits(target), // TODO: F80?
385	.is_vector = false,	510	.is_vector = false,
386	.signedness = .signed, // Technically, but doesn't matter for this class.	511	.signedness = .signed, // Technically, but doesn't matter for this class.
387	.class = .float,	512	.class = .float,
...	@@ -392,6 +517,7 @@ pub const DeclGen = struct {	...	@@ -392,6 +517,7 @@ pub const DeclGen = struct {
392	const maybe_backing_bits = self.backingIntBits(int_info.bits);	517	const maybe_backing_bits = self.backingIntBits(int_info.bits);
393	break :blk ArithmeticTypeInfo{	518	break :blk ArithmeticTypeInfo{
394	.bits = int_info.bits,	519	.bits = int_info.bits,
		520	.backing_bits = maybe_backing_bits orelse 0,
395	.is_vector = false,	521	.is_vector = false,
396	.signedness = int_info.signedness,	522	.signedness = int_info.signedness,
397	.class = if (maybe_backing_bits) \|backing_bits\|	523	.class = if (maybe_backing_bits) \|backing_bits\|
...	@@ -403,8 +529,19 @@ pub const DeclGen = struct {	...	@@ -403,8 +529,19 @@ pub const DeclGen = struct {
403	.composite_integer,	529	.composite_integer,
404	};	530	};
405	},	531	},
		532	.Enum => return self.arithmeticTypeInfo(ty.intTagType(mod)),
406	// As of yet, there is no vector support in the self-hosted compiler.	533	// As of yet, there is no vector support in the self-hosted compiler.
407	.Vector => self.todo("implement arithmeticTypeInfo for Vector", .{}),	534	.Vector => blk: {
		535	const child_type = ty.childType(mod);
		536	const child_ty_info = try self.arithmeticTypeInfo(child_type);
		537	break :blk ArithmeticTypeInfo{
		538	.bits = child_ty_info.bits,
		539	.backing_bits = child_ty_info.backing_bits,
		540	.is_vector = true,
		541	.signedness = child_ty_info.signedness,
		542	.class = child_ty_info.class,
		543	};
		544	},
408	// TODO: For which types is this the case?	545	// TODO: For which types is this the case?
409	// else => self.todo("implement arithmeticTypeInfo for {}", .{ty.fmt(self.module)}),	546	// else => self.todo("implement arithmeticTypeInfo for {}", .{ty.fmt(self.module)}),
410	else => unreachable,	547	else => unreachable,
...	@@ -482,7 +619,7 @@ pub const DeclGen = struct {	...	@@ -482,7 +619,7 @@ pub const DeclGen = struct {
482	return result_id;	619	return result_id;
483	}	620	}
484		621
485	/// Construct a struct at runtime.	622	/// Construct an array at runtime.
486	/// result_ty_ref must be an array type.	623	/// result_ty_ref must be an array type.
487	/// Constituents should be in `indirect` representation (as the elements of an array should be).	624	/// Constituents should be in `indirect` representation (as the elements of an array should be).
488	/// Result is in `direct` representation.	625	/// Result is in `direct` representation.
...	@@ -521,59 +658,6 @@ pub const DeclGen = struct {	...	@@ -521,59 +658,6 @@ pub const DeclGen = struct {
521	return result_id;	658	return result_id;
522	}	659	}
523		660
524	fn constructDeclRef(self: *DeclGen, ty: Type, decl_index: Decl.Index) !IdRef {
525	const mod = self.module;
526	const ty_ref = try self.resolveType(ty, .direct);
527	const ty_id = self.typeId(ty_ref);
528	const decl = mod.declPtr(decl_index);
529	const spv_decl_index = try self.resolveDecl(decl_index);
530	switch (mod.intern_pool.indexToKey(decl.val.ip_index)) {
531	.func => {
532	// TODO: Properly lower function pointers. For now we are going to hack around it and
533	// just generate an empty pointer. Function pointers are represented by a pointer to usize.
534	// TODO: Add dependency
535	return try self.spv.constNull(ty_ref);
536	},
537	.extern_func => unreachable, // TODO
538	else => {
539	const decl_id = self.spv.declPtr(spv_decl_index).result_id;
540	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
541
542	const final_storage_class = spvStorageClass(decl.@"addrspace");
543
544	const decl_ty_ref = try self.resolveType(decl.ty, .indirect);
545	const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
546
547	const ptr_id = switch (final_storage_class) {
548	.Generic => blk: {
549	// Pointer should be Generic, but is actually placed in CrossWorkgroup.
550	const result_id = self.spv.allocId();
551	try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
552	.id_result_type = self.typeId(decl_ptr_ty_ref),
553	.id_result = result_id,
554	.pointer = decl_id,
555	});
556	break :blk result_id;
557	},
558	else => decl_id,
559	};
560
561	if (decl_ptr_ty_ref != ty_ref) {
562	// Differing pointer types, insert a cast.
563	const casted_ptr_id = self.spv.allocId();
564	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
565	.id_result_type = ty_id,
566	.id_result = casted_ptr_id,
567	.operand = ptr_id,
568	});
569	return casted_ptr_id;
570	} else {
571	return ptr_id;
572	}
573	},
574	}
575	}
576
577	/// This function generates a load for a constant in direct (ie, non-memory) representation.	661	/// This function generates a load for a constant in direct (ie, non-memory) representation.
578	/// When the constant is simple, it can be generated directly using OpConstant instructions.	662	/// When the constant is simple, it can be generated directly using OpConstant instructions.
579	/// When the constant is more complicated however, it needs to be constructed using multiple values. This	663	/// When the constant is more complicated however, it needs to be constructed using multiple values. This
...	@@ -738,7 +822,7 @@ pub const DeclGen = struct {	...	@@ -738,7 +822,7 @@ pub const DeclGen = struct {
738	return try self.constructStruct(result_ty_ref, &.{ payload_id, has_pl_id });	822	return try self.constructStruct(result_ty_ref, &.{ payload_id, has_pl_id });
739	},	823	},
740	.aggregate => \|aggregate\| switch (ip.indexToKey(ty.ip_index)) {	824	.aggregate => \|aggregate\| switch (ip.indexToKey(ty.ip_index)) {
741	.array_type => \|array_type\| {	825	inline .array_type, .vector_type => \|array_type, tag\| {
742	const elem_ty = array_type.child.toType();	826	const elem_ty = array_type.child.toType();
743	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);	827	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
744		828
...	@@ -765,9 +849,14 @@ pub const DeclGen = struct {	...	@@ -765,9 +849,14 @@ pub const DeclGen = struct {
765	}	849	}
766	},	850	},
767	}	851	}
768	if (array_type.sentinel != .none) {	852
769	constituents[constituents.len - 1] = try self.constant(elem_ty, array_type.sentinel.toValue(), .indirect);	853	switch (tag) {
		854	inline .array_type => if (array_type.sentinel != .none) {
		855	constituents[constituents.len - 1] = try self.constant(elem_ty, array_type.sentinel.toValue(), .indirect);
		856	},
		857	else => {},
770	}	858	}
		859
771	return try self.constructArray(result_ty_ref, constituents);	860	return try self.constructArray(result_ty_ref, constituents);
772	},	861	},
773	.struct_type => {	862	.struct_type => {
...	@@ -796,7 +885,7 @@ pub const DeclGen = struct {	...	@@ -796,7 +885,7 @@ pub const DeclGen = struct {
796		885
797	return try self.constructStruct(result_ty_ref, constituents.items);	886	return try self.constructStruct(result_ty_ref, constituents.items);
798	},	887	},
799	.vector_type, .anon_struct_type => unreachable, // TODO	888	.anon_struct_type => unreachable, // TODO
800	else => unreachable,	889	else => unreachable,
801	},	890	},
802	.un => \|un\| {	891	.un => \|un\| {
...	@@ -817,9 +906,9 @@ pub const DeclGen = struct {	...	@@ -817,9 +906,9 @@ pub const DeclGen = struct {
817	const result_ty_ref = try self.resolveType(ptr_ty, .direct);	906	const result_ty_ref = try self.resolveType(ptr_ty, .direct);
818	const mod = self.module;	907	const mod = self.module;
819	switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {	908	switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {
820	.decl => \|decl\| return try self.constructDeclRef(ptr_ty, decl),	909	.decl => \|decl\| return try self.constantDeclRef(ptr_ty, decl),
821	.anon_decl => @panic("TODO"),	910	.mut_decl => \|decl_mut\| return try self.constantDeclRef(ptr_ty, decl_mut.decl),
822	.mut_decl => \|decl_mut\| return try self.constructDeclRef(ptr_ty, decl_mut.decl),	911	.anon_decl => \|anon_decl\| return try self.constantAnonDeclRef(ptr_ty, anon_decl),
823	.int => \|int\| {	912	.int => \|int\| {
824	const ptr_id = self.spv.allocId();	913	const ptr_id = self.spv.allocId();
825	// TODO: This can probably be an OpSpecConstantOp Bitcast, but	914	// TODO: This can probably be an OpSpecConstantOp Bitcast, but
...	@@ -836,16 +925,156 @@ pub const DeclGen = struct {	...	@@ -836,16 +925,156 @@ pub const DeclGen = struct {
836	.opt_payload => unreachable, // TODO	925	.opt_payload => unreachable, // TODO
837	.comptime_field => unreachable,	926	.comptime_field => unreachable,
838	.elem => \|elem_ptr\| {	927	.elem => \|elem_ptr\| {
839	const elem_ptr_ty = mod.intern_pool.typeOf(elem_ptr.base).toType();	928	const parent_ptr_ty = mod.intern_pool.typeOf(elem_ptr.base).toType();
840	const parent_ptr_id = try self.constantPtr(elem_ptr_ty, elem_ptr.base.toValue());	929	const parent_ptr_id = try self.constantPtr(parent_ptr_ty, elem_ptr.base.toValue());
841	const size_ty_ref = try self.sizeType();	930	const size_ty_ref = try self.sizeType();
842	const index_id = try self.constInt(size_ty_ref, elem_ptr.index);	931	const index_id = try self.constInt(size_ty_ref, elem_ptr.index);
843	return self.ptrAccessChain(result_ty_ref, parent_ptr_id, index_id, &.{});	932
		933	const elem_ptr_id = try self.ptrElemPtr(parent_ptr_ty, parent_ptr_id, index_id);
		934
		935	// TODO: Can we consolidate this in ptrElemPtr?
		936	const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
		937	const elem_ty_ref = try self.resolveType(elem_ty, .direct);
		938	const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
		939
		940	if (elem_ptr_ty_ref == result_ty_ref) {
		941	return elem_ptr_id;
		942	}
		943	// This may happen when we have pointer-to-array and the result is
		944	// another pointer-to-array instead of a pointer-to-element.
		945	const result_id = self.spv.allocId();
		946	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
		947	.id_result_type = self.typeId(result_ty_ref),
		948	.id_result = result_id,
		949	.operand = elem_ptr_id,
		950	});
		951	return result_id;
844	},	952	},
845	.field => unreachable, // TODO	953	.field => unreachable, // TODO
846	}	954	}
847	}	955	}
848		956
		957	fn constantAnonDeclRef(self: *DeclGen, ty: Type, decl_val: InternPool.Index) !IdRef {
		958	// TODO: Merge this function with constantDeclRef.
		959
		960	const mod = self.module;
		961	const ip = &mod.intern_pool;
		962	const ty_ref = try self.resolveType(ty, .direct);
		963	const decl_ty = ip.typeOf(decl_val).toType();
		964
		965	if (decl_val.toValue().getFunction(mod)) \|func\| {
		966	_ = func;
		967	unreachable; // TODO
		968	} else if (decl_val.toValue().getExternFunc(mod)) \|func\| {
		969	_ = func;
		970	unreachable;
		971	}
		972
		973	// const is_fn_body = decl_ty.zigTypeTag(mod) == .Fn;
		974	if (!decl_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) {
		975	// Pointer to nothing - return undefoined
		976	return self.spv.constUndef(ty_ref);
		977	}
		978
		979	if (decl_ty.zigTypeTag(mod) == .Fn) {
		980	unreachable; // TODO
		981	}
		982
		983	const final_storage_class = spvStorageClass(ty.ptrAddressSpace(mod));
		984	const actual_storage_class = switch (final_storage_class) {
		985	.Generic => .CrossWorkgroup,
		986	else => \|other\| other,
		987	};
		988
		989	const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);
		990	const decl_ty_ref = try self.resolveType(decl_ty, .indirect);
		991	const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
		992
		993	const ptr_id = switch (final_storage_class) {
		994	.Generic => blk: {
		995	const result_id = self.spv.allocId();
		996	try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
		997	.id_result_type = self.typeId(decl_ptr_ty_ref),
		998	.id_result = result_id,
		999	.pointer = decl_id,
		1000	});
		1001	break :blk result_id;
		1002	},
		1003	else => decl_id,
		1004	};
		1005
		1006	if (decl_ptr_ty_ref != ty_ref) {
		1007	// Differing pointer types, insert a cast.
		1008	const casted_ptr_id = self.spv.allocId();
		1009	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
		1010	.id_result_type = self.typeId(ty_ref),
		1011	.id_result = casted_ptr_id,
		1012	.operand = ptr_id,
		1013	});
		1014	return casted_ptr_id;
		1015	} else {
		1016	return ptr_id;
		1017	}
		1018	}
		1019
		1020	fn constantDeclRef(self: *DeclGen, ty: Type, decl_index: Decl.Index) !IdRef {
		1021	const mod = self.module;
		1022	const ty_ref = try self.resolveType(ty, .direct);
		1023	const ty_id = self.typeId(ty_ref);
		1024	const decl = mod.declPtr(decl_index);
		1025	switch (mod.intern_pool.indexToKey(decl.val.ip_index)) {
		1026	.func => {
		1027	// TODO: Properly lower function pointers. For now we are going to hack around it and
		1028	// just generate an empty pointer. Function pointers are represented by a pointer to usize.
		1029	return try self.spv.constUndef(ty_ref);
		1030	},
		1031	.extern_func => unreachable, // TODO
		1032	else => {},
		1033	}
		1034
		1035	if (!decl.ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) {
		1036	// Pointer to nothing - return undefined.
		1037	return self.spv.constUndef(ty_ref);
		1038	}
		1039
		1040	const spv_decl_index = try self.object.resolveDecl(mod, decl_index);
		1041
		1042	const decl_id = self.spv.declPtr(spv_decl_index).result_id;
		1043	try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
		1044
		1045	const final_storage_class = spvStorageClass(decl.@"addrspace");
		1046
		1047	const decl_ty_ref = try self.resolveType(decl.ty, .indirect);
		1048	const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
		1049
		1050	const ptr_id = switch (final_storage_class) {
		1051	.Generic => blk: {
		1052	// Pointer should be Generic, but is actually placed in CrossWorkgroup.
		1053	const result_id = self.spv.allocId();
		1054	try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
		1055	.id_result_type = self.typeId(decl_ptr_ty_ref),
		1056	.id_result = result_id,
		1057	.pointer = decl_id,
		1058	});
		1059	break :blk result_id;
		1060	},
		1061	else => decl_id,
		1062	};
		1063
		1064	if (decl_ptr_ty_ref != ty_ref) {
		1065	// Differing pointer types, insert a cast.
		1066	const casted_ptr_id = self.spv.allocId();
		1067	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
		1068	.id_result_type = ty_id,
		1069	.id_result = casted_ptr_id,
		1070	.operand = ptr_id,
		1071	});
		1072	return casted_ptr_id;
		1073	} else {
		1074	return ptr_id;
		1075	}
		1076	}
		1077
849	// Turn a Zig type's name into a cache reference.	1078	// Turn a Zig type's name into a cache reference.
850	fn resolveTypeName(self: *DeclGen, ty: Type) !CacheString {	1079	fn resolveTypeName(self: *DeclGen, ty: Type) !CacheString {
851	var name = std.ArrayList(u8).init(self.gpa);	1080	var name = std.ArrayList(u8).init(self.gpa);
...	@@ -968,6 +1197,22 @@ pub const DeclGen = struct {	...	@@ -968,6 +1197,22 @@ pub const DeclGen = struct {
968	return ty_ref;	1197	return ty_ref;
969	}	1198	}
970		1199
		1200	fn resolveFnReturnType(self: *DeclGen, ret_ty: Type) !CacheRef {
		1201	const mod = self.module;
		1202	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
		1203	// If the return type is an error set or an error union, then we make this
		1204	// anyerror return type instead, so that it can be coerced into a function
		1205	// pointer type which has anyerror as the return type.
		1206	if (ret_ty.isError(mod)) {
		1207	return self.resolveType(Type.anyerror, .direct);
		1208	} else {
		1209	return self.resolveType(Type.void, .direct);
		1210	}
		1211	}
		1212
		1213	return try self.resolveType(ret_ty, .direct);
		1214	}
		1215
971	/// Turn a Zig type into a SPIR-V Type, and return a reference to it.	1216	/// Turn a Zig type into a SPIR-V Type, and return a reference to it.
972	fn resolveType(self: *DeclGen, ty: Type, repr: Repr) Error!CacheRef {	1217	fn resolveType(self: *DeclGen, ty: Type, repr: Repr) Error!CacheRef {
973	const mod = self.module;	1218	const mod = self.module;
...	@@ -975,14 +1220,31 @@ pub const DeclGen = struct {	...	@@ -975,14 +1220,31 @@ pub const DeclGen = struct {
975	log.debug("resolveType: ty = {}", .{ty.fmt(mod)});	1220	log.debug("resolveType: ty = {}", .{ty.fmt(mod)});
976	const target = self.getTarget();	1221	const target = self.getTarget();
977	switch (ty.zigTypeTag(mod)) {	1222	switch (ty.zigTypeTag(mod)) {
978	.Void, .NoReturn => return try self.spv.resolve(.void_type),	1223	.NoReturn => {
		1224	assert(repr == .direct);
		1225	return try self.spv.resolve(.void_type);
		1226	},
		1227	.Void => switch (repr) {
		1228	.direct => return try self.spv.resolve(.void_type),
		1229	// Pointers to void
		1230	.indirect => return try self.spv.resolve(.{ .opaque_type = .{
		1231	.name = try self.spv.resolveString("void"),
		1232	} }),
		1233	},
979	.Bool => switch (repr) {	1234	.Bool => switch (repr) {
980	.direct => return try self.spv.resolve(.bool_type),	1235	.direct => return try self.spv.resolve(.bool_type),
981	.indirect => return try self.intType(.unsigned, 1),	1236	.indirect => return try self.intType(.unsigned, 1),
982	},	1237	},
983	.Int => {	1238	.Int => {
984	const int_info = ty.intInfo(mod);	1239	const int_info = ty.intInfo(mod);
985	// TODO: Integers in OpenCL kernels are always unsigned.	1240	if (int_info.bits == 0) {
		1241	// Some times, the backend will be asked to generate a pointer to i0. OpTypeInt
		1242	// with 0 bits is invalid, so return an opaque type in this case.
		1243	assert(repr == .indirect);
		1244	return try self.spv.resolve(.{ .opaque_type = .{
		1245	.name = try self.spv.resolveString("u0"),
		1246	} });
		1247	}
986	return try self.intType(int_info.signedness, int_info.bits);	1248	return try self.intType(int_info.signedness, int_info.bits);
987	},	1249	},
988	.Enum => {	1250	.Enum => {
...	@@ -1012,10 +1274,32 @@ pub const DeclGen = struct {	...	@@ -1012,10 +1274,32 @@ pub const DeclGen = struct {
1012		1274
1013	const elem_ty = ty.childType(mod);	1275	const elem_ty = ty.childType(mod);
1014	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);	1276	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
1015	const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel(mod)) orelse {	1277	var total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel(mod)) orelse {
1016	return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(mod)});	1278	return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(mod)});
1017	};	1279	};
1018	const ty_ref = try self.spv.arrayType(total_len, elem_ty_ref);	1280	const ty_ref = if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) blk: {
		1281	// The size of the array would be 0, but that is not allowed in SPIR-V.
		1282	// This path can be reached when the backend is asked to generate a pointer to
		1283	// an array of some zero-bit type. This should always be an indirect path.
		1284	assert(repr == .indirect);
		1285
		1286	// We cannot use the child type here, so just use an opaque type.
		1287	break :blk try self.spv.resolve(.{ .opaque_type = .{
		1288	.name = try self.spv.resolveString("zero-sized array"),
		1289	} });
		1290	} else if (total_len == 0) blk: {
		1291	// The size of the array would be 0, but that is not allowed in SPIR-V.
		1292	// This path can be reached for example when there is a slicing of a pointer
		1293	// that produces a zero-length array. In all cases where this type can be generated,
		1294	// this should be an indirect path.
		1295	assert(repr == .indirect);
		1296
		1297	// In this case, we have an array of a non-zero sized type. In this case,
		1298	// generate an array of 1 element instead, so that ptr_elem_ptr instructions
		1299	// can be lowered to ptrAccessChain instead of manually performing the math.
		1300	break :blk try self.spv.arrayType(1, elem_ty_ref);
		1301	} else try self.spv.arrayType(total_len, elem_ty_ref);
		1302
1019	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });	1303	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1020	return ty_ref;	1304	return ty_ref;
1021	},	1305	},
...	@@ -1030,14 +1314,19 @@ pub const DeclGen = struct {	...	@@ -1030,14 +1314,19 @@ pub const DeclGen = struct {
1030		1314
1031	const param_ty_refs = try self.gpa.alloc(CacheRef, fn_info.param_types.len);	1315	const param_ty_refs = try self.gpa.alloc(CacheRef, fn_info.param_types.len);
1032	defer self.gpa.free(param_ty_refs);	1316	defer self.gpa.free(param_ty_refs);
1033	for (param_ty_refs, fn_info.param_types.get(ip)) \|*param_type, fn_param_type\| {	1317	var param_index: usize = 0;
1034	param_type.* = try self.resolveType(fn_param_type.toType(), .direct);	1318	for (fn_info.param_types.get(ip)) \|param_ty_index\| {
		1319	const param_ty = param_ty_index.toType();
		1320	if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
		1321
		1322	param_ty_refs[param_index] = try self.resolveType(param_ty, .direct);
		1323	param_index += 1;
1035	}	1324	}
1036	const return_ty_ref = try self.resolveType(fn_info.return_type.toType(), .direct);	1325	const return_ty_ref = try self.resolveFnReturnType(fn_info.return_type.toType());
1037		1326
1038	const ty_ref = try self.spv.resolve(.{ .function_type = .{	1327	const ty_ref = try self.spv.resolve(.{ .function_type = .{
1039	.return_type = return_ty_ref,	1328	.return_type = return_ty_ref,
1040	.parameters = param_ty_refs,	1329	.parameters = param_ty_refs[0..param_index],
1041	} });	1330	} });
1042		1331
1043	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });	1332	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
...	@@ -1072,19 +1361,14 @@ pub const DeclGen = struct {	...	@@ -1072,19 +1361,14 @@ pub const DeclGen = struct {
1072	} });	1361	} });
1073	},	1362	},
1074	.Vector => {	1363	.Vector => {
1075	// Although not 100% the same, Zig vectors map quite neatly to SPIR-V vectors (including many integer and float operations	1364	if (self.type_map.get(ty.toIntern())) \|info\| return info.ty_ref;
1076	// which work on them), so simply use those.	1365
1077	// Note: SPIR-V vectors only support bools, ints and floats, so pointer vectors need to be supported another way.	1366	const elem_ty = ty.childType(mod);
1078	// "composite integers" (larger than the largest supported native type) can probably be represented by an array of vectors.	1367	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
1079	// TODO: The SPIR-V spec mentions that vector sizes may be quite restricted! look into which we can use, and whether OpTypeVector	1368
1080	// is adequate at all for this.	1369	const ty_ref = try self.spv.arrayType(ty.vectorLen(mod), elem_ty_ref);
1081		1370	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1082	// TODO: Properly verify sizes and child type.	1371	return ty_ref;
1083
1084	return try self.spv.resolve(.{ .vector_type = .{
1085	.component_type = try self.resolveType(ty.childType(mod), repr),
1086	.component_count = @as(u32, @intCast(ty.vectorLen(mod))),
1087	} });
1088	},	1372	},
1089	.Struct => {	1373	.Struct => {
1090	if (self.type_map.get(ty.toIntern())) \|info\| return info.ty_ref;	1374	if (self.type_map.get(ty.toIntern())) \|info\| return info.ty_ref;
...	@@ -1126,10 +1410,16 @@ pub const DeclGen = struct {	...	@@ -1126,10 +1410,16 @@ pub const DeclGen = struct {
1126		1410
1127	var it = struct_type.iterateRuntimeOrder(ip);	1411	var it = struct_type.iterateRuntimeOrder(ip);
1128	while (it.next()) \|field_index\| {	1412	while (it.next()) \|field_index\| {
1129	const field_ty = struct_type.field_types.get(ip)[field_index];	1413	const field_ty = struct_type.field_types.get(ip)[field_index].toType();
1130	const field_name = ip.stringToSlice(struct_type.field_names.get(ip)[field_index]);	1414	if (!field_ty.hasRuntimeBitsIgnoreComptime(mod)) {
1131	try member_types.append(try self.resolveType(field_ty.toType(), .indirect));	1415	// This is a zero-bit field - we only needed it for the alignment.
1132	try member_names.append(try self.spv.resolveString(field_name));	1416	continue;
		1417	}
		1418
		1419	const field_name = struct_type.fieldName(ip, field_index).unwrap() orelse
		1420	try ip.getOrPutStringFmt(mod.gpa, "{d}", .{field_index});
		1421	try member_types.append(try self.resolveType(field_ty, .indirect));
		1422	try member_names.append(try self.spv.resolveString(ip.stringToSlice(field_name)));
1133	}	1423	}
1134		1424
1135	const ty_ref = try self.spv.resolve(.{ .struct_type = .{	1425	const ty_ref = try self.spv.resolve(.{ .struct_type = .{
...	@@ -1215,6 +1505,13 @@ pub const DeclGen = struct {	...	@@ -1215,6 +1505,13 @@ pub const DeclGen = struct {
1215	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });	1505	try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1216	return ty_ref;	1506	return ty_ref;
1217	},	1507	},
		1508	.Opaque => {
		1509	return try self.spv.resolve(.{
		1510	.opaque_type = .{
		1511	.name = .none, // TODO
		1512	},
		1513	});
		1514	},
1218		1515
1219	.Null,	1516	.Null,
1220	.Undefined,	1517	.Undefined,
...	@@ -1431,7 +1728,7 @@ pub const DeclGen = struct {	...	@@ -1431,7 +1728,7 @@ pub const DeclGen = struct {
1431	const mod = self.module;	1728	const mod = self.module;
1432	const ip = &mod.intern_pool;	1729	const ip = &mod.intern_pool;
1433	const decl = mod.declPtr(self.decl_index);	1730	const decl = mod.declPtr(self.decl_index);
1434	const spv_decl_index = try self.resolveDecl(self.decl_index);	1731	const spv_decl_index = try self.object.resolveDecl(mod, self.decl_index);
1435		1732
1436	const decl_id = self.spv.declPtr(spv_decl_index).result_id;	1733	const decl_id = self.spv.declPtr(spv_decl_index).result_id;
1437		1734
...	@@ -1439,20 +1736,23 @@ pub const DeclGen = struct {	...	@@ -1439,20 +1736,23 @@ pub const DeclGen = struct {
1439		1736
1440	if (decl.val.getFunction(mod)) \|_\| {	1737	if (decl.val.getFunction(mod)) \|_\| {
1441	assert(decl.ty.zigTypeTag(mod) == .Fn);	1738	assert(decl.ty.zigTypeTag(mod) == .Fn);
		1739	const fn_info = mod.typeToFunc(decl.ty).?;
		1740	const return_ty_ref = try self.resolveFnReturnType(fn_info.return_type.toType());
		1741
1442	const prototype_id = try self.resolveTypeId(decl.ty);	1742	const prototype_id = try self.resolveTypeId(decl.ty);
1443	try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{	1743	try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{
1444	.id_result_type = try self.resolveTypeId(decl.ty.fnReturnType(mod)),	1744	.id_result_type = self.typeId(return_ty_ref),
1445	.id_result = decl_id,	1745	.id_result = decl_id,
1446	.function_control = .{}, // TODO: We can set inline here if the type requires it.	1746	.function_control = .{}, // TODO: We can set inline here if the type requires it.
1447	.function_type = prototype_id,	1747	.function_type = prototype_id,
1448	});	1748	});
1449		1749
1450	const fn_info = mod.typeToFunc(decl.ty).?;
1451
1452	try self.args.ensureUnusedCapacity(self.gpa, fn_info.param_types.len);	1750	try self.args.ensureUnusedCapacity(self.gpa, fn_info.param_types.len);
1453	for (0..fn_info.param_types.len) \|i\| {	1751	for (fn_info.param_types.get(ip)) \|param_ty_index\| {
1454	const param_type = fn_info.param_types.get(ip)[i];	1752	const param_ty = param_ty_index.toType();
1455	const param_type_id = try self.resolveTypeId(param_type.toType());	1753	if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
		1754
		1755	const param_type_id = try self.resolveTypeId(param_ty);
1456	const arg_result_id = self.spv.allocId();	1756	const arg_result_id = self.spv.allocId();
1457	try self.func.prologue.emit(self.spv.gpa, .OpFunctionParameter, .{	1757	try self.func.prologue.emit(self.spv.gpa, .OpFunctionParameter, .{
1458	.id_result_type = param_type_id,	1758	.id_result_type = param_type_id,
...	@@ -1693,11 +1993,15 @@ pub const DeclGen = struct {	...	@@ -1693,11 +1993,15 @@ pub const DeclGen = struct {
1693		1993
1694	.shl => try self.airShift(inst, .OpShiftLeftLogical),	1994	.shl => try self.airShift(inst, .OpShiftLeftLogical),
1695		1995
		1996	.min => try self.airMinMax(inst, .lt),
		1997	.max => try self.airMinMax(inst, .gt),
		1998
1696	.bitcast => try self.airBitCast(inst),	1999	.bitcast => try self.airBitCast(inst),
1697	.intcast, .trunc => try self.airIntCast(inst),	2000	.intcast, .trunc => try self.airIntCast(inst),
1698	.int_from_ptr => try self.airIntFromPtr(inst),	2001	.int_from_ptr => try self.airIntFromPtr(inst),
1699	.float_from_int => try self.airFloatFromInt(inst),	2002	.float_from_int => try self.airFloatFromInt(inst),
1700	.int_from_float => try self.airIntFromFloat(inst),	2003	.int_from_float => try self.airIntFromFloat(inst),
		2004	.fpext, .fptrunc => try self.airFloatCast(inst),
1701	.not => try self.airNot(inst),	2005	.not => try self.airNot(inst),
1702		2006
1703	.array_to_slice => try self.airArrayToSlice(inst),	2007	.array_to_slice => try self.airArrayToSlice(inst),
...	@@ -1723,12 +2027,13 @@ pub const DeclGen = struct {	...	@@ -1723,12 +2027,13 @@ pub const DeclGen = struct {
1723	.struct_field_ptr_index_2 => try self.airStructFieldPtrIndex(inst, 2),	2027	.struct_field_ptr_index_2 => try self.airStructFieldPtrIndex(inst, 2),
1724	.struct_field_ptr_index_3 => try self.airStructFieldPtrIndex(inst, 3),	2028	.struct_field_ptr_index_3 => try self.airStructFieldPtrIndex(inst, 3),
1725		2029
1726	.cmp_eq => try self.airCmp(inst, .eq),	2030	.cmp_eq => try self.airCmp(inst, .eq),
1727	.cmp_neq => try self.airCmp(inst, .neq),	2031	.cmp_neq => try self.airCmp(inst, .neq),
1728	.cmp_gt => try self.airCmp(inst, .gt),	2032	.cmp_gt => try self.airCmp(inst, .gt),
1729	.cmp_gte => try self.airCmp(inst, .gte),	2033	.cmp_gte => try self.airCmp(inst, .gte),
1730	.cmp_lt => try self.airCmp(inst, .lt),	2034	.cmp_lt => try self.airCmp(inst, .lt),
1731	.cmp_lte => try self.airCmp(inst, .lte),	2035	.cmp_lte => try self.airCmp(inst, .lte),
		2036	.cmp_vector => try self.airVectorCmp(inst),
1732		2037
1733	.arg => self.airArg(),	2038	.arg => self.airArg(),
1734	.alloc => try self.airAlloc(inst),	2039	.alloc => try self.airAlloc(inst),
...	@@ -1784,13 +2089,30 @@ pub const DeclGen = struct {	...	@@ -1784,13 +2089,30 @@ pub const DeclGen = struct {
1784	try self.inst_results.putNoClobber(self.gpa, inst, result_id);	2089	try self.inst_results.putNoClobber(self.gpa, inst, result_id);
1785	}	2090	}
1786		2091
1787	fn airBinOpSimple(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {	2092	fn binOpSimple(self: *DeclGen, ty: Type, lhs_id: IdRef, rhs_id: IdRef, comptime opcode: Opcode) !IdRef {
1788	if (self.liveness.isUnused(inst)) return null;	2093	const mod = self.module;
1789	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2094
1790	const lhs_id = try self.resolve(bin_op.lhs);	2095	if (ty.isVector(mod)) {
1791	const rhs_id = try self.resolve(bin_op.rhs);	2096	const child_ty = ty.childType(mod);
		2097	const vector_len = ty.vectorLen(mod);
		2098
		2099	var constituents = try self.gpa.alloc(IdRef, vector_len);
		2100	defer self.gpa.free(constituents);
		2101
		2102	for (constituents, 0..) \|*constituent, i\| {
		2103	const lhs_index_id = try self.extractField(child_ty, lhs_id, @intCast(i));
		2104	const rhs_index_id = try self.extractField(child_ty, rhs_id, @intCast(i));
		2105	const result_id = try self.binOpSimple(child_ty, lhs_index_id, rhs_index_id, opcode);
		2106	constituent.* = try self.convertToIndirect(child_ty, result_id);
		2107	}
		2108
		2109	const result_ty = try self.resolveType(child_ty, .indirect);
		2110	const result_ty_ref = try self.spv.arrayType(vector_len, result_ty);
		2111	return try self.constructArray(result_ty_ref, constituents);
		2112	}
		2113
1792	const result_id = self.spv.allocId();	2114	const result_id = self.spv.allocId();
1793	const result_type_id = try self.resolveTypeId(self.typeOfIndex(inst));	2115	const result_type_id = try self.resolveTypeId(ty);
1794	try self.func.body.emit(self.spv.gpa, opcode, .{	2116	try self.func.body.emit(self.spv.gpa, opcode, .{
1795	.id_result_type = result_type_id,	2117	.id_result_type = result_type_id,
1796	.id_result = result_id,	2118	.id_result = result_id,
...	@@ -1800,6 +2122,17 @@ pub const DeclGen = struct {	...	@@ -1800,6 +2122,17 @@ pub const DeclGen = struct {
1800	return result_id;	2122	return result_id;
1801	}	2123	}
1802		2124
		2125	fn airBinOpSimple(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {
		2126	if (self.liveness.isUnused(inst)) return null;
		2127
		2128	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
		2129	const lhs_id = try self.resolve(bin_op.lhs);
		2130	const rhs_id = try self.resolve(bin_op.rhs);
		2131	const ty = self.typeOf(bin_op.lhs);
		2132
		2133	return try self.binOpSimple(ty, lhs_id, rhs_id, opcode);
		2134	}
		2135
1803	fn airShift(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {	2136	fn airShift(self: *DeclGen, inst: Air.Inst.Index, comptime opcode: Opcode) !?IdRef {
1804	if (self.liveness.isUnused(inst)) return null;	2137	if (self.liveness.isUnused(inst)) return null;
1805	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2138	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
...	@@ -1825,19 +2158,99 @@ pub const DeclGen = struct {	...	@@ -1825,19 +2158,99 @@ pub const DeclGen = struct {
1825	return result_id;	2158	return result_id;
1826	}	2159	}
1827		2160
1828	fn maskStrangeInt(self: *DeclGen, ty_ref: CacheRef, value_id: IdRef, bits: u16) !IdRef {	2161	fn airMinMax(self: *DeclGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !?IdRef {
1829	const mask_value = if (bits == 64) 0xFFFF_FFFF_FFFF_FFFF else (@as(u64, 1) << @as(u6, @intCast(bits))) - 1;	2162	if (self.liveness.isUnused(inst)) return null;
		2163
		2164	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
		2165	const lhs_id = try self.resolve(bin_op.lhs);
		2166	const rhs_id = try self.resolve(bin_op.rhs);
		2167	const result_ty = self.typeOfIndex(inst);
		2168	const result_ty_ref = try self.resolveType(result_ty, .direct);
		2169
		2170	const info = try self.arithmeticTypeInfo(result_ty);
		2171	// TODO: Use fmin for OpenCL
		2172	const cmp_id = try self.cmp(op, result_ty, lhs_id, rhs_id);
		2173	const selection_id = switch (info.class) {
		2174	.float => blk: {
		2175	// cmp uses OpFOrd. When we have 0 [<>] nan this returns false,
		2176	// but we want it to pick lhs. Therefore we also have to check if
		2177	// rhs is nan. We don't need to care about the result when both
		2178	// are nan.
		2179	const rhs_is_nan_id = self.spv.allocId();
		2180	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
		2181	try self.func.body.emit(self.spv.gpa, .OpIsNan, .{
		2182	.id_result_type = self.typeId(bool_ty_ref),
		2183	.id_result = rhs_is_nan_id,
		2184	.x = rhs_id,
		2185	});
		2186	const float_cmp_id = self.spv.allocId();
		2187	try self.func.body.emit(self.spv.gpa, .OpLogicalOr, .{
		2188	.id_result_type = self.typeId(bool_ty_ref),
		2189	.id_result = float_cmp_id,
		2190	.operand_1 = cmp_id,
		2191	.operand_2 = rhs_is_nan_id,
		2192	});
		2193	break :blk float_cmp_id;
		2194	},
		2195	else => cmp_id,
		2196	};
		2197
1830	const result_id = self.spv.allocId();	2198	const result_id = self.spv.allocId();
1831	const mask_id = try self.constInt(ty_ref, mask_value);	2199	try self.func.body.emit(self.spv.gpa, .OpSelect, .{
1832	try self.func.body.emit(self.spv.gpa, .OpBitwiseAnd, .{	2200	.id_result_type = self.typeId(result_ty_ref),
1833	.id_result_type = self.typeId(ty_ref),
1834	.id_result = result_id,	2201	.id_result = result_id,
1835	.operand_1 = value_id,	2202	.condition = selection_id,
1836	.operand_2 = mask_id,	2203	.object_1 = lhs_id,
		2204	.object_2 = rhs_id,
1837	});	2205	});
1838	return result_id;	2206	return result_id;
1839	}	2207	}
1840		2208
		2209	/// This function canonicalizes a "strange" integer value:
		2210	/// For unsigned integers, the value is masked so that only the relevant bits can contain
		2211	/// non-zeros.
		2212	/// For signed integers, the value is also sign extended.
		2213	fn normalizeInt(self: *DeclGen, ty_ref: CacheRef, value_id: IdRef, info: ArithmeticTypeInfo) !IdRef {
		2214	assert(info.class != .composite_integer); // TODO
		2215	if (info.bits == info.backing_bits) {
		2216	return value_id;
		2217	}
		2218
		2219	switch (info.signedness) {
		2220	.unsigned => {
		2221	const mask_value = if (info.bits == 64) 0xFFFF_FFFF_FFFF_FFFF else (@as(u64, 1) << @as(u6, @intCast(info.bits))) - 1;
		2222	const result_id = self.spv.allocId();
		2223	const mask_id = try self.constInt(ty_ref, mask_value);
		2224	try self.func.body.emit(self.spv.gpa, .OpBitwiseAnd, .{
		2225	.id_result_type = self.typeId(ty_ref),
		2226	.id_result = result_id,
		2227	.operand_1 = value_id,
		2228	.operand_2 = mask_id,
		2229	});
		2230	return result_id;
		2231	},
		2232	.signed => {
		2233	// Shift left and right so that we can copy the sight bit that way.
		2234	const shift_amt_id = try self.constInt(ty_ref, info.backing_bits - info.bits);
		2235	const left_id = self.spv.allocId();
		2236	try self.func.body.emit(self.spv.gpa, .OpShiftLeftLogical, .{
		2237	.id_result_type = self.typeId(ty_ref),
		2238	.id_result = left_id,
		2239	.base = value_id,
		2240	.shift = shift_amt_id,
		2241	});
		2242	const right_id = self.spv.allocId();
		2243	try self.func.body.emit(self.spv.gpa, .OpShiftRightArithmetic, .{
		2244	.id_result_type = self.typeId(ty_ref),
		2245	.id_result = right_id,
		2246	.base = left_id,
		2247	.shift = shift_amt_id,
		2248	});
		2249	return right_id;
		2250	},
		2251	}
		2252	}
		2253
1841	fn airArithOp(	2254	fn airArithOp(
1842	self: *DeclGen,	2255	self: *DeclGen,
1843	inst: Air.Inst.Index,	2256	inst: Air.Inst.Index,
...	@@ -1848,18 +2261,52 @@ pub const DeclGen = struct {	...	@@ -1848,18 +2261,52 @@ pub const DeclGen = struct {
1848	comptime modular: bool,	2261	comptime modular: bool,
1849	) !?IdRef {	2262	) !?IdRef {
1850	if (self.liveness.isUnused(inst)) return null;	2263	if (self.liveness.isUnused(inst)) return null;
		2264
1851	// LHS and RHS are guaranteed to have the same type, and AIR guarantees	2265	// LHS and RHS are guaranteed to have the same type, and AIR guarantees
1852	// the result to be the same as the LHS and RHS, which matches SPIR-V.	2266	// the result to be the same as the LHS and RHS, which matches SPIR-V.
1853	const ty = self.typeOfIndex(inst);	2267	const ty = self.typeOfIndex(inst);
1854	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2268	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
1855	var lhs_id = try self.resolve(bin_op.lhs);	2269	const lhs_id = try self.resolve(bin_op.lhs);
1856	var rhs_id = try self.resolve(bin_op.rhs);	2270	const rhs_id = try self.resolve(bin_op.rhs);
1857
1858	const result_ty_ref = try self.resolveType(ty, .direct);
1859		2271
1860	assert(self.typeOf(bin_op.lhs).eql(ty, self.module));	2272	assert(self.typeOf(bin_op.lhs).eql(ty, self.module));
1861	assert(self.typeOf(bin_op.rhs).eql(ty, self.module));	2273	assert(self.typeOf(bin_op.rhs).eql(ty, self.module));
1862		2274
		2275	return try self.arithOp(ty, lhs_id, rhs_id, fop, sop, uop, modular);
		2276	}
		2277
		2278	fn arithOp(
		2279	self: *DeclGen,
		2280	ty: Type,
		2281	lhs_id_: IdRef,
		2282	rhs_id_: IdRef,
		2283	comptime fop: Opcode,
		2284	comptime sop: Opcode,
		2285	comptime uop: Opcode,
		2286	/// true if this operation holds under modular arithmetic.
		2287	comptime modular: bool,
		2288	) !IdRef {
		2289	var rhs_id = rhs_id_;
		2290	var lhs_id = lhs_id_;
		2291
		2292	const mod = self.module;
		2293	const result_ty_ref = try self.resolveType(ty, .direct);
		2294
		2295	if (ty.isVector(mod)) {
		2296	const child_ty = ty.childType(mod);
		2297	const vector_len = ty.vectorLen(mod);
		2298	var constituents = try self.gpa.alloc(IdRef, vector_len);
		2299	defer self.gpa.free(constituents);
		2300
		2301	for (constituents, 0..) \|*constituent, i\| {
		2302	const lhs_index_id = try self.extractField(child_ty, lhs_id, @intCast(i));
		2303	const rhs_index_id = try self.extractField(child_ty, rhs_id, @intCast(i));
		2304	constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);
		2305	}
		2306
		2307	return self.constructArray(result_ty_ref, constituents);
		2308	}
		2309
1863	// Binary operations are generally applicable to both scalar and vector operations	2310	// Binary operations are generally applicable to both scalar and vector operations
1864	// in SPIR-V, but int and float versions of operations require different opcodes.	2311	// in SPIR-V, but int and float versions of operations require different opcodes.
1865	const info = try self.arithmeticTypeInfo(ty);	2312	const info = try self.arithmeticTypeInfo(ty);
...	@@ -1870,8 +2317,8 @@ pub const DeclGen = struct {	...	@@ -1870,8 +2317,8 @@ pub const DeclGen = struct {
1870	},	2317	},
1871	.strange_integer => blk: {	2318	.strange_integer => blk: {
1872	if (!modular) {	2319	if (!modular) {
1873	lhs_id = try self.maskStrangeInt(result_ty_ref, lhs_id, info.bits);	2320	lhs_id = try self.normalizeInt(result_ty_ref, lhs_id, info);
1874	rhs_id = try self.maskStrangeInt(result_ty_ref, rhs_id, info.bits);	2321	rhs_id = try self.normalizeInt(result_ty_ref, rhs_id, info);
1875	}	2322	}
1876	break :blk switch (info.signedness) {	2323	break :blk switch (info.signedness) {
1877	.signed => @as(usize, 1),	2324	.signed => @as(usize, 1),
...	@@ -2174,8 +2621,7 @@ pub const DeclGen = struct {	...	@@ -2174,8 +2621,7 @@ pub const DeclGen = struct {
2174		2621
2175	fn cmp(	2622	fn cmp(
2176	self: *DeclGen,	2623	self: *DeclGen,
2177	comptime op: std.math.CompareOperator,	2624	op: std.math.CompareOperator,
2178	bool_ty_id: IdRef,
2179	ty: Type,	2625	ty: Type,
2180	lhs_id: IdRef,	2626	lhs_id: IdRef,
2181	rhs_id: IdRef,	2627	rhs_id: IdRef,
...	@@ -2183,38 +2629,104 @@ pub const DeclGen = struct {	...	@@ -2183,38 +2629,104 @@ pub const DeclGen = struct {
2183	const mod = self.module;	2629	const mod = self.module;
2184	var cmp_lhs_id = lhs_id;	2630	var cmp_lhs_id = lhs_id;
2185	var cmp_rhs_id = rhs_id;	2631	var cmp_rhs_id = rhs_id;
2186	const opcode: Opcode = opcode: {	2632	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
2187	const op_ty = switch (ty.zigTypeTag(mod)) {	2633	const op_ty = switch (ty.zigTypeTag(mod)) {
2188	.Int, .Bool, .Float => ty,	2634	.Int, .Bool, .Float => ty,
2189	.Enum => ty.intTagType(mod),	2635	.Enum => ty.intTagType(mod),
2190	.ErrorSet => Type.u16,	2636	.ErrorSet => Type.u16,
2191	.Pointer => blk: {	2637	.Pointer => blk: {
2192	// Note that while SPIR-V offers OpPtrEqual and OpPtrNotEqual, they are	2638	// Note that while SPIR-V offers OpPtrEqual and OpPtrNotEqual, they are
2193	// currently not implemented in the SPIR-V LLVM translator. Thus, we emit these using	2639	// currently not implemented in the SPIR-V LLVM translator. Thus, we emit these using
2194	// OpConvertPtrToU...	2640	// OpConvertPtrToU...
2195	cmp_lhs_id = self.spv.allocId();	2641	cmp_lhs_id = self.spv.allocId();
2196	cmp_rhs_id = self.spv.allocId();	2642	cmp_rhs_id = self.spv.allocId();
2197		2643
2198	const usize_ty_id = self.typeId(try self.sizeType());	2644	const usize_ty_id = self.typeId(try self.sizeType());
2199		2645
2200	try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{	2646	try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
2201	.id_result_type = usize_ty_id,	2647	.id_result_type = usize_ty_id,
2202	.id_result = cmp_lhs_id,	2648	.id_result = cmp_lhs_id,
2203	.pointer = lhs_id,	2649	.pointer = lhs_id,
2204	});	2650	});
2205		2651
2206	try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{	2652	try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
2207	.id_result_type = usize_ty_id,	2653	.id_result_type = usize_ty_id,
2208	.id_result = cmp_rhs_id,	2654	.id_result = cmp_rhs_id,
2209	.pointer = rhs_id,	2655	.pointer = rhs_id,
2210	});	2656	});
2211		2657
2212	break :blk Type.usize;	2658	break :blk Type.usize;
2213	},	2659	},
2214	.Optional => unreachable, // TODO	2660	.Optional => {
2215	else => unreachable,	2661	const payload_ty = ty.optionalChild(mod);
2216	};	2662	if (ty.optionalReprIsPayload(mod)) {
		2663	assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));
		2664	assert(!payload_ty.isSlice(mod));
		2665	return self.cmp(op, payload_ty, lhs_id, rhs_id);
		2666	}
		2667
		2668	const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
		2669	try self.extractField(Type.bool, lhs_id, 1)
		2670	else
		2671	try self.convertToDirect(Type.bool, lhs_id);
		2672
		2673	const rhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
		2674	try self.extractField(Type.bool, rhs_id, 1)
		2675	else
		2676	try self.convertToDirect(Type.bool, rhs_id);
		2677
		2678	const valid_cmp_id = try self.cmp(op, Type.bool, lhs_valid_id, rhs_valid_id);
		2679	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
		2680	return valid_cmp_id;
		2681	}
		2682
		2683	// TODO: Should we short circuit here? It shouldn't affect correctness, but
		2684	// perhaps it will generate more efficient code.
		2685
		2686	const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);
		2687	const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);
		2688
		2689	const pl_cmp_id = try self.cmp(op, payload_ty, lhs_pl_id, rhs_pl_id);
2217		2690
		2691	// op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl
		2692	// op == .neq => lhs_valid != rhs_valid \|\| lhs_pl != rhs_pl
		2693
		2694	const result_id = self.spv.allocId();
		2695	const args = .{
		2696	.id_result_type = self.typeId(bool_ty_ref),
		2697	.id_result = result_id,
		2698	.operand_1 = valid_cmp_id,
		2699	.operand_2 = pl_cmp_id,
		2700	};
		2701	switch (op) {
		2702	.eq => try self.func.body.emit(self.spv.gpa, .OpLogicalAnd, args),
		2703	.neq => try self.func.body.emit(self.spv.gpa, .OpLogicalOr, args),
		2704	else => unreachable,
		2705	}
		2706	return result_id;
		2707	},
		2708	.Vector => {
		2709	const child_ty = ty.childType(mod);
		2710	const vector_len = ty.vectorLen(mod);
		2711	const bool_ty_ref_indirect = try self.resolveType(Type.bool, .indirect);
		2712
		2713	var constituents = try self.gpa.alloc(IdRef, vector_len);
		2714	defer self.gpa.free(constituents);
		2715
		2716	for (constituents, 0..) \|*constituent, i\| {
		2717	const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));
		2718	const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));
		2719	const result_id = try self.cmp(op, child_ty, lhs_index_id, rhs_index_id);
		2720	constituent.* = try self.convertToIndirect(Type.bool, result_id);
		2721	}
		2722
		2723	const result_ty_ref = try self.spv.arrayType(vector_len, bool_ty_ref_indirect);
		2724	return try self.constructArray(result_ty_ref, constituents);
		2725	},
		2726	else => unreachable,
		2727	};
		2728
		2729	const opcode: Opcode = opcode: {
2218	const info = try self.arithmeticTypeInfo(op_ty);	2730	const info = try self.arithmeticTypeInfo(op_ty);
2219	const signedness = switch (info.class) {	2731	const signedness = switch (info.class) {
2220	.composite_integer => {	2732	.composite_integer => {
...	@@ -2222,7 +2734,7 @@ pub const DeclGen = struct {	...	@@ -2222,7 +2734,7 @@ pub const DeclGen = struct {
2222	},	2734	},
2223	.float => break :opcode switch (op) {	2735	.float => break :opcode switch (op) {
2224	.eq => .OpFOrdEqual,	2736	.eq => .OpFOrdEqual,
2225	.neq => .OpFOrdNotEqual,	2737	.neq => .OpFUnordNotEqual,
2226	.lt => .OpFOrdLessThan,	2738	.lt => .OpFOrdLessThan,
2227	.lte => .OpFOrdLessThanEqual,	2739	.lte => .OpFOrdLessThanEqual,
2228	.gt => .OpFOrdGreaterThan,	2740	.gt => .OpFOrdGreaterThan,
...	@@ -2236,8 +2748,8 @@ pub const DeclGen = struct {	...	@@ -2236,8 +2748,8 @@ pub const DeclGen = struct {
2236	.strange_integer => sign: {	2748	.strange_integer => sign: {
2237	const op_ty_ref = try self.resolveType(op_ty, .direct);	2749	const op_ty_ref = try self.resolveType(op_ty, .direct);
2238	// Mask operands before performing comparison.	2750	// Mask operands before performing comparison.
2239	cmp_lhs_id = try self.maskStrangeInt(op_ty_ref, cmp_lhs_id, info.bits);	2751	cmp_lhs_id = try self.normalizeInt(op_ty_ref, cmp_lhs_id, info);
2240	cmp_rhs_id = try self.maskStrangeInt(op_ty_ref, cmp_rhs_id, info.bits);	2752	cmp_rhs_id = try self.normalizeInt(op_ty_ref, cmp_rhs_id, info);
2241	break :sign info.signedness;	2753	break :sign info.signedness;
2242	},	2754	},
2243	.integer => info.signedness,	2755	.integer => info.signedness,
...	@@ -2265,7 +2777,7 @@ pub const DeclGen = struct {	...	@@ -2265,7 +2777,7 @@ pub const DeclGen = struct {
2265		2777
2266	const result_id = self.spv.allocId();	2778	const result_id = self.spv.allocId();
2267	try self.func.body.emitRaw(self.spv.gpa, opcode, 4);	2779	try self.func.body.emitRaw(self.spv.gpa, opcode, 4);
2268	self.func.body.writeOperand(spec.IdResultType, bool_ty_id);	2780	self.func.body.writeOperand(spec.IdResultType, self.typeId(bool_ty_ref));
2269	self.func.body.writeOperand(spec.IdResult, result_id);	2781	self.func.body.writeOperand(spec.IdResult, result_id);
2270	self.func.body.writeOperand(spec.IdResultType, cmp_lhs_id);	2782	self.func.body.writeOperand(spec.IdResultType, cmp_lhs_id);
2271	self.func.body.writeOperand(spec.IdResultType, cmp_rhs_id);	2783	self.func.body.writeOperand(spec.IdResultType, cmp_rhs_id);
...	@@ -2281,11 +2793,22 @@ pub const DeclGen = struct {	...	@@ -2281,11 +2793,22 @@ pub const DeclGen = struct {
2281	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2793	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2282	const lhs_id = try self.resolve(bin_op.lhs);	2794	const lhs_id = try self.resolve(bin_op.lhs);
2283	const rhs_id = try self.resolve(bin_op.rhs);	2795	const rhs_id = try self.resolve(bin_op.rhs);
2284	const bool_ty_id = try self.resolveTypeId(Type.bool);
2285	const ty = self.typeOf(bin_op.lhs);	2796	const ty = self.typeOf(bin_op.lhs);
2286	assert(ty.eql(self.typeOf(bin_op.rhs), self.module));
2287		2797
2288	return try self.cmp(op, bool_ty_id, ty, lhs_id, rhs_id);	2798	return try self.cmp(op, ty, lhs_id, rhs_id);
		2799	}
		2800
		2801	fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
		2802	if (self.liveness.isUnused(inst)) return null;
		2803
		2804	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
		2805	const vec_cmp = self.air.extraData(Air.VectorCmp, ty_pl.payload).data;
		2806	const lhs_id = try self.resolve(vec_cmp.lhs);
		2807	const rhs_id = try self.resolve(vec_cmp.rhs);
		2808	const op = vec_cmp.compareOperator();
		2809	const ty = self.typeOf(vec_cmp.lhs);
		2810
		2811	return try self.cmp(op, ty, lhs_id, rhs_id);
2289	}	2812	}
2290		2813
2291	fn bitCast(	2814	fn bitCast(
...	@@ -2295,26 +2818,58 @@ pub const DeclGen = struct {	...	@@ -2295,26 +2818,58 @@ pub const DeclGen = struct {
2295	src_id: IdRef,	2818	src_id: IdRef,
2296	) !IdRef {	2819	) !IdRef {
2297	const mod = self.module;	2820	const mod = self.module;
		2821	const src_ty_ref = try self.resolveType(src_ty, .direct);
2298	const dst_ty_ref = try self.resolveType(dst_ty, .direct);	2822	const dst_ty_ref = try self.resolveType(dst_ty, .direct);
2299	const result_id = self.spv.allocId();	2823	if (src_ty_ref == dst_ty_ref) {
		2824	return src_id;
		2825	}
2300		2826
2301	// TODO: Some more cases are missing here	2827	// TODO: Some more cases are missing here
2302	// See fn bitCast in llvm.zig	2828	// See fn bitCast in llvm.zig
2303		2829
2304	if (src_ty.zigTypeTag(mod) == .Int and dst_ty.isPtrAtRuntime(mod)) {	2830	if (src_ty.zigTypeTag(mod) == .Int and dst_ty.isPtrAtRuntime(mod)) {
		2831	const result_id = self.spv.allocId();
2305	try self.func.body.emit(self.spv.gpa, .OpConvertUToPtr, .{	2832	try self.func.body.emit(self.spv.gpa, .OpConvertUToPtr, .{
2306	.id_result_type = self.typeId(dst_ty_ref),	2833	.id_result_type = self.typeId(dst_ty_ref),
2307	.id_result = result_id,	2834	.id_result = result_id,
2308	.integer_value = src_id,	2835	.integer_value = src_id,
2309	});	2836	});
2310	} else {	2837	return result_id;
		2838	}
		2839
		2840	// We can only use OpBitcast for specific conversions: between numerical types, and
		2841	// between pointers. If the resolved spir-v types fall into this category then emit OpBitcast,
		2842	// otherwise use a temporary and perform a pointer cast.
		2843	const src_key = self.spv.cache.lookup(src_ty_ref);
		2844	const dst_key = self.spv.cache.lookup(dst_ty_ref);
		2845
		2846	if ((src_key.isNumericalType() and dst_key.isNumericalType()) or (src_key == .ptr_type and dst_key == .ptr_type)) {
		2847	const result_id = self.spv.allocId();
2311	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{	2848	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
2312	.id_result_type = self.typeId(dst_ty_ref),	2849	.id_result_type = self.typeId(dst_ty_ref),
2313	.id_result = result_id,	2850	.id_result = result_id,
2314	.operand = src_id,	2851	.operand = src_id,
2315	});	2852	});
		2853	return result_id;
2316	}	2854	}
2317	return result_id;	2855
		2856	const src_ptr_ty_ref = try self.spv.ptrType(src_ty_ref, .Function);
		2857	const dst_ptr_ty_ref = try self.spv.ptrType(dst_ty_ref, .Function);
		2858
		2859	const tmp_id = self.spv.allocId();
		2860	try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
		2861	.id_result_type = self.typeId(src_ptr_ty_ref),
		2862	.id_result = tmp_id,
		2863	.storage_class = .Function,
		2864	});
		2865	try self.store(src_ty, tmp_id, src_id, false);
		2866	const casted_ptr_id = self.spv.allocId();
		2867	try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
		2868	.id_result_type = self.typeId(dst_ptr_ty_ref),
		2869	.id_result = casted_ptr_id,
		2870	.operand = tmp_id,
		2871	});
		2872	return try self.load(dst_ty, casted_ptr_id, false);
2318	}	2873	}
2319		2874
2320	fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	2875	fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...	@@ -2331,25 +2886,33 @@ pub const DeclGen = struct {	...	@@ -2331,25 +2886,33 @@ pub const DeclGen = struct {
2331		2886
2332	const ty_op = self.air.instructions.items(.data)[inst].ty_op;	2887	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2333	const operand_id = try self.resolve(ty_op.operand);	2888	const operand_id = try self.resolve(ty_op.operand);
2334	const dest_ty = self.typeOfIndex(inst);	2889	const src_ty = self.typeOf(ty_op.operand);
2335	const dest_ty_id = try self.resolveTypeId(dest_ty);	2890	const dst_ty = self.typeOfIndex(inst);
		2891	const src_ty_ref = try self.resolveType(src_ty, .direct);
		2892	const dst_ty_ref = try self.resolveType(dst_ty, .direct);
2336		2893
2337	const mod = self.module;	2894	const src_info = try self.arithmeticTypeInfo(src_ty);
2338	const dest_info = dest_ty.intInfo(mod);	2895	const dst_info = try self.arithmeticTypeInfo(dst_ty);
2339		2896
2340	// TODO: Masking?	2897	// While intcast promises that the value already fits, the upper bits of a
		2898	// strange integer may contain garbage. Therefore, mask/sign extend it before.
		2899	const src_id = try self.normalizeInt(src_ty_ref, operand_id, src_info);
		2900
		2901	if (src_info.backing_bits == dst_info.backing_bits) {
		2902	return src_id;
		2903	}
2341		2904
2342	const result_id = self.spv.allocId();	2905	const result_id = self.spv.allocId();
2343	switch (dest_info.signedness) {	2906	switch (dst_info.signedness) {
2344	.signed => try self.func.body.emit(self.spv.gpa, .OpSConvert, .{	2907	.signed => try self.func.body.emit(self.spv.gpa, .OpSConvert, .{
2345	.id_result_type = dest_ty_id,	2908	.id_result_type = self.typeId(dst_ty_ref),
2346	.id_result = result_id,	2909	.id_result = result_id,
2347	.signed_value = operand_id,	2910	.signed_value = src_id,
2348	}),	2911	}),
2349	.unsigned => try self.func.body.emit(self.spv.gpa, .OpUConvert, .{	2912	.unsigned => try self.func.body.emit(self.spv.gpa, .OpUConvert, .{
2350	.id_result_type = dest_ty_id,	2913	.id_result_type = self.typeId(dst_ty_ref),
2351	.id_result = result_id,	2914	.id_result = result_id,
2352	.unsigned_value = operand_id,	2915	.unsigned_value = src_id,
2353	}),	2916	}),
2354	}	2917	}
2355	return result_id;	2918	return result_id;
...	@@ -2422,6 +2985,23 @@ pub const DeclGen = struct {	...	@@ -2422,6 +2985,23 @@ pub const DeclGen = struct {
2422	return result_id;	2985	return result_id;
2423	}	2986	}
2424		2987
		2988	fn airFloatCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
		2989	if (self.liveness.isUnused(inst)) return null;
		2990
		2991	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
		2992	const operand_id = try self.resolve(ty_op.operand);
		2993	const dest_ty = self.typeOfIndex(inst);
		2994	const dest_ty_id = try self.resolveTypeId(dest_ty);
		2995
		2996	const result_id = self.spv.allocId();
		2997	try self.func.body.emit(self.spv.gpa, .OpFConvert, .{
		2998	.id_result_type = dest_ty_id,
		2999	.id_result = result_id,
		3000	.float_value = operand_id,
		3001	});
		3002	return result_id;
		3003	}
		3004
2425	fn airNot(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	3005	fn airNot(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2426	if (self.liveness.isUnused(inst)) return null;	3006	if (self.liveness.isUnused(inst)) return null;
2427	const ty_op = self.air.instructions.items(.data)[inst].ty_op;	3007	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
...	@@ -2461,22 +3041,23 @@ pub const DeclGen = struct {	...	@@ -2461,22 +3041,23 @@ pub const DeclGen = struct {
2461	const ty_op = self.air.instructions.items(.data)[inst].ty_op;	3041	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2462	const array_ptr_ty = self.typeOf(ty_op.operand);	3042	const array_ptr_ty = self.typeOf(ty_op.operand);
2463	const array_ty = array_ptr_ty.childType(mod);	3043	const array_ty = array_ptr_ty.childType(mod);
2464	const elem_ty = array_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
2465	const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
2466	const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(array_ptr_ty.ptrAddressSpace(mod)));
2467	const slice_ty = self.typeOfIndex(inst);	3044	const slice_ty = self.typeOfIndex(inst);
		3045	const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
		3046
		3047	const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);
2468	const slice_ty_ref = try self.resolveType(slice_ty, .direct);	3048	const slice_ty_ref = try self.resolveType(slice_ty, .direct);
2469	const size_ty_ref = try self.sizeType();	3049	const size_ty_ref = try self.sizeType();
2470		3050
2471	const array_ptr_id = try self.resolve(ty_op.operand);	3051	const array_ptr_id = try self.resolve(ty_op.operand);
2472	const len_id = try self.constInt(size_ty_ref, array_ty.arrayLen(mod));	3052	const len_id = try self.constInt(size_ty_ref, array_ty.arrayLen(mod));
2473		3053
2474	if (!array_ty.hasRuntimeBitsIgnoreComptime(mod)) {	3054	const elem_ptr_id = if (!array_ty.hasRuntimeBitsIgnoreComptime(mod))
2475	unreachable; // TODO	3055	// Note: The pointer is something like *opaque{}, so we need to bitcast it to the element type.
2476	}	3056	try self.bitCast(elem_ptr_ty, array_ptr_ty, array_ptr_id)
		3057	else
		3058	// Convert the pointer-to-array to a pointer to the first element.
		3059	try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});
2477		3060
2478	// Convert the pointer-to-array to a pointer to the first element.
2479	const elem_ptr_id = try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});
2480	return try self.constructStruct(slice_ty_ref, &.{ elem_ptr_id, len_id });	3061	return try self.constructStruct(slice_ty_ref, &.{ elem_ptr_id, len_id });
2481	}	3062	}
2482		3063
...	@@ -2500,6 +3081,7 @@ pub const DeclGen = struct {	...	@@ -2500,6 +3081,7 @@ pub const DeclGen = struct {
2500	if (self.liveness.isUnused(inst)) return null;	3081	if (self.liveness.isUnused(inst)) return null;
2501		3082
2502	const mod = self.module;	3083	const mod = self.module;
		3084	const ip = &mod.intern_pool;
2503	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	3085	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2504	const result_ty = self.typeOfIndex(inst);	3086	const result_ty = self.typeOfIndex(inst);
2505	const result_ty_ref = try self.resolveType(result_ty, .direct);	3087	const result_ty_ref = try self.resolveType(result_ty, .direct);
...	@@ -2508,15 +3090,53 @@ pub const DeclGen = struct {	...	@@ -2508,15 +3090,53 @@ pub const DeclGen = struct {
2508		3090
2509	switch (result_ty.zigTypeTag(mod)) {	3091	switch (result_ty.zigTypeTag(mod)) {
2510	.Vector => unreachable, // TODO	3092	.Vector => unreachable, // TODO
2511	.Struct => unreachable, // TODO	3093	.Struct => {
		3094	if (mod.typeToPackedStruct(result_ty)) \|struct_type\| {
		3095	_ = struct_type;
		3096	unreachable; // TODO
		3097	}
		3098
		3099	const constituents = try self.gpa.alloc(IdRef, elements.len);
		3100	defer self.gpa.free(constituents);
		3101	var index: usize = 0;
		3102
		3103	switch (ip.indexToKey(result_ty.toIntern())) {
		3104	.anon_struct_type => \|tuple\| {
		3105	for (tuple.types.get(ip), elements, 0..) \|field_ty, element, i\| {
		3106	if ((try result_ty.structFieldValueComptime(mod, i)) != null) continue;
		3107	assert(field_ty.toType().hasRuntimeBits(mod));
		3108
		3109	const id = try self.resolve(element);
		3110	constituents[index] = try self.convertToIndirect(field_ty.toType(), id);
		3111	index += 1;
		3112	}
		3113	},
		3114	.struct_type => \|struct_type\| {
		3115	var it = struct_type.iterateRuntimeOrder(ip);
		3116	for (elements, 0..) \|element, i\| {
		3117	const field_index = it.next().?;
		3118	if ((try result_ty.structFieldValueComptime(mod, i)) != null) continue;
		3119	const field_ty = struct_type.field_types.get(ip)[field_index].toType();
		3120	assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));
		3121
		3122	const id = try self.resolve(element);
		3123	constituents[index] = try self.convertToIndirect(field_ty, id);
		3124	index += 1;
		3125	}
		3126	},
		3127	else => unreachable,
		3128	}
		3129
		3130	return try self.constructStruct(result_ty_ref, constituents[0..index]);
		3131	},
2512	.Array => {	3132	.Array => {
2513	const array_info = result_ty.arrayInfo(mod);	3133	const array_info = result_ty.arrayInfo(mod);
2514	const n_elems: usize = @intCast(result_ty.arrayLenIncludingSentinel(mod));	3134	const n_elems: usize = @intCast(result_ty.arrayLenIncludingSentinel(mod));
2515	const elem_ids = try self.gpa.alloc(IdRef, n_elems);	3135	const elem_ids = try self.gpa.alloc(IdRef, n_elems);
2516	defer self.gpa.free(elem_ids);	3136	defer self.gpa.free(elem_ids);
2517		3137
2518	for (elements, 0..) \|elem_inst, i\| {	3138	for (elements, 0..) \|element, i\| {
2519	const id = try self.resolve(elem_inst);	3139	const id = try self.resolve(element);
2520	elem_ids[i] = try self.convertToIndirect(array_info.elem_type, id);	3140	elem_ids[i] = try self.convertToIndirect(array_info.elem_type, id);
2521	}	3141	}
2522		3142
...	@@ -2540,7 +3160,8 @@ pub const DeclGen = struct {	...	@@ -2540,7 +3160,8 @@ pub const DeclGen = struct {
2540		3160
2541	fn airSliceElemPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	3161	fn airSliceElemPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2542	const mod = self.module;	3162	const mod = self.module;
2543	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	3163	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
		3164	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
2544	const slice_ty = self.typeOf(bin_op.lhs);	3165	const slice_ty = self.typeOf(bin_op.lhs);
2545	if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;	3166	if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
2546		3167
...	@@ -2593,14 +3214,17 @@ pub const DeclGen = struct {	...	@@ -2593,14 +3214,17 @@ pub const DeclGen = struct {
2593	const mod = self.module;	3214	const mod = self.module;
2594	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	3215	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2595	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;	3216	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
2596	const ptr_ty = self.typeOf(bin_op.lhs);	3217	const src_ptr_ty = self.typeOf(bin_op.lhs);
2597	const elem_ty = ptr_ty.childType(mod);	3218	const elem_ty = src_ptr_ty.childType(mod);
2598	// TODO: Make this return a null ptr or something
2599	if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) return null;
2600
2601	const ptr_id = try self.resolve(bin_op.lhs);	3219	const ptr_id = try self.resolve(bin_op.lhs);
		3220
		3221	if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) {
		3222	const dst_ptr_ty = self.typeOfIndex(inst);
		3223	return try self.bitCast(dst_ptr_ty, src_ptr_ty, ptr_id);
		3224	}
		3225
2602	const index_id = try self.resolve(bin_op.rhs);	3226	const index_id = try self.resolve(bin_op.rhs);
2603	return try self.ptrElemPtr(ptr_ty, ptr_id, index_id);	3227	return try self.ptrElemPtr(src_ptr_ty, ptr_id, index_id);
2604	}	3228	}
2605		3229
2606	fn airArrayElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	3230	fn airArrayElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...	@@ -3101,15 +3725,25 @@ pub const DeclGen = struct {	...	@@ -3101,15 +3725,25 @@ pub const DeclGen = struct {
3101		3725
3102	fn airRet(self: *DeclGen, inst: Air.Inst.Index) !void {	3726	fn airRet(self: *DeclGen, inst: Air.Inst.Index) !void {
3103	const operand = self.air.instructions.items(.data)[inst].un_op;	3727	const operand = self.air.instructions.items(.data)[inst].un_op;
3104	const operand_ty = self.typeOf(operand);	3728	const ret_ty = self.typeOf(operand);
3105	const mod = self.module;	3729	const mod = self.module;
3106	if (operand_ty.hasRuntimeBits(mod)) {	3730	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3107	// TODO: If we return an empty struct, this branch is also hit incorrectly.	3731	const decl = mod.declPtr(self.decl_index);
3108	const operand_id = try self.resolve(operand);	3732	const fn_info = mod.typeToFunc(decl.ty).?;
3109	try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{ .value = operand_id });	3733	if (fn_info.return_type.toType().isError(mod)) {
3110	} else {	3734	// Functions with an empty error set are emitted with an error code
3111	try self.func.body.emit(self.spv.gpa, .OpReturn, {});	3735	// return type and return zero so they can be function pointers coerced
		3736	// to functions that return anyerror.
		3737	const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
		3738	const no_err_id = try self.constInt(err_ty_ref, 0);
		3739	return try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{ .value = no_err_id });
		3740	} else {
		3741	return try self.func.body.emit(self.spv.gpa, .OpReturn, {});
		3742	}
3112	}	3743	}
		3744
		3745	const operand_id = try self.resolve(operand);
		3746	try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{ .value = operand_id });
3113	}	3747	}
3114		3748
3115	fn airRetLoad(self: *DeclGen, inst: Air.Inst.Index) !void {	3749	fn airRetLoad(self: *DeclGen, inst: Air.Inst.Index) !void {
...	@@ -3119,8 +3753,18 @@ pub const DeclGen = struct {	...	@@ -3119,8 +3753,18 @@ pub const DeclGen = struct {
3119	const ret_ty = ptr_ty.childType(mod);	3753	const ret_ty = ptr_ty.childType(mod);
3120		3754
3121	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {	3755	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3122	try self.func.body.emit(self.spv.gpa, .OpReturn, {});	3756	const decl = mod.declPtr(self.decl_index);
3123	return;	3757	const fn_info = mod.typeToFunc(decl.ty).?;
		3758	if (fn_info.return_type.toType().isError(mod)) {
		3759	// Functions with an empty error set are emitted with an error code
		3760	// return type and return zero so they can be function pointers coerced
		3761	// to functions that return anyerror.
		3762	const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
		3763	const no_err_id = try self.constInt(err_ty_ref, 0);
		3764	return try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{ .value = no_err_id });
		3765	} else {
		3766	return try self.func.body.emit(self.spv.gpa, .OpReturn, {});
		3767	}
3124	}	3768	}
3125		3769
3126	const ptr = try self.resolve(un_op);	3770	const ptr = try self.resolve(un_op);
...	@@ -3297,31 +3941,26 @@ pub const DeclGen = struct {	...	@@ -3297,31 +3941,26 @@ pub const DeclGen = struct {
3297	payload_ty;	3941	payload_ty;
3298		3942
3299	const ptr_id = if (payload_ty.isSlice(mod))	3943	const ptr_id = if (payload_ty.isSlice(mod))
3300	try self.extractField(Type.bool, operand_id, 0)	3944	try self.extractField(ptr_ty, operand_id, 0)
3301	else	3945	else
3302	operand_id;	3946	operand_id;
3303		3947
3304	const payload_ty_ref = try self.resolveType(ptr_ty, .direct);	3948	const payload_ty_ref = try self.resolveType(ptr_ty, .direct);
3305	const null_id = try self.spv.constNull(payload_ty_ref);	3949	const null_id = try self.spv.constNull(payload_ty_ref);
3306	const result_id = self.spv.allocId();	3950	const op: std.math.CompareOperator = switch (pred) {
3307	const operands = .{	3951	.is_null => .eq,
3308	.id_result_type = self.typeId(bool_ty_ref),	3952	.is_non_null => .neq,
3309	.id_result = result_id,
3310	.operand_1 = ptr_id,
3311	.operand_2 = null_id,
3312	};	3953	};
3313	switch (pred) {	3954	return try self.cmp(op, ptr_ty, ptr_id, null_id);
3314	.is_null => try self.func.body.emit(self.spv.gpa, .OpPtrEqual, operands),
3315	.is_non_null => try self.func.body.emit(self.spv.gpa, .OpPtrNotEqual, operands),
3316	}
3317	return result_id;
3318	}	3955	}
3319		3956
3320	const is_non_null_id = if (optional_ty.hasRuntimeBitsIgnoreComptime(mod))	3957	const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
3321	try self.extractField(Type.bool, operand_id, 1)	3958	try self.extractField(Type.bool, operand_id, 1)
3322	else	3959	else
3323	// Optional representation is bool indicating whether the optional is set	3960	// Optional representation is bool indicating whether the optional is set
3324	operand_id;	3961	// Optionals with no payload are represented as an (indirect) bool, so convert
		3962	// it back to the direct bool here.
		3963	try self.convertToDirect(Type.bool, operand_id);
3325		3964
3326	return switch (pred) {	3965	return switch (pred) {
3327	.is_null => blk: {	3966	.is_null => blk: {
...	@@ -3400,17 +4039,19 @@ pub const DeclGen = struct {	...	@@ -3400,17 +4039,19 @@ pub const DeclGen = struct {
3400	const payload_ty = self.typeOf(ty_op.operand);	4039	const payload_ty = self.typeOf(ty_op.operand);
3401		4040
3402	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {	4041	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3403	return try self.constBool(true, .direct);	4042	return try self.constBool(true, .indirect);
3404	}	4043	}
3405		4044
3406	const operand_id = try self.resolve(ty_op.operand);	4045	const operand_id = try self.resolve(ty_op.operand);
		4046
3407	const optional_ty = self.typeOfIndex(inst);	4047	const optional_ty = self.typeOfIndex(inst);
3408	if (optional_ty.optionalReprIsPayload(mod)) {	4048	if (optional_ty.optionalReprIsPayload(mod)) {
3409	return operand_id;	4049	return operand_id;
3410	}	4050	}
3411		4051
3412	const optional_ty_ref = try self.resolveType(optional_ty, .direct);	4052	const optional_ty_ref = try self.resolveType(optional_ty, .direct);
3413	const members = [_]IdRef{ operand_id, try self.constBool(true, .indirect) };	4053	const payload_id = try self.convertToIndirect(payload_ty, operand_id);
		4054	const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };
3414	return try self.constructStruct(optional_ty_ref, &members);	4055	return try self.constructStruct(optional_ty_ref, &members);
3415	}	4056	}
3416		4057
...	@@ -3437,6 +4078,7 @@ pub const DeclGen = struct {	...	@@ -3437,6 +4078,7 @@ pub const DeclGen = struct {
3437	};	4078	};
3438	break :blk if (backing_bits <= 32) @as(u32, 1) else 2;	4079	break :blk if (backing_bits <= 32) @as(u32, 1) else 2;
3439	},	4080	},
		4081	.ErrorSet => 1,
3440	else => return self.todo("implement switch for type {s}", .{@tagName(cond_ty.zigTypeTag(mod))}), // TODO: Figure out which types apply here, and work around them as we can only do integers.	4082	else => return self.todo("implement switch for type {s}", .{@tagName(cond_ty.zigTypeTag(mod))}), // TODO: Figure out which types apply here, and work around them as we can only do integers.
3441	};	4083	};
3442		4084
...	@@ -3490,6 +4132,7 @@ pub const DeclGen = struct {	...	@@ -3490,6 +4132,7 @@ pub const DeclGen = struct {
3490	// TODO: figure out of cond_ty is correct (something with enum literals)	4132	// TODO: figure out of cond_ty is correct (something with enum literals)
3491	break :blk (try value.intFromEnum(cond_ty, mod)).toUnsignedInt(mod); // TODO: composite integer constants	4133	break :blk (try value.intFromEnum(cond_ty, mod)).toUnsignedInt(mod); // TODO: composite integer constants
3492	},	4134	},
		4135	.ErrorSet => value.getErrorInt(mod),
3493	else => unreachable,	4136	else => unreachable,
3494	};	4137	};
3495	const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) {	4138	const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) {
...	@@ -3533,10 +4176,10 @@ pub const DeclGen = struct {	...	@@ -3533,10 +4176,10 @@ pub const DeclGen = struct {
3533		4176
3534	fn airDbgStmt(self: *DeclGen, inst: Air.Inst.Index) !void {	4177	fn airDbgStmt(self: *DeclGen, inst: Air.Inst.Index) !void {
3535	const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;	4178	const dbg_stmt = self.air.instructions.items(.data)[inst].dbg_stmt;
3536	const src_fname_id = try self.spv.resolveSourceFileName(	4179	const mod = self.module;
3537	self.module,	4180	const decl = mod.declPtr(self.decl_index);
3538	self.module.declPtr(self.decl_index),	4181	const path = decl.getFileScope(mod).sub_file_path;
3539	);	4182	const src_fname_id = try self.spv.resolveSourceFileName(path);
3540	const base_line = self.base_line_stack.getLast();	4183	const base_line = self.base_line_stack.getLast();
3541	try self.func.body.emit(self.spv.gpa, .OpLine, .{	4184	try self.func.body.emit(self.spv.gpa, .OpLine, .{
3542	.file = src_fname_id,	4185	.file = src_fname_id,
...	@@ -3710,7 +4353,7 @@ pub const DeclGen = struct {	...	@@ -3710,7 +4353,7 @@ pub const DeclGen = struct {
3710	const fn_info = mod.typeToFunc(zig_fn_ty).?;	4353	const fn_info = mod.typeToFunc(zig_fn_ty).?;
3711	const return_type = fn_info.return_type;	4354	const return_type = fn_info.return_type;
3712		4355
3713	const result_type_id = try self.resolveTypeId(return_type.toType());	4356	const result_type_ref = try self.resolveFnReturnType(return_type.toType());
3714	const result_id = self.spv.allocId();	4357	const result_id = self.spv.allocId();
3715	const callee_id = try self.resolve(pl_op.operand);	4358	const callee_id = try self.resolve(pl_op.operand);
3716		4359
...	@@ -3722,16 +4365,16 @@ pub const DeclGen = struct {	...	@@ -3722,16 +4365,16 @@ pub const DeclGen = struct {
3722	// Note: resolve() might emit instructions, so we need to call it	4365	// Note: resolve() might emit instructions, so we need to call it
3723	// before starting to emit OpFunctionCall instructions. Hence the	4366	// before starting to emit OpFunctionCall instructions. Hence the
3724	// temporary params buffer.	4367	// temporary params buffer.
3725	const arg_id = try self.resolve(arg);
3726	const arg_ty = self.typeOf(arg);	4368	const arg_ty = self.typeOf(arg);
3727	if (!arg_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;	4369	if (!arg_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
		4370	const arg_id = try self.resolve(arg);
3728		4371
3729	params[n_params] = arg_id;	4372	params[n_params] = arg_id;
3730	n_params += 1;	4373	n_params += 1;
3731	}	4374	}
3732		4375
3733	try self.func.body.emit(self.spv.gpa, .OpFunctionCall, .{	4376	try self.func.body.emit(self.spv.gpa, .OpFunctionCall, .{
3734	.id_result_type = result_type_id,	4377	.id_result_type = self.typeId(result_type_ref),
3735	.id_result = result_id,	4378	.id_result = result_id,
3736	.function = callee_id,	4379	.function = callee_id,
3737	.id_ref_3 = params[0..n_params],	4380	.id_ref_3 = params[0..n_params],

src/codegen/spirv/Cache.zig+32

 @@ -81,6 +81,9 @@ const Tag = enum {
     /// have member names trailing.
     /// data is payload to SimpleStructType
     type_struct_simple_with_member_names,
+    /// Opaque type.
+    /// data is name string.
+    type_opaque,
     // -- Values
     /// Value of type u8
 @@ -235,6 +238,7 @@ pub const Key = union(enum) {
     function_type: FunctionType,
     ptr_type: PointerType,
     struct_type: StructType,
+    opaque_type: OpaqueType,
     // -- values
     int: Int,
 @@ -289,6 +293,10 @@ pub const Key = union(enum) {
         }
     };
+    pub const OpaqueType = struct {
+        name: String = .none,
+    };
     pub const Int = struct {
         /// The type: any bitness integer.
         ty: Ref,
 @@ -427,6 +435,13 @@ pub const Key = union(enum) {
             else => unreachable,
         };
     }
+    pub fn isNumericalType(self: Key) bool {
+        return switch (self) {
+            .int_type, .float_type => true,
+            else => false,
+        };
+    }
 };
 pub fn deinit(self: *Self, spv: *const Module) void {
 @@ -539,6 +554,13 @@ fn emit(
             }
             // TODO: Decorations?
         },
+        .opaque_type => |opaque_type| {
+            const name = if (self.getString(opaque_type.name)) |name| name else "";
+            try section.emit(spv.gpa, .OpTypeOpaque, .{
+                .id_result = result_id,
+                .literal_string = name,
+            });
+        },
         .int => |int| {
             const int_type = self.lookup(int.ty).int_type;
             const ty_id = self.resultId(int.ty);
 @@ -697,6 +719,11 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
                 };
             }
         },
+        .opaque_type => |opaque_type| Item{
+            .tag = .type_opaque,
+            .result_id = result_id,
+            .data = @intFromEnum(opaque_type.name),
+        },
         .int => |int| blk: {
             const int_type = self.lookup(int.ty).int_type;
             if (int_type.signedness == .unsigned and int_type.bits == 8) {
 @@ -874,6 +901,11 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
                 },
             };
         },
+        .type_opaque => .{
+            .opaque_type = .{
+                .name = @as(String, @enumFromInt(data)),
+            },
+        },
         .float16 => .{ .float = .{
             .ty = self.get(.{ .float_type = .{ .bits = 16 } }),
             .value = .{ .float16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },

src/codegen/spirv/Module.zig+21-22

 @@ -11,9 +11,6 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
-const ZigModule = @import("../../Module.zig");
-const ZigDecl = ZigModule.Decl;
 const spec = @import("spec.zig");
 const Word = spec.Word;
 const IdRef = spec.IdRef;
 @@ -103,15 +100,12 @@ pub const EntryPoint = struct {
     /// The declaration that should be exported.
     decl_index: Decl.Index,
     /// The name of the kernel to be exported.
-    name: []const u8,
+    name: CacheString,
 };
 /// A general-purpose allocator which may be used to allocate resources for this module
 gpa: Allocator,
-/// An arena allocator used to store things that have the same lifetime as this module.
-arena: Allocator,
 /// Module layout, according to SPIR-V Spec section 2.4, "Logical Layout of a Module".
 sections: struct {
     /// Capability instructions
 @@ -150,7 +144,7 @@ next_result_id: Word,
 /// Cache for results of OpString instructions for module file names fed to OpSource.
 /// Since OpString is pretty much only used for those, we don't need to keep track of all strings,
 /// just the ones for OpLine. Note that OpLine needs the result of OpString, and not that of OpSource.
-source_file_names: std.StringHashMapUnmanaged(IdRef) = .{},
+source_file_names: std.AutoArrayHashMapUnmanaged(CacheString, IdRef) = .{},
 /// SPIR-V type- and constant cache. This structure is used to store information about these in a more
 /// efficient manner.
 @@ -176,10 +170,9 @@ globals: struct {
     section: Section = .{},
 } = .{},
-pub fn init(gpa: Allocator, arena: Allocator) Module {
+pub fn init(gpa: Allocator) Module {
     return .{
         .gpa = gpa,
-        .arena = arena,
         .next_result_id = 1, // 0 is an invalid SPIR-V result id, so start counting at 1.
     };
 }
 @@ -321,7 +314,7 @@ fn entryPoints(self: *Module) !Section {
         try entry_points.emit(self.gpa, .OpEntryPoint, .{
             .execution_model = .Kernel,
             .entry_point = entry_point_id,
-            .name = entry_point.name,
+            .name = self.cache.getString(entry_point.name).?,
             .interface = interface.items,
         });
     }
 @@ -422,6 +415,18 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
         0, // Schema (currently reserved for future use)
     };
+    var source = Section{};
+    defer source.deinit(self.gpa);
+    try self.sections.debug_strings.emit(self.gpa, .OpSource, .{
+        .source_language = .Unknown,
+        .version = 0,
+        // We cannot emit these because the Khronos translator does not parse this instruction
+        // correctly.
+        // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/2188
+        .file = null,
+        .source = null,
+    });
     // Note: needs to be kept in order according to section 2.3!
     const buffers = &[_][]const Word{
         &header,
 @@ -429,6 +434,7 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
         self.sections.extensions.toWords(),
         entry_points.toWords(),
         self.sections.execution_modes.toWords(),
+        source.toWords(),
         self.sections.debug_strings.toWords(),
         self.sections.debug_names.toWords(),
         self.sections.annotations.toWords(),
 @@ -464,9 +470,9 @@ pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void {
 /// Fetch the result-id of an OpString instruction that encodes the path of the source
 /// file of the decl. This function may also emit an OpSource with source-level information regarding
 /// the decl.
-pub fn resolveSourceFileName(self: *Module, zig_module: *ZigModule, zig_decl: *ZigDecl) !IdRef {
+pub fn resolveSourceFileName(self: *Module, path: []const u8) !IdRef {
-    const path = zig_decl.getFileScope(zig_module).sub_file_path;
+    const path_ref = try self.resolveString(path);
-    const result = try self.source_file_names.getOrPut(self.gpa, path);
+    const result = try self.source_file_names.getOrPut(self.gpa, path_ref);
     if (!result.found_existing) {
         const file_result_id = self.allocId();
         result.value_ptr.* = file_result_id;
 @@ -474,13 +480,6 @@ pub fn resolveSourceFileName(self: *Module, zig_module: *ZigModule, zig_decl: *Z
             .id_result = file_result_id,
             .string = path,
         });
-        try self.sections.debug_strings.emit(self.gpa, .OpSource, .{
-            .source_language = .Unknown, // TODO: Register Zig source language.
-            .version = 0, // TODO: Zig version as u32?
-            .file = file_result_id,
-            .source = null, // TODO: Store actual source also?
-        });
     }
     return result.value_ptr.*;
 @@ -641,7 +640,7 @@ pub fn endGlobal(self: *Module, global_index: Decl.Index, begin_inst: u32, resul
 pub fn declareEntryPoint(self: *Module, decl_index: Decl.Index, name: []const u8) !void {
     try self.entry_points.append(self.gpa, .{
         .decl_index = decl_index,
-        .name = try self.arena.dupe(u8, name),
+        .name = try self.resolveString(name),
     });
 }

src/link/SpirV.zig+18-37

 @@ -45,9 +45,7 @@ const IdResult = spec.IdResult;
 base: link.File,
-spv: SpvModule,
+object: codegen.Object,
-spv_arena: ArenaAllocator,
-decl_link: codegen.DeclLinkMap,
 pub fn createEmpty(gpa: Allocator, options: link.Options) !*SpirV {
     const self = try gpa.create(SpirV);
 @@ -58,11 +56,8 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*SpirV {
             .file = null,
             .allocator = gpa,
         },
-        .spv = undefined,
+        .object = codegen.Object.init(gpa),
-        .spv_arena = ArenaAllocator.init(gpa),
-        .decl_link = codegen.DeclLinkMap.init(self.base.allocator),
     };
-    self.spv = SpvModule.init(gpa, self.spv_arena.allocator());
     errdefer self.deinit();
     // TODO: Figure out where to put all of these
 @@ -99,9 +94,7 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
 }
 pub fn deinit(self: *SpirV) void {
-    self.spv.deinit();
+    self.object.deinit();
-    self.spv_arena.deinit();
-    self.decl_link.deinit();
 }
 pub fn updateFunc(self: *SpirV, module: *Module, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
 @@ -113,12 +106,7 @@ pub fn updateFunc(self: *SpirV, module: *Module, func_index: InternPool.Index, a
     const decl = module.declPtr(func.owner_decl);
     log.debug("lowering function {s}", .{module.intern_pool.stringToSlice(decl.name)});
-    var decl_gen = codegen.DeclGen.init(self.base.allocator, module, &self.spv, &self.decl_link);
+    try self.object.updateFunc(module, func_index, air, liveness);
-    defer decl_gen.deinit();
-    if (try decl_gen.gen(func.owner_decl, air, liveness)) |msg| {
-        try module.failed_decls.put(module.gpa, func.owner_decl, msg);
-    }
 }
 pub fn updateDecl(self: *SpirV, module: *Module, decl_index: Module.Decl.Index) !void {
 @@ -129,12 +117,7 @@ pub fn updateDecl(self: *SpirV, module: *Module, decl_index: Module.Decl.Index)
     const decl = module.declPtr(decl_index);
     log.debug("lowering declaration {s}", .{module.intern_pool.stringToSlice(decl.name)});
-    var decl_gen = codegen.DeclGen.init(self.base.allocator, module, &self.spv, &self.decl_link);
+    try self.object.updateDecl(module, decl_index);
-    defer decl_gen.deinit();
-    if (try decl_gen.gen(decl_index, undefined, undefined)) |msg| {
-        try module.failed_decls.put(module.gpa, decl_index, msg);
-    }
 }
 pub fn updateDeclExports(
 @@ -145,15 +128,9 @@ pub fn updateDeclExports(
 ) !void {
     const decl = mod.declPtr(decl_index);
     if (decl.val.isFuncBody(mod) and decl.ty.fnCallingConvention(mod) == .Kernel) {
-        // TODO: Unify with resolveDecl in spirv.zig.
+        const spv_decl_index = try self.object.resolveDecl(mod, decl_index);
-        const entry = try self.decl_link.getOrPut(decl_index);
-        if (!entry.found_existing) {
-            entry.value_ptr.* = try self.spv.allocDecl(.func);
-        }
-        const spv_decl_index = entry.value_ptr.*;
         for (exports) |exp| {
-            try self.spv.declareEntryPoint(spv_decl_index, mod.intern_pool.stringToSlice(exp.opts.name));
+            try self.object.spv.declareEntryPoint(spv_decl_index, mod.intern_pool.stringToSlice(exp.opts.name));
         }
     }
 @@ -185,15 +162,19 @@ pub fn flushModule(self: *SpirV, comp: *Compilation, prog_node: *std.Progress.No
     sub_prog_node.activate();
     defer sub_prog_node.end();
+    const spv = &self.object.spv;
     const target = comp.getTarget();
-    try writeCapabilities(&self.spv, target);
+    try writeCapabilities(spv, target);
-    try writeMemoryModel(&self.spv, target);
+    try writeMemoryModel(spv, target);
     // We need to export the list of error names somewhere so that we can pretty-print them in the
     // executor. This is not really an important thing though, so we can just dump it in any old
     // nonsemantic instruction. For now, just put it in OpSourceExtension with a special name.
-    var error_info = std.ArrayList(u8).init(self.spv.arena);
+    var error_info = std.ArrayList(u8).init(self.object.gpa);
+    defer error_info.deinit();
     try error_info.appendSlice("zig_errors");
     const module = self.base.options.module.?;
     for (module.global_error_set.keys()) |name_nts| {
 @@ -207,17 +188,17 @@ pub fn flushModule(self: *SpirV, comp: *Compilation, prog_node: *std.Progress.No
         defer self.base.allocator.free(escaped_name);
         try error_info.writer().print(":{s}", .{escaped_name});
     }
-    try self.spv.sections.debug_strings.emit(self.spv.gpa, .OpSourceExtension, .{
+    try spv.sections.debug_strings.emit(spv.gpa, .OpSourceExtension, .{
         .extension = error_info.items,
     });
-    try self.spv.flush(self.base.file.?);
+    try spv.flush(self.base.file.?);
 }
 fn writeCapabilities(spv: *SpvModule, target: std.Target) !void {
     // TODO: Integrate with a hypothetical feature system
     const caps: []const spec.Capability = switch (target.os.tag) {
-        .opencl => &.{ .Kernel, .Addresses, .Int8, .Int16, .Int64, .Float64, .GenericPointer },
+        .opencl => &.{ .Kernel, .Addresses, .Int8, .Int16, .Int64, .Float64, .Float16, .GenericPointer },
         .glsl450 => &.{.Shader},
         .vulkan => &.{.Shader},
         else => unreachable, // TODO
 @@ -249,7 +230,7 @@ fn writeMemoryModel(spv: *SpvModule, target: std.Target) !void {
     };
     // TODO: Put this in a proper section.
-    try spv.sections.capabilities.emit(spv.gpa, .OpMemoryModel, .{
+    try spv.sections.extensions.emit(spv.gpa, .OpMemoryModel, .{
         .addressing_model = addressing_model,
         .memory_model = memory_model,
     });

test/behavior/abs.zig-1

...	@@ -48,7 +48,6 @@ test "@abs unsigned integers" {	...	@@ -48,7 +48,6 @@ test "@abs unsigned integers" {
48	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	48	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO	49	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52		51
53	try comptime testAbsUnsignedIntegers();	52	try comptime testAbsUnsignedIntegers();
54	try testAbsUnsignedIntegers();	53	try testAbsUnsignedIntegers();

test/behavior/align.zig-7

test/behavior/array.zig-6

test/behavior/basic.zig-13

test/behavior/bitcast.zig-8

...	@@ -149,8 +149,6 @@ test "bitcast literal [4]u8 param to u32" {	...	@@ -149,8 +149,6 @@ test "bitcast literal [4]u8 param to u32" {
149	}	149	}
150		150
151	test "bitcast generates a temporary value" {	151	test "bitcast generates a temporary value" {
152	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
153
154	var y = @as(u16, 0x55AA);	152	var y = @as(u16, 0x55AA);
155	const x = @as(u16, @bitCast(@as([2]u8, @bitCast(y))));	153	const x = @as(u16, @bitCast(@as([2]u8, @bitCast(y))));
156	try expect(y == x);	154	try expect(y == x);
...	@@ -186,7 +184,6 @@ test "@bitCast packed structs at runtime and comptime" {	...	@@ -186,7 +184,6 @@ test "@bitCast packed structs at runtime and comptime" {
186	test "@bitCast extern structs at runtime and comptime" {	184	test "@bitCast extern structs at runtime and comptime" {
187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	186	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
189	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
190		187
191	const Full = extern struct {	188	const Full = extern struct {
192	number: u16,	189	number: u16,
...	@@ -241,7 +238,6 @@ test "bitcast packed struct to integer and back" {	...	@@ -241,7 +238,6 @@ test "bitcast packed struct to integer and back" {
241	test "implicit cast to error union by returning" {	238	test "implicit cast to error union by returning" {
242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	239	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
244	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
245		241
246	const S = struct {	242	const S = struct {
247	fn entry() !void {	243	fn entry() !void {
...	@@ -271,8 +267,6 @@ test "comptime bitcast used in expression has the correct type" {	...	@@ -271,8 +267,6 @@ test "comptime bitcast used in expression has the correct type" {
271	}	267	}
272		268
273	test "bitcast passed as tuple element" {	269	test "bitcast passed as tuple element" {
274	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
275
276	const S = struct {	270	const S = struct {
277	fn foo(args: anytype) !void {	271	fn foo(args: anytype) !void {
278	try comptime expect(@TypeOf(args[0]) == f32);	272	try comptime expect(@TypeOf(args[0]) == f32);
...	@@ -283,8 +277,6 @@ test "bitcast passed as tuple element" {	...	@@ -283,8 +277,6 @@ test "bitcast passed as tuple element" {
283	}	277	}
284		278
285	test "triple level result location with bitcast sandwich passed as tuple element" {	279	test "triple level result location with bitcast sandwich passed as tuple element" {
286	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
287
288	const S = struct {	280	const S = struct {
289	fn foo(args: anytype) !void {	281	fn foo(args: anytype) !void {
290	try comptime expect(@TypeOf(args[0]) == f64);	282	try comptime expect(@TypeOf(args[0]) == f64);

test/behavior/bugs/10684.zig-1

...	@@ -6,7 +6,6 @@ test "slicing slices" {	...	@@ -6,7 +6,6 @@ test "slicing slices" {
6	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10		9
11	const foo = "1234";	10	const foo = "1234";
12	const bar = foo[0..4];	11	const bar = foo[0..4];

test/behavior/bugs/1076.zig-1

...	@@ -6,7 +6,6 @@ const expect = std.testing.expect;	...	@@ -6,7 +6,6 @@ const expect = std.testing.expect;
6	test "comptime code should not modify constant data" {	6	test "comptime code should not modify constant data" {
7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_spirv64) return error.SkipZigTest;
10		9
11	try testCastPtrOfArrayToSliceAndPtr();	10	try testCastPtrOfArrayToSliceAndPtr();
12	try comptime testCastPtrOfArrayToSliceAndPtr();	11	try comptime testCastPtrOfArrayToSliceAndPtr();

test/behavior/bugs/11046.zig-1

...	@@ -13,7 +13,6 @@ test "fixed" {	...	@@ -13,7 +13,6 @@ test "fixed" {
13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
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;
17		16
18	bar() catch \|err\| switch (err) {	17	bar() catch \|err\| switch (err) {
19	error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}	18	error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}

test/behavior/bugs/11139.zig-1

...	@@ -6,7 +6,6 @@ test "store array of array of structs at comptime" {	...	@@ -6,7 +6,6 @@ test "store array of array of structs at comptime" {
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_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_spirv64) return error.SkipZigTest;
10		9
11	try expect(storeArrayOfArrayOfStructs() == 15);	10	try expect(storeArrayOfArrayOfStructs() == 15);
12	try comptime expect(storeArrayOfArrayOfStructs() == 15);	11	try comptime expect(storeArrayOfArrayOfStructs() == 15);

test/behavior/bugs/11213.zig-2

...	@@ -3,8 +3,6 @@ const builtin = @import("builtin");	...	@@ -3,8 +3,6 @@ const builtin = @import("builtin");
3	const testing = std.testing;	3	const testing = std.testing;
4		4
5	test {	5	test {
6	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7
8	const g: error{Test}!void = error.Test;	6	const g: error{Test}!void = error.Test;
9		7
10	var v: u32 = 0;	8	var v: u32 = 0;

test/behavior/bugs/11995.zig-1

...	@@ -20,7 +20,6 @@ test {	...	@@ -20,7 +20,6 @@ test {
20	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	20	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
24		23
25	var string: [5]u8 = "hello".*;	24	var string: [5]u8 = "hello".*;
26	const arg_data = wuffs_base__slice_u8{ .ptr = @as([*c]u8, @ptrCast(&string)), .len = string.len };	25	const arg_data = wuffs_base__slice_u8{ .ptr = @as([*c]u8, @ptrCast(&string)), .len = string.len };

test/behavior/bugs/12092.zig-1

...	@@ -17,7 +17,6 @@ test {	...	@@ -17,7 +17,6 @@ test {
17	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
21		20
22	var baz: u32 = 24;	21	var baz: u32 = 24;
23	try takeFoo(&.{	22	try takeFoo(&.{

test/behavior/bugs/12142.zig-1

...	@@ -22,7 +22,6 @@ test {	...	@@ -22,7 +22,6 @@ test {
22	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26		25
27	const test_struct = Test{	26	const test_struct = Test{
28	.holders = &.{	27	.holders = &.{

test/behavior/bugs/12551.zig-1

...	@@ -4,7 +4,6 @@ const builtin = @import("builtin");	...	@@ -4,7 +4,6 @@ const builtin = @import("builtin");
4	test {	4	test {
5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8		7
9	try std.testing.expect(for ([1]u8{0}) \|x\| {	8	try std.testing.expect(for ([1]u8{0}) \|x\| {
10	if (x == 0) break true;	9	if (x == 0) break true;

test/behavior/bugs/12644.zig-2

...	@@ -10,8 +10,6 @@ fn main0() !void {	...	@@ -10,8 +10,6 @@ fn main0() !void {
10	}	10	}
11		11
12	test "issue12644" {	12	test "issue12644" {
13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14
15	main0() catch \|e\| {	13	main0() catch \|e\| {
16	try std.testing.expect(e == error.AnError);	14	try std.testing.expect(e == error.AnError);
17	};	15	};

test/behavior/bugs/12890.zig-1

...	@@ -11,7 +11,6 @@ fn a(b: []u3, c: u3) void {	...	@@ -11,7 +11,6 @@ fn a(b: []u3, c: u3) void {
11	test {	11	test {
12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_aarch64) 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;
15		14
16	var arr: [8]u3 = undefined;	15	var arr: [8]u3 = undefined;
17	a(&arr, 5);	16	a(&arr, 5);

test/behavior/bugs/12891.zig-6

test/behavior/bugs/12972.zig-1

...	@@ -6,7 +6,6 @@ test {	...	@@ -6,7 +6,6 @@ test {
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_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_spirv64) return error.SkipZigTest;
10		9
11	const c: u8 = 42;	10	const c: u8 = 42;
12	f(&[_:null]?u8{c});	11	f(&[_:null]?u8{c});

test/behavior/bugs/13064.zig-1

...	@@ -6,7 +6,6 @@ test {	...	@@ -6,7 +6,6 @@ test {
6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_aarch64) 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_spirv64) return error.SkipZigTest;
10		9
11	var x: [10][10]u32 = undefined;	10	var x: [10][10]u32 = undefined;
12		11

test/behavior/bugs/13065.zig-1

...	@@ -11,7 +11,6 @@ test {	...	@@ -11,7 +11,6 @@ test {
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_aarch64) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_aarch64) 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;
15		14
16	var x = U{ .array = undefined };	15	var x = U{ .array = undefined };
17		16

test/behavior/bugs/13366.zig-1

...	@@ -16,7 +16,6 @@ test {	...	@@ -16,7 +16,6 @@ test {
16	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20		19
21	var a: u32 = 16;	20	var a: u32 = 16;
22	var reason = .{ .c_import = .{ .a = a } };	21	var reason = .{ .c_import = .{ .a = a } };

test/behavior/bugs/1381.zig-1

...	@@ -15,7 +15,6 @@ test "union that needs padding bytes inside an array" {	...	@@ -15,7 +15,6 @@ test "union that needs padding bytes inside an array" {
15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	16	if (builtin.zig_backend == .stage2_arm) 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_spirv64) return error.SkipZigTest;
19		18
20	var as = [_]A{	19	var as = [_]A{
21	A{ .B = B{ .D = 1 } },	20	A{ .B = B{ .D = 1 } },

test/behavior/bugs/1442.zig-1

...	@@ -10,7 +10,6 @@ test "const error union field alignment" {	...	@@ -10,7 +10,6 @@ test "const error union field alignment" {
10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_spirv64) return error.SkipZigTest;
14		13
15	var union_or_err: anyerror!Union = Union{ .Color = 1234 };	14	var union_or_err: anyerror!Union = Union{ .Color = 1234 };
16	try std.testing.expect((union_or_err catch unreachable).Color == 1234);	15	try std.testing.expect((union_or_err catch unreachable).Color == 1234);

test/behavior/bugs/1607.zig-1

...	@@ -14,7 +14,6 @@ test "slices pointing at the same address as global array." {	...	@@ -14,7 +14,6 @@ test "slices pointing at the same address as global array." {
14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18		17
19	try checkAddress(&a);	18	try checkAddress(&a);
20	try comptime checkAddress(&a);	19	try comptime checkAddress(&a);

test/behavior/bugs/1741.zig+1-1

...	@@ -4,7 +4,7 @@ const builtin = @import("builtin");	...	@@ -4,7 +4,7 @@ const builtin = @import("builtin");
4	test "fixed" {	4	test "fixed" {
5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky
8		8
9	const x: f32 align(128) = 12.34;	9	const x: f32 align(128) = 12.34;
10	try std.testing.expect(@intFromPtr(&x) % 128 == 0);	10	try std.testing.expect(@intFromPtr(&x) % 128 == 0);

test/behavior/bugs/2346.zig+2

...	@@ -1,3 +1,5 @@	...	@@ -1,3 +1,5 @@
		1	const builtin = @import("builtin");
		2
1	test "fixed" {	3	test "fixed" {
2	const a: *void = undefined;	4	const a: *void = undefined;
3	const b: *[1]void = a;	5	const b: *[1]void = a;

test/behavior/bugs/2578.zig-1

...	@@ -15,7 +15,6 @@ test "fixed" {	...	@@ -15,7 +15,6 @@ test "fixed" {
15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
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_spirv64) return error.SkipZigTest;
19		18
20	bar(t);	19	bar(t);
21	}	20	}

test/behavior/bugs/2692.zig-1

...	@@ -7,7 +7,6 @@ fn foo(a: []u8) void {	...	@@ -7,7 +7,6 @@ fn foo(a: []u8) void {
7	test "address of 0 length array" {	7	test "address of 0 length array" {
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_sparc64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11		10
12	var pt: [0]u8 = undefined;	11	var pt: [0]u8 = undefined;
13	foo(&pt);	12	foo(&pt);

test/behavior/bugs/3046.zig-1

...	@@ -16,7 +16,6 @@ test "fixed" {	...	@@ -16,7 +16,6 @@ test "fixed" {
16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20		19
21	some_struct = SomeStruct{	20	some_struct = SomeStruct{
22	.field = couldFail() catch @as(i32, 0),	21	.field = couldFail() catch @as(i32, 0),

test/behavior/bugs/3367.zig-2

...	@@ -10,8 +10,6 @@ const Mixin = struct {	...	@@ -10,8 +10,6 @@ const Mixin = struct {
10	};	10	};
11		11
12	test "container member access usingnamespace decls" {	12	test "container member access usingnamespace decls" {
13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14
15	var foo = Foo{};	13	var foo = Foo{};
16	foo.two();	14	foo.two();
17	}	15	}

test/behavior/bugs/3742.zig-1

...	@@ -40,7 +40,6 @@ test "fixed" {	...	@@ -40,7 +40,6 @@ test "fixed" {
40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	if (builtin.zig_backend == .stage2_llvm and	41	if (builtin.zig_backend == .stage2_llvm and
42	builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;	42	builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
44		43
45	ArgSerializer.serializeCommand(GET.init("banana"));	44	ArgSerializer.serializeCommand(GET.init("banana"));
46	}	45	}

test/behavior/bugs/3779.zig-3

test/behavior/bugs/5487.zig-1

...	@@ -13,6 +13,5 @@ test "crash" {	...	@@ -13,6 +13,5 @@ test "crash" {
13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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;
17	_ = io.multiWriter(.{writer()});	16	_ = io.multiWriter(.{writer()});
18	}	17	}

test/behavior/bugs/6905.zig-1

...	@@ -5,7 +5,6 @@ test "sentinel-terminated 0-length slices" {	...	@@ -5,7 +5,6 @@ test "sentinel-terminated 0-length slices" {
5	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	5	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
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_arm) return error.SkipZigTest; // TODO	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9		8
10	var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };	9	var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };
11		10

test/behavior/bugs/726.zig-2

...	@@ -5,7 +5,6 @@ test "@ptrCast from const to nullable" {	...	@@ -5,7 +5,6 @@ test "@ptrCast from const to nullable" {
5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
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;
9		8
10	const c: u8 = 4;	9	const c: u8 = 4;
11	var x: ?const u8 = @as(?const u8, @ptrCast(&c));	10	var x: ?const u8 = @as(?const u8, @ptrCast(&c));
...	@@ -16,7 +15,6 @@ test "@ptrCast from var in empty struct to nullable" {	...	@@ -16,7 +15,6 @@ test "@ptrCast from var in empty struct to nullable" {
16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20		18
21	const container = struct {	19	const container = struct {
22	var c: u8 = 4;	20	var c: u8 = 4;

test/behavior/bugs/8646.zig-1

...	@@ -10,7 +10,6 @@ test {	...	@@ -10,7 +10,6 @@ test {
10	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
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_spirv64) return error.SkipZigTest;
14		13
15	try std.testing.expect(array[0].len == 1);	14	try std.testing.expect(array[0].len == 1);
16	try std.testing.expectEqualStrings("hello", array[0][0]);	15	try std.testing.expectEqualStrings("hello", array[0][0]);

test/behavior/call.zig-6

test/behavior/cast.zig+3-55

test/behavior/cast_int.zig+3

...	@@ -149,6 +149,8 @@ const Piece = packed struct {	...	@@ -149,6 +149,8 @@ const Piece = packed struct {
149		149
150	test "load non byte-sized optional value" {	150	test "load non byte-sized optional value" {
151	// Originally reported at https://github.com/ziglang/zig/issues/14200	151	// Originally reported at https://github.com/ziglang/zig/issues/14200
		152	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		153
152	// note: this bug is triggered by the == operator, expectEqual will hide it	154	// note: this bug is triggered by the == operator, expectEqual will hide it
153	var opt: ?Piece = try Piece.charToPiece('p');	155	var opt: ?Piece = try Piece.charToPiece('p');
154	try expect(opt.?.type == .PAWN);	156	try expect(opt.?.type == .PAWN);
...	@@ -162,6 +164,7 @@ test "load non byte-sized optional value" {	...	@@ -162,6 +164,7 @@ test "load non byte-sized optional value" {
162		164
163	test "load non byte-sized value in struct" {	165	test "load non byte-sized value in struct" {
164	if (builtin.cpu.arch.endian() != .Little) return error.SkipZigTest; // packed struct TODO	166	if (builtin.cpu.arch.endian() != .Little) return error.SkipZigTest; // packed struct TODO
		167	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
165		168
166	// note: this bug is triggered by the == operator, expectEqual will hide it	169	// note: this bug is triggered by the == operator, expectEqual will hide it
167	// using ptrCast not to depend on unitialised memory state	170	// using ptrCast not to depend on unitialised memory state

test/behavior/comptime_memory.zig-4

...	@@ -426,8 +426,6 @@ test "mutate entire slice at comptime" {	...	@@ -426,8 +426,6 @@ test "mutate entire slice at comptime" {
426	}	426	}
427		427
428	test "dereference undefined pointer to zero-bit type" {	428	test "dereference undefined pointer to zero-bit type" {
429	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
430
431	const p0: *void = undefined;	429	const p0: *void = undefined;
432	try testing.expectEqual({}, p0.*);	430	try testing.expectEqual({}, p0.*);
433		431
...	@@ -436,8 +434,6 @@ test "dereference undefined pointer to zero-bit type" {	...	@@ -436,8 +434,6 @@ test "dereference undefined pointer to zero-bit type" {
436	}	434	}
437		435
438	test "type pun extern struct" {	436	test "type pun extern struct" {
439	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
440
441	const S = extern struct { f: u8 };	437	const S = extern struct { f: u8 };
442	comptime var s = S{ .f = 123 };	438	comptime var s = S{ .f = 123 };
443	@as(u8, @ptrCast(&s)). = 72;	439	@as(u8, @ptrCast(&s)). = 72;

test/behavior/const_slice_child.zig-1

...	@@ -10,7 +10,6 @@ test "const slice child" {	...	@@ -10,7 +10,6 @@ test "const slice child" {
10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
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_spirv64) return error.SkipZigTest;
14		13
15	const strs = [_][*]const u8{ "one", "two", "three" };	14	const strs = [_][*]const u8{ "one", "two", "three" };
16	argv = &strs;	15	argv = &strs;

test/behavior/defer.zig-3

test/behavior/empty_union.zig-4

...	@@ -44,8 +44,6 @@ test "empty extern union" {	...	@@ -44,8 +44,6 @@ test "empty extern union" {
44	}	44	}
45		45
46	test "empty union passed as argument" {	46	test "empty union passed as argument" {
47	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
48
49	const U = union(enum) {	47	const U = union(enum) {
50	fn f(u: @This()) void {	48	fn f(u: @This()) void {
51	switch (u) {}	49	switch (u) {}
...	@@ -55,8 +53,6 @@ test "empty union passed as argument" {	...	@@ -55,8 +53,6 @@ test "empty union passed as argument" {
55	}	53	}
56		54
57	test "empty enum passed as argument" {	55	test "empty enum passed as argument" {
58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59
60	const E = enum {	56	const E = enum {
61	fn f(e: @This()) void {	57	fn f(e: @This()) void {
62	switch (e) {}	58	switch (e) {}

test/behavior/enum.zig-8

...	@@ -617,7 +617,6 @@ test "enum with specified tag values" {	...	@@ -617,7 +617,6 @@ test "enum with specified tag values" {
617	test "non-exhaustive enum" {	617	test "non-exhaustive enum" {
618	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	618	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
619	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;
621		620
622	const S = struct {	621	const S = struct {
623	const E = enum(u8) { a, b, _ };	622	const E = enum(u8) { a, b, _ };
...	@@ -660,8 +659,6 @@ test "non-exhaustive enum" {	...	@@ -660,8 +659,6 @@ test "non-exhaustive enum" {
660	}	659	}
661		660
662	test "empty non-exhaustive enum" {	661	test "empty non-exhaustive enum" {
663	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
664
665	const S = struct {	662	const S = struct {
666	const E = enum(u8) { _ };	663	const E = enum(u8) { _ };
667		664
...	@@ -683,7 +680,6 @@ test "empty non-exhaustive enum" {	...	@@ -683,7 +680,6 @@ test "empty non-exhaustive enum" {
683	test "single field non-exhaustive enum" {	680	test "single field non-exhaustive enum" {
684	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	681	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
685	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	682	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
686	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
687		683
688	const S = struct {	684	const S = struct {
689	const E = enum(u8) { a, _ };	685	const E = enum(u8) { a, _ };
...	@@ -856,8 +852,6 @@ fn doALoopThing(id: EnumWithOneMember) void {	...	@@ -856,8 +852,6 @@ fn doALoopThing(id: EnumWithOneMember) void {
856	}	852	}
857		853
858	test "comparison operator on enum with one member is comptime-known" {	854	test "comparison operator on enum with one member is comptime-known" {
859	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
860
861	doALoopThing(EnumWithOneMember.Eof);	855	doALoopThing(EnumWithOneMember.Eof);
862	}	856	}
863		857
...	@@ -1211,8 +1205,6 @@ test "enum tag from a local variable" {	...	@@ -1211,8 +1205,6 @@ test "enum tag from a local variable" {
1211	}	1205	}
1212		1206
1213	test "auto-numbered enum with signed tag type" {	1207	test "auto-numbered enum with signed tag type" {
1214	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1215
1216	const E = enum(i32) { a, b };	1208	const E = enum(i32) { a, b };
1217		1209
1218	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));	1210	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));

test/behavior/error.zig-10

test/behavior/eval.zig-8

test/behavior/floatop.zig+18-2

test/behavior/fn.zig-11

test/behavior/for.zig-16

test/behavior/generics.zig-4

test/behavior/if.zig-3

test/behavior/inline_switch.zig-1

...	@@ -84,7 +84,6 @@ test "inline else bool" {	...	@@ -84,7 +84,6 @@ test "inline else bool" {
84	test "inline else error" {	84	test "inline else error" {
85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
88		87
89	const Err = error{ a, b, c };	88	const Err = error{ a, b, c };
90	var a = Err.a;	89	var a = Err.a;

test/behavior/int_comparison_elision.zig+1-2

...	@@ -4,8 +4,6 @@ const maxInt = std.math.maxInt;	...	@@ -4,8 +4,6 @@ const maxInt = std.math.maxInt;
4	const builtin = @import("builtin");	4	const builtin = @import("builtin");
5		5
6	test "int comparison elision" {	6	test "int comparison elision" {
7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8
9	testIntEdges(u0);	7	testIntEdges(u0);
10	testIntEdges(i0);	8	testIntEdges(i0);
11	testIntEdges(u1);	9	testIntEdges(u1);
...	@@ -17,6 +15,7 @@ test "int comparison elision" {	...	@@ -17,6 +15,7 @@ test "int comparison elision" {
17	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	15	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
20		19
21	// TODO: panic: integer overflow with int types > 65528 bits wide	20	// TODO: panic: integer overflow with int types > 65528 bits wide
22	// TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide	21	// TODO: LLVM generates too many parameters for wasmtime when splitting up int > 64000 bits wide

test/behavior/ir_block_deps.zig-1

...	@@ -21,7 +21,6 @@ test "ir block deps" {	...	@@ -21,7 +21,6 @@ test "ir block deps" {
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_arm) return error.SkipZigTest; // TODO	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25		24
26	try expect((foo(1) catch unreachable) == 0);	25	try expect((foo(1) catch unreachable) == 0);
27	try expect((foo(2) catch unreachable) == 0);	26	try expect((foo(2) catch unreachable) == 0);

test/behavior/lower_strlit_to_vector.zig-1

...	@@ -6,7 +6,6 @@ test "strlit to vector" {	...	@@ -6,7 +6,6 @@ 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;
10		9
11	const strlit = "0123456789abcdef0123456789ABCDEF";	10	const strlit = "0123456789abcdef0123456789ABCDEF";
12	const vec_from_strlit: @Vector(32, u8) = strlit.*;	11	const vec_from_strlit: @Vector(32, u8) = strlit.*;

test/behavior/math.zig+6-3

...	@@ -413,6 +413,7 @@ test "division" {	...	@@ -413,6 +413,7 @@ test "division" {
413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		416	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
416	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	417	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
417		418
418	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {	419	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
...	@@ -468,6 +469,9 @@ fn testDivision() !void {	...	@@ -468,6 +469,9 @@ fn testDivision() !void {
468	try expect(mod(i32, -14, -12) == -2);	469	try expect(mod(i32, -14, -12) == -2);
469	try expect(mod(i32, -2, -12) == -2);	470	try expect(mod(i32, -2, -12) == -2);
470		471
		472	try expect(divTrunc(i20, 20, -5) == -4);
		473	try expect(divTrunc(i20, -20, -4) == 5);
		474
471	comptime {	475	comptime {
472	try expect(	476	try expect(
473	1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600,	477	1194735857077236777412821811143690633098347576 % 508740759824825164163191790951174292733114988 == 177254337427586449086438229241342047632117600,
...	@@ -1116,6 +1120,8 @@ test "@shlWithOverflow" {	...	@@ -1116,6 +1120,8 @@ test "@shlWithOverflow" {
1116	}	1120	}
1117		1121
1118	test "overflow arithmetic with u0 values" {	1122	test "overflow arithmetic with u0 values" {
		1123	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1124
1119	{	1125	{
1120	var a: u0 = 0;	1126	var a: u0 = 0;
1121	const ov = @addWithOverflow(a, 0);	1127	const ov = @addWithOverflow(a, 0);
...	@@ -1284,8 +1290,6 @@ fn testShrExact(x: u8) !void {	...	@@ -1284,8 +1290,6 @@ fn testShrExact(x: u8) !void {
1284	}	1290	}
1285		1291
1286	test "shift left/right on u0 operand" {	1292	test "shift left/right on u0 operand" {
1287	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1288
1289	const S = struct {	1293	const S = struct {
1290	fn doTheTest() !void {	1294	fn doTheTest() !void {
1291	var x: u0 = 0;	1295	var x: u0 = 0;
...	@@ -1562,7 +1566,6 @@ test "vector comparison" {	...	@@ -1562,7 +1566,6 @@ test "vector comparison" {
1562	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1563	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	1567	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1564	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1565	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1566		1569
1567	const S = struct {	1570	const S = struct {
1568	fn doTheTest() !void {	1571	fn doTheTest() !void {

test/behavior/maximum_minimum.zig+12-9

 @@ -9,14 +9,16 @@ test "@max" {
     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 {
             var x: i32 = 10;
             var y: f32 = 0.68;
+            var nan: f32 = std.math.nan(f32);
             try expect(@as(i32, 10) == @max(@as(i32, -3), x));
             try expect(@as(f32, 3.2) == @max(@as(f32, 3.2), y));
+            try expect(y == @max(nan, y));
+            try expect(y == @max(y, nan));
         }
     };
     try S.doTheTest();
 @@ -58,14 +60,16 @@ test "@min" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const S = struct {
         fn doTheTest() !void {
             var x: i32 = 10;
             var y: f32 = 0.68;
+            var nan: f32 = std.math.nan(f32);
             try expect(@as(i32, -3) == @min(@as(i32, -3), x));
             try expect(@as(f32, 0.68) == @min(@as(f32, 3.2), y));
+            try expect(y == @min(nan, y));
+            try expect(y == @min(y, nan));
         }
     };
     try S.doTheTest();
 @@ -119,6 +123,12 @@ test "@min/max for floats" {
             try expectEqual(x, @min(y, x));
             try expectEqual(y, @max(x, y));
             try expectEqual(y, @max(y, x));
+            if (T != comptime_float) {
+                var nan: T = std.math.nan(T);
+                try expectEqual(y, @max(nan, y));
+                try expectEqual(y, @max(y, nan));
+            }
         }
     };
 @@ -137,8 +147,6 @@ test "@min/@max on lazy values" {
 }
 test "@min/@max more than two arguments" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const x: u32 = 30;
     const y: u32 = 10;
     const z: u32 = 20;
 @@ -151,7 +159,6 @@ test "@min/@max more than two vector arguments" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     const x: @Vector(2, u32) = .{ 3, 2 };
     const y: @Vector(2, u32) = .{ 4, 1 };
 @@ -164,7 +171,6 @@ test "@min/@max notices bounds" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     var x: u16 = 20;
     const y = 30;
 @@ -214,7 +220,6 @@ test "@min/@max notices bounds from types" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     var x: u16 = 123;
     var y: u32 = 456;
 @@ -295,8 +300,6 @@ test "@min/@max notices bounds from vector types when element of comptime-known
 }
 test "@min/@max of signed and unsigned runtime integers" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     var x: i32 = -1;
     var y: u31 = 1;

test/behavior/merge_error_sets.zig-1

...	@@ -13,7 +13,6 @@ fn foo() C!void {	...	@@ -13,7 +13,6 @@ fn foo() C!void {
13		13
14	test "merge error sets" {	14	test "merge error sets" {
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;
17		16
18	if (foo()) {	17	if (foo()) {
19	@panic("unexpected");	18	@panic("unexpected");

test/behavior/null.zig-4

test/behavior/optional.zig-16

test/behavior/packed-struct.zig+5

test/behavior/packed-union.zig+1

...	@@ -88,6 +88,7 @@ test "flags in packed union at offset" {	...	@@ -88,6 +88,7 @@ test "flags in packed union at offset" {
88		88
89	test "packed union in packed struct" {	89	test "packed union in packed struct" {
90	// Originally reported at https://github.com/ziglang/zig/issues/16581	90	// Originally reported at https://github.com/ziglang/zig/issues/16581
		91	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
91		92
92	const ReadRequest = packed struct { key: i32 };	93	const ReadRequest = packed struct { key: i32 };
93	const RequestType = enum {	94	const RequestType = enum {

test/behavior/pointers.zig-7

test/behavior/ptrcast.zig+2-2

test/behavior/ptrfromint.zig-2

...	@@ -33,7 +33,6 @@ test "@ptrFromInt creates null pointer" {	...	@@ -33,7 +33,6 @@ test "@ptrFromInt creates null pointer" {
33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	34	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37		36
38	const ptr = @as(?*u32, @ptrFromInt(0));	37	const ptr = @as(?*u32, @ptrFromInt(0));
39	try expectEqual(@as(?*u32, null), ptr);	38	try expectEqual(@as(?*u32, null), ptr);
...	@@ -43,7 +42,6 @@ test "@ptrFromInt creates allowzero zero pointer" {	...	@@ -43,7 +42,6 @@ test "@ptrFromInt creates allowzero zero pointer" {
43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
44	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
45	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
47		45
48	const ptr = @as(*allowzero u32, @ptrFromInt(0));	46	const ptr = @as(*allowzero u32, @ptrFromInt(0));
49	try expectEqual(@as(usize, 0), @intFromPtr(ptr));	47	try expectEqual(@as(usize, 0), @intFromPtr(ptr));

test/behavior/sizeof_and_typeof.zig-3

...	@@ -18,8 +18,6 @@ test "@sizeOf on compile-time types" {	...	@@ -18,8 +18,6 @@ test "@sizeOf on compile-time types" {
18	}	18	}
19		19
20	test "@TypeOf() with multiple arguments" {	20	test "@TypeOf() with multiple arguments" {
21	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
22
23	{	21	{
24	var var_1: u32 = undefined;	22	var var_1: u32 = undefined;
25	var var_2: u8 = undefined;	23	var var_2: u8 = undefined;
...	@@ -268,7 +266,6 @@ test "runtime instructions inside typeof in comptime only scope" {	...	@@ -268,7 +266,6 @@ test "runtime instructions inside typeof in comptime only scope" {
268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	266	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
269	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	267	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
271	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
272		269
273	{	270	{
274	var y: i8 = 2;	271	var y: i8 = 2;

test/behavior/slice.zig-19

test/behavior/src.zig-3

...	@@ -17,7 +17,6 @@ test "@src" {	...	@@ -17,7 +17,6 @@ test "@src" {
17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
21		20
22	try doTheTest();	21	try doTheTest();
23	}	22	}
...	@@ -34,8 +33,6 @@ test "@src used as a comptime parameter" {	...	@@ -34,8 +33,6 @@ test "@src used as a comptime parameter" {
34	}	33	}
35		34
36	test "@src in tuple passed to anytype function" {	35	test "@src in tuple passed to anytype function" {
37	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
38
39	const S = struct {	36	const S = struct {
40	fn Foo(a: anytype) u32 {	37	fn Foo(a: anytype) u32 {
41	return a[0].line;	38	return a[0].line;

test/behavior/struct.zig-16

...	@@ -134,8 +134,6 @@ test "invoke static method in global scope" {	...	@@ -134,8 +134,6 @@ test "invoke static method in global scope" {
134	const empty_global_instance = StructWithNoFields{};	134	const empty_global_instance = StructWithNoFields{};
135		135
136	test "return empty struct instance" {	136	test "return empty struct instance" {
137	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
138
139	_ = returnEmptyStructInstance();	137	_ = returnEmptyStructInstance();
140	}	138	}
141	fn returnEmptyStructInstance() StructWithNoFields {	139	fn returnEmptyStructInstance() StructWithNoFields {
...	@@ -311,7 +309,6 @@ test "struct point to self" {	...	@@ -311,7 +309,6 @@ test "struct point to self" {
311	test "void struct fields" {	309	test "void struct fields" {
312	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	311	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
314	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
315		312
316	const foo = VoidStructFieldsFoo{	313	const foo = VoidStructFieldsFoo{
317	.a = void{},	314	.a = void{},
...	@@ -329,7 +326,6 @@ const VoidStructFieldsFoo = struct {	...	@@ -329,7 +326,6 @@ const VoidStructFieldsFoo = struct {
329		326
330	test "return empty struct from fn" {	327	test "return empty struct from fn" {
331	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	328	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
332	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
333		329
334	_ = testReturnEmptyStructFromFn();	330	_ = testReturnEmptyStructFromFn();
335	}	331	}
...	@@ -340,7 +336,6 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {	...	@@ -340,7 +336,6 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
340		336
341	test "pass slice of empty struct to fn" {	337	test "pass slice of empty struct to fn" {
342	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	338	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
343	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
344		339
345	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);	340	try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
346	}	341	}
...	@@ -889,8 +884,6 @@ test "anonymous struct literal syntax" {	...	@@ -889,8 +884,6 @@ test "anonymous struct literal syntax" {
889	}	884	}
890		885
891	test "fully anonymous struct" {	886	test "fully anonymous struct" {
892	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
893
894	const S = struct {	887	const S = struct {
895	fn doTheTest() !void {	888	fn doTheTest() !void {
896	try dump(.{	889	try dump(.{
...	@@ -913,8 +906,6 @@ test "fully anonymous struct" {	...	@@ -913,8 +906,6 @@ test "fully anonymous struct" {
913	}	906	}
914		907
915	test "fully anonymous list literal" {	908	test "fully anonymous list literal" {
916	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
917
918	const S = struct {	909	const S = struct {
919	fn doTheTest() !void {	910	fn doTheTest() !void {
920	try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });	911	try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi" });
...	@@ -960,7 +951,6 @@ test "tuple element initialized with fn call" {	...	@@ -960,7 +951,6 @@ test "tuple element initialized with fn call" {
960	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
961	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	952	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
962	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	953	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
963	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
964		954
965	const S = struct {	955	const S = struct {
966	fn doTheTest() !void {	956	fn doTheTest() !void {
...	@@ -1229,7 +1219,6 @@ test "typed init through error unions and optionals" {	...	@@ -1229,7 +1219,6 @@ test "typed init through error unions and optionals" {
1229	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1230	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1231	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1232	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1233		1222
1234	const S = struct {	1223	const S = struct {
1235	a: u32,	1224	a: u32,
...	@@ -1550,7 +1539,6 @@ test "no dependency loop on optional field wrapped in generic function" {	...	@@ -1550,7 +1539,6 @@ test "no dependency loop on optional field wrapped in generic function" {
1550	test "optional field init with tuple" {	1539	test "optional field init with tuple" {
1551	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1540	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1552	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1541	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1553	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1554		1542
1555	const S = struct {	1543	const S = struct {
1556	a: ?struct { b: u32 },	1544	a: ?struct { b: u32 },
...	@@ -1652,7 +1640,6 @@ test "struct field pointer has correct alignment" {	...	@@ -1652,7 +1640,6 @@ test "struct field pointer has correct alignment" {
1652	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1640	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1653	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1641	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1654	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1642	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1655	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1656		1643
1657	const S = struct {	1644	const S = struct {
1658	fn doTheTest() !void {	1645	fn doTheTest() !void {
...	@@ -1683,7 +1670,6 @@ test "extern struct field pointer has correct alignment" {	...	@@ -1683,7 +1670,6 @@ test "extern struct field pointer has correct alignment" {
1683	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1670	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1684	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1671	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1685	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1672	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1686	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1687		1673
1688	const S = struct {	1674	const S = struct {
1689	fn doTheTest() !void {	1675	fn doTheTest() !void {
...	@@ -1721,8 +1707,6 @@ test "extern struct field pointer has correct alignment" {	...	@@ -1721,8 +1707,6 @@ test "extern struct field pointer has correct alignment" {
1721	}	1707	}
1722		1708
1723	test "packed struct field in anonymous struct" {	1709	test "packed struct field in anonymous struct" {
1724	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1725
1726	const T = packed struct {	1710	const T = packed struct {
1727	f1: bool = false,	1711	f1: bool = false,
1728	};	1712	};

test/behavior/switch.zig-7

...	@@ -623,7 +623,6 @@ test "switch capture copies its payload" {	...	@@ -623,7 +623,6 @@ test "switch capture copies its payload" {
623	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_aarch64) return error.SkipZigTest; // TODO	624	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
625	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	625	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
626	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
627		626
628	const S = struct {	627	const S = struct {
629	fn doTheTest() !void {	628	fn doTheTest() !void {
...	@@ -710,8 +709,6 @@ test "comptime inline switch" {	...	@@ -710,8 +709,6 @@ test "comptime inline switch" {
710	}	709	}
711		710
712	test "switch capture peer type resolution" {	711	test "switch capture peer type resolution" {
713	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
714
715	const U = union(enum) {	712	const U = union(enum) {
716	a: u32,	713	a: u32,
717	b: u64,	714	b: u64,
...	@@ -727,8 +724,6 @@ test "switch capture peer type resolution" {	...	@@ -727,8 +724,6 @@ test "switch capture peer type resolution" {
727	}	724	}
728		725
729	test "switch capture peer type resolution for in-memory coercible payloads" {	726	test "switch capture peer type resolution for in-memory coercible payloads" {
730	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
731
732	const T1 = c_int;	727	const T1 = c_int;
733	const T2 = @Type(@typeInfo(T1));	728	const T2 = @Type(@typeInfo(T1));
734		729
...	@@ -777,8 +772,6 @@ test "switch pointer capture peer type resolution" {	...	@@ -777,8 +772,6 @@ test "switch pointer capture peer type resolution" {
777	}	772	}
778		773
779	test "inline switch range that includes the maximum value of the switched type" {	774	test "inline switch range that includes the maximum value of the switched type" {
780	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
781
782	const inputs: [3]u8 = .{ 0, 254, 255 };	775	const inputs: [3]u8 = .{ 0, 254, 255 };
783	for (inputs) \|input\| {	776	for (inputs) \|input\| {
784	switch (input) {	777	switch (input) {

test/behavior/switch_prong_err_enum.zig-1

...	@@ -24,7 +24,6 @@ test "switch prong returns error enum" {	...	@@ -24,7 +24,6 @@ test "switch prong returns error enum" {
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_aarch64) return error.SkipZigTest;	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
28		27
29	switch (doThing(17) catch unreachable) {	28	switch (doThing(17) catch unreachable) {
30	FormValue.Address => \|payload\| {	29	FormValue.Address => \|payload\| {

test/behavior/switch_prong_implicit_cast.zig-1

...	@@ -18,7 +18,6 @@ test "switch prong implicit cast" {	...	@@ -18,7 +18,6 @@ test "switch prong implicit cast" {
18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
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_spirv64) return error.SkipZigTest;
22		21
23	const result = switch (foo(2) catch unreachable) {	22	const result = switch (foo(2) catch unreachable) {
24	FormValue.One => false,	23	FormValue.One => false,

test/behavior/threadlocal.zig-1

...	@@ -33,7 +33,6 @@ test "pointer to thread local array" {	...	@@ -33,7 +33,6 @@ test "pointer to thread local array" {
33	else => return error.SkipZigTest,	33	else => return error.SkipZigTest,
34	}; // TODO	34	}; // TODO
35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37		36
38	const s = "Hello world";	37	const s = "Hello world";
39	std.mem.copy(u8, buffer[0..], s);	38	std.mem.copy(u8, buffer[0..], s);

test/behavior/try.zig-3

...	@@ -4,7 +4,6 @@ const expect = std.testing.expect;	...	@@ -4,7 +4,6 @@ const expect = std.testing.expect;
4		4
5	test "try on error union" {	5	test "try on error union" {
6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8		7
9	try tryOnErrorUnionImpl();	8	try tryOnErrorUnionImpl();
10	try comptime tryOnErrorUnionImpl();	9	try comptime tryOnErrorUnionImpl();
...	@@ -40,8 +39,6 @@ fn failIfTrue(ok: bool) anyerror!void {	...	@@ -40,8 +39,6 @@ fn failIfTrue(ok: bool) anyerror!void {
40	}	39	}
41		40
42	test "try then not executed with assignment" {	41	test "try then not executed with assignment" {
43	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
44
45	if (failIfTrue(true)) {	42	if (failIfTrue(true)) {
46	unreachable;	43	unreachable;
47	} else \|err\| {	44	} else \|err\| {

test/behavior/tuple.zig-10

test/behavior/tuple_declarations.zig-2

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

test/behavior/type.zig-3

test/behavior/type_info.zig-1

...	@@ -565,7 +565,6 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {	...	@@ -565,7 +565,6 @@ test "value from struct @typeInfo default_value can be loaded at comptime" {
565	test "@typeInfo decls and usingnamespace" {	565	test "@typeInfo decls and usingnamespace" {
566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
568	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
569		568
570	const A = struct {	569	const A = struct {
571	pub const x = 5;	570	pub const x = 5;

test/behavior/type_info_only_pub_decls.zig-2

...	@@ -15,8 +15,6 @@ const other = struct {	...	@@ -15,8 +15,6 @@ const other = struct {
15	};	15	};
16		16
17	test {	17	test {
18	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19
20	const ti = @typeInfo(other);	18	const ti = @typeInfo(other);
21	const decls = ti.Struct.decls;	19	const decls = ti.Struct.decls;
22		20

test/behavior/typename.zig-2

...	@@ -67,7 +67,6 @@ test "basic" {	...	@@ -67,7 +67,6 @@ 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;
71		70
72	try expectEqualStrings("i64", @typeName(i64));	71	try expectEqualStrings("i64", @typeName(i64));
73	try expectEqualStrings("usize", @typeName(usize));	72	try expectEqualStrings("usize", @typeName(usize));
...	@@ -231,7 +230,6 @@ test "comptime parameters not converted to anytype in function type" {	...	@@ -231,7 +230,6 @@ test "comptime parameters not converted to anytype in function type" {
231	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	230	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	231	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	232	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
234	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
235		233
236	const T = fn (fn (type) void, void) void;	234	const T = fn (fn (type) void, void) void;
237	try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));	235	try expectEqualStrings("fn (comptime fn (comptime type) void, void) void", @typeName(T));

test/behavior/union.zig+10-7

...	@@ -97,7 +97,6 @@ const FooExtern = extern union {	...	@@ -97,7 +97,6 @@ const FooExtern = extern union {
97	test "basic extern unions" {	97	test "basic extern unions" {
98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
100	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
101		100
102	var foo = FooExtern{ .int = 1 };	101	var foo = FooExtern{ .int = 1 };
103	try expect(foo.int == 1);	102	try expect(foo.int == 1);
...	@@ -218,7 +217,6 @@ test "union with specified enum tag" {	...	@@ -218,7 +217,6 @@ test "union with specified enum tag" {
218	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	217	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	218	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
221	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
222		220
223	try doTest();	221	try doTest();
224	try comptime doTest();	222	try comptime doTest();
...	@@ -381,7 +379,6 @@ test "tagged union initialization with runtime void" {	...	@@ -381,7 +379,6 @@ test "tagged union initialization with runtime void" {
381	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	379	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
382	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	380	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
383	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	381	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
384	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
385		382
386	try expect(testTaggedUnionInit({}));	383	try expect(testTaggedUnionInit({}));
387	}	384	}
...	@@ -466,7 +463,6 @@ test "initialize global array of union" {	...	@@ -466,7 +463,6 @@ test "initialize global array of union" {
466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	463	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	464	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
468	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	465	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
469	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
470		466
471	glbl_array[1] = FooUnion{ .U1 = 2 };	467	glbl_array[1] = FooUnion{ .U1 = 2 };
472	glbl_array[0] = FooUnion{ .U0 = 1 };	468	glbl_array[0] = FooUnion{ .U0 = 1 };
...	@@ -966,7 +962,6 @@ test "cast from anonymous struct to union" {	...	@@ -966,7 +962,6 @@ test "cast from anonymous struct to union" {
966	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	962	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
967	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	963	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
968	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	964	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
969	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
970		965
971	const S = struct {	966	const S = struct {
972	const U = union(enum) {	967	const U = union(enum) {
...	@@ -1056,7 +1051,6 @@ test "containers with single-field enums" {	...	@@ -1056,7 +1051,6 @@ test "containers with single-field enums" {
1056	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1051	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1057	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1052	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1058	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1059	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1060		1054
1061	const S = struct {	1055	const S = struct {
1062	const A = union(enum) { f1 };	1056	const A = union(enum) { f1 };
...	@@ -1573,7 +1567,6 @@ test "undefined-layout union field pointer has correct alignment" {	...	@@ -1573,7 +1567,6 @@ test "undefined-layout union field pointer has correct alignment" {
1573	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1567	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1574	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1568	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1575	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1569	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1576	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1577		1570
1578	const S = struct {	1571	const S = struct {
1579	fn doTheTest(comptime U: type) !void {	1572	fn doTheTest(comptime U: type) !void {
...	@@ -1659,6 +1652,8 @@ test "union with 128 bit integer" {	...	@@ -1659,6 +1652,8 @@ test "union with 128 bit integer" {
1659	}	1652	}
1660		1653
1661	test "memset extern union" {	1654	test "memset extern union" {
		1655	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1656
1662	const U = extern union {	1657	const U = extern union {
1663	foo: u8,	1658	foo: u8,
1664	bar: u32,	1659	bar: u32,
...	@@ -1678,6 +1673,8 @@ test "memset extern union" {	...	@@ -1678,6 +1673,8 @@ test "memset extern union" {
1678	}	1673	}
1679		1674
1680	test "memset packed union" {	1675	test "memset packed union" {
		1676	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1677
1681	const U = packed union {	1678	const U = packed union {
1682	a: u32,	1679	a: u32,
1683	b: u8,	1680	b: u8,
...	@@ -1703,6 +1700,8 @@ fn littleToNativeEndian(comptime T: type, v: T) T {	...	@@ -1703,6 +1700,8 @@ fn littleToNativeEndian(comptime T: type, v: T) T {
1703	}	1700	}
1704		1701
1705	test "reinterpret extern union" {	1702	test "reinterpret extern union" {
		1703	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1704
1706	const U = extern union {	1705	const U = extern union {
1707	foo: u8,	1706	foo: u8,
1708	baz: u32 align(8),	1707	baz: u32 align(8),
...	@@ -1771,6 +1770,8 @@ test "reinterpret extern union" {	...	@@ -1771,6 +1770,8 @@ test "reinterpret extern union" {
1771	}	1770	}
1772		1771
1773	test "reinterpret packed union" {	1772	test "reinterpret packed union" {
		1773	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1774
1774	const U = packed union {	1775	const U = packed union {
1775	foo: u8,	1776	foo: u8,
1776	bar: u29,	1777	bar: u29,
...	@@ -1842,6 +1843,8 @@ test "reinterpret packed union" {	...	@@ -1842,6 +1843,8 @@ test "reinterpret packed union" {
1842	}	1843	}
1843		1844
1844	test "reinterpret packed union inside packed struct" {	1845	test "reinterpret packed union inside packed struct" {
		1846	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		1847
1845	const U = packed union {	1848	const U = packed union {
1846	a: u7,	1849	a: u7,
1847	b: u1,	1850	b: u1,

test/behavior/usingnamespace.zig-1

...	@@ -55,7 +55,6 @@ usingnamespace @import("usingnamespace/a.zig");	...	@@ -55,7 +55,6 @@ usingnamespace @import("usingnamespace/a.zig");
55	test "two files usingnamespace import each other" {	55	test "two files usingnamespace import each other" {
56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59		58
60	try expect(@This().ok());	59	try expect(@This().ok());
61	}	60	}

test/behavior/var_args.zig-10

 @@ -14,8 +14,6 @@ fn add(args: anytype) i32 {
 }
 test "add arbitrary args" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(add(.{@as(i32, 1234)}) == 1234);
     try expect(add(.{}) == 0);
 @@ -26,15 +24,12 @@ fn readFirstVarArg(args: anytype) void {
 }
 test "send void arg to var args" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     readFirstVarArg(.{{}});
 }
 test "pass args directly" {
     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;
     try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
 @@ -48,7 +43,6 @@ fn addSomeStuff(args: anytype) i32 {
 test "runtime parameter before var args" {
     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;
     try expect((try extraFn(10, .{})) == 0);
     try expect((try extraFn(10, .{false})) == 1);
 @@ -87,15 +81,11 @@ fn foo2(args: anytype) bool {
 }
 test "array of var args functions" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     try expect(foos[0](.{}));
     try expect(!foos[1](.{}));
 }
 test "pass zero length array to var args param" {
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     doNothingWithFirstArg(.{""});
 }

test/behavior/vector.zig-21

test/behavior/void.zig-2

...	@@ -20,7 +20,6 @@ test "compare void with void compile time known" {	...	@@ -20,7 +20,6 @@ test "compare void with void compile time known" {
20		20
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_spirv64) return error.SkipZigTest;
24		23
25	var j: usize = 0;	24	var j: usize = 0;
26	for (times(10), 0..) \|_, i\| {	25	for (times(10), 0..) \|_, i\| {
...	@@ -37,7 +36,6 @@ test "void optional" {	...	@@ -37,7 +36,6 @@ test "void optional" {
37	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	36	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
39	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	38	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41		39
42	var x: ?void = {};	40	var x: ?void = {};
43	try expect(x != null);	41	try expect(x != null);

test/behavior/while.zig-1

...	@@ -172,7 +172,6 @@ test "while with optional as condition with else" {	...	@@ -172,7 +172,6 @@ test "while with optional as condition with else" {
172		172
173	test "while with error union condition" {	173	test "while with error union condition" {
174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
175	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
176		175
177	numbers_left = 10;	176	numbers_left = 10;
178	var sum: i32 = 0;	177	var sum: i32 = 0;

test/behavior/widening.zig-2

...	@@ -22,8 +22,6 @@ fn zero() u0 {	...	@@ -22,8 +22,6 @@ fn zero() u0 {
22	return 0;	22	return 0;
23	}	23	}
24	test "integer widening u0 to u8" {	24	test "integer widening u0 to u8" {
25	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26
27	const a: u8 = zero();	25	const a: u8 = zero();
28	try expect(a == 0);	26	try expect(a == 0);
29	}	27	}

author	Robin Voetter <robin@voetter.nl> 2023-10-16 02:04:09+02:00
committer	GitHub <noreply@github.com> 2023-10-16 02:04:09+02:00
log	fd6b3db34252f2a548630c0e57fe80f32202aa12
tree	0111caae6ee7e5c69a98702199609b163ed27405
parent	a1e0b9979ab2a47ad1d13dd06106c3143d9a1c9e
parent	8c153221b9e1ff34edd18382770d02aae36dbe74
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -18,7 +18,6 @@ test "global variable alignment" {	...	@@ -18,7 +18,6 @@ test "global variable alignment" {
18	test "slicing array of length 1 can not assume runtime index is always zero" {	18	test "slicing array of length 1 can not assume runtime index is always zero" {
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_spirv64) return error.SkipZigTest;
22		21
23	var runtime_index: usize = 1;	22	var runtime_index: usize = 1;
24	const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];	23	const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
...	@@ -226,7 +225,6 @@ fn fnWithAlignedStack() i32 {	...	@@ -226,7 +225,6 @@ fn fnWithAlignedStack() i32 {
226	test "implicitly decreasing slice alignment" {	225	test "implicitly decreasing slice alignment" {
227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	226	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	227	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
229	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
230		228
231	const a: u32 align(4) = 3;	229	const a: u32 align(4) = 3;
232	const b: u32 align(8) = 4;	230	const b: u32 align(8) = 4;
...	@@ -396,7 +394,6 @@ test "function align expression depends on generic parameter" {	...	@@ -396,7 +394,6 @@ test "function align expression depends on generic parameter" {
396		394
397	test "function callconv expression depends on generic parameter" {	395	test "function callconv expression depends on generic parameter" {
398	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	396	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
399	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
400		397
401	const S = struct {	398	const S = struct {
402	fn doTheTest() !void {	399	fn doTheTest() !void {
...	@@ -414,7 +411,6 @@ test "function callconv expression depends on generic parameter" {	...	@@ -414,7 +411,6 @@ test "function callconv expression depends on generic parameter" {
414		411
415	test "runtime-known array index has best alignment possible" {	412	test "runtime-known array index has best alignment possible" {
416	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	413	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
417	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
418		414
419	// take full advantage of over-alignment	415	// take full advantage of over-alignment
420	var array align(4) = [_]u8{ 1, 2, 3, 4 };	416	var array align(4) = [_]u8{ 1, 2, 3, 4 };
...	@@ -546,7 +542,6 @@ test "align(N) on functions" {	...	@@ -546,7 +542,6 @@ test "align(N) on functions" {
546	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	542	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
547	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	543	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
548	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	544	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
549	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
550		545
551	if (builtin.zig_backend == .stage2_c) {	546	if (builtin.zig_backend == .stage2_c) {
552	// https://github.com/ziglang/zig/issues/16845	547	// https://github.com/ziglang/zig/issues/16845
...	@@ -585,7 +580,6 @@ test "comptime alloc alignment" {	...	@@ -585,7 +580,6 @@ test "comptime alloc alignment" {
585	test "@alignCast null" {	580	test "@alignCast null" {
586	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	581	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
587	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	582	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
588	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
589		583
590	var ptr: ?*anyopaque = null;	584	var ptr: ?*anyopaque = null;
591	const aligned: ?*anyopaque = @alignCast(ptr);	585	const aligned: ?*anyopaque = @alignCast(ptr);
...	@@ -601,7 +595,6 @@ test "sub-aligned pointer field access" {	...	@@ -601,7 +595,6 @@ test "sub-aligned pointer field access" {
601	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	595	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
602	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	596	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
603	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	597	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
604	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
605	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;	598	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
606		599
607	// Originally reported at https://github.com/ziglang/zig/issues/14904	600	// Originally reported at https://github.com/ziglang/zig/issues/14904

...	@@ -72,7 +72,6 @@ test "array concat with tuple" {	...	@@ -72,7 +72,6 @@ test "array concat with tuple" {
72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	72	if (builtin.zig_backend == .stage2_arm) 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_sparc64) return error.SkipZigTest; // TODO	74	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
75	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
76		75
77	const array: [2]u8 = .{ 1, 2 };	76	const array: [2]u8 = .{ 1, 2 };
78	{	77	{
...	@@ -261,7 +260,6 @@ fn doSomeMangling(array: *[4]u8) void {	...	@@ -261,7 +260,6 @@ fn doSomeMangling(array: *[4]u8) void {
261		260
262	test "implicit cast zero sized array ptr to slice" {	261	test "implicit cast zero sized array ptr to slice" {
263	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	262	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
264	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
265		263
266	{	264	{
267	var b = "".*;	265	var b = "".*;
...	@@ -299,7 +297,6 @@ const Str = struct { a: []Sub };	...	@@ -299,7 +297,6 @@ const Str = struct { a: []Sub };
299	test "set global var array via slice embedded in struct" {	297	test "set global var array via slice embedded in struct" {
300	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	298	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
301	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
302	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
303		300
304	var s = Str{ .a = s_array[0..] };	301	var s = Str{ .a = s_array[0..] };
305		302
...	@@ -569,7 +566,6 @@ test "type coercion of anon struct literal to array" {	...	@@ -569,7 +566,6 @@ test "type coercion of anon struct literal to array" {
569	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
570	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	567	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
571	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	568	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
572	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
573		569
574	const S = struct {	570	const S = struct {
575	const U = union {	571	const U = union {
...	@@ -652,7 +648,6 @@ test "array init of container level array variable" {	...	@@ -652,7 +648,6 @@ test "array init of container level array variable" {
652	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	648	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
653	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	649	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
654	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	650	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
655	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
656		651
657	const S = struct {	652	const S = struct {
658	var pair: [2]usize = .{ 1, 2 };	653	var pair: [2]usize = .{ 1, 2 };
...	@@ -732,7 +727,6 @@ test "slicing array of zero-sized values" {	...	@@ -732,7 +727,6 @@ test "slicing array of zero-sized values" {
732	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	727	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
733	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	728	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
734	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	729	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
735	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
736		730
737	var arr: [32]u0 = undefined;	731	var arr: [32]u0 = undefined;
738	for (arr[0..]) \|*zero\|	732	for (arr[0..]) \|*zero\|

...	@@ -357,8 +357,6 @@ fn f2(x: bool) []const u8 {	...	@@ -357,8 +357,6 @@ fn f2(x: bool) []const u8 {
357	}	357	}
358		358
359	test "variable is allowed to be a pointer to an opaque type" {	359	test "variable is allowed to be a pointer to an opaque type" {
360	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
361
362	var x: i32 = 1234;	360	var x: i32 = 1234;
363	_ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));	361	_ = hereIsAnOpaqueType(@as(*OpaqueA, @ptrCast(&x)));
364	}	362	}
...	@@ -380,8 +378,6 @@ fn testTakeAddressOfParameter(f: f32) !void {	...	@@ -380,8 +378,6 @@ fn testTakeAddressOfParameter(f: f32) !void {
380	}	378	}
381		379
382	test "pointer to void return type" {	380	test "pointer to void return type" {
383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
384
385	try testPointerToVoidReturnType();	381	try testPointerToVoidReturnType();
386	}	382	}
387	fn testPointerToVoidReturnType() anyerror!void {	383	fn testPointerToVoidReturnType() anyerror!void {
...	@@ -397,7 +393,6 @@ test "array 2D const double ptr" {	...	@@ -397,7 +393,6 @@ test "array 2D const double ptr" {
397	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
398	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
399	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	395	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
400	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
401		396
402	const rect_2d_vertexes = [_][1]f32{	397	const rect_2d_vertexes = [_][1]f32{
403	[_]f32{1.0},	398	[_]f32{1.0},
...	@@ -410,7 +405,6 @@ test "array 2D const double ptr with offset" {	...	@@ -410,7 +405,6 @@ test "array 2D const double ptr with offset" {
410	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	405	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
411	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
412	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	407	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
413	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
414		408
415	const rect_2d_vertexes = [_][2]f32{	409	const rect_2d_vertexes = [_][2]f32{
416	[_]f32{ 3.0, 4.239 },	410	[_]f32{ 3.0, 4.239 },
...	@@ -423,7 +417,6 @@ test "array 3D const double ptr with offset" {	...	@@ -423,7 +417,6 @@ test "array 3D const double ptr with offset" {
423	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	417	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
424	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	418	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
426	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
427		420
428	const rect_3d_vertexes = [_][2][2]f32{	421	const rect_3d_vertexes = [_][2][2]f32{
429	[_][2]f32{	422	[_][2]f32{
...	@@ -478,7 +471,6 @@ fn testStructInFn() !void {	...	@@ -478,7 +471,6 @@ fn testStructInFn() !void {
478		471
479	test "fn call returning scalar optional in equality expression" {	472	test "fn call returning scalar optional in equality expression" {
480	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
482	try expect(getNull() == null);	474	try expect(getNull() == null);
483	}	475	}
484		476
...	@@ -489,7 +481,6 @@ fn getNull() ?*i32 {	...	@@ -489,7 +481,6 @@ fn getNull() ?*i32 {
489	test "global variable assignment with optional unwrapping with var initialized to undefined" {	481	test "global variable assignment with optional unwrapping with var initialized to undefined" {
490	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	482	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
491	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	483	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
492	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
493		484
494	const S = struct {	485	const S = struct {
495	var data: i32 = 1234;	486	var data: i32 = 1234;
...	@@ -578,8 +569,6 @@ test "comptime cast fn to ptr" {	...	@@ -578,8 +569,6 @@ test "comptime cast fn to ptr" {
578	}	569	}
579		570
580	test "equality compare fn ptrs" {	571	test "equality compare fn ptrs" {
581	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
582
583	var a = &emptyFn;	572	var a = &emptyFn;
584	try expect(a == a);	573	try expect(a == a);
585	}	574	}
...	@@ -649,7 +638,6 @@ test "string escapes" {	...	@@ -649,7 +638,6 @@ test "string escapes" {
649	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	638	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
650	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	639	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
651	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	640	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
652	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
653		641
654	try expectEqualStrings("\"", "\x22");	642	try expectEqualStrings("\"", "\x22");
655	try expectEqualStrings("\'", "\x27");	643	try expectEqualStrings("\'", "\x27");
...	@@ -846,7 +834,6 @@ test "labeled block implicitly ends in a break" {	...	@@ -846,7 +834,6 @@ test "labeled block implicitly ends in a break" {
846	test "catch in block has correct result location" {	834	test "catch in block has correct result location" {
847	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	835	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
848	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	836	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
849	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
850		837
851	const S = struct {	838	const S = struct {
852	fn open() error{A}!@This() {	839	fn open() error{A}!@This() {

...	@@ -29,7 +29,6 @@ test "inf >= 1" {	...	@@ -29,7 +29,6 @@ test "inf >= 1" {
29	test "isNan(nan * 1)" {	29	test "isNan(nan * 1)" {
30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33		32
34	const nan_times_one = comptime std.math.nan(f64) * 1;	33	const nan_times_one = comptime std.math.nan(f64) * 1;
35	try std.testing.expect(std.math.isNan(nan_times_one));	34	try std.testing.expect(std.math.isNan(nan_times_one));
...	@@ -37,7 +36,6 @@ test "isNan(nan * 1)" {	...	@@ -37,7 +36,6 @@ test "isNan(nan * 1)" {
37	test "runtime isNan(nan * 1)" {	36	test "runtime isNan(nan * 1)" {
38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	37	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
41		39
42	const nan_times_one = std.math.nan(f64) * 1;	40	const nan_times_one = std.math.nan(f64) * 1;
43	try std.testing.expect(std.math.isNan(nan_times_one));	41	try std.testing.expect(std.math.isNan(nan_times_one));
...	@@ -45,7 +43,6 @@ test "runtime isNan(nan * 1)" {	...	@@ -45,7 +43,6 @@ test "runtime isNan(nan * 1)" {
45	test "isNan(nan * 0)" {	43	test "isNan(nan * 0)" {
46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	44	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	45	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
49		46
50	const nan_times_zero = comptime std.math.nan(f64) * 0;	47	const nan_times_zero = comptime std.math.nan(f64) * 0;
51	try std.testing.expect(std.math.isNan(nan_times_zero));	48	try std.testing.expect(std.math.isNan(nan_times_zero));
...	@@ -55,7 +52,6 @@ test "isNan(nan * 0)" {	...	@@ -55,7 +52,6 @@ test "isNan(nan * 0)" {
55	test "isNan(inf * 0)" {	52	test "isNan(inf * 0)" {
56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
59		55
60	const inf_times_zero = comptime std.math.inf(f64) * 0;	56	const inf_times_zero = comptime std.math.inf(f64) * 0;
61	try std.testing.expect(std.math.isNan(inf_times_zero));	57	try std.testing.expect(std.math.isNan(inf_times_zero));
...	@@ -65,7 +61,6 @@ test "isNan(inf * 0)" {	...	@@ -65,7 +61,6 @@ test "isNan(inf * 0)" {
65	test "runtime isNan(nan * 0)" {	61	test "runtime isNan(nan * 0)" {
66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
67	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	63	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
68	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
69		64
70	const nan_times_zero = std.math.nan(f64) * 0;	65	const nan_times_zero = std.math.nan(f64) * 0;
71	try std.testing.expect(std.math.isNan(nan_times_zero));	66	try std.testing.expect(std.math.isNan(nan_times_zero));
...	@@ -75,7 +70,6 @@ test "runtime isNan(nan * 0)" {	...	@@ -75,7 +70,6 @@ test "runtime isNan(nan * 0)" {
75	test "runtime isNan(inf * 0)" {	70	test "runtime isNan(inf * 0)" {
76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
78	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
79		73
80	const inf_times_zero = std.math.inf(f64) * 0;	74	const inf_times_zero = std.math.inf(f64) * 0;
81	try std.testing.expect(std.math.isNan(inf_times_zero));	75	try std.testing.expect(std.math.isNan(inf_times_zero));

...	@@ -34,7 +34,6 @@ const ptr_type_name: [*:0]const u8 = type_name;	...	@@ -34,7 +34,6 @@ const ptr_type_name: [*:0]const u8 = type_name;
34	test "@typeName() returns a string literal" {	34	test "@typeName() returns a string literal" {
35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
38		37
39	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));	38	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
40	try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));	39	try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
...	@@ -48,7 +47,6 @@ const expected_contents = "hello zig\n";	...	@@ -48,7 +47,6 @@ const expected_contents = "hello zig\n";
48	test "@embedFile() returns a string literal" {	47	test "@embedFile() returns a string literal" {
49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	49	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52		50
53	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));	51	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
54	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));	52	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
...	@@ -63,7 +61,6 @@ fn testFnForSrc() std.builtin.SourceLocation {	...	@@ -63,7 +61,6 @@ fn testFnForSrc() std.builtin.SourceLocation {
63	test "@src() returns a struct containing 0-terminated string slices" {	61	test "@src() returns a struct containing 0-terminated string slices" {
64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	63	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
67		64
68	const src = testFnForSrc();	65	const src = testFnForSrc();
69	try std.testing.expect([:0]const u8 == @TypeOf(src.file));	66	try std.testing.expect([:0]const u8 == @TypeOf(src.file));

...	@@ -90,7 +90,6 @@ test "result location of function call argument through runtime condition and st	...	@@ -90,7 +90,6 @@ test "result location of function call argument through runtime condition and st
90	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	90	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
93	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
94		93
95	const E = enum { a, b };	94	const E = enum { a, b };
96	const S = struct {	95	const S = struct {
...	@@ -400,7 +399,6 @@ test "recursive inline call with comptime known argument" {	...	@@ -400,7 +399,6 @@ test "recursive inline call with comptime known argument" {
400	test "inline while with @call" {	399	test "inline while with @call" {
401	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	400	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
402	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	401	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
403	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
404		402
405	const S = struct {	403	const S = struct {
406	fn inc(a: *u32) void {	404	fn inc(a: *u32) void {
...	@@ -416,8 +414,6 @@ test "inline while with @call" {	...	@@ -416,8 +414,6 @@ test "inline while with @call" {
416	}	414	}
417		415
418	test "method call as parameter type" {	416	test "method call as parameter type" {
419	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
420
421	const S = struct {	417	const S = struct {
422	fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {	418	fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
423	return y;	419	return y;
...	@@ -436,7 +432,6 @@ test "non-anytype generic parameters provide result type" {	...	@@ -436,7 +432,6 @@ test "non-anytype generic parameters provide result type" {
436	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	432	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	433	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	434	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
439	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
440		435
441	const S = struct {	436	const S = struct {
442	fn f(comptime T: type, y: T) !void {	437	fn f(comptime T: type, y: T) !void {
...	@@ -467,7 +462,6 @@ test "argument to generic function has correct result type" {	...	@@ -467,7 +462,6 @@ test "argument to generic function has correct result type" {
467	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
468	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	463	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
469	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	464	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
470	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
471		465
472	const S = struct {	466	const S = struct {
473	fn foo(_: anytype, e: enum { a, b }) bool {	467	fn foo(_: anytype, e: enum { a, b }) bool {

...	@@ -34,7 +34,6 @@ test "defer and labeled break" {	...	@@ -34,7 +34,6 @@ test "defer and labeled break" {
34	test "errdefer does not apply to fn inside fn" {	34	test "errdefer does not apply to fn inside fn" {
35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
38		37
39	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| try expect(e == error.Bad);	38	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| try expect(e == error.Bad);
40	}	39	}
...	@@ -95,7 +94,6 @@ test "mixing normal and error defers" {	...	@@ -95,7 +94,6 @@ test "mixing normal and error defers" {
95	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
96	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	95	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
99		97
100	try expect(runSomeErrorDefers(true) catch unreachable);	98	try expect(runSomeErrorDefers(true) catch unreachable);
101	try expect(result[0] == 'c');	99	try expect(result[0] == 'c');
...	@@ -160,7 +158,6 @@ test "reference to errdefer payload" {	...	@@ -160,7 +158,6 @@ test "reference to errdefer payload" {
160	test "simple else prong doesn't emit an error for unreachable else prong" {	158	test "simple else prong doesn't emit an error for unreachable else prong" {
161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	159	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	160	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
164		161
165	const S = struct {	162	const S = struct {
166	fn foo() error{Foo}!void {	163	fn foo() error{Foo}!void {

...	@@ -124,7 +124,6 @@ test "debug info for optional error set" {	...	@@ -124,7 +124,6 @@ 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;
128		127
129	const S = struct {	128	const S = struct {
130	fn entry() !void {	129	fn entry() !void {
...	@@ -218,7 +217,6 @@ fn testErrorSetType() !void {	...	@@ -218,7 +217,6 @@ fn testErrorSetType() !void {
218		217
219	test "explicit error set cast" {	218	test "explicit error set cast" {
220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
221	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
222		220
223	try testExplicitErrorSetCast(Set1.A);	221	try testExplicitErrorSetCast(Set1.A);
224	try comptime testExplicitErrorSetCast(Set1.A);	222	try comptime testExplicitErrorSetCast(Set1.A);
...	@@ -320,7 +318,6 @@ test "error inference with an empty set" {	...	@@ -320,7 +318,6 @@ test "error inference with an empty set" {
320		318
321	test "error union peer type resolution" {	319	test "error union peer type resolution" {
322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
323	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
324		321
325	try testErrorUnionPeerTypeResolution(1);	322	try testErrorUnionPeerTypeResolution(1);
326	}	323	}
...	@@ -404,7 +401,6 @@ test "nested error union function call in optional unwrap" {	...	@@ -404,7 +401,6 @@ test "nested error union function call in optional unwrap" {
404	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	401	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
405	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	402	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	403	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
407	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
408		404
409	const S = struct {	405	const S = struct {
410	const Foo = struct {	406	const Foo = struct {
...	@@ -469,7 +465,6 @@ test "optional error set is the same size as error set" {	...	@@ -469,7 +465,6 @@ test "optional error set is the same size as error set" {
469	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	465	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
470	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	466	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
471	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	467	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
472	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
473		468
474	try comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror));	469	try comptime expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
475	try comptime expect(@alignOf(?anyerror) == @alignOf(anyerror));	470	try comptime expect(@alignOf(?anyerror) == @alignOf(anyerror));
...	@@ -485,7 +480,6 @@ test "optional error set is the same size as error set" {	...	@@ -485,7 +480,6 @@ test "optional error set is the same size as error set" {
485	test "nested catch" {	480	test "nested catch" {
486	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	481	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	482	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
488	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
489		483
490	const S = struct {	484	const S = struct {
491	fn entry() !void {	485	fn entry() !void {
...	@@ -536,7 +530,6 @@ test "return result loc as peer result loc in inferred error set function" {	...	@@ -536,7 +530,6 @@ test "return result loc as peer result loc in inferred error set function" {
536	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	530	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
537	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	531	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
539	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
540		533
541	const S = struct {	534	const S = struct {
542	fn doTheTest() !void {	535	fn doTheTest() !void {
...	@@ -568,7 +561,6 @@ test "error payload type is correctly resolved" {	...	@@ -568,7 +561,6 @@ test "error payload type is correctly resolved" {
568	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	561	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
569	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	562	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
570	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	563	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
571	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
572		564
573	const MyIntWrapper = struct {	565	const MyIntWrapper = struct {
574	const Self = @This();	566	const Self = @This();
...	@@ -736,7 +728,6 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {	...	@@ -736,7 +728,6 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {
736		728
737	test "simple else prong allowed even when all errors handled" {	729	test "simple else prong allowed even when all errors handled" {
738	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	730	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
740		731
741	const S = struct {	732	const S = struct {
742	fn foo() !u8 {	733	fn foo() !u8 {
...	@@ -920,7 +911,6 @@ test "optional error union return type" {	...	@@ -920,7 +911,6 @@ test "optional error union return type" {
920	test "optional error set return type" {	911	test "optional error set return type" {
921	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	912	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
922	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	913	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
923	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
924		914
925	const E = error{ A, B };	915	const E = error{ A, B };
926	const S = struct {	916	const S = struct {

...	@@ -441,7 +441,6 @@ test "binary math operator in partially inlined function" {	...	@@ -441,7 +441,6 @@ test "binary math operator in partially inlined function" {
441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
444	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
445		444
446	var s: [4]u32 = undefined;	445	var s: [4]u32 = undefined;
447	var b: [16]u8 = undefined;	446	var b: [16]u8 = undefined;
...	@@ -710,7 +709,6 @@ fn loopNTimes(comptime n: usize) void {	...	@@ -710,7 +709,6 @@ fn loopNTimes(comptime n: usize) void {
710	}	709	}
711		710
712	test "variable inside inline loop that has different types on different iterations" {	711	test "variable inside inline loop that has different types on different iterations" {
713	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
714	try testVarInsideInlineLoop(.{ true, @as(u32, 42) });	712	try testVarInsideInlineLoop(.{ true, @as(u32, 42) });
715	}	713	}
716		714
...	@@ -760,7 +758,6 @@ test "array concatenation peer resolves element types - value" {	...	@@ -760,7 +758,6 @@ test "array concatenation peer resolves element types - value" {
760	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	758	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
761	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	759	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
762	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	760	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
763	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
764		761
765	var a = [2]u3{ 1, 7 };	762	var a = [2]u3{ 1, 7 };
766	var b = [3]u8{ 200, 225, 255 };	763	var b = [3]u8{ 200, 225, 255 };
...	@@ -777,7 +774,6 @@ test "array concatenation peer resolves element types - pointer" {	...	@@ -777,7 +774,6 @@ test "array concatenation peer resolves element types - pointer" {
777	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	774	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
778	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	775	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
779	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	776	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
780	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
781		777
782	var a = [2]u3{ 1, 7 };	778	var a = [2]u3{ 1, 7 };
783	var b = [3]u8{ 200, 225, 255 };	779	var b = [3]u8{ 200, 225, 255 };
...	@@ -794,7 +790,6 @@ test "array concatenation sets the sentinel - value" {	...	@@ -794,7 +790,6 @@ test "array concatenation sets the sentinel - value" {
794	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	790	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
795	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	791	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
796	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	792	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
797	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
798		793
799	var a = [2]u3{ 1, 7 };	794	var a = [2]u3{ 1, 7 };
800	var b = [3:69]u8{ 200, 225, 255 };	795	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -812,7 +807,6 @@ test "array concatenation sets the sentinel - value" {	...	@@ -812,7 +807,6 @@ test "array concatenation sets the sentinel - value" {
812	test "array concatenation sets the sentinel - pointer" {	807	test "array concatenation sets the sentinel - pointer" {
813	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	808	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
814	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	809	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
815	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
816		810
817	var a = [2]u3{ 1, 7 };	811	var a = [2]u3{ 1, 7 };
818	var b = [3:69]u8{ 200, 225, 255 };	812	var b = [3:69]u8{ 200, 225, 255 };
...	@@ -1668,8 +1662,6 @@ test "early exit in container level const" {	...	@@ -1668,8 +1662,6 @@ test "early exit in container level const" {
1668	}	1662	}
1669		1663
1670	test "@inComptime" {	1664	test "@inComptime" {
1671	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1672
1673	const S = struct {	1665	const S = struct {
1674	fn inComptime() bool {	1666	fn inComptime() bool {
1675	return @inComptime();	1667	return @inComptime();

...	@@ -29,6 +29,7 @@ test "add f32/f64" {	...	@@ -29,6 +29,7 @@ test "add f32/f64" {
29		29
30	test "add f80/f128/c_longdouble" {	30	test "add f80/f128/c_longdouble" {
31	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	31	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
32		33
33	try testAdd(f80);	34	try testAdd(f80);
34	try comptime testAdd(f80);	35	try comptime testAdd(f80);
...	@@ -60,6 +61,7 @@ test "sub f32/f64" {	...	@@ -60,6 +61,7 @@ test "sub f32/f64" {
60		61
61	test "sub f80/f128/c_longdouble" {	62	test "sub f80/f128/c_longdouble" {
62	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	63	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		64	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
63		65
64	try testSub(f80);	66	try testSub(f80);
65	try comptime testSub(f80);	67	try comptime testSub(f80);
...	@@ -91,6 +93,7 @@ test "mul f32/f64" {	...	@@ -91,6 +93,7 @@ test "mul f32/f64" {
91		93
92	test "mul f80/f128/c_longdouble" {	94	test "mul f80/f128/c_longdouble" {
93	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	95	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		96	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
94		97
95	try testMul(f80);	98	try testMul(f80);
96	try comptime testMul(f80);	99	try comptime testMul(f80);
...	@@ -200,7 +203,6 @@ test "different sized float comparisons" {	...	@@ -200,7 +203,6 @@ test "different sized float comparisons" {
200	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
203	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
204	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	206	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
205		207
206	try testDifferentSizedFloatComparisons();	208	try testDifferentSizedFloatComparisons();
...	@@ -235,6 +237,7 @@ fn testDifferentSizedFloatComparisons() !void {	...	@@ -235,6 +237,7 @@ fn testDifferentSizedFloatComparisons() !void {
235	test "negative f128 intFromFloat at compile-time" {	237	test "negative f128 intFromFloat at compile-time" {
236	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
237	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;
238		241
239	const a: f128 = -2;	242	const a: f128 = -2;
240	var b = @as(i64, @intFromFloat(a));	243	var b = @as(i64, @intFromFloat(a));
...	@@ -908,6 +911,7 @@ test "@abs f16" {	...	@@ -908,6 +911,7 @@ test "@abs f16" {
908	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	911	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
909	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	912	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	913	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		914	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
911		915
912	try testFabs(f16);	916	try testFabs(f16);
913	try comptime testFabs(f16);	917	try comptime testFabs(f16);
...	@@ -917,6 +921,7 @@ test "@abs f32/f64" {	...	@@ -917,6 +921,7 @@ test "@abs f32/f64" {
917	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	921	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	922	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
919	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	923	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		924	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
920		925
921	try testFabs(f32);	926	try testFabs(f32);
922	try comptime testFabs(f32);	927	try comptime testFabs(f32);
...	@@ -930,6 +935,7 @@ test "@abs f80/f128/c_longdouble" {	...	@@ -930,6 +935,7 @@ test "@abs f80/f128/c_longdouble" {
930	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	935	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
931	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	936	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
932	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	937	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		938	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
933		939
934	try testFabs(f80);	940	try testFabs(f80);
935	try comptime testFabs(f80);	941	try comptime testFabs(f80);
...	@@ -1007,6 +1013,7 @@ test "@floor f16" {	...	@@ -1007,6 +1013,7 @@ test "@floor f16" {
1007	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1013	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1008	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1009	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1015	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1016	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1010		1017
1011	try testFloor(f16);	1018	try testFloor(f16);
1012	try comptime testFloor(f16);	1019	try comptime testFloor(f16);
...	@@ -1017,6 +1024,7 @@ test "@floor f32/f64" {	...	@@ -1017,6 +1024,7 @@ test "@floor f32/f64" {
1017	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1024	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1018	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1025	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1019	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1026	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1027	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1020		1028
1021	try testFloor(f32);	1029	try testFloor(f32);
1022	try comptime testFloor(f32);	1030	try comptime testFloor(f32);
...	@@ -1030,6 +1038,7 @@ test "@floor f80/f128/c_longdouble" {	...	@@ -1030,6 +1038,7 @@ test "@floor f80/f128/c_longdouble" {
1030	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	1038	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
1031	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1039	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1032	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1040	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1041	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1033		1042
1034	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {	1043	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
1035	// https://github.com/ziglang/zig/issues/12602	1044	// https://github.com/ziglang/zig/issues/12602
...	@@ -1089,6 +1098,7 @@ test "@ceil f16" {	...	@@ -1089,6 +1098,7 @@ test "@ceil f16" {
1089	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1098	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1090	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1099	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1091	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1100	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1101	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1092		1102
1093	try testCeil(f16);	1103	try testCeil(f16);
1094	try comptime testCeil(f16);	1104	try comptime testCeil(f16);
...	@@ -1099,6 +1109,7 @@ test "@ceil f32/f64" {	...	@@ -1099,6 +1109,7 @@ test "@ceil f32/f64" {
1099	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1110	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1101	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1111	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1112	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1102		1113
1103	try testCeil(f32);	1114	try testCeil(f32);
1104	try comptime testCeil(f32);	1115	try comptime testCeil(f32);
...	@@ -1112,6 +1123,7 @@ test "@ceil f80/f128/c_longdouble" {	...	@@ -1112,6 +1123,7 @@ test "@ceil f80/f128/c_longdouble" {
1112	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	1123	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
1113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1114	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1125	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1126	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1115		1127
1116	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {	1128	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
1117	// https://github.com/ziglang/zig/issues/12602	1129	// https://github.com/ziglang/zig/issues/12602
...	@@ -1148,8 +1160,8 @@ fn testCeil(comptime T: type) !void {	...	@@ -1148,8 +1160,8 @@ fn testCeil(comptime T: type) !void {
1148	test "@ceil with vectors" {	1160	test "@ceil with vectors" {
1149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1151	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1152	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1163	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		1164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1153	if (builtin.zig_backend == .stage2_x86_64 and	1165	if (builtin.zig_backend == .stage2_x86_64 and
1154	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;	1166	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest;
1155		1167
...	@@ -1171,6 +1183,7 @@ test "@trunc f16" {	...	@@ -1171,6 +1183,7 @@ test "@trunc f16" {
1171	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1183	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1172	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1173	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1185	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1186	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1174		1187
1175	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {	1188	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
1176	// https://github.com/ziglang/zig/issues/16846	1189	// https://github.com/ziglang/zig/issues/16846
...	@@ -1186,6 +1199,7 @@ test "@trunc f32/f64" {	...	@@ -1186,6 +1199,7 @@ test "@trunc f32/f64" {
1186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1188	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1201	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1202	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1189		1203
1190	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {	1204	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS()) {
1191	// https://github.com/ziglang/zig/issues/16846	1205	// https://github.com/ziglang/zig/issues/16846
...	@@ -1204,6 +1218,7 @@ test "@trunc f80/f128/c_longdouble" {	...	@@ -1204,6 +1218,7 @@ test "@trunc f80/f128/c_longdouble" {
1204	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;	1218	if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
1205	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1206	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;	1220	if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf) return error.SkipZigTest;
		1221	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1207		1222
1208	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {	1223	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
1209	// https://github.com/ziglang/zig/issues/12602	1224	// https://github.com/ziglang/zig/issues/12602
...	@@ -1390,6 +1405,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {	...	@@ -1390,6 +1405,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
1390	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1405	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1391	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1406	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1392	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
		1408	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1393		1409
1394	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {	1410	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
1395	const pos = @as(F, 1) / @as(F, 0);	1411	const pos = @as(F, 1) / @as(F, 0);

...	@@ -201,7 +201,6 @@ fn addPointCoords(pt: Point) i32 {	...	@@ -201,7 +201,6 @@ fn addPointCoords(pt: Point) i32 {
201		201
202	test "pass by non-copying value through var arg" {	202	test "pass by non-copying value through var arg" {
203	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;
205		204
206	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);	205	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
207	}	206	}
...	@@ -257,7 +256,6 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -257,7 +256,6 @@ test "implicit cast fn call result to optional in field result" {
257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	256	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
261		259
262	const S = struct {	260	const S = struct {
263	fn entry() !void {	261	fn entry() !void {
...	@@ -284,7 +282,6 @@ test "implicit cast fn call result to optional in field result" {	...	@@ -284,7 +282,6 @@ test "implicit cast fn call result to optional in field result" {
284	test "void parameters" {	282	test "void parameters" {
285	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	283	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
286	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
287	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
288		285
289	try voidFun(1, void{}, 2, {});	286	try voidFun(1, void{}, 2, {});
290	}	287	}
...	@@ -348,7 +345,6 @@ test "function call with anon list literal" {	...	@@ -348,7 +345,6 @@ test "function call with anon list literal" {
348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	345	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	346	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
350	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	347	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
351	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
352		348
353	const S = struct {	349	const S = struct {
354	fn doTheTest() !void {	350	fn doTheTest() !void {
...	@@ -369,7 +365,6 @@ test "function call with anon list literal - 2D" {	...	@@ -369,7 +365,6 @@ test "function call with anon list literal - 2D" {
369	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
370	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
371	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	367	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
372	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
373		368
374	const S = struct {	369	const S = struct {
375	fn doTheTest() !void {	370	fn doTheTest() !void {
...	@@ -415,7 +410,6 @@ test "function with inferred error set but returning no error" {	...	@@ -415,7 +410,6 @@ test "function with inferred error set but returning no error" {
415		410
416	test "import passed byref to function in return type" {	411	test "import passed byref to function in return type" {
417	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	412	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
418	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
419		413
420	const S = struct {	414	const S = struct {
421	fn get() @import("std").ArrayListUnmanaged(i32) {	415	fn get() @import("std").ArrayListUnmanaged(i32) {
...	@@ -451,7 +445,6 @@ test "implicit cast function to function ptr" {	...	@@ -451,7 +445,6 @@ test "implicit cast function to function ptr" {
451	test "method call with optional and error union first param" {	445	test "method call with optional and error union first param" {
452	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
453	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
454	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
455		448
456	const S = struct {	449	const S = struct {
457	x: i32 = 1234,	450	x: i32 = 1234,
...	@@ -471,7 +464,6 @@ test "method call with optional and error union first param" {	...	@@ -471,7 +464,6 @@ test "method call with optional and error union first param" {
471	test "method call with optional pointer first param" {	464	test "method call with optional pointer first param" {
472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	465	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	466	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
474	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
475		467
476	const S = struct {	468	const S = struct {
477	x: i32 = 1234,	469	x: i32 = 1234,
...	@@ -528,7 +520,6 @@ test "function returns function returning type" {	...	@@ -528,7 +520,6 @@ test "function returns function returning type" {
528		520
529	test "peer type resolution of inferred error set with non-void payload" {	521	test "peer type resolution of inferred error set with non-void payload" {
530	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	522	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
531	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
532		523
533	const S = struct {	524	const S = struct {
534	fn openDataFile(mode: enum { read, write }) !u32 {	525	fn openDataFile(mode: enum { read, write }) !u32 {
...	@@ -571,8 +562,6 @@ test "lazy values passed to anytype parameter" {	...	@@ -571,8 +562,6 @@ test "lazy values passed to anytype parameter" {
571	}	562	}
572		563
573	test "pass and return comptime-only types" {	564	test "pass and return comptime-only types" {
574	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
575
576	const S = struct {	565	const S = struct {
577	fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {	566	fn returnNull(comptime x: @Type(.Null)) @Type(.Null) {
578	return x;	567	return x;

...	@@ -7,7 +7,6 @@ const mem = std.mem;	...	@@ -7,7 +7,6 @@ const mem = std.mem;
7	test "continue in for loop" {	7	test "continue in for loop" {
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_sparc64) return error.SkipZigTest; // TODO	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11		10
12	const array = [_]i32{ 1, 2, 3, 4, 5 };	11	const array = [_]i32{ 1, 2, 3, 4, 5 };
13	var sum: i32 = 0;	12	var sum: i32 = 0;
...	@@ -70,7 +69,6 @@ test "basic for loop" {	...	@@ -70,7 +69,6 @@ test "basic for loop" {
70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
74		72
75	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;	73	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
76		74
...	@@ -114,7 +112,6 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -114,7 +112,6 @@ test "for with null and T peer types and inferred result location type" {
114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	114	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
118		115
119	const S = struct {	116	const S = struct {
120	fn doTheTest(slice: []const u8) !void {	117	fn doTheTest(slice: []const u8) !void {
...	@@ -135,7 +132,6 @@ test "for with null and T peer types and inferred result location type" {	...	@@ -135,7 +132,6 @@ test "for with null and T peer types and inferred result location type" {
135	test "2 break statements and an else" {	132	test "2 break statements and an else" {
136	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
137	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	134	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
139		135
140	const S = struct {	136	const S = struct {
141	fn entry(t: bool, f: bool) !void {	137	fn entry(t: bool, f: bool) !void {
...	@@ -157,7 +153,6 @@ test "for loop with pointer elem var" {	...	@@ -157,7 +153,6 @@ test "for loop with pointer elem var" {
157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	153	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
160	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
161		156
162	const source = "abcdefg";	157	const source = "abcdefg";
163	var target: [source.len]u8 = undefined;	158	var target: [source.len]u8 = undefined;
...	@@ -184,7 +179,6 @@ fn mangleString(s: []u8) void {	...	@@ -184,7 +179,6 @@ fn mangleString(s: []u8) void {
184	test "for copies its payload" {	179	test "for copies its payload" {
185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	180	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
186	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	181	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
187	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
188		182
189	const S = struct {	183	const S = struct {
190	fn doTheTest() !void {	184	fn doTheTest() !void {
...	@@ -204,7 +198,6 @@ test "for on slice with allowzero ptr" {	...	@@ -204,7 +198,6 @@ test "for on slice with allowzero ptr" {
204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
205	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
207	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
208		201
209	const S = struct {	202	const S = struct {
210	fn doTheTest(slice: []const u8) !void {	203	fn doTheTest(slice: []const u8) !void {
...	@@ -220,7 +213,6 @@ test "for on slice with allowzero ptr" {	...	@@ -220,7 +213,6 @@ test "for on slice with allowzero ptr" {
220	test "else continue outer for" {	213	test "else continue outer for" {
221	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	214	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	215	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
223	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
224		216
225	var i: usize = 6;	217	var i: usize = 6;
226	var buf: [5]u8 = undefined;	218	var buf: [5]u8 = undefined;
...	@@ -282,7 +274,6 @@ test "two counters" {	...	@@ -282,7 +274,6 @@ test "two counters" {
282	test "1-based counter and ptr to array" {	274	test "1-based counter and ptr to array" {
283	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	275	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
284	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	276	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
285	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
286		277
287	var ok: usize = 0;	278	var ok: usize = 0;
288		279
...	@@ -344,7 +335,6 @@ test "two slices, one captured by-ref" {	...	@@ -344,7 +335,6 @@ test "two slices, one captured by-ref" {
344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
345	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	336	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
346	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	337	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
347	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
348		338
349	var buf: [10]u8 = undefined;	339	var buf: [10]u8 = undefined;
350	const slice1: []const u8 = "blah";	340	const slice1: []const u8 = "blah";
...	@@ -364,7 +354,6 @@ test "raw pointer and slice" {	...	@@ -364,7 +354,6 @@ test "raw pointer and slice" {
364	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	354	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	355	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
367	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
368		357
369	var buf: [10]u8 = undefined;	358	var buf: [10]u8 = undefined;
370	const slice: []const u8 = "blah";	359	const slice: []const u8 = "blah";
...	@@ -384,7 +373,6 @@ test "raw pointer and counter" {	...	@@ -384,7 +373,6 @@ test "raw pointer and counter" {
384	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	373	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
385	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	374	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
386	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	375	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
387	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
388		376
389	var buf: [10]u8 = undefined;	377	var buf: [10]u8 = undefined;
390	const ptr: [*]u8 = &buf;	378	const ptr: [*]u8 = &buf;
...	@@ -433,7 +421,6 @@ test "inline for with counter as the comptime-known" {	...	@@ -433,7 +421,6 @@ test "inline for with counter as the comptime-known" {
433	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	421	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
434	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	422	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
435	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	423	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
437		424
438	var runtime_slice = "hello";	425	var runtime_slice = "hello";
439	var runtime_i: usize = 3;	426	var runtime_i: usize = 3;
...	@@ -464,7 +451,6 @@ test "inline for on tuple pointer" {	...	@@ -464,7 +451,6 @@ test "inline for on tuple pointer" {
464	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	451	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	452	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
466	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
467	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
468		454
469	const S = struct { u32, u32, u32 };	455	const S = struct { u32, u32, u32 };
470	var s: S = .{ 100, 200, 300 };	456	var s: S = .{ 100, 200, 300 };
...	@@ -480,7 +466,6 @@ test "ref counter that starts at zero" {	...	@@ -480,7 +466,6 @@ test "ref counter that starts at zero" {
480	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	466	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	467	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
482	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	468	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
483	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
484		469
485	for ([_]usize{ 0, 1, 2 }, 0..) \|i, j\| {	470	for ([_]usize{ 0, 1, 2 }, 0..) \|i, j\| {
486	try expectEqual(i, j);	471	try expectEqual(i, j);
...	@@ -496,7 +481,6 @@ test "inferred alloc ptr of for loop" {	...	@@ -496,7 +481,6 @@ test "inferred alloc ptr of for loop" {
496	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	481	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
497	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	482	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
498	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	483	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
499	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
500		484
501	{	485	{
502	var cond = false;	486	var cond = false;

...	@@ -153,7 +153,6 @@ test "generic fn with implicit cast" {	...	@@ -153,7 +153,6 @@ test "generic fn with implicit cast" {
153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
154	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	154	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	155	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157		156
158	try expect(getFirstByte(u8, &[_]u8{13}) == 13);	157	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
159	try expect(getFirstByte(u16, &[_]u16{	158	try expect(getFirstByte(u16, &[_]u16{
...	@@ -280,7 +279,6 @@ test "generic function instantiation turns into comptime call" {	...	@@ -280,7 +279,6 @@ test "generic function instantiation turns into comptime call" {
280		279
281	test "generic function with void and comptime parameter" {	280	test "generic function with void and comptime parameter" {
282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	281	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
284		282
285	const S = struct { x: i32 };	283	const S = struct { x: i32 };
286	const namespace = struct {	284	const namespace = struct {
...	@@ -315,7 +313,6 @@ test "generic function instantiation non-duplicates" {	...	@@ -315,7 +313,6 @@ test "generic function instantiation non-duplicates" {
315	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	313	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	314	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	315	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
318	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
319	if (builtin.os.tag == .wasi) return error.SkipZigTest;	316	if (builtin.os.tag == .wasi) return error.SkipZigTest;
320		317
321	const S = struct {	318	const S = struct {
...	@@ -433,7 +430,6 @@ test "generic function passed as comptime argument" {	...	@@ -433,7 +430,6 @@ test "generic function passed as comptime argument" {
433		430
434	test "return type of generic function is function pointer" {	431	test "return type of generic function is function pointer" {
435	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	432	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
437		433
438	const S = struct {	434	const S = struct {
439	fn b(comptime T: type) ?*const fn () error{}!T {	435	fn b(comptime T: type) ?*const fn () error{}!T {

...	@@ -45,7 +45,6 @@ var global_with_err: anyerror!u32 = error.SomeError;	...	@@ -45,7 +45,6 @@ var global_with_err: anyerror!u32 = error.SomeError;
45		45
46	test "unwrap mutable global var" {	46	test "unwrap mutable global var" {
47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	47	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
48	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
49		48
50	if (global_with_val) \|v\| {	49	if (global_with_val) \|v\| {
51	try expect(v == 0);	50	try expect(v == 0);
...	@@ -116,7 +115,6 @@ test "if peer expressions inferred optional type" {	...	@@ -116,7 +115,6 @@ test "if peer expressions inferred optional type" {
116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
117	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	116	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
118	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
119	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
120		118
121	var self: []const u8 = "abcdef";	119	var self: []const u8 = "abcdef";
122	var index: usize = 0;	120	var index: usize = 0;
...	@@ -134,7 +132,6 @@ test "if-else expression with runtime condition result location is inferred opti	...	@@ -134,7 +132,6 @@ test "if-else expression with runtime condition result location is inferred opti
134	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	132	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	134	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
138		135
139	const A = struct { b: u64, c: u64 };	136	const A = struct { b: u64, c: u64 };
140	var d: bool = true;	137	var d: bool = true;

...	@@ -53,7 +53,6 @@ test "maybe return" {	...	@@ -53,7 +53,6 @@ test "maybe return" {
53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
57		56
58	try maybeReturnImpl();	57	try maybeReturnImpl();
59	try comptime maybeReturnImpl();	58	try comptime maybeReturnImpl();
...	@@ -84,7 +83,6 @@ fn testTestNullRuntime(x: ?i32) !void {	...	@@ -84,7 +83,6 @@ fn testTestNullRuntime(x: ?i32) !void {
84	test "optional void" {	83	test "optional void" {
85	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	84	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
88		86
89	try optionalVoidImpl();	87	try optionalVoidImpl();
90	try comptime optionalVoidImpl();	88	try comptime optionalVoidImpl();
...	@@ -108,7 +106,6 @@ const Empty = struct {};	...	@@ -108,7 +106,6 @@ const Empty = struct {};
108	test "optional struct{}" {	106	test "optional struct{}" {
109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	107	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
110	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	108	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
111	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
112		109
113	_ = try optionalEmptyStructImpl();	110	_ = try optionalEmptyStructImpl();
114	_ = try comptime optionalEmptyStructImpl();	111	_ = try comptime optionalEmptyStructImpl();
...	@@ -134,7 +131,6 @@ test "null with default unwrap" {	...	@@ -134,7 +131,6 @@ test "null with default unwrap" {
134		131
135	test "optional pointer to 0 bit type null value at runtime" {	132	test "optional pointer to 0 bit type null value at runtime" {
136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
138		134
139	const EmptyStruct = struct {};	135	const EmptyStruct = struct {};
140	var x: ?*EmptyStruct = null;	136	var x: ?*EmptyStruct = null;

...	@@ -27,7 +27,6 @@ pub const EmptyStruct = struct {};	...	@@ -27,7 +27,6 @@ pub const EmptyStruct = struct {};
27		27
28	test "optional pointer to size zero struct" {	28	test "optional pointer to size zero struct" {
29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
31		30
32	var e = EmptyStruct{};	31	var e = EmptyStruct{};
33	var o: ?*EmptyStruct = &e;	32	var o: ?*EmptyStruct = &e;
...	@@ -35,8 +34,6 @@ test "optional pointer to size zero struct" {	...	@@ -35,8 +34,6 @@ test "optional pointer to size zero struct" {
35	}	34	}
36		35
37	test "equality compare optional pointers" {	36	test "equality compare optional pointers" {
38	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
39
40	try testNullPtrsEql();	37	try testNullPtrsEql();
41	try comptime testNullPtrsEql();	38	try comptime testNullPtrsEql();
42	}	39	}
...	@@ -61,7 +58,6 @@ test "optional with void type" {	...	@@ -61,7 +58,6 @@ test "optional with void type" {
61	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
62	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
63	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
65		61
66	const Foo = struct {	62	const Foo = struct {
67	x: ?void,	63	x: ?void,
...	@@ -96,7 +92,6 @@ test "nested optional field in struct" {	...	@@ -96,7 +92,6 @@ test "nested optional field in struct" {
96	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
97	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	94	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
99	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
100		95
101	const S2 = struct {	96	const S2 = struct {
102	y: u8,	97	y: u8,
...	@@ -114,7 +109,6 @@ test "equality compare optional with non-optional" {	...	@@ -114,7 +109,6 @@ test "equality compare optional with non-optional" {
114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	109	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
118		112
119	try test_cmp_optional_non_optional();	113	try test_cmp_optional_non_optional();
120	try comptime test_cmp_optional_non_optional();	114	try comptime test_cmp_optional_non_optional();
...	@@ -152,7 +146,6 @@ fn test_cmp_optional_non_optional() !void {	...	@@ -152,7 +146,6 @@ fn test_cmp_optional_non_optional() !void {
152	test "unwrap function call with optional pointer return value" {	146	test "unwrap function call with optional pointer return value" {
153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	147	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
155	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
156		149
157	const S = struct {	150	const S = struct {
158	fn entry() !void {	151	fn entry() !void {
...	@@ -174,7 +167,6 @@ test "unwrap function call with optional pointer return value" {	...	@@ -174,7 +167,6 @@ test "unwrap function call with optional pointer return value" {
174	test "nested orelse" {	167	test "nested orelse" {
175	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
178		170
179	const S = struct {	171	const S = struct {
180	fn entry() !void {	172	fn entry() !void {
...	@@ -257,7 +249,6 @@ test "0-bit child type coerced to optional return ptr result location" {	...	@@ -257,7 +249,6 @@ test "0-bit child type coerced to optional return ptr result location" {
257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	249	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
258	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	250	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	251	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
261		252
262	const S = struct {	253	const S = struct {
263	fn doTheTest() !void {	254	fn doTheTest() !void {
...	@@ -310,7 +301,6 @@ test "array of optional unaligned types" {	...	@@ -310,7 +301,6 @@ test "array of optional unaligned types" {
310	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
311	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	302	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
312	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	303	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
314		304
315	const Enum = enum { one, two, three };	305	const Enum = enum { one, two, three };
316		306
...	@@ -400,7 +390,6 @@ const NoReturn = struct {	...	@@ -400,7 +390,6 @@ const NoReturn = struct {
400		390
401	test "optional of noreturn used with if" {	391	test "optional of noreturn used with if" {
402	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	392	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
403	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
404		393
405	NoReturn.a = 64;	394	NoReturn.a = 64;
406	if (NoReturn.loop()) \|_\| {	395	if (NoReturn.loop()) \|_\| {
...	@@ -412,7 +401,6 @@ test "optional of noreturn used with if" {	...	@@ -412,7 +401,6 @@ test "optional of noreturn used with if" {
412		401
413	test "optional of noreturn used with orelse" {	402	test "optional of noreturn used with orelse" {
414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	403	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
416		404
417	NoReturn.a = 64;	405	NoReturn.a = 64;
418	const val = NoReturn.testOrelse();	406	const val = NoReturn.testOrelse();
...	@@ -448,7 +436,6 @@ test "Optional slice size is optimized" {	...	@@ -448,7 +436,6 @@ test "Optional slice size is optimized" {
448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	436	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
449	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
450	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
451	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
452		439
453	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));	440	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
454	var a: ?[]const u8 = null;	441	var a: ?[]const u8 = null;
...	@@ -460,7 +447,6 @@ test "Optional slice size is optimized" {	...	@@ -460,7 +447,6 @@ test "Optional slice size is optimized" {
460	test "peer type resolution in nested if expressions" {	447	test "peer type resolution in nested if expressions" {
461	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
462	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	449	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
463	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
464		450
465	const Thing = struct { n: i32 };	451	const Thing = struct { n: i32 };
466	var a = false;	452	var a = false;
...	@@ -500,8 +486,6 @@ test "cast slice to const slice nested in error union and optional" {	...	@@ -500,8 +486,6 @@ test "cast slice to const slice nested in error union and optional" {
500	}	486	}
501		487
502	test "variable of optional of noreturn" {	488	test "variable of optional of noreturn" {
503	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
504
505	var null_opv: ?noreturn = null;	489	var null_opv: ?noreturn = null;
506	try std.testing.expectEqual(@as(?noreturn, null), null_opv);	490	try std.testing.expectEqual(@as(?noreturn, null), null_opv);
507	}	491	}

...	@@ -622,6 +622,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {	...	@@ -622,6 +622,7 @@ test "@intFromPtr on a packed struct field unaligned and nested" {
622		622
623	test "packed struct fields modification" {	623	test "packed struct fields modification" {
624	// Originally reported at https://github.com/ziglang/zig/issues/16615	624	// Originally reported at https://github.com/ziglang/zig/issues/16615
		625	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
625		626
626	const Small = packed struct {	627	const Small = packed struct {
627	val: u8 = 0,	628	val: u8 = 0,
...	@@ -980,6 +981,8 @@ test "store undefined to packed result location" {	...	@@ -980,6 +981,8 @@ test "store undefined to packed result location" {
980	}	981	}
981		982
982	test "bitcast back and forth" {	983	test "bitcast back and forth" {
		984	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		985
983	// Originally reported at https://github.com/ziglang/zig/issues/9914	986	// Originally reported at https://github.com/ziglang/zig/issues/9914
984	const S = packed struct { one: u6, two: u1 };	987	const S = packed struct { one: u6, two: u1 };
985	const s = S{ .one = 0b110101, .two = 0b1 };	988	const s = S{ .one = 0b110101, .two = 0b1 };
...	@@ -991,6 +994,7 @@ test "bitcast back and forth" {	...	@@ -991,6 +994,7 @@ test "bitcast back and forth" {
991		994
992	test "field access of packed struct smaller than its abi size inside struct initialized with rls" {	995	test "field access of packed struct smaller than its abi size inside struct initialized with rls" {
993	// Originally reported at https://github.com/ziglang/zig/issues/14200	996	// Originally reported at https://github.com/ziglang/zig/issues/14200
		997	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
994		998
995	const S = struct {	999	const S = struct {
996	ps: packed struct { x: i2, y: i2 },	1000	ps: packed struct { x: i2, y: i2 },
...	@@ -1039,6 +1043,7 @@ test "modify nested packed struct aligned field" {	...	@@ -1039,6 +1043,7 @@ test "modify nested packed struct aligned field" {
1039		1043
1040	test "assigning packed struct inside another packed struct" {	1044	test "assigning packed struct inside another packed struct" {
1041	// Originally reported at https://github.com/ziglang/zig/issues/9674	1045	// Originally reported at https://github.com/ziglang/zig/issues/9674
		1046	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1042		1047
1043	const S = struct {	1048	const S = struct {
1044	const Inner = packed struct {	1049	const Inner = packed struct {

...	@@ -149,7 +149,6 @@ test "implicit casting between C pointer and optional non-C pointer" {	...	@@ -149,7 +149,6 @@ test "implicit casting between C pointer and optional non-C pointer" {
149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
150	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	150	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
151	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	151	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
152	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
153		152
154	var slice: []const u8 = "aoeu";	153	var slice: []const u8 = "aoeu";
155	const opt_many_ptr: ?[*]const u8 = slice.ptr;	154	const opt_many_ptr: ?[*]const u8 = slice.ptr;
...	@@ -192,7 +191,6 @@ test "allowzero pointer and slice" {	...	@@ -192,7 +191,6 @@ test "allowzero pointer and slice" {
192	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	191	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
193	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	192	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
195	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
196		194
197	var ptr = @as([*]allowzero i32, @ptrFromInt(0));	195	var ptr = @as([*]allowzero i32, @ptrFromInt(0));
198	var opt_ptr: ?[*]allowzero i32 = ptr;	196	var opt_ptr: ?[*]allowzero i32 = ptr;
...	@@ -211,7 +209,6 @@ test "assign null directly to C pointer and test null equality" {	...	@@ -211,7 +209,6 @@ test "assign null directly to C pointer and test null equality" {
211	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	209	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
212	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	210	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
215		212
216	var x: [*c]i32 = null;	213	var x: [*c]i32 = null;
217	try expect(x == null);	214	try expect(x == null);
...	@@ -278,7 +275,6 @@ test "array initialization types" {	...	@@ -278,7 +275,6 @@ test "array initialization types" {
278	test "null terminated pointer" {	275	test "null terminated pointer" {
279	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
280	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	277	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
281	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
282		278
283	const S = struct {	279	const S = struct {
284	fn doTheTest() !void {	280	fn doTheTest() !void {
...	@@ -413,7 +409,6 @@ test "indexing array with sentinel returns correct type" {	...	@@ -413,7 +409,6 @@ test "indexing array with sentinel returns correct type" {
413	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	409	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
414	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	410	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
415	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	411	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
416	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
417		412
418	var s: [:0]const u8 = "abc";	413	var s: [:0]const u8 = "abc";
419	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));	414	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
...	@@ -498,7 +493,6 @@ test "ptrCast comptime known slice to C pointer" {	...	@@ -498,7 +493,6 @@ test "ptrCast comptime known slice to C pointer" {
498	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	493	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
499	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	494	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	495	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
502		496
503	const s: [:0]const u8 = "foo";	497	const s: [:0]const u8 = "foo";
504	var p = @as([*c]const u8, @ptrCast(s));	498	var p = @as([*c]const u8, @ptrCast(s));
...	@@ -509,7 +503,6 @@ test "intFromPtr on a generic function" {	...	@@ -509,7 +503,6 @@ test "intFromPtr on a generic function" {
509	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	503	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
510	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
511	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
512	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
513		506
514	const S = struct {	507	const S = struct {
515	fn generic(i: anytype) @TypeOf(i) {	508	fn generic(i: anytype) @TypeOf(i) {

...	@@ -233,7 +233,6 @@ test "implicit optional pointer to optional anyopaque pointer" {	...	@@ -233,7 +233,6 @@ test "implicit optional pointer to optional anyopaque pointer" {
233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	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;
237		236
238	var buf: [4]u8 = "aoeu".*;	237	var buf: [4]u8 = "aoeu".*;
239	var x: ?[*]u8 = &buf;	238	var x: ?[*]u8 = &buf;
...	@@ -246,7 +245,6 @@ test "@ptrCast slice to slice" {	...	@@ -246,7 +245,6 @@ test "@ptrCast slice to slice" {
246	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
247	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
248	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
249	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
250		248
251	const S = struct {	249	const S = struct {
252	fn foo(slice: []u32) []i32 {	250	fn foo(slice: []u32) []i32 {
...	@@ -286,6 +284,8 @@ test "@ptrCast undefined value at comptime" {	...	@@ -286,6 +284,8 @@ test "@ptrCast undefined value at comptime" {
286	}	284	}
287		285
288	test "comptime @ptrCast with packed struct leaves value unmodified" {	286	test "comptime @ptrCast with packed struct leaves value unmodified" {
		287	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		288
289	const S = packed struct { three: u3 };	289	const S = packed struct { three: u3 };
290	const st: S = .{ .three = 6 };	290	const st: S = .{ .three = 6 };
291	try expect(st.three == 6);	291	try expect(st.three == 6);

...	@@ -64,7 +64,6 @@ test "comptime slice of undefined pointer of length 0" {	...	@@ -64,7 +64,6 @@ test "comptime slice of undefined pointer of length 0" {
64		64
65	test "implicitly cast array of size 0 to slice" {	65	test "implicitly cast array of size 0 to slice" {
66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
68		67
69	var msg = [_]u8{};	68	var msg = [_]u8{};
70	try assertLenIsZero(&msg);	69	try assertLenIsZero(&msg);
...	@@ -172,7 +171,6 @@ test "comptime pointer cast array and then slice" {	...	@@ -172,7 +171,6 @@ test "comptime pointer cast array and then slice" {
172	test "slicing zero length array" {	171	test "slicing zero length array" {
173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	172	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
174	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
175	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
176		174
177	const s1 = ""[0..];	175	const s1 = ""[0..];
178	const s2 = ([_]u32{})[0..];	176	const s2 = ([_]u32{})[0..];
...	@@ -183,8 +181,6 @@ test "slicing zero length array" {	...	@@ -183,8 +181,6 @@ test "slicing zero length array" {
183	}	181	}
184		182
185	test "slicing pointer by length" {	183	test "slicing pointer by length" {
186	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
187
188	const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };	184	const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
189	const ptr: []const u8 = @as([]const u8, @ptrCast(&array));	185	const ptr: []const u8 = @as([]const u8, @ptrCast(&array));
190	const slice = ptr[1..][0..5];	186	const slice = ptr[1..][0..5];
...	@@ -219,7 +215,6 @@ test "slice string literal has correct type" {	...	@@ -219,7 +215,6 @@ test "slice string literal has correct type" {
219		215
220	test "result location zero sized array inside struct field implicit cast to slice" {	216	test "result location zero sized array inside struct field implicit cast to slice" {
221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
223		218
224	const E = struct {	219	const E = struct {
225	entries: []u32,	220	entries: []u32,
...	@@ -232,7 +227,6 @@ test "runtime safety lets us slice from len..len" {	...	@@ -232,7 +227,6 @@ test "runtime safety lets us slice from len..len" {
232	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
233	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	228	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	229	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
236		230
237	var an_array = [_]u8{ 1, 2, 3 };	231	var an_array = [_]u8{ 1, 2, 3 };
238	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));	232	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
...	@@ -245,7 +239,6 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {	...	@@ -245,7 +239,6 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
245	test "C pointer" {	239	test "C pointer" {
246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	240	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	241	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
248	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
249		242
250	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";	243	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
251	var len: u32 = 10;	244	var len: u32 = 10;
...	@@ -257,7 +250,6 @@ test "C pointer slice access" {	...	@@ -257,7 +250,6 @@ test "C pointer slice access" {
257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	250	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
258	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	251	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
259	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
261		253
262	var buf: [10]u32 = [1]u32{42} ** 10;	254	var buf: [10]u32 = [1]u32{42} ** 10;
263	const c_ptr = @as([*c]const u32, @ptrCast(&buf));	255	const c_ptr = @as([*c]const u32, @ptrCast(&buf));
...	@@ -287,7 +279,6 @@ fn sliceSum(comptime q: []const u8) i32 {	...	@@ -287,7 +279,6 @@ fn sliceSum(comptime q: []const u8) i32 {
287	test "slice type with custom alignment" {	279	test "slice type with custom alignment" {
288	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	281	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
291		282
292	const LazilyResolvedType = struct {	283	const LazilyResolvedType = struct {
293	anything: i32,	284	anything: i32,
...	@@ -361,7 +352,6 @@ test "slice syntax resulting in pointer-to-array" {	...	@@ -361,7 +352,6 @@ test "slice syntax resulting in pointer-to-array" {
361	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	352	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
362	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	353	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	354	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
364	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
365		355
366	const S = struct {	356	const S = struct {
367	fn doTheTest() !void {	357	fn doTheTest() !void {
...	@@ -586,7 +576,6 @@ test "slice pointer-to-array null terminated" {	...	@@ -586,7 +576,6 @@ test "slice pointer-to-array null terminated" {
586		576
587	test "slice pointer-to-array zero length" {	577	test "slice pointer-to-array zero length" {
588	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	578	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
589	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
590		579
591	comptime {	580	comptime {
592	{	581	{
...	@@ -795,8 +784,6 @@ test "global slice field access" {	...	@@ -795,8 +784,6 @@ test "global slice field access" {
795	}	784	}
796		785
797	test "slice of void" {	786	test "slice of void" {
798	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
799
800	var n: usize = 10;	787	var n: usize = 10;
801	var arr: [12]void = undefined;	788	var arr: [12]void = undefined;
802	const slice = @as([]void, &arr)[0..n];	789	const slice = @as([]void, &arr)[0..n];
...	@@ -804,8 +791,6 @@ test "slice of void" {	...	@@ -804,8 +791,6 @@ test "slice of void" {
804	}	791	}
805		792
806	test "slice with dereferenced value" {	793	test "slice with dereferenced value" {
807	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
808
809	var a: usize = 0;	794	var a: usize = 0;
810	var idx: *usize = &a;	795	var idx: *usize = &a;
811	_ = blk: {	796	_ = blk: {
...	@@ -821,7 +806,6 @@ test "slice with dereferenced value" {	...	@@ -821,7 +806,6 @@ test "slice with dereferenced value" {
821		806
822	test "empty slice ptr is non null" {	807	test "empty slice ptr is non null" {
823	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO	808	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO
824	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
825		809
826	{	810	{
827	const empty_slice: []u8 = &[_]u8{};	811	const empty_slice: []u8 = &[_]u8{};
...	@@ -840,7 +824,6 @@ test "empty slice ptr is non null" {	...	@@ -840,7 +824,6 @@ test "empty slice ptr is non null" {
840	test "slice decays to many pointer" {	824	test "slice decays to many pointer" {
841	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	825	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
842	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	826	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
843	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
844		827
845	var buf: [8]u8 = "abcdefg\x00".*;	828	var buf: [8]u8 = "abcdefg\x00".*;
846	const p: [*:0]const u8 = buf[0..7 :0];	829	const p: [*:0]const u8 = buf[0..7 :0];
...	@@ -851,7 +834,6 @@ test "write through pointer to optional slice arg" {	...	@@ -851,7 +834,6 @@ test "write through pointer to optional slice arg" {
851	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	834	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
852	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	835	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
853	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	836	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
854	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
855		837
856	const S = struct {	838	const S = struct {
857	fn bar(foo: *?[]const u8) !void {	839	fn bar(foo: *?[]const u8) !void {
...	@@ -871,7 +853,6 @@ test "modify slice length at comptime" {	...	@@ -871,7 +853,6 @@ test "modify slice length at comptime" {
871	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	853	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
872	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	854	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
873	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;	855	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
874	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
875		856
876	const arr: [2]u8 = .{ 10, 20 };	857	const arr: [2]u8 = .{ 10, 20 };
877	comptime var s: []const u8 = arr[0..0];	858	comptime var s: []const u8 = arr[0..0];

Merge pull request #17293 from Snektron/spirv-aaaa

...	@@ -10,7 +10,6 @@ test "tuple concatenation" {	...	@@ -10,7 +10,6 @@ test "tuple concatenation" {
10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
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_sparc64) return error.SkipZigTest; // TODO	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14		13
15	const S = struct {	14	const S = struct {
16	fn doTheTest() !void {	15	fn doTheTest() !void {
...	@@ -269,7 +268,6 @@ test "tuple in tuple passed to generic function" {	...	@@ -269,7 +268,6 @@ test "tuple in tuple passed to generic function" {
269	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
270	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	269	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
271	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
272	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
273		271
274	const S = struct {	272	const S = struct {
275	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {	273	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {
...	@@ -310,8 +308,6 @@ test "tuple type with void field" {	...	@@ -310,8 +308,6 @@ test "tuple type with void field" {
310	}	308	}
311		309
312	test "zero sized struct in tuple handled correctly" {	310	test "zero sized struct in tuple handled correctly" {
313	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
314
315	const State = struct {	311	const State = struct {
316	const Self = @This();	312	const Self = @This();
317	data: @Type(.{	313	data: @Type(.{
...	@@ -351,7 +347,6 @@ test "branching inside tuple literal" {	...	@@ -351,7 +347,6 @@ test "branching inside tuple literal" {
351	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
352	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	348	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
353	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	349	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
354	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
355		350
356	const S = struct {	351	const S = struct {
357	fn foo(a: anytype) !void {	352	fn foo(a: anytype) !void {
...	@@ -366,7 +361,6 @@ test "tuple initialized with a runtime known value" {	...	@@ -366,7 +361,6 @@ test "tuple initialized with a runtime known value" {
366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	361	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
367	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	362	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
369	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
370		364
371	const E = union(enum) { e: []const u8 };	365	const E = union(enum) { e: []const u8 };
372	const W = union(enum) { w: E };	366	const W = union(enum) { w: E };
...	@@ -380,7 +374,6 @@ test "tuple of struct concatenation and coercion to array" {	...	@@ -380,7 +374,6 @@ test "tuple of struct concatenation and coercion to array" {
380	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	374	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
381	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;	375	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	376	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
383	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
384		377
385	const StructWithDefault = struct { value: f32 = 42 };	378	const StructWithDefault = struct { value: f32 = 42 };
386	const SomeStruct = struct { array: [4]StructWithDefault };	379	const SomeStruct = struct { array: [4]StructWithDefault };
...	@@ -395,7 +388,6 @@ test "nested runtime conditionals in tuple initializer" {	...	@@ -395,7 +388,6 @@ test "nested runtime conditionals in tuple initializer" {
395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	388	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
396	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	389	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
397	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
398	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
399		391
400	var data: u8 = 0;	392	var data: u8 = 0;
401	const x = .{	393	const x = .{
...	@@ -430,7 +422,6 @@ test "tuple pointer is indexable" {	...	@@ -430,7 +422,6 @@ test "tuple pointer is indexable" {
430	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
431	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	423	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
432	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	424	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
433	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
434		425
435	const S = struct { u32, bool };	426	const S = struct { u32, bool };
436		427
...	@@ -454,7 +445,6 @@ test "coerce anon tuple to tuple" {	...	@@ -454,7 +445,6 @@ test "coerce anon tuple to tuple" {
454	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	445	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
455	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	446	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
456	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	447	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
457	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
458		448
459	var x: u8 = 1;	449	var x: u8 = 1;
460	var y: u16 = 2;	450	var y: u16 = 2;

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

...	@@ -11,7 +11,6 @@ test "implicit cast vector to array - bool" {	...	@@ -11,7 +11,6 @@ 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;
15		14
16	const S = struct {	15	const S = struct {
17	fn doTheTest() !void {	16	fn doTheTest() !void {
...	@@ -29,7 +28,6 @@ test "vector wrap operators" {	...	@@ -29,7 +28,6 @@ test "vector wrap operators" {
29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
33	if (builtin.zig_backend == .stage2_x86_64 and	31	if (builtin.zig_backend == .stage2_x86_64 and
34	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO	32	!comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sse4_1)) return error.SkipZigTest; // TODO
35		33
...	@@ -54,7 +52,6 @@ test "vector bin compares with mem.eql" {	...	@@ -54,7 +52,6 @@ test "vector bin compares with mem.eql" {
54	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	52	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
55	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	53	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
58		55
59	const S = struct {	56	const S = struct {
60	fn doTheTest() !void {	57	fn doTheTest() !void {
...	@@ -124,7 +121,6 @@ test "vector bit operators" {	...	@@ -124,7 +121,6 @@ test "vector bit operators" {
124	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
125	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	122	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
128		124
129	const S = struct {	125	const S = struct {
130	fn doTheTest() !void {	126	fn doTheTest() !void {
...	@@ -143,7 +139,6 @@ test "implicit cast vector to array" {	...	@@ -143,7 +139,6 @@ test "implicit cast vector to array" {
143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	139	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
147		142
148	const S = struct {	143	const S = struct {
149	fn doTheTest() !void {	144	fn doTheTest() !void {
...	@@ -161,7 +156,6 @@ test "array to vector" {	...	@@ -161,7 +156,6 @@ test "array to vector" {
161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
164	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
165		159
166	const S = struct {	160	const S = struct {
167	fn doTheTest() !void {	161	fn doTheTest() !void {
...	@@ -286,7 +280,6 @@ test "vector casts of sizes not divisible by 8" {	...	@@ -286,7 +280,6 @@ test "vector casts of sizes not divisible by 8" {
286	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	280	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
287	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	281	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
288	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
289	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
290		283
291	const S = struct {	284	const S = struct {
292	fn doTheTest() !void {	285	fn doTheTest() !void {
...	@@ -367,7 +360,6 @@ test "load vector elements via comptime index" {	...	@@ -367,7 +360,6 @@ test "load vector elements via comptime index" {
367	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	360	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
368	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	361	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
369	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	362	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
370	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
371		363
372	const S = struct {	364	const S = struct {
373	fn doTheTest() !void {	365	fn doTheTest() !void {
...	@@ -389,7 +381,6 @@ test "store vector elements via comptime index" {	...	@@ -389,7 +381,6 @@ test "store vector elements via comptime index" {
389	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	381	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
390	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	382	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
391	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	383	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
392	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
393		384
394	const S = struct {	385	const S = struct {
395	fn doTheTest() !void {	386	fn doTheTest() !void {
...	@@ -417,7 +408,6 @@ test "load vector elements via runtime index" {	...	@@ -417,7 +408,6 @@ test "load vector elements via runtime index" {
417	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	408	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
418	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	409	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
420	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
421		411
422	const S = struct {	412	const S = struct {
423	fn doTheTest() !void {	413	fn doTheTest() !void {
...	@@ -439,7 +429,6 @@ test "store vector elements via runtime index" {	...	@@ -439,7 +429,6 @@ test "store vector elements via runtime index" {
439	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	429	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
440	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	430	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
441	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	431	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
442	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
443		432
444	const S = struct {	433	const S = struct {
445	fn doTheTest() !void {	434	fn doTheTest() !void {
...	@@ -462,7 +451,6 @@ test "initialize vector which is a struct field" {	...	@@ -462,7 +451,6 @@ test "initialize vector which is a struct field" {
462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	451	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
463	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	452	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
464	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	453	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
466		454
467	const Vec4Obj = struct {	455	const Vec4Obj = struct {
468	data: @Vector(4, f32),	456	data: @Vector(4, f32),
...	@@ -486,7 +474,6 @@ test "vector comparison operators" {	...	@@ -486,7 +474,6 @@ test "vector comparison operators" {
486	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	474	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
487	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	475	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	476	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
489	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
490		477
491	const S = struct {	478	const S = struct {
492	fn doTheTest() !void {	479	fn doTheTest() !void {
...	@@ -1168,7 +1155,6 @@ test "loading the second vector from a slice of vectors" {	...	@@ -1168,7 +1155,6 @@ test "loading the second vector from a slice of vectors" {
1168	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1156	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1171	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1172		1158
1173	@setRuntimeSafety(false);	1159	@setRuntimeSafety(false);
1174	var small_bases = [2]@Vector(2, u8){	1160	var small_bases = [2]@Vector(2, u8){
...	@@ -1185,7 +1171,6 @@ test "array of vectors is copied" {	...	@@ -1185,7 +1171,6 @@ test "array of vectors is copied" {
1185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1171	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1172	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1187	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1188	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1189		1174
1190	const Vec3 = @Vector(3, i32);	1175	const Vec3 = @Vector(3, i32);
1191	var points = [_]Vec3{	1176	var points = [_]Vec3{
...	@@ -1256,7 +1241,6 @@ test "zero multiplicand" {	...	@@ -1256,7 +1241,6 @@ test "zero multiplicand" {
1256	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1259	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1260		1244
1261	const zeros = @Vector(2, u32){ 0.0, 0.0 };	1245	const zeros = @Vector(2, u32){ 0.0, 0.0 };
1262	var ones = @Vector(2, u32){ 1.0, 1.0 };	1246	var ones = @Vector(2, u32){ 1.0, 1.0 };
...	@@ -1317,7 +1301,6 @@ test "load packed vector element" {	...	@@ -1317,7 +1301,6 @@ test "load packed vector element" {
1317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1302	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1319	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1303	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1320	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1321	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1304	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1322	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	1305	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1323		1306
...	@@ -1348,7 +1331,6 @@ test "store to vector in slice" {	...	@@ -1348,7 +1331,6 @@ test "store to vector in slice" {
1348	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1331	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1349	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	1332	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1350	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1333	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1351	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1352		1334
1353	var v = [_]@Vector(3, f32){	1335	var v = [_]@Vector(3, f32){
1354	.{ 1, 1, 1 },	1336	.{ 1, 1, 1 },
...	@@ -1412,7 +1394,6 @@ test "store vector with memset" {	...	@@ -1412,7 +1394,6 @@ test "store vector with memset" {
1412	test "addition of vectors represented as strings" {	1394	test "addition of vectors represented as strings" {
1413	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1414	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1396	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1415	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1416		1397
1417	const V = @Vector(3, u8);	1398	const V = @Vector(3, u8);
1418	const foo: V = "foo".*;	1399	const foo: V = "foo".*;
...	@@ -1438,7 +1419,6 @@ test "vector pointer is indexable" {	...	@@ -1438,7 +1419,6 @@ test "vector pointer is indexable" {
1438	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1419	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1439	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1420	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1440	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1421	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1441	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1442		1422
1443	const V = @Vector(2, u32);	1423	const V = @Vector(2, u32);
1444		1424
...	@@ -1479,7 +1459,6 @@ test "bitcast to vector with different child type" {	...	@@ -1479,7 +1459,6 @@ test "bitcast to vector with different child type" {
1479	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1459	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1480	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1460	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1481	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1461	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1482	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
1483		1462
1484	const S = struct {	1463	const S = struct {
1485	fn doTheTest() !void {	1464	fn doTheTest() !void {