Commit 309aacfc8993ff4ec5914a7ee2c487eabbe00998 | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-07-01 14:21:04-07:00
committer	GitHub <noreply@github.com> 2023-07-01 14:21:04-07:00
log	309aacfc8993ff4ec5914a7ee2c487eabbe00998
tree	febc13c372a0fb6c4a237e065a7e00575046339a
parent	8f14431bc883898aaf78cc985e2d90716187e882
parent	073289d0dadfd1ea0088837563a109100b065ed3
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #16284 from Snektron/spirv-internpool-fixes

SPIR-V InternPool aftermath damage control

9 files changed, 189 insertions(+), 101 deletions(-)

lib
- std
  - builtin.zig
  - testing.zig
src
- codegen
  - spirv.zig
test
- behavior

lib/std/builtin.zig+2-1

...	...	@@ -741,7 +741,8 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
741	741	builtin.zig_backend == .stage2_x86_64 or
742	742	builtin.zig_backend == .stage2_x86 or
743	743	builtin.zig_backend == .stage2_riscv64 or
744		builtin.zig_backend == .stage2_sparc64)
	744	builtin.zig_backend == .stage2_sparc64 or
	745	builtin.zig_backend == .stage2_spirv64)
745	746	{
746	747	while (true) {
747	748	@breakpoint();

lib/std/testing.zig+50-44

...	...	@@ -2,7 +2,6 @@ const std = @import("std.zig");
2	2	const builtin = @import("builtin");
3	3
4	4	const math = std.math;
5		const print = std.debug.print;
6	5
7	6	pub const FailingAllocator = @import("testing/failing_allocator.zig").FailingAllocator;
8	7
...	...	@@ -22,15 +21,22 @@ pub var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
22	21	/// TODO https://github.com/ziglang/zig/issues/5738
23	22	pub var log_level = std.log.Level.warn;
24	23
	24	fn print(comptime fmt: []const u8, args: anytype) void {
	25	// Disable printing in tests for simple backends.
	26	if (builtin.zig_backend == .stage2_spirv64) return;
	27
	28	std.debug.print(fmt, args);
	29	}
	30
25	31	/// This function is intended to be used only in tests. It prints diagnostics to stderr
26	32	/// and then returns a test failure error when actual_error_union is not expected_error.
27	33	pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
28	34	if (actual_error_union) \|actual_payload\| {
29		std.debug.print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
	35	print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
30	36	return error.TestUnexpectedError;
31	37	} else \|actual_error\| {
32	38	if (expected_error != actual_error) {
33		std.debug.print("expected error.{s}, found error.{s}\n", .{
	39	print("expected error.{s}, found error.{s}\n", .{
34	40	@errorName(expected_error),
35	41	@errorName(actual_error),
36	42	});
...	...	@@ -58,7 +64,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
58	64
59	65	.Type => {
60	66	if (actual != expected) {
61		std.debug.print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
	67	print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
62	68	return error.TestExpectedEqual;
63	69	}
64	70	},
...	...	@@ -74,7 +80,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
74	80	.ErrorSet,
75	81	=> {
76	82	if (actual != expected) {
77		std.debug.print("expected {}, found {}\n", .{ expected, actual });
	83	print("expected {}, found {}\n", .{ expected, actual });
78	84	return error.TestExpectedEqual;
79	85	}
80	86	},
...	...	@@ -83,17 +89,17 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
83	89	switch (pointer.size) {
84	90	.One, .Many, .C => {
85	91	if (actual != expected) {
86		std.debug.print("expected {}, found {}\n", .{ expected, actual });
	92	print("expected {}, found {}\n", .{ expected, actual });
87	93	return error.TestExpectedEqual;
88	94	}
89	95	},
90	96	.Slice => {
91	97	if (actual.ptr != expected.ptr) {
92		std.debug.print("expected slice ptr {}, found {}\n", .{ expected.ptr, actual.ptr });
	98	print("expected slice ptr {}, found {}\n", .{ expected.ptr, actual.ptr });
93	99	return error.TestExpectedEqual;
94	100	}
95	101	if (actual.len != expected.len) {
96		std.debug.print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
	102	print("expected slice len {}, found {}\n", .{ expected.len, actual.len });
97	103	return error.TestExpectedEqual;
98	104	}
99	105	},
...	...	@@ -106,7 +112,7 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
106	112	var i: usize = 0;
107	113	while (i < info.len) : (i += 1) {
108	114	if (!std.meta.eql(expected[i], actual[i])) {
109		std.debug.print("index {} incorrect. expected {}, found {}\n", .{
	115	print("index {} incorrect. expected {}, found {}\n", .{
110	116	i, expected[i], actual[i],
111	117	});
112	118	return error.TestExpectedEqual;
...	...	@@ -151,12 +157,12 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
151	157	if (actual) \|actual_payload\| {
152	158	try expectEqual(expected_payload, actual_payload);
153	159	} else {
154		std.debug.print("expected {any}, found null\n", .{expected_payload});
	160	print("expected {any}, found null\n", .{expected_payload});
155	161	return error.TestExpectedEqual;
156	162	}
157	163	} else {
158	164	if (actual) \|actual_payload\| {
159		std.debug.print("expected null, found {any}\n", .{actual_payload});
	165	print("expected null, found {any}\n", .{actual_payload});
160	166	return error.TestExpectedEqual;
161	167	}
162	168	}
...	...	@@ -167,12 +173,12 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) !void {
167	173	if (actual) \|actual_payload\| {
168	174	try expectEqual(expected_payload, actual_payload);
169	175	} else \|actual_err\| {
170		std.debug.print("expected {any}, found {}\n", .{ expected_payload, actual_err });
	176	print("expected {any}, found {}\n", .{ expected_payload, actual_err });
171	177	return error.TestExpectedEqual;
172	178	}
173	179	} else \|expected_err\| {
174	180	if (actual) \|actual_payload\| {
175		std.debug.print("expected {}, found {any}\n", .{ expected_err, actual_payload });
	181	print("expected {}, found {any}\n", .{ expected_err, actual_payload });
176	182	return error.TestExpectedEqual;
177	183	} else \|actual_err\| {
178	184	try expectEqual(expected_err, actual_err);
...	...	@@ -219,7 +225,7 @@ pub fn expectApproxEqAbs(expected: anytype, actual: @TypeOf(expected), tolerance
219	225
220	226	switch (@typeInfo(T)) {
221	227	.Float => if (!math.approxEqAbs(T, expected, actual, tolerance)) {
222		std.debug.print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
	228	print("actual {}, not within absolute tolerance {} of expected {}\n", .{ actual, tolerance, expected });
223	229	return error.TestExpectedApproxEqAbs;
224	230	},
225	231
...	...	@@ -251,7 +257,7 @@ pub fn expectApproxEqRel(expected: anytype, actual: @TypeOf(expected), tolerance
251	257
252	258	switch (@typeInfo(T)) {
253	259	.Float => if (!math.approxEqRel(T, expected, actual, tolerance)) {
254		std.debug.print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
	260	print("actual {}, not within relative tolerance {} of expected {}\n", .{ actual, tolerance, expected });
255	261	return error.TestExpectedApproxEqRel;
256	262	},
257	263
...	...	@@ -294,7 +300,7 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
294	300	break :diff_index if (expected.len == actual.len) return else shortest;
295	301	};
296	302
297		std.debug.print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
	303	print("slices differ. first difference occurs at index {d} (0x{X})\n", .{ diff_index, diff_index });
298	304
299	305	// TODO: Should this be configurable by the caller?
300	306	const max_lines: usize = 16;
...	...	@@ -329,12 +335,12 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
329	335	// that is usually useful.
330	336	const index_fmt = if (T == u8) "0x{X}" else "{}";
331	337
332		std.debug.print("\n============ expected this output: ============= len: {} (0x{X})\n\n", .{ expected.len, expected.len });
	338	print("\n============ expected this output: ============= len: {} (0x{X})\n\n", .{ expected.len, expected.len });
333	339	if (window_start > 0) {
334	340	if (T == u8) {
335		std.debug.print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
	341	print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
336	342	} else {
337		std.debug.print("... truncated ...\n", .{});
	343	print("... truncated ...\n", .{});
338	344	}
339	345	}
340	346	differ.write(stderr.writer()) catch {};
...	...	@@ -342,21 +348,21 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
342	348	const end_offset = window_start + expected_window.len;
343	349	const num_missing_items = expected.len - (window_start + expected_window.len);
344	350	if (T == u8) {
345		std.debug.print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
	351	print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
346	352	} else {
347		std.debug.print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
	353	print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
348	354	}
349	355	}
350	356
351	357	// now reverse expected/actual and print again
352	358	differ.expected = actual_window;
353	359	differ.actual = expected_window;
354		std.debug.print("\n============= instead found this: ============== len: {} (0x{X})\n\n", .{ actual.len, actual.len });
	360	print("\n============= instead found this: ============== len: {} (0x{X})\n\n", .{ actual.len, actual.len });
355	361	if (window_start > 0) {
356	362	if (T == u8) {
357		std.debug.print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
	363	print("... truncated, start index: " ++ index_fmt ++ " ...\n", .{window_start});
358	364	} else {
359		std.debug.print("... truncated ...\n", .{});
	365	print("... truncated ...\n", .{});
360	366	}
361	367	}
362	368	differ.write(stderr.writer()) catch {};
...	...	@@ -364,12 +370,12 @@ pub fn expectEqualSlices(comptime T: type, expected: []const T, actual: []const
364	370	const end_offset = window_start + actual_window.len;
365	371	const num_missing_items = actual.len - (window_start + actual_window.len);
366	372	if (T == u8) {
367		std.debug.print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
	373	print("... truncated, indexes [" ++ index_fmt ++ "..] not shown, remaining bytes: " ++ index_fmt ++ " ...\n", .{ end_offset, num_missing_items });
368	374	} else {
369		std.debug.print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
	375	print("... truncated, remaining items: " ++ index_fmt ++ " ...\n", .{num_missing_items});
370	376	}
371	377	}
372		std.debug.print("\n================================================\n\n", .{});
	378	print("\n================================================\n\n", .{});
373	379
374	380	return error.TestExpectedEqual;
375	381	}
...	...	@@ -493,12 +499,12 @@ pub fn expectEqualSentinel(comptime T: type, comptime sentinel: T, expected: [:s
493	499	};
494	500
495	501	if (!std.meta.eql(sentinel, expected_value_sentinel)) {
496		std.debug.print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
	502	print("expectEqualSentinel: 'expected' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, expected_value_sentinel });
497	503	return error.TestExpectedEqual;
498	504	}
499	505
500	506	if (!std.meta.eql(sentinel, actual_value_sentinel)) {
501		std.debug.print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
	507	print("expectEqualSentinel: 'actual' sentinel in memory is different from its type sentinel. type sentinel {}, in memory sentinel {}\n", .{ sentinel, actual_value_sentinel });
502	508	return error.TestExpectedEqual;
503	509	}
504	510	}
...	...	@@ -697,7 +703,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
697	703
698	704	.Type => {
699	705	if (actual != expected) {
700		std.debug.print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
	706	print("expected type {s}, found type {s}\n", .{ @typeName(expected), @typeName(actual) });
701	707	return error.TestExpectedEqual;
702	708	}
703	709	},
...	...	@@ -713,7 +719,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
713	719	.ErrorSet,
714	720	=> {
715	721	if (actual != expected) {
716		std.debug.print("expected {}, found {}\n", .{ expected, actual });
	722	print("expected {}, found {}\n", .{ expected, actual });
717	723	return error.TestExpectedEqual;
718	724	}
719	725	},
...	...	@@ -723,7 +729,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
723	729	// We have no idea what is behind those pointers, so the best we can do is `==` check.
724	730	.C, .Many => {
725	731	if (actual != expected) {
726		std.debug.print("expected {}, found {}\n", .{ expected, actual });
	732	print("expected {}, found {}\n", .{ expected, actual });
727	733	return error.TestExpectedEqual;
728	734	}
729	735	},
...	...	@@ -732,7 +738,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
732	738	switch (@typeInfo(pointer.child)) {
733	739	.Fn, .Opaque => {
734	740	if (actual != expected) {
735		std.debug.print("expected {}, found {}\n", .{ expected, actual });
	741	print("expected {}, found {}\n", .{ expected, actual });
736	742	return error.TestExpectedEqual;
737	743	}
738	744	},
...	...	@@ -741,13 +747,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
741	747	},
742	748	.Slice => {
743	749	if (expected.len != actual.len) {
744		std.debug.print("Slice len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
	750	print("Slice len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
745	751	return error.TestExpectedEqual;
746	752	}
747	753	var i: usize = 0;
748	754	while (i < expected.len) : (i += 1) {
749	755	expectEqualDeep(expected[i], actual[i]) catch \|e\| {
750		std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
	756	print("index {d} incorrect. expected {any}, found {any}\n", .{
751	757	i, expected[i], actual[i],
752	758	});
753	759	return e;
...	...	@@ -759,13 +765,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
759	765
760	766	.Array => \|_\| {
761	767	if (expected.len != actual.len) {
762		std.debug.print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
	768	print("Array len not the same, expected {d}, found {d}\n", .{ expected.len, actual.len });
763	769	return error.TestExpectedEqual;
764	770	}
765	771	var i: usize = 0;
766	772	while (i < expected.len) : (i += 1) {
767	773	expectEqualDeep(expected[i], actual[i]) catch \|e\| {
768		std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
	774	print("index {d} incorrect. expected {any}, found {any}\n", .{
769	775	i, expected[i], actual[i],
770	776	});
771	777	return e;
...	...	@@ -775,13 +781,13 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
775	781
776	782	.Vector => \|info\| {
777	783	if (info.len != @typeInfo(@TypeOf(actual)).Vector.len) {
778		std.debug.print("Vector len not the same, expected {d}, found {d}\n", .{ info.len, @typeInfo(@TypeOf(actual)).Vector.len });
	784	print("Vector len not the same, expected {d}, found {d}\n", .{ info.len, @typeInfo(@TypeOf(actual)).Vector.len });
779	785	return error.TestExpectedEqual;
780	786	}
781	787	var i: usize = 0;
782	788	while (i < info.len) : (i += 1) {
783	789	expectEqualDeep(expected[i], actual[i]) catch \|e\| {
784		std.debug.print("index {d} incorrect. expected {any}, found {any}\n", .{
	790	print("index {d} incorrect. expected {any}, found {any}\n", .{
785	791	i, expected[i], actual[i],
786	792	});
787	793	return e;
...	...	@@ -792,7 +798,7 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
792	798	.Struct => \|structType\| {
793	799	inline for (structType.fields) \|field\| {
794	800	expectEqualDeep(@field(expected, field.name), @field(actual, field.name)) catch \|e\| {
795		std.debug.print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
	801	print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
796	802	return e;
797	803	};
798	804	}
...	...	@@ -823,12 +829,12 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
823	829	if (actual) \|actual_payload\| {
824	830	try expectEqualDeep(expected_payload, actual_payload);
825	831	} else {
826		std.debug.print("expected {any}, found null\n", .{expected_payload});
	832	print("expected {any}, found null\n", .{expected_payload});
827	833	return error.TestExpectedEqual;
828	834	}
829	835	} else {
830	836	if (actual) \|actual_payload\| {
831		std.debug.print("expected null, found {any}\n", .{actual_payload});
	837	print("expected null, found {any}\n", .{actual_payload});
832	838	return error.TestExpectedEqual;
833	839	}
834	840	}
...	...	@@ -839,12 +845,12 @@ pub fn expectEqualDeep(expected: anytype, actual: @TypeOf(expected)) !void {
839	845	if (actual) \|actual_payload\| {
840	846	try expectEqualDeep(expected_payload, actual_payload);
841	847	} else \|actual_err\| {
842		std.debug.print("expected {any}, found {any}\n", .{ expected_payload, actual_err });
	848	print("expected {any}, found {any}\n", .{ expected_payload, actual_err });
843	849	return error.TestExpectedEqual;
844	850	}
845	851	} else \|expected_err\| {
846	852	if (actual) \|actual_payload\| {
847		std.debug.print("expected {any}, found {any}\n", .{ expected_err, actual_payload });
	853	print("expected {any}, found {any}\n", .{ expected_err, actual_payload });
848	854	return error.TestExpectedEqual;
849	855	} else \|actual_err\| {
850	856	try expectEqualDeep(expected_err, actual_err);

src/codegen/spirv.zig+124-56

...	...	@@ -537,6 +537,12 @@ pub const DeclGen = struct {
537	537
538	538	fn addInt(self: *@This(), ty: Type, val: Value) !void {
539	539	const mod = self.dg.module;
	540	const len = ty.abiSize(mod);
	541	if (val.isUndef(mod)) {
	542	try self.addUndef(len);
	543	return;
	544	}
	545
540	546	const int_info = ty.intInfo(mod);
541	547	const int_bits = switch (int_info.signedness) {
542	548	.signed => @as(u64, @bitCast(val.toSignedInt(mod))),
...	...	@@ -544,7 +550,6 @@ pub const DeclGen = struct {
544	550	};
545	551
546	552	// TODO: Swap endianess if the compiler is big endian.
547		const len = ty.abiSize(mod);
548	553	try self.addBytes(std.mem.asBytes(&int_bits)[0..@as(usize, @intCast(len))]);
549	554	}
550	555
...	...	@@ -667,31 +672,41 @@ pub const DeclGen = struct {
667	672	try self.addConstInt(u16, @as(u16, @intCast(int)));
668	673	},
669	674	.error_union => \|error_union\| {
	675	const err_ty = switch (error_union.val) {
	676	.err_name => ty.errorUnionSet(mod),
	677	.payload => Type.err_int,
	678	};
	679	const err_val = switch (error_union.val) {
	680	.err_name => \|err_name\| (try mod.intern(.{ .err = .{
	681	.ty = ty.errorUnionSet(mod).toIntern(),
	682	.name = err_name,
	683	} })).toValue(),
	684	.payload => try mod.intValue(Type.err_int, 0),
	685	};
670	686	const payload_ty = ty.errorUnionPayload(mod);
671		const is_pl = val.errorUnionIsPayload(mod);
672		const error_val = if (!is_pl) val else try mod.intValue(Type.anyerror, 0);
673
674	687	const eu_layout = dg.errorUnionLayout(payload_ty);
675	688	if (!eu_layout.payload_has_bits) {
676		return try self.lower(Type.anyerror, error_val);
	689	// We use the error type directly as the type.
	690	try self.lower(err_ty, err_val);
	691	return;
677	692	}
678	693
679	694	const payload_size = payload_ty.abiSize(mod);
680		const error_size = Type.anyerror.abiAlignment(mod);
	695	const error_size = err_ty.abiSize(mod);
681	696	const ty_size = ty.abiSize(mod);
682	697	const padding = ty_size - payload_size - error_size;
683	698
684	699	const payload_val = switch (error_union.val) {
685		.err_name => try mod.intern(.{ .undef = payload_ty.ip_index }),
	700	.err_name => try mod.intern(.{ .undef = payload_ty.toIntern() }),
686	701	.payload => \|payload\| payload,
687	702	}.toValue();
688	703
689	704	if (eu_layout.error_first) {
690		try self.lower(Type.anyerror, error_val);
	705	try self.lower(err_ty, err_val);
691	706	try self.lower(payload_ty, payload_val);
692	707	} else {
693	708	try self.lower(payload_ty, payload_val);
694		try self.lower(Type.anyerror, error_val);
	709	try self.lower(err_ty, err_val);
695	710	}
696	711
697	712	try self.addUndef(padding);
...	...	@@ -705,9 +720,14 @@ pub const DeclGen = struct {
705	720	},
706	721	.float => try self.addFloat(ty, val),
707	722	.ptr => \|ptr\| {
	723	const ptr_ty = switch (ptr.len) {
	724	.none => ty,
	725	else => ty.slicePtrFieldType(mod),
	726	};
708	727	switch (ptr.addr) {
709		.decl => \|decl\| try self.addDeclRef(ty, decl),
710		.mut_decl => \|mut_decl\| try self.addDeclRef(ty, mut_decl.decl),
	728	.decl => \|decl\| try self.addDeclRef(ptr_ty, decl),
	729	.mut_decl => \|mut_decl\| try self.addDeclRef(ptr_ty, mut_decl.decl),
	730	.int => \|int\| try self.addInt(Type.usize, int.toValue()),
711	731	else => \|tag\| return dg.todo("pointer value of type {s}", .{@tagName(tag)}),
712	732	}
713	733	if (ptr.len != .none) {
...	...	@@ -979,38 +999,84 @@ pub const DeclGen = struct {
979	999	/// the constant is more complicated however, it needs to be lowered to an indirect constant, which
980	1000	/// is then loaded using OpLoad. Such values are loaded into the UniformConstant storage class by default.
981	1001	/// This function should only be called during function code generation.
982		fn constant(self: *DeclGen, ty: Type, val: Value, repr: Repr) !IdRef {
	1002	fn constant(self: *DeclGen, ty: Type, arg_val: Value, repr: Repr) !IdRef {
983	1003	const mod = self.module;
984	1004	const target = self.getTarget();
985	1005	const result_ty_ref = try self.resolveType(ty, repr);
986	1006
987		log.debug("constant: ty = {}, val = {}", .{ ty.fmt(self.module), val.fmtValue(ty, self.module) });
	1007	var val = arg_val;
	1008	switch (mod.intern_pool.indexToKey(val.toIntern())) {
	1009	.runtime_value => \|rt\| val = rt.val.toValue(),
	1010	else => {},
	1011	}
988	1012
	1013	log.debug("constant: ty = {}, val = {}", .{ ty.fmt(self.module), val.fmtValue(ty, self.module) });
989	1014	if (val.isUndef(mod)) {
990	1015	return self.spv.constUndef(result_ty_ref);
991	1016	}
992	1017
993		switch (ty.zigTypeTag(mod)) {
994		.Int => {
	1018	switch (mod.intern_pool.indexToKey(val.toIntern())) {
	1019	.int_type,
	1020	.ptr_type,
	1021	.array_type,
	1022	.vector_type,
	1023	.opt_type,
	1024	.anyframe_type,
	1025	.error_union_type,
	1026	.simple_type,
	1027	.struct_type,
	1028	.anon_struct_type,
	1029	.union_type,
	1030	.opaque_type,
	1031	.enum_type,
	1032	.func_type,
	1033	.error_set_type,
	1034	.inferred_error_set_type,
	1035	=> unreachable, // types, not values
	1036
	1037	.undef => unreachable, // handled above
	1038	.runtime_value => unreachable, // ???
	1039
	1040	.variable,
	1041	.extern_func,
	1042	.func,
	1043	.enum_literal,
	1044	.empty_enum_value,
	1045	=> unreachable, // non-runtime values
	1046
	1047	.simple_value => \|simple_value\| switch (simple_value) {
	1048	.undefined,
	1049	.void,
	1050	.null,
	1051	.empty_struct,
	1052	.@"unreachable",
	1053	.generic_poison,
	1054	=> unreachable, // non-runtime values
	1055
	1056	.false, .true => switch (repr) {
	1057	.direct => return try self.spv.constBool(result_ty_ref, val.toBool()),
	1058	.indirect => return try self.spv.constInt(result_ty_ref, @intFromBool(val.toBool())),
	1059	},
	1060	},
	1061
	1062	.int => {
995	1063	if (ty.isSignedInt(mod)) {
996	1064	return try self.spv.constInt(result_ty_ref, val.toSignedInt(mod));
997	1065	} else {
998	1066	return try self.spv.constInt(result_ty_ref, val.toUnsignedInt(mod));
999	1067	}
1000	1068	},
1001		.Bool => switch (repr) {
1002		.direct => return try self.spv.constBool(result_ty_ref, val.toBool()),
1003		.indirect => return try self.spv.constInt(result_ty_ref, @intFromBool(val.toBool())),
1004		},
1005		.Float => return switch (ty.floatBits(target)) {
	1069	.float => return switch (ty.floatBits(target)) {
1006	1070	16 => try self.spv.resolveId(.{ .float = .{ .ty = result_ty_ref, .value = .{ .float16 = val.toFloat(f16, mod) } } }),
1007	1071	32 => try self.spv.resolveId(.{ .float = .{ .ty = result_ty_ref, .value = .{ .float32 = val.toFloat(f32, mod) } } }),
1008	1072	64 => try self.spv.resolveId(.{ .float = .{ .ty = result_ty_ref, .value = .{ .float64 = val.toFloat(f64, mod) } } }),
1009	1073	80, 128 => unreachable, // TODO
1010	1074	else => unreachable,
1011	1075	},
1012		.ErrorSet => @panic("TODO"),
1013		.ErrorUnion => @panic("TODO"),
	1076	.err => \|err\| {
	1077	const value = try mod.getErrorValue(err.name);
	1078	return try self.spv.constInt(result_ty_ref, value);
	1079	},
1014	1080	// TODO: We can handle most pointers here (decl refs etc), because now they emit an extra
1015	1081	// OpVariable that is not really required.
1016	1082	else => {
...	...	@@ -1263,51 +1329,53 @@ pub const DeclGen = struct {
1263	1329	} });
1264	1330	},
1265	1331	.Struct => {
1266		const struct_ty = mod.typeToStruct(ty).?;
1267		const fields = struct_ty.fields.values();
1268
1269		if (ty.isSimpleTupleOrAnonStruct(mod)) {
1270		const member_types = try self.gpa.alloc(CacheRef, fields.len);
1271		defer self.gpa.free(member_types);
	1332	const struct_ty = switch (mod.intern_pool.indexToKey(ty.toIntern())) {
	1333	.anon_struct_type => \|tuple\| {
	1334	const member_types = try self.gpa.alloc(CacheRef, tuple.values.len);
	1335	defer self.gpa.free(member_types);
1272	1336
1273		var member_index: usize = 0;
1274		for (fields) \|field\| {
1275		if (field.ty.ip_index != .unreachable_value or !field.ty.hasRuntimeBits(mod)) continue;
	1337	var member_index: usize = 0;
	1338	for (tuple.types, tuple.values) \|field_ty, field_val\| {
	1339	if (field_val != .none or !field_ty.toType().hasRuntimeBits(mod)) continue;
1276	1340
1277		member_types[member_index] = try self.resolveType(field.ty, .indirect);
1278		member_index += 1;
1279		}
	1341	member_types[member_index] = try self.resolveType(field_ty.toType(), .indirect);
	1342	member_index += 1;
	1343	}
1280	1344
1281		return try self.spv.resolve(.{ .struct_type = .{
1282		.member_types = member_types[0..member_index],
1283		} });
1284		}
	1345	return try self.spv.resolve(.{ .struct_type = .{
	1346	.member_types = member_types[0..member_index],
	1347	} });
	1348	},
	1349	.struct_type => \|struct_ty\| struct_ty,
	1350	else => unreachable,
	1351	};
1285	1352
1286		if (struct_ty.layout == .Packed) {
1287		return try self.resolveType(struct_ty.backing_int_ty, .direct);
	1353	const struct_obj = mod.structPtrUnwrap(struct_ty.index).?;
	1354	if (struct_obj.layout == .Packed) {
	1355	return try self.resolveType(struct_obj.backing_int_ty, .direct);
1288	1356	}
1289	1357
1290		const member_types = try self.gpa.alloc(CacheRef, fields.len);
1291		defer self.gpa.free(member_types);
1292
1293		const member_names = try self.gpa.alloc(CacheString, fields.len);
1294		defer self.gpa.free(member_names);
	1358	var member_types = std.ArrayList(CacheRef).init(self.gpa);
	1359	defer member_types.deinit();
1295	1360
1296		var member_index: usize = 0;
1297		for (fields, 0..) \|field, i\| {
1298		if (field.is_comptime or !field.ty.hasRuntimeBits(mod)) continue;
	1361	var member_names = std.ArrayList(CacheString).init(self.gpa);
	1362	defer member_names.deinit();
1299	1363
1300		member_types[member_index] = try self.resolveType(field.ty, .indirect);
1301		member_names[member_index] = try self.spv.resolveString(mod.intern_pool.stringToSlice(struct_ty.fields.keys()[i]));
1302		member_index += 1;
	1364	var it = struct_obj.runtimeFieldIterator(mod);
	1365	while (it.next()) \|field_and_index\| {
	1366	const field = field_and_index.field;
	1367	const index = field_and_index.index;
	1368	const field_name = mod.intern_pool.stringToSlice(struct_obj.fields.keys()[index]);
	1369	try member_types.append(try self.resolveType(field.ty, .indirect));
	1370	try member_names.append(try self.spv.resolveString(field_name));
1303	1371	}
1304	1372
1305		const name = mod.intern_pool.stringToSlice(try struct_ty.getFullyQualifiedName(self.module));
	1373	const name = mod.intern_pool.stringToSlice(try struct_obj.getFullyQualifiedName(self.module));
1306	1374
1307	1375	return try self.spv.resolve(.{ .struct_type = .{
1308	1376	.name = try self.spv.resolveString(name),
1309		.member_types = member_types[0..member_index],
1310		.member_names = member_names[0..member_index],
	1377	.member_types = member_types.items,
	1378	.member_names = member_names.items,
1311	1379	} });
1312	1380	},
1313	1381	.Optional => {
...	...	@@ -2512,9 +2580,9 @@ pub const DeclGen = struct {
2512	2580	// just an element.
2513	2581	var elem_ptr_info = ptr_ty.ptrInfo(mod);
2514	2582	elem_ptr_info.flags.size = .One;
2515		const elem_ptr_ty = elem_ptr_info.child.toType();
	2583	const elem_ptr_ty = try mod.intern_pool.get(mod.gpa, .{ .ptr_type = elem_ptr_info });
2516	2584
2517		return try self.load(elem_ptr_ty, elem_ptr_id);
	2585	return try self.load(elem_ptr_ty.toType(), elem_ptr_id);
2518	2586	}
2519	2587
2520	2588	fn airGetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {

test/behavior/c_char_signedness.zig+3

...	...	@@ -1,10 +1,13 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expectEqual = std.testing.expectEqual;
3	4	const c = @cImport({
4	5	@cInclude("limits.h");
5	6	});
6	7
7	8	test "c_char signedness" {
	9	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	10
8	11	try expectEqual(@as(c_char, c.CHAR_MIN), std.math.minInt(c_char));
9	12	try expectEqual(@as(c_char, c.CHAR_MAX), std.math.maxInt(c_char));
10	13	}

test/behavior/call.zig+2

...	...	@@ -417,6 +417,8 @@ test "inline while with @call" {
417	417	}
418	418
419	419	test "method call as parameter type" {
	420	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	421
420	422	const S = struct {
421	423	fn foo(x: anytype, y: @TypeOf(x).Inner()) @TypeOf(y) {
422	424	return y;

test/behavior/comptime_memory.zig+2

...	...	@@ -433,6 +433,8 @@ test "dereference undefined pointer to zero-bit type" {
433	433	}
434	434
435	435	test "type pun extern struct" {
	436	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	437
436	438	const S = extern struct { f: u8 };
437	439	comptime var s = S{ .f = 123 };
438	440	@as(u8, @ptrCast(&s)). = 72;

test/behavior/enum.zig+2

...	...	@@ -1199,6 +1199,8 @@ test "enum tag from a local variable" {
1199	1199	}
1200	1200
1201	1201	test "auto-numbered enum with signed tag type" {
	1202	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	1203
1202	1204	const E = enum(i32) { a, b };
1203	1205
1204	1206	try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a));

test/behavior/maximum_minimum.zig+2

...	...	@@ -297,6 +297,8 @@ test "@min/@max notices bounds from vector types when element of comptime-known
297	297	}
298	298
299	299	test "@min/@max of signed and unsigned runtime integers" {
	300	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
	301
300	302	var x: i32 = -1;
301	303	var y: u31 = 1;
302	304

test/behavior/ptrfromint.zig+2

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