Commit b27c56fe5087872800f6b340ec3d1fc219d0d77b | zig

lib/std/zig/target.zig+7-4

...	...	@@ -519,10 +519,13 @@ pub fn intAlignment(target: *const std.Target, bits: u16) u16 {
519	519	33...64 => 8,
520	520	else => 16,
521	521	},
522		else => return @min(
523		std.math.ceilPowerOfTwoPromote(u16, @as(u16, @intCast((@as(u17, bits) + 7) / 8))),
524		target.cMaxIntAlignment(),
525		),
	522	else => switch (bits) {
	523	0 => 1,
	524	else => @min(
	525	std.math.ceilPowerOfTwoPromote(u16, @intCast((@as(u17, bits) + 7) / 8)),
	526	target.cMaxIntAlignment(),
	527	),
	528	},
526	529	};
527	530	}
528	531

src/codegen/aarch64/Select.zig+37-52

...	...	@@ -2791,9 +2791,9 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2791	2791	} else return isel.fail("invalid constraint: '{s}'", .{constraint});
2792	2792	}
2793	2793
2794		const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers);
	2794	const clobbers_val: Constant = .fromInterned(unwrapped_asm.clobbers);
2795	2795	const clobbers_ty = clobbers_val.typeOf(zcu);
2796		var clobbers_bigint_buf: Value.BigIntSpace = undefined;
	2796	var clobbers_bigint_buf: Constant.BigIntSpace = undefined;
2797	2797	const clobbers_bigint = clobbers_val.toBigInt(&clobbers_bigint_buf, zcu);
2798	2798	for (0..clobbers_ty.structFieldCount(zcu)) \|field_index\| {
2799	2799	assert(clobbers_ty.fieldType(field_index, zcu).toIntern() == .bool_type);
...	...	@@ -2818,7 +2818,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2818	2818	for (0..clobbers_ty.structFieldCount(zcu)) \|field_index\| {
2819	2819	const limb_bits = @bitSizeOf(std.math.big.Limb);
2820	2820	if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
2821		switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
	2821	switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
2822	2822	0 => continue, // field is false
2823	2823	1 => {}, // field is true
2824	2824	}
...	...	@@ -2871,7 +2871,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2871	2871	for (0..clobbers_ty.structFieldCount(zcu)) \|field_index\| {
2872	2872	const limb_bits = @bitSizeOf(std.math.big.Limb);
2873	2873	if (field_index / limb_bits >= clobbers_bigint.limbs.len) continue; // field is false
2874		switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> field_index % limb_bits))) {
	2874	switch (@as(u1, @truncate(clobbers_bigint.limbs[field_index / limb_bits] >> @intCast(field_index % limb_bits)))) {
2875	2875	0 => continue, // field is false
2876	2876	1 => {}, // field is true
2877	2877	}
...	...	@@ -3283,8 +3283,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
3283	3283	} else if (dst_ty.isSliceAtRuntime(zcu) and src_ty.isSliceAtRuntime(zcu)) {
3284	3284	try dst_vi.value.move(isel, ty_op.operand);
3285	3285	} else if (dst_tag == .error_union and src_tag == .error_union) {
3286		assert(dst_ty.errorUnionSet(zcu).hasRuntimeBitsIgnoreComptime(zcu) ==
3287		src_ty.errorUnionSet(zcu).hasRuntimeBitsIgnoreComptime(zcu));
	3286	assert(dst_ty.errorUnionSet(zcu).hasRuntimeBits(zcu) ==
	3287	src_ty.errorUnionSet(zcu).hasRuntimeBits(zcu));
3288	3288	if (dst_ty.errorUnionPayload(zcu).toIntern() == src_ty.errorUnionPayload(zcu).toIntern()) {
3289	3289	try dst_vi.value.move(isel, ty_op.operand);
3290	3290	} else return isel.fail("bad {t} {f} {f}", .{ air_tag, isel.fmtType(dst_ty), isel.fmtType(src_ty) });
...	...	@@ -4562,7 +4562,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
4562	4562	}
4563	4563	if (case.ranges.len == 0 and case.items.len == 1 and Constant.fromInterned(
4564	4564	case.items[0].toInterned().?,
4565		).orderAgainstZero(zcu).compare(.eq)) {
	4565	).compareHetero(.eq, .zero_comptime_int, zcu)) {
4566	4566	try isel.emit(.cbnz(
4567	4567	cond_reg,
4568	4568	@intCast((isel.instructions.items.len + 1 - next_label) << 2),
...	...	@@ -6893,11 +6893,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
6893	6893	var field_it = loaded_struct.iterateRuntimeOrder(ip);
6894	6894	while (field_it.next()) \|field_index\| {
6895	6895	const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
6896		field_offset = field_ty.structFieldAlignment(
6897		loaded_struct.fieldAlign(ip, field_index),
6898		loaded_struct.layout,
6899		zcu,
6900		).forward(field_offset);
	6896	field_offset = loaded_struct.field_offsets.get(ip)[field_index];
6901	6897	const field_size = field_ty.abiSize(zcu);
6902	6898	if (field_size == 0) continue;
6903	6899	var agg_part_it = agg_vi.value.field(agg_ty, field_offset, field_size);
...	...	@@ -6905,7 +6901,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
6905	6901	try agg_part_vi.?.move(isel, elems[field_index]);
6906	6902	field_offset += field_size;
6907	6903	}
6908		assert(loaded_struct.flagsUnordered(ip).alignment.forward(field_offset) == agg_vi.value.size(isel));
	6904	assert(loaded_struct.alignment.forward(field_offset) == agg_vi.value.size(isel));
6909	6905	},
6910	6906	.tuple_type => \|tuple_type\| {
6911	6907	const elems: []const Air.Inst.Ref =
...	...	@@ -6947,23 +6943,23 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
6947	6943	const union_layout = ZigType.getUnionLayout(loaded_union, zcu);
6948	6944
6949	6945	if (union_layout.tag_size > 0) unused_tag: {
6950		const loaded_tag = loaded_union.loadTagType(ip);
	6946	const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
6951	6947	var tag_it = union_vi.value.field(union_ty, union_layout.tagOffset(), union_layout.tag_size);
6952	6948	const tag_vi = try tag_it.only(isel);
6953	6949	const tag_ra = try tag_vi.?.defReg(isel) orelse break :unused_tag;
6954	6950	switch (union_layout.tag_size) {
6955	6951	0 => unreachable,
6956		1...4 => try isel.movImmediate(tag_ra.w(), @as(u32, switch (loaded_tag.values.len) {
	6952	1...4 => try isel.movImmediate(tag_ra.w(), @as(u32, switch (loaded_tag.field_values.len) {
6957	6953	0 => extra.field_index,
6958		else => switch (ip.indexToKey(loaded_tag.values.get(ip)[extra.field_index]).int.storage) {
	6954	else => switch (ip.indexToKey(loaded_tag.field_values.get(ip)[extra.field_index]).int.storage) {
6959	6955	.u64 => \|imm\| @intCast(imm),
6960	6956	.i64 => \|imm\| @bitCast(@as(i32, @intCast(imm))),
6961	6957	else => unreachable,
6962	6958	},
6963	6959	})),
6964		5...8 => try isel.movImmediate(tag_ra.x(), switch (loaded_tag.values.len) {
	6960	5...8 => try isel.movImmediate(tag_ra.x(), switch (loaded_tag.field_values.len) {
6965	6961	0 => extra.field_index,
6966		else => switch (ip.indexToKey(loaded_tag.values.get(ip)[extra.field_index]).int.storage) {
	6962	else => switch (ip.indexToKey(loaded_tag.field_values.get(ip)[extra.field_index]).int.storage) {
6967	6963	.u64 => \|imm\| imm,
6968	6964	.i64 => \|imm\| @bitCast(imm),
6969	6965	else => unreachable,
...	...	@@ -10391,7 +10387,7 @@ pub const Value = struct {
10391	10387	switch (loaded_struct.layout) {
10392	10388	.auto, .@"extern" => {},
10393	10389	.@"packed" => continue :type_key .{
10394		.int_type = ip.indexToKey(loaded_struct.backingIntTypeUnordered(ip)).int_type,
	10390	.int_type = ip.indexToKey(loaded_struct.packed_backing_int_type).int_type,
10395	10391	},
10396	10392	}
10397	10393	const min_part_log2_stride: u5 = if (size > 16) 4 else if (size > 8) 3 else 0;
...	...	@@ -10406,7 +10402,7 @@ pub const Value = struct {
10406	10402	var field_it = loaded_struct.iterateRuntimeOrder(ip);
10407	10403	while (field_it.next()) \|field_index\| {
10408	10404	const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
10409		const field_begin = switch (loaded_struct.fieldAlign(ip, field_index)) {
	10405	const field_begin = switch (loaded_struct.field_aligns.getOrNone(ip, field_index)) {
10410	10406	.none => field_ty.abiAlignment(zcu),
10411	10407	else => \|field_align\| field_align,
10412	10408	}.forward(field_end);
...	...	@@ -10504,7 +10500,7 @@ pub const Value = struct {
10504	10500	},
10505	10501	.union_type => {
10506	10502	const loaded_union = ip.loadUnionType(ty.toIntern());
10507		switch (loaded_union.flagsUnordered(ip).layout) {
	10503	switch (loaded_union.layout) {
10508	10504	.auto, .@"extern" => {},
10509	10505	.@"packed" => continue :type_key .{ .int_type = .{
10510	10506	.signedness = .unsigned,
...	...	@@ -10539,12 +10535,13 @@ pub const Value = struct {
10539	10535	const field_signedness = field_signedness: switch (field) {
10540	10536	.tag => {
10541	10537	if (offset >= field_begin and offset + size <= field_begin + field_size) {
10542		ty = .fromInterned(loaded_union.enum_tag_ty);
	10538	ty = .fromInterned(loaded_union.enum_tag_type);
10543	10539	ty_size = field_size;
10544	10540	offset -= field_begin;
10545		continue :type_key ip.indexToKey(loaded_union.enum_tag_ty);
	10541	continue :type_key ip.indexToKey(loaded_union.enum_tag_type);
10546	10542	}
10547		break :field_signedness ip.indexToKey(loaded_union.loadTagType(ip).tag_ty).int_type.signedness;
	10543	const loaded_enum = ip.loadEnumType(loaded_union.enum_tag_type);
	10544	break :field_signedness ip.indexToKey(loaded_enum.int_tag_type).int_type.signedness;
10548	10545	},
10549	10546	.payload => null,
10550	10547	};
...	...	@@ -10574,7 +10571,7 @@ pub const Value = struct {
10574	10571	}
10575	10572	},
10576	10573	.opaque_type, .func_type => continue :type_key .{ .simple_type = .anyopaque },
10577		.enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).tag_ty),
	10574	.enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).int_tag_type),
10578	10575	.error_set_type,
10579	10576	.inferred_error_set_type,
10580	10577	=> continue :type_key .{ .simple_type = .anyerror },
...	...	@@ -10740,7 +10737,7 @@ pub const Value = struct {
10740	10737	.storage = .{ .u64 = 0 },
10741	10738	} },
10742	10739	},
10743		.int => \|int\| break :free storage: switch (int.storage) {
	10740	.int => \|int\| break :free switch (int.storage) {
10744	10741	.u64 => \|imm\| try isel.movImmediate(switch (size) {
10745	10742	else => unreachable,
10746	10743	1...4 => mat.ra.w(),
...	...	@@ -10772,12 +10769,6 @@ pub const Value = struct {
10772	10769	}
10773	10770	try isel.movImmediate(mat.ra.x(), imm);
10774	10771	},
10775		.lazy_align => \|ty\| continue :storage .{
10776		.u64 = ZigType.fromInterned(ty).abiAlignment(zcu).toByteUnits().?,
10777		},
10778		.lazy_size => \|ty\| continue :storage .{
10779		.u64 = ZigType.fromInterned(ty).abiSize(zcu),
10780		},
10781	10772	},
10782	10773	.err => \|err\| continue :constant_key .{ .int = .{
10783	10774	.ty = err.ty,
...	...	@@ -11084,13 +11075,9 @@ pub const Value = struct {
11084	11075	var field_offset: u64 = 0;
11085	11076	var field_it = loaded_struct.iterateRuntimeOrder(ip);
11086	11077	while (field_it.next()) \|field_index\| {
11087		if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
	11078	if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
11088	11079	const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
11089		field_offset = field_ty.structFieldAlignment(
11090		loaded_struct.fieldAlign(ip, field_index),
11091		loaded_struct.layout,
11092		zcu,
11093		).forward(field_offset);
	11080	field_offset = loaded_struct.field_offsets.get(ip)[field_index];
11094	11081	const field_size = field_ty.abiSize(zcu);
11095	11082	if (offset >= field_offset and offset + size <= field_offset + field_size) {
11096	11083	offset -= field_offset;
...	...	@@ -11132,7 +11119,7 @@ pub const Value = struct {
11132	11119	.un => \|un\| {
11133	11120	const loaded_union = ip.loadUnionType(un.ty);
11134	11121	const union_layout = ZigType.getUnionLayout(loaded_union, zcu);
11135		if (loaded_union.hasTag(ip)) {
	11122	if (loaded_union.has_runtime_tag) {
11136	11123	const tag_offset = union_layout.tagOffset();
11137	11124	if (offset >= tag_offset and offset + size <= tag_offset + union_layout.tag_size) {
11138	11125	offset -= tag_offset;
...	...	@@ -11477,13 +11464,9 @@ fn writeKeyToMemory(isel: *Select, constant_key: InternPool.Key, buffer: []u8) e
11477	11464	var field_offset: u64 = 0;
11478	11465	var field_it = loaded_struct.iterateRuntimeOrder(ip);
11479	11466	while (field_it.next()) \|field_index\| {
11480		if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
	11467	if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
11481	11468	const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
11482		field_offset = field_ty.structFieldAlignment(
11483		loaded_struct.fieldAlign(ip, field_index),
11484		loaded_struct.layout,
11485		zcu,
11486		).forward(field_offset);
	11469	field_offset = loaded_struct.field_offsets.get(ip)[field_index];
11487	11470	const field_size = field_ty.abiSize(zcu);
11488	11471	if (!try isel.writeToMemory(.fromInterned(switch (aggregate.storage) {
11489	11472	.bytes => unreachable,
...	...	@@ -12082,7 +12065,7 @@ pub const CallAbiIterator = struct {
12082	12065	const zcu = isel.pt.zcu;
12083	12066	const ip = &zcu.intern_pool;
12084	12067
12085		if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
	12068	if (!ty.hasRuntimeBits(zcu)) return null;
12086	12069	try isel.values.ensureUnusedCapacity(zcu.gpa, Value.max_parts);
12087	12070	const wip_vi = isel.initValue(ty);
12088	12071	type_key: switch (ip.indexToKey(ty.toIntern())) {
...	...	@@ -12186,7 +12169,7 @@ pub const CallAbiIterator = struct {
12186	12169	switch (loaded_struct.layout) {
12187	12170	.auto, .@"extern" => {},
12188	12171	.@"packed" => continue :type_key .{
12189		.int_type = ip.indexToKey(loaded_struct.backingIntTypeUnordered(ip)).int_type,
	12172	.int_type = ip.indexToKey(loaded_struct.packed_backing_int_type).int_type,
12190	12173	},
12191	12174	}
12192	12175	const size = wip_vi.size(isel);
...	...	@@ -12210,7 +12193,7 @@ pub const CallAbiIterator = struct {
12210	12193	const field_end = next_field_end;
12211	12194	const next_field_begin = if (field_it.next()) \|field_index\| next_field_begin: {
12212	12195	const field_ty: ZigType = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
12213		const next_field_begin = switch (loaded_struct.fieldAlign(ip, field_index)) {
	12196	const next_field_begin = switch (loaded_struct.field_aligns.getOrNone(ip, field_index)) {
12214	12197	.none => field_ty.abiAlignment(zcu),
12215	12198	else => \|field_align\| field_align,
12216	12199	}.forward(field_end);
...	...	@@ -12276,7 +12259,7 @@ pub const CallAbiIterator = struct {
12276	12259	},
12277	12260	.union_type => {
12278	12261	const loaded_union = ip.loadUnionType(ty.toIntern());
12279		switch (loaded_union.flagsUnordered(ip).layout) {
	12262	switch (loaded_union.layout) {
12280	12263	.auto, .@"extern" => {},
12281	12264	.@"packed" => continue :type_key .{ .int_type = .{
12282	12265	.signedness = .unsigned,
...	...	@@ -12309,7 +12292,9 @@ pub const CallAbiIterator = struct {
12309	12292	}
12310	12293	},
12311	12294	.opaque_type, .func_type => continue :type_key .{ .simple_type = .anyopaque },
12312		.enum_type => continue :type_key ip.indexToKey(ip.loadEnumType(ty.toIntern()).tag_ty),
	12295	.enum_type => continue :type_key .{
	12296	.int_type = ip.indexToKey(ip.loadEnumType(ty.toIntern()).int_tag_type).int_type,
	12297	},
12313	12298	.error_set_type,
12314	12299	.inferred_error_set_type,
12315	12300	=> continue :type_key .{ .simple_type = .anyerror },
...	...	@@ -12414,8 +12399,8 @@ pub const CallAbiIterator = struct {
12414	12399	const ip = &zcu.intern_pool;
12415	12400	var common_fdt: ?FundamentalDataType = null;
12416	12401	for (0.., loaded_struct.field_types.get(ip)) \|field_index, field_ty\| {
12417		if (loaded_struct.fieldIsComptime(ip, field_index)) continue;
12418		if (loaded_struct.fieldAlign(ip, field_index) != .none) return null;
	12402	if (loaded_struct.field_is_comptime_bits.get(ip, field_index)) continue;
	12403	if (loaded_struct.field_aligns.getOrNone(ip, field_index) != .none) return null;
12419	12404	if (!ZigType.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
12420	12405	const fdt = homogeneousAggregateBaseType(zcu, field_ty);
12421	12406	if (common_fdt == null) common_fdt = fdt else if (fdt != common_fdt) return null;

src/codegen/c.zig+56-87

...	...	@@ -1052,17 +1052,7 @@ pub const DeclGen = struct {
1052	1052	.func,
1053	1053	.enum_literal,
1054	1054	=> unreachable, // non-runtime values
1055		.int => \|int\| switch (int.storage) {
1056		.u64, .i64, .big_int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
1057		.lazy_align, .lazy_size => {
1058		try w.writeAll("((");
1059		try dg.renderCType(w, ctype);
1060		try w.print("){f})", .{try dg.fmtIntLiteralHex(
1061		try pt.intValue(.usize, val.toUnsignedInt(zcu)),
1062		.Other,
1063		)});
1064		},
1065		},
	1055	.int => try w.print("{f}", .{try dg.fmtIntLiteralDec(val, location)}),
1066	1056	.err => \|err\| try dg.renderErrorName(w, err.name),
1067	1057	.error_union => \|error_union\| switch (ctype.info(ctype_pool)) {
1068	1058	.basic => switch (error_union.val) {
...	...	@@ -1338,7 +1328,7 @@ pub const DeclGen = struct {
1338	1328	const comptime_val = tuple.values.get(ip)[field_index];
1339	1329	if (comptime_val != .none) continue;
1340	1330	const field_ty: Type = .fromInterned(tuple.types.get(ip)[field_index]);
1341		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1331	if (!field_ty.hasRuntimeBits(zcu)) continue;
1342	1332
1343	1333	if (!empty) try w.writeByte(',');
1344	1334
...	...	@@ -1373,7 +1363,7 @@ pub const DeclGen = struct {
1373	1363	var need_comma = false;
1374	1364	while (field_it.next()) \|field_index\| {
1375	1365	const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
1376		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1366	if (!field_ty.hasRuntimeBits(zcu)) continue;
1377	1367
1378	1368	if (need_comma) try w.writeByte(',');
1379	1369	need_comma = true;
...	...	@@ -1396,7 +1386,7 @@ pub const DeclGen = struct {
1396	1386	const loaded_union = ip.loadUnionType(ty.toIntern());
1397	1387	if (un.tag == .none) {
1398	1388	const backing_ty = try ty.externUnionBackingType(pt);
1399		assert(loaded_union.flagsUnordered(ip).layout == .@"extern");
	1389	assert(loaded_union.layout == .@"extern");
1400	1390	if (location == .StaticInitializer) {
1401	1391	return dg.fail("TODO: C backend: implement extern union backing type rendering in static initializers", .{});
1402	1392	}
...	...	@@ -1418,9 +1408,9 @@ pub const DeclGen = struct {
1418	1408
1419	1409	const field_index = zcu.unionTagFieldIndex(loaded_union, Value.fromInterned(un.tag)).?;
1420	1410	const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
1421		const field_name = loaded_union.loadTagType(ip).names.get(ip)[field_index];
	1411	const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
1422	1412
1423		const has_tag = loaded_union.hasTag(ip);
	1413	const has_tag = loaded_union.has_runtime_tag;
1424	1414	if (has_tag) try w.writeByte('{');
1425	1415	const aggregate = ctype.info(ctype_pool).aggregate;
1426	1416	for (0..if (has_tag) aggregate.fields.len else 1) \|outer_field_index\| {
...	...	@@ -1597,7 +1587,7 @@ pub const DeclGen = struct {
1597	1587	var need_comma = false;
1598	1588	while (field_it.next()) \|field_index\| {
1599	1589	const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
1600		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1590	if (!field_ty.hasRuntimeBits(zcu)) continue;
1601	1591
1602	1592	if (need_comma) try w.writeByte(',');
1603	1593	need_comma = true;
...	...	@@ -1620,7 +1610,7 @@ pub const DeclGen = struct {
1620	1610	for (0..tuple_info.types.len) \|field_index\| {
1621	1611	if (tuple_info.values.get(ip)[field_index] != .none) continue;
1622	1612	const field_ty: Type = .fromInterned(tuple_info.types.get(ip)[field_index]);
1623		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1613	if (!field_ty.hasRuntimeBits(zcu)) continue;
1624	1614
1625	1615	if (need_comma) try w.writeByte(',');
1626	1616	need_comma = true;
...	...	@@ -1630,7 +1620,7 @@ pub const DeclGen = struct {
1630	1620	},
1631	1621	.union_type => {
1632	1622	const loaded_union = ip.loadUnionType(ty.toIntern());
1633		switch (loaded_union.flagsUnordered(ip).layout) {
	1623	switch (loaded_union.layout) {
1634	1624	.auto, .@"extern" => {
1635	1625	if (!location.isInitializer()) {
1636	1626	try w.writeByte('(');
...	...	@@ -1638,7 +1628,7 @@ pub const DeclGen = struct {
1638	1628	try w.writeByte(')');
1639	1629	}
1640	1630
1641		const has_tag = loaded_union.hasTag(ip);
	1631	const has_tag = loaded_union.has_runtime_tag;
1642	1632	if (has_tag) try w.writeByte('{');
1643	1633	const aggregate = ctype.info(ctype_pool).aggregate;
1644	1634	for (0..if (has_tag) aggregate.fields.len else 1) \|outer_field_index\| {
...	...	@@ -1649,7 +1639,7 @@ pub const DeclGen = struct {
1649	1639	.payload) {
1650	1640	.tag => try dg.renderUndefValue(
1651	1641	w,
1652		.fromInterned(loaded_union.enum_tag_ty),
	1642	.fromInterned(loaded_union.enum_tag_type),
1653	1643	initializer_type,
1654	1644	),
1655	1645	.payload => {
...	...	@@ -1760,6 +1750,7 @@ pub const DeclGen = struct {
1760	1750	.opt,
1761	1751	.aggregate,
1762	1752	.un,
	1753	.bitpack,
1763	1754	.memoized_call,
1764	1755	=> unreachable, // values, not types
1765	1756	},
...	...	@@ -2797,7 +2788,7 @@ pub fn genLazyFn(o: Object, lazy_ctype_pool: const CType.Pool, lazy_fn: LazyFn
2797	2788	} });
2798	2789
2799	2790	try w.print("case {f}: {{", .{
2800		try o.dg.fmtIntLiteralDec(try tag_val.intFromEnum(enum_ty, pt), .Other),
	2791	try o.dg.fmtIntLiteralDec(tag_val.intFromEnum(zcu), .Other),
2801	2792	});
2802	2793	o.indent();
2803	2794	try o.newline();
...	...	@@ -3599,10 +3590,7 @@ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
3599	3590	const zcu = f.object.dg.pt.zcu;
3600	3591	const inst_ty = f.typeOfIndex(inst);
3601	3592	const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
3602		if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
3603		try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
3604		return .none;
3605		}
	3593	assert(inst_ty.hasRuntimeBits(zcu));
3606	3594
3607	3595	const ptr = try f.resolveInst(bin_op.lhs);
3608	3596	const index = try f.resolveInst(bin_op.rhs);
...	...	@@ -3629,7 +3617,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
3629	3617
3630	3618	const inst_ty = f.typeOfIndex(inst);
3631	3619	const ptr_ty = f.typeOf(bin_op.lhs);
3632		const elem_has_bits = ptr_ty.indexableElem(zcu).hasRuntimeBitsIgnoreComptime(zcu);
	3620	assert(ptr_ty.indexableElem(zcu).hasRuntimeBits(zcu));
3633	3621
3634	3622	const ptr = try f.resolveInst(bin_op.lhs);
3635	3623	const index = try f.resolveInst(bin_op.rhs);
...	...	@@ -3643,16 +3631,14 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
3643	3631	try w.writeByte('(');
3644	3632	try f.renderType(w, inst_ty);
3645	3633	try w.writeByte(')');
3646		if (elem_has_bits) try w.writeByte('&');
3647		if (elem_has_bits and ptr_ty.ptrSize(zcu) == .one) {
	3634	try w.writeByte('&');
	3635	if (ptr_ty.ptrSize(zcu) == .one) {
3648	3636	// It's a pointer to an array, so we need to de-reference.
3649	3637	try f.writeCValueDeref(w, ptr);
3650	3638	} else try f.writeCValue(w, ptr, .Other);
3651		if (elem_has_bits) {
3652		try w.writeByte('[');
3653		try f.writeCValue(w, index, .Other);
3654		try w.writeByte(']');
3655		}
	3639	try w.writeByte('[');
	3640	try f.writeCValue(w, index, .Other);
	3641	try w.writeByte(']');
3656	3642	try a.end(f, w);
3657	3643	return local;
3658	3644	}
...	...	@@ -3661,10 +3647,7 @@ fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
3661	3647	const zcu = f.object.dg.pt.zcu;
3662	3648	const inst_ty = f.typeOfIndex(inst);
3663	3649	const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
3664		if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
3665		try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
3666		return .none;
3667		}
	3650	assert(inst_ty.hasRuntimeBits(zcu));
3668	3651
3669	3652	const slice = try f.resolveInst(bin_op.lhs);
3670	3653	const index = try f.resolveInst(bin_op.rhs);
...	...	@@ -3692,7 +3675,7 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
3692	3675	const inst_ty = f.typeOfIndex(inst);
3693	3676	const slice_ty = f.typeOf(bin_op.lhs);
3694	3677	const elem_ty = slice_ty.childType(zcu);
3695		const elem_has_bits = elem_ty.hasRuntimeBitsIgnoreComptime(zcu);
	3678	assert(elem_ty.hasRuntimeBits(zcu));
3696	3679
3697	3680	const slice = try f.resolveInst(bin_op.lhs);
3698	3681	const index = try f.resolveInst(bin_op.rhs);
...	...	@@ -3703,13 +3686,11 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue {
3703	3686	const a = try Assignment.start(f, w, try f.ctypeFromType(inst_ty, .complete));
3704	3687	try f.writeCValue(w, local, .Other);
3705	3688	try a.assign(f, w);
3706		if (elem_has_bits) try w.writeByte('&');
	3689	try w.writeByte('&');
3707	3690	try f.writeCValueMember(w, slice, .{ .identifier = "ptr" });
3708		if (elem_has_bits) {
3709		try w.writeByte('[');
3710		try f.writeCValue(w, index, .Other);
3711		try w.writeByte(']');
3712		}
	3691	try w.writeByte('[');
	3692	try f.writeCValue(w, index, .Other);
	3693	try w.writeByte(']');
3713	3694	try a.end(f, w);
3714	3695	return local;
3715	3696	}
...	...	@@ -3718,10 +3699,7 @@ fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue {
3718	3699	const zcu = f.object.dg.pt.zcu;
3719	3700	const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
3720	3701	const inst_ty = f.typeOfIndex(inst);
3721		if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
3722		try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
3723		return .none;
3724		}
	3702	assert(inst_ty.hasRuntimeBits(zcu));
3725	3703
3726	3704	const array = try f.resolveInst(bin_op.lhs);
3727	3705	const index = try f.resolveInst(bin_op.rhs);
...	...	@@ -3853,10 +3831,7 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue {
3853	3831	// bit-pointers we see here are vector element pointers.
3854	3832	assert(ptr_info.packed_offset.host_size == 0 or ptr_info.flags.vector_index != .none);
3855	3833
3856		if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
3857		try reap(f, inst, &.{ty_op.operand});
3858		return .none;
3859		}
	3834	assert(src_ty.hasRuntimeBits(zcu));
3860	3835
3861	3836	const operand = try f.resolveInst(ty_op.operand);
3862	3837
...	...	@@ -4456,7 +4431,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue {
4456	4431	const inst_ty = f.typeOfIndex(inst);
4457	4432	const inst_scalar_ty = inst_ty.scalarType(zcu);
4458	4433	const elem_ty = inst_scalar_ty.indexableElem(zcu);
4459		if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return f.moveCValue(inst, inst_ty, lhs);
	4434	assert(elem_ty.hasRuntimeBits(zcu));
4460	4435	const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);
4461	4436
4462	4437	const local = try f.allocLocal(inst, inst_ty);
...	...	@@ -4787,7 +4762,7 @@ fn lowerBlock(f: *Function, inst: Air.Inst.Index, body: []const Air.Inst.Index)
4787	4762	const w = &f.object.code.writer;
4788	4763
4789	4764	const inst_ty = f.typeOfIndex(inst);
4790		const result = if (inst_ty.hasRuntimeBitsIgnoreComptime(zcu) and !f.liveness.isUnused(inst))
	4765	const result = if (inst_ty.hasRuntimeBits(zcu) and !f.liveness.isUnused(inst))
4791	4766	try f.allocLocal(inst, inst_ty)
4792	4767	else
4793	4768	.none;
...	...	@@ -4853,7 +4828,7 @@ fn lowerTry(
4853	4828	const liveness_condbr = f.liveness.getCondBr(inst);
4854	4829	const w = &f.object.code.writer;
4855	4830	const payload_ty = err_union_ty.errorUnionPayload(zcu);
4856		const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
	4831	const payload_has_bits = payload_ty.hasRuntimeBits(zcu);
4857	4832
4858	4833	if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
4859	4834	try w.writeAll("if (");
...	...	@@ -5393,7 +5368,7 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
5393	5368	const result = result: {
5394	5369	const w = &f.object.code.writer;
5395	5370	const inst_ty = f.typeOfIndex(inst);
5396		const inst_local = if (inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) local: {
	5371	const inst_local = if (inst_ty.hasRuntimeBits(zcu)) local: {
5397	5372	const inst_local = try f.allocLocalValue(.{
5398	5373	.ctype = try f.ctypeFromType(inst_ty, .complete),
5399	5374	.alignas = CType.AlignAs.fromAbiAlignment(inst_ty.abiAlignment(zcu)),
...	...	@@ -5820,12 +5795,12 @@ fn fieldLocation(
5820	5795	.struct_type => {
5821	5796	const loaded_struct = ip.loadStructType(container_ty.toIntern());
5822	5797	return switch (loaded_struct.layout) {
5823		.auto, .@"extern" => if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
	5798	.auto, .@"extern" => if (!container_ty.hasRuntimeBits(zcu))
5824	5799	.begin
5825		else if (!field_ptr_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu))
5826		.{ .byte_offset = loaded_struct.offsets.get(ip)[field_index] }
	5800	else if (!field_ptr_ty.childType(zcu).hasRuntimeBits(zcu))
	5801	.{ .byte_offset = loaded_struct.field_offsets.get(ip)[field_index] }
5827	5802	else
5828		.{ .field = .{ .identifier = loaded_struct.fieldName(ip, field_index).toSlice(ip) } },
	5803	.{ .field = .{ .identifier = loaded_struct.field_names.get(ip)[field_index].toSlice(ip) } },
5829	5804	.@"packed" => if (field_ptr_ty.ptrInfo(zcu).packed_offset.host_size == 0)
5830	5805	.{ .byte_offset = @divExact(zcu.structPackedFieldBitOffset(loaded_struct, field_index) +
5831	5806	container_ptr_ty.ptrInfo(zcu).packed_offset.bit_offset, 8) }
...	...	@@ -5833,24 +5808,24 @@ fn fieldLocation(
5833	5808	.begin,
5834	5809	};
5835	5810	},
5836		.tuple_type => return if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
	5811	.tuple_type => return if (!container_ty.hasRuntimeBits(zcu))
5837	5812	.begin
5838		else if (!field_ptr_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu))
	5813	else if (!field_ptr_ty.childType(zcu).hasRuntimeBits(zcu))
5839	5814	.{ .byte_offset = container_ty.structFieldOffset(field_index, zcu) }
5840	5815	else
5841	5816	.{ .field = .{ .field = field_index } },
5842	5817	.union_type => {
5843	5818	const loaded_union = ip.loadUnionType(container_ty.toIntern());
5844		switch (loaded_union.flagsUnordered(ip).layout) {
	5819	switch (loaded_union.layout) {
5845	5820	.auto, .@"extern" => {
5846	5821	const field_ty: Type = .fromInterned(loaded_union.field_types.get(ip)[field_index]);
5847		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu))
	5822	if (!field_ty.hasRuntimeBits(zcu))
5848	5823	return if (loaded_union.has_runtime_tag and !container_ty.unionHasAllZeroBitFieldTypes(zcu))
5849	5824	.{ .field = .{ .identifier = "payload" } }
5850	5825	else
5851	5826	.begin;
5852		const field_name = loaded_union.loadTagType(ip).names.get(ip)[field_index];
5853		return .{ .field = if (loaded_union.hasTag(ip))
	5827	const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[field_index];
	5828	return .{ .field = if (loaded_union.has_runtime_tag)
5854	5829	.{ .payload_identifier = field_name.toSlice(ip) }
5855	5830	else
5856	5831	.{ .identifier = field_name.toSlice(ip) } };
...	...	@@ -5996,10 +5971,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
5996	5971	const extra = f.air.extraData(Air.StructField, ty_pl.payload).data;
5997	5972
5998	5973	const inst_ty = f.typeOfIndex(inst);
5999		if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
6000		try reap(f, inst, &.{extra.struct_operand});
6001		return .none;
6002		}
	5974	assert(inst_ty.hasRuntimeBits(zcu));
6003	5975
6004	5976	const struct_byval = try f.resolveInst(extra.struct_operand);
6005	5977	try reap(f, inst, &.{extra.struct_operand});
...	...	@@ -6014,9 +5986,9 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
6014	5986	.struct_type => .{ .identifier = struct_ty.structFieldName(extra.field_index, zcu).unwrap().?.toSlice(ip) },
6015	5987	.union_type => name: {
6016	5988	const union_type = ip.loadUnionType(struct_ty.toIntern());
6017		const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_ty);
	5989	const enum_tag_ty: Type = .fromInterned(union_type.enum_tag_type);
6018	5990	const field_name_str = enum_tag_ty.enumFieldName(extra.field_index, zcu).toSlice(ip);
6019		if (union_type.hasTag(ip)) {
	5991	if (union_type.has_runtime_tag) {
6020	5992	break :name .{ .payload_identifier = field_name_str };
6021	5993	} else {
6022	5994	break :name .{ .identifier = field_name_str };
...	...	@@ -6161,7 +6133,7 @@ fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
6161	6133
6162	6134	const inst_ty = f.typeOfIndex(inst);
6163	6135	const payload_ty = inst_ty.errorUnionPayload(zcu);
6164		const repr_is_err = !payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
	6136	const repr_is_err = !payload_ty.hasRuntimeBits(zcu);
6165	6137	const err_ty = inst_ty.errorUnionSet(zcu);
6166	6138	const err = try f.resolveInst(ty_op.operand);
6167	6139	try reap(f, inst, &.{ty_op.operand});
...	...	@@ -6210,7 +6182,7 @@ fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
6210	6182	try reap(f, inst, &.{ty_op.operand});
6211	6183
6212	6184	// First, set the non-error value.
6213		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	6185	if (!payload_ty.hasRuntimeBits(zcu)) {
6214	6186	const a = try Assignment.start(f, w, try f.ctypeFromType(operand_ty, .complete));
6215	6187	try f.writeCValueDeref(w, operand);
6216	6188	try a.assign(f, w);
...	...	@@ -6262,13 +6234,13 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
6262	6234	const inst_ty = f.typeOfIndex(inst);
6263	6235	const payload_ty = inst_ty.errorUnionPayload(zcu);
6264	6236	const payload = try f.resolveInst(ty_op.operand);
6265		const repr_is_err = !payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
	6237	assert(payload_ty.hasRuntimeBits(zcu));
6266	6238	const err_ty = inst_ty.errorUnionSet(zcu);
6267	6239	try reap(f, inst, &.{ty_op.operand});
6268	6240
6269	6241	const w = &f.object.code.writer;
6270	6242	const local = try f.allocLocal(inst, inst_ty);
6271		if (!repr_is_err) {
	6243	{
6272	6244	const a = try Assignment.start(f, w, try f.ctypeFromType(payload_ty, .complete));
6273	6245	try f.writeCValueMember(w, local, .{ .identifier = "payload" });
6274	6246	try a.assign(f, w);
...	...	@@ -6277,10 +6249,7 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {
6277	6249	}
6278	6250	{
6279	6251	const a = try Assignment.start(f, w, try f.ctypeFromType(err_ty, .complete));
6280		if (repr_is_err)
6281		try f.writeCValue(w, local, .Other)
6282		else
6283		try f.writeCValueMember(w, local, .{ .identifier = "error" });
	6252	try f.writeCValueMember(w, local, .{ .identifier = "error" });
6284	6253	try a.assign(f, w);
6285	6254	try f.object.dg.renderValue(w, try pt.intValue(try pt.errorIntType(), 0), .Other);
6286	6255	try a.end(f, w);
...	...	@@ -7411,10 +7380,10 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
7411	7380	var field_it = loaded_struct.iterateRuntimeOrder(ip);
7412	7381	while (field_it.next()) \|field_index\| {
7413	7382	const field_ty: Type = .fromInterned(loaded_struct.field_types.get(ip)[field_index]);
7414		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	7383	if (!field_ty.hasRuntimeBits(zcu)) continue;
7415	7384
7416	7385	const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
7417		try f.writeCValueMember(w, local, .{ .identifier = loaded_struct.fieldName(ip, field_index).toSlice(ip) });
	7386	try f.writeCValueMember(w, local, .{ .identifier = loaded_struct.field_names.get(ip)[field_index].toSlice(ip) });
7418	7387	try a.assign(f, w);
7419	7388	try f.writeCValue(w, resolved_elements[field_index], .Other);
7420	7389	try a.end(f, w);
...	...	@@ -7426,7 +7395,7 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
7426	7395	.tuple_type => \|tuple_info\| for (0..tuple_info.types.len) \|field_index\| {
7427	7396	if (tuple_info.values.get(ip)[field_index] != .none) continue;
7428	7397	const field_ty: Type = .fromInterned(tuple_info.types.get(ip)[field_index]);
7429		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	7398	if (!field_ty.hasRuntimeBits(zcu)) continue;
7430	7399
7431	7400	const a = try Assignment.start(f, w, try f.ctypeFromType(field_ty, .complete));
7432	7401	try f.writeCValueMember(w, local, .{ .field = field_index });
...	...	@@ -7449,13 +7418,13 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
7449	7418
7450	7419	const union_ty = f.typeOfIndex(inst);
7451	7420	const loaded_union = ip.loadUnionType(union_ty.toIntern());
7452		const field_name = loaded_union.loadTagType(ip).names.get(ip)[extra.field_index];
	7421	const field_name = ip.loadEnumType(loaded_union.enum_tag_type).field_names.get(ip)[extra.field_index];
7453	7422	const payload_ty = f.typeOf(extra.init);
7454	7423	const payload = try f.resolveInst(extra.init);
7455	7424	try reap(f, inst, &.{extra.init});
7456	7425
7457	7426	const w = &f.object.code.writer;
7458		if (loaded_union.flagsUnordered(ip).layout == .@"packed") return f.moveCValue(inst, union_ty, payload);
	7427	if (loaded_union.layout == .@"packed") return f.moveCValue(inst, union_ty, payload);
7459	7428
7460	7429	const local = try f.allocLocal(inst, union_ty);
7461	7430
...	...	@@ -7466,7 +7435,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue {
7466	7435	const a = try Assignment.start(f, w, try f.ctypeFromType(tag_ty, .complete));
7467	7436	try f.writeCValueMember(w, local, .{ .identifier = "tag" });
7468	7437	try a.assign(f, w);
7469		try w.print("{f}", .{try f.fmtIntLiteralDec(try tag_val.intFromEnum(tag_ty, pt))});
	7438	try w.print("{f}", .{try f.fmtIntLiteralDec(tag_val.intFromEnum(zcu))});
7470	7439	try a.end(f, w);
7471	7440	break :field .{ .payload_identifier = field_name.toSlice(ip) };
7472	7441	} else .{ .identifier = field_name.toSlice(ip) };

src/codegen/c/Type.zig+30-29

...	...	@@ -2558,7 +2558,7 @@ pub const Pool = struct {
2558	2558	.tag = .@"struct",
2559	2559	.name = .{ .index = ip_index },
2560	2560	});
2561		if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
	2561	if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
2562	2562	fwd_decl
2563	2563	else
2564	2564	.void;
...	...	@@ -2584,9 +2584,9 @@ pub const Pool = struct {
2584	2584	kind.noParameter(),
2585	2585	);
2586	2586	if (field_ctype.index == .void) continue;
2587		const field_name = try pool.string(allocator, loaded_struct.fieldName(ip, field_index).toSlice(ip));
	2587	const field_name = try pool.string(allocator, loaded_struct.field_names.get(ip)[field_index].toSlice(ip));
2588	2588	const field_alignas = AlignAs.fromAlignment(.{
2589		.@"align" = loaded_struct.fieldAlign(ip, field_index),
	2589	.@"align" = loaded_struct.field_aligns.getOrNone(ip, field_index),
2590	2590	.abi = field_type.abiAlignment(zcu),
2591	2591	});
2592	2592	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
...	...	@@ -2613,7 +2613,7 @@ pub const Pool = struct {
2613	2613	.@"packed" => return pool.fromType(
2614	2614	allocator,
2615	2615	scratch,
2616		Type.fromInterned(loaded_struct.backingIntTypeUnordered(ip)),
	2616	.fromInterned(loaded_struct.packed_backing_int_type),
2617	2617	pt,
2618	2618	mod,
2619	2619	kind,
...	...	@@ -2682,17 +2682,17 @@ pub const Pool = struct {
2682	2682	},
2683	2683	.union_type => {
2684	2684	const loaded_union = ip.loadUnionType(ip_index);
2685		switch (loaded_union.flagsUnordered(ip).layout) {
	2685	switch (loaded_union.layout) {
2686	2686	.auto, .@"extern" => {
2687	2687	const fwd_decl = try pool.getFwdDecl(allocator, .{
2688	2688	.tag = if (loaded_union.has_runtime_tag) .@"struct" else .@"union",
2689	2689	.name = .{ .index = ip_index },
2690	2690	});
2691		if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
	2691	if (kind.isForward()) return if (ty.hasRuntimeBits(zcu))
2692	2692	fwd_decl
2693	2693	else
2694	2694	.void;
2695		const loaded_tag = loaded_union.loadTagType(ip);
	2695	const loaded_tag = ip.loadEnumType(loaded_union.enum_tag_type);
2696	2696	const scratch_top = scratch.items.len;
2697	2697	defer scratch.shrinkRetainingCapacity(scratch_top);
2698	2698	try scratch.ensureUnusedCapacity(
...	...	@@ -2718,10 +2718,10 @@ pub const Pool = struct {
2718	2718	if (field_ctype.index == .void) continue;
2719	2719	const field_name = try pool.string(
2720	2720	allocator,
2721		loaded_tag.names.get(ip)[field_index].toSlice(ip),
	2721	loaded_tag.field_names.get(ip)[field_index].toSlice(ip),
2722	2722	);
2723	2723	const field_alignas = AlignAs.fromAlignment(.{
2724		.@"align" = loaded_union.fieldAlign(ip, field_index),
	2724	.@"align" = loaded_union.field_aligns.getOrNone(ip, field_index),
2725	2725	.abi = field_type.abiAlignment(zcu),
2726	2726	});
2727	2727	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
...	...	@@ -2753,24 +2753,22 @@ pub const Pool = struct {
2753	2753	try pool.ensureUnusedCapacity(allocator, 2);
2754	2754	var struct_fields: [2]Info.Field = undefined;
2755	2755	var struct_fields_len: usize = 0;
2756		if (loaded_tag.tag_ty != .comptime_int_type) {
2757		const tag_type = Type.fromInterned(loaded_tag.tag_ty);
2758		const tag_ctype: CType = try pool.fromType(
2759		allocator,
2760		scratch,
2761		tag_type,
2762		pt,
2763		mod,
2764		kind.noParameter(),
2765		);
2766		if (tag_ctype.index != .void) {
2767		struct_fields[struct_fields_len] = .{
2768		.name = .{ .index = .tag },
2769		.ctype = tag_ctype,
2770		.alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
2771		};
2772		struct_fields_len += 1;
2773		}
	2756	const tag_type = Type.fromInterned(loaded_tag.int_tag_type);
	2757	const tag_ctype: CType = try pool.fromType(
	2758	allocator,
	2759	scratch,
	2760	tag_type,
	2761	pt,
	2762	mod,
	2763	kind.noParameter(),
	2764	);
	2765	if (tag_ctype.index != .void) {
	2766	struct_fields[struct_fields_len] = .{
	2767	.name = .{ .index = .tag },
	2768	.ctype = tag_ctype,
	2769	.alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
	2770	};
	2771	struct_fields_len += 1;
2774	2772	}
2775	2773	if (fields_len > 0) {
2776	2774	const payload_ctype = payload_ctype: {
...	...	@@ -2823,12 +2821,14 @@ pub const Pool = struct {
2823	2821	.enum_type => return pool.fromType(
2824	2822	allocator,
2825	2823	scratch,
2826		Type.fromInterned(ip.loadEnumType(ip_index).tag_ty),
	2824	.fromInterned(ip.loadEnumType(ip_index).int_tag_type),
2827	2825	pt,
2828	2826	mod,
2829	2827	kind,
2830	2828	),
2831		.func_type => \|func_info\| if (func_info.is_generic) return .void else {
	2829	.func_type => \|func_info\| {
	2830	if (!ty.fnHasRuntimeBits(zcu)) return .void;
	2831
2832	2832	const scratch_top = scratch.items.len;
2833	2833	defer scratch.shrinkRetainingCapacity(scratch_top);
2834	2834	try scratch.ensureUnusedCapacity(allocator, func_info.param_types.len);
...	...	@@ -2894,6 +2894,7 @@ pub const Pool = struct {
2894	2894	.opt,
2895	2895	.aggregate,
2896	2896	.un,
	2897	.bitpack,
2897	2898	.memoized_call,
2898	2899	=> unreachable, // values, not types
2899	2900	},

src/codegen/riscv64/CodeGen.zig+23-30

...	...	@@ -3257,7 +3257,7 @@ fn airOptionalPayload(func: *Func, inst: Air.Inst.Index) !void {
3257	3257	const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
3258	3258	const result: MCValue = result: {
3259	3259	const pl_ty = func.typeOfIndex(inst);
3260		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
	3260	if (!pl_ty.hasRuntimeBits(zcu)) break :result .none;
3261	3261
3262	3262	const opt_mcv = try func.resolveInst(ty_op.operand);
3263	3263	if (func.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) {
...	...	@@ -3331,7 +3331,7 @@ fn airUnwrapErrErr(func: *Func, inst: Air.Inst.Index) !void {
3331	3331	break :result .{ .immediate = 0 };
3332	3332	}
3333	3333
3334		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	3334	if (!payload_ty.hasRuntimeBits(zcu)) {
3335	3335	break :result operand;
3336	3336	}
3337	3337
...	...	@@ -3384,7 +3384,7 @@ fn genUnwrapErrUnionPayloadMir(
3384	3384	const payload_ty = err_union_ty.errorUnionPayload(zcu);
3385	3385
3386	3386	const result: MCValue = result: {
3387		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
	3387	if (!payload_ty.hasRuntimeBits(zcu)) break :result .none;
3388	3388
3389	3389	const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
3390	3390	switch (err_union) {
...	...	@@ -3547,7 +3547,7 @@ fn airWrapErrUnionPayload(func: *Func, inst: Air.Inst.Index) !void {
3547	3547	const operand = try func.resolveInst(ty_op.operand);
3548	3548
3549	3549	const result: MCValue = result: {
3550		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .{ .immediate = 0 };
	3550	if (!pl_ty.hasRuntimeBits(zcu)) break :result .{ .immediate = 0 };
3551	3551
3552	3552	const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
3553	3553	const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
...	...	@@ -3571,7 +3571,7 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void {
3571	3571	const err_ty = eu_ty.errorUnionSet(zcu);
3572	3572
3573	3573	const result: MCValue = result: {
3574		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result try func.resolveInst(ty_op.operand);
	3574	if (!pl_ty.hasRuntimeBits(zcu)) break :result try func.resolveInst(ty_op.operand);
3575	3575
3576	3576	const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
3577	3577	const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
...	...	@@ -3761,7 +3761,7 @@ fn airSliceElemVal(func: *Func, inst: Air.Inst.Index) !void {
3761	3761
3762	3762	const result: MCValue = result: {
3763	3763	const elem_ty = func.typeOfIndex(inst);
3764		if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
	3764	assert(elem_ty.hasRuntimeBits(zcu));
3765	3765
3766	3766	const slice_ty = func.typeOf(bin_op.lhs);
3767	3767	const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
...	...	@@ -3914,7 +3914,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void {
3914	3914
3915	3915	const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: {
3916	3916	const elem_ty = base_ptr_ty.indexableElem(zcu);
3917		if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
	3917	assert(elem_ty.hasRuntimeBits(zcu));
3918	3918	const base_ptr_mcv = try func.resolveInst(bin_op.lhs);
3919	3919	const base_ptr_lock: ?RegisterLock = switch (base_ptr_mcv) {
3920	3920	.register => \|reg\| func.register_manager.lockRegAssumeUnused(reg),
...	...	@@ -4617,7 +4617,7 @@ fn airStructFieldVal(func: *Func, inst: Air.Inst.Index) !void {
4617	4617	const src_mcv = try func.resolveInst(operand);
4618	4618	const struct_ty = func.typeOf(operand);
4619	4619	const field_ty = struct_ty.fieldType(index, zcu);
4620		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
	4620	assert(field_ty.hasRuntimeBits(zcu));
4621	4621
4622	4622	const field_off: u32 = switch (struct_ty.containerLayout(zcu)) {
4623	4623	.auto, .@"extern" => @intCast(struct_ty.structFieldOffset(index, zcu) * 8),
...	...	@@ -5126,7 +5126,6 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
5126	5126	const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
5127	5127	const pt = func.pt;
5128	5128	const zcu = pt.zcu;
5129		const ip = &zcu.intern_pool;
5130	5129
5131	5130	const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: {
5132	5131	const lhs_ty = func.typeOf(bin_op.lhs);
...	...	@@ -5140,28 +5139,23 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
5140	5139	.optional,
5141	5140	.@"struct",
5142	5141	=> {
5143		const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
	5142	const int_ty: Type = switch (lhs_ty.zigTypeTag(zcu)) {
5144	5143	.@"enum" => lhs_ty.intTagType(zcu),
5145	5144	.int => lhs_ty,
5146		.bool => Type.u1,
5147		.pointer => Type.u64,
5148		.error_set => Type.anyerror,
	5145	.bool => .u1,
	5146	.pointer => .u64,
	5147	.error_set => .anyerror,
5149	5148	.optional => blk: {
5150	5149	const payload_ty = lhs_ty.optionalChild(zcu);
5151		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
5152		break :blk Type.u1;
	5150	if (!payload_ty.hasRuntimeBits(zcu)) {
	5151	break :blk .u1;
5153	5152	} else if (lhs_ty.isPtrLikeOptional(zcu)) {
5154		break :blk Type.u64;
	5153	break :blk .u64;
5155	5154	} else {
5156	5155	return func.fail("TODO riscv cmp non-pointer optionals", .{});
5157	5156	}
5158	5157	},
5159		.@"struct" => blk: {
5160		const struct_obj = ip.loadStructType(lhs_ty.toIntern());
5161		assert(struct_obj.layout == .@"packed");
5162		const backing_index = struct_obj.backingIntTypeUnordered(ip);
5163		break :blk Type.fromInterned(backing_index);
5164		},
	5158	.@"struct", .@"union" => lhs_ty.bitpackBackingInt(zcu),
5165	5159	else => unreachable,
5166	5160	};
5167	5161
...	...	@@ -5925,8 +5919,7 @@ fn airBr(func: *Func, inst: Air.Inst.Index) !void {
5925	5919	const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br;
5926	5920
5927	5921	const block_ty = func.typeOfIndex(br.block_inst);
5928		const block_unused =
5929		!block_ty.hasRuntimeBitsIgnoreComptime(zcu) or func.liveness.isUnused(br.block_inst);
	5922	const block_unused = !block_ty.hasRuntimeBits(zcu) or func.liveness.isUnused(br.block_inst);
5930	5923	const block_tracking = func.inst_tracking.getPtr(br.block_inst).?;
5931	5924	const block_data = func.blocks.getPtr(br.block_inst).?;
5932	5925	const first_br = block_data.relocs.items.len == 0;
...	...	@@ -8249,7 +8242,7 @@ fn resolveCallingConventionValues(
8249	8242	// Return values
8250	8243	if (ret_ty.zigTypeTag(zcu) == .noreturn) {
8251	8244	result.return_value = InstTracking.init(.unreach);
8252		} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	8245	} else if (!ret_ty.hasRuntimeBits(zcu)) {
8253	8246	result.return_value = InstTracking.init(.none);
8254	8247	} else {
8255	8248	var ret_tracking: [2]InstTracking = undefined;
...	...	@@ -8300,7 +8293,7 @@ fn resolveCallingConventionValues(
8300	8293	var param_float_reg_i: usize = 0;
8301	8294
8302	8295	for (param_types, result.args) \|ty, *arg\| {
8303		if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	8296	if (!ty.hasRuntimeBits(zcu)) {
8304	8297	assert(cc == .auto);
8305	8298	arg.* = .none;
8306	8299	continue;
...	...	@@ -8415,10 +8408,10 @@ fn hasFeature(func: *Func, feature: Target.riscv.Feature) bool {
8415	8408	}
8416	8409
8417	8410	pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
8418		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
	8411	if (!payload_ty.hasRuntimeBits(zcu)) return 0;
8419	8412	const payload_align = payload_ty.abiAlignment(zcu);
8420	8413	const error_align = Type.anyerror.abiAlignment(zcu);
8421		if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	8414	if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBits(zcu)) {
8422	8415	return 0;
8423	8416	} else {
8424	8417	return payload_align.forward(Type.anyerror.abiSize(zcu));
...	...	@@ -8426,10 +8419,10 @@ pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
8426	8419	}
8427	8420
8428	8421	pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 {
8429		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
	8422	if (!payload_ty.hasRuntimeBits(zcu)) return 0;
8430	8423	const payload_align = payload_ty.abiAlignment(zcu);
8431	8424	const error_align = Type.anyerror.abiAlignment(zcu);
8432		if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	8425	if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBits(zcu)) {
8433	8426	return error_align.forward(payload_ty.abiSize(zcu));
8434	8427	} else {
8435	8428	return 0;

src/codegen/sparc64/CodeGen.zig+11-11

...	...	@@ -1102,7 +1102,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
1102	1102	fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void {
1103	1103	try self.blocks.putNoClobber(self.gpa, inst, .{
1104	1104	// A block is a setup to be able to jump to the end.
1105		.relocs = .{},
	1105	.relocs = .empty,
1106	1106	// It also acts as a receptacle for break operands.
1107	1107	// Here we use `MCValue.none` to represent a null value so that the first
1108	1108	// break instruction will choose a MCValue for the block result and overwrite
...	...	@@ -1376,19 +1376,19 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
1376	1376	const rhs = try self.resolveInst(bin_op.rhs);
1377	1377	const lhs_ty = self.typeOf(bin_op.lhs);
1378	1378
1379		const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
	1379	const int_ty: Type = switch (lhs_ty.zigTypeTag(zcu)) {
1380	1380	.vector => unreachable, // Handled by cmp_vector.
1381	1381	.@"enum" => lhs_ty.intTagType(zcu),
1382	1382	.int => lhs_ty,
1383		.bool => Type.u1,
1384		.pointer => Type.usize,
1385		.error_set => Type.u16,
	1383	.bool => .u1,
	1384	.pointer => .usize,
	1385	.error_set => .u16,
1386	1386	.optional => blk: {
1387	1387	const payload_ty = lhs_ty.optionalChild(zcu);
1388		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
1389		break :blk Type.u1;
	1388	if (!payload_ty.hasRuntimeBits(zcu)) {
	1389	break :blk .u1;
1390	1390	} else if (lhs_ty.isPtrLikeOptional(zcu)) {
1391		break :blk Type.usize;
	1391	break :blk .usize;
1392	1392	} else {
1393	1393	return self.fail("TODO SPARCv9 cmp non-pointer optionals", .{});
1394	1394	}
...	...	@@ -3452,8 +3452,8 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
3452	3452	if (err_ty.errorSetIsEmpty(zcu)) {
3453	3453	return error_union_mcv;
3454	3454	}
3455		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
3456		return MCValue.none;
	3455	if (!payload_ty.hasRuntimeBits(zcu)) {
	3456	return .none;
3457	3457	}
3458	3458
3459	3459	const payload_offset: u32 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
...	...	@@ -4481,7 +4481,7 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
4481	4481	const ty = self.typeOf(ref);
4482	4482
4483	4483	// If the type has no codegen bits, no need to store it.
4484		if (!ty.hasRuntimeBitsIgnoreComptime(pt.zcu)) return .none;
	4484	if (!ty.hasRuntimeBits(pt.zcu)) return .none;
4485	4485
4486	4486	if (ref.toIndex()) \|inst\| {
4487	4487	return self.getResolvedInstValue(inst);

src/codegen/spirv/CodeGen.zig+50-65

...	...	@@ -208,7 +208,7 @@ pub fn genNav(cg: *CodeGen, do_codegen: bool) Error!void {
208	208	try cg.args.ensureUnusedCapacity(gpa, fn_info.param_types.len);
209	209	for (fn_info.param_types.get(ip)) \|param_ty_index\| {
210	210	const param_ty: Type = .fromInterned(param_ty_index);
211		if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	211	if (!param_ty.hasRuntimeBits(zcu)) continue;
212	212
213	213	const param_type_id = try cg.resolveType(param_ty, .direct);
214	214	const arg_result_id = cg.module.allocId();
...	...	@@ -884,7 +884,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
884	884	return try cg.constructComposite(comp_ty_id, &constituents);
885	885	},
886	886	.enum_tag => {
887		const int_val = try val.intFromEnum(ty, pt);
	887	const int_val = val.intFromEnum(zcu);
888	888	const int_ty = ty.intTagType(zcu);
889	889	break :cache try cg.constant(int_ty, int_val, repr);
890	890	},
...	...	@@ -959,18 +959,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
959	959	},
960	960	.struct_type => {
961	961	const struct_type = zcu.typeToStruct(ty).?;
962
963		if (struct_type.layout == .@"packed") {
964		// TODO: composite int
965		// TODO: endianness
966		const bits: u16 = @intCast(ty.bitSize(zcu));
967		const bytes = std.mem.alignForward(u16, cg.module.backingIntBits(bits).@"0", 8) / 8;
968		var limbs: [8]u8 = undefined;
969		@memset(&limbs, 0);
970		val.writeToPackedMemory(pt, limbs[0..bytes], 0) catch unreachable;
971		const backing_ty: Type = .fromInterned(struct_type.backingIntTypeUnordered(ip));
972		return try cg.constInt(backing_ty, @as(u64, @bitCast(limbs)));
973		}
	962	assert(struct_type.layout != .@"packed"); // packed structs use `bitpack`
974	963
975	964	var types = std.array_list.Managed(Type).init(gpa);
976	965	defer types.deinit();
...	...	@@ -981,7 +970,7 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
981	970	var it = struct_type.iterateRuntimeOrder(ip);
982	971	while (it.next()) \|field_index\| {
983	972	const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
984		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	973	if (!field_ty.hasRuntimeBits(zcu)) {
985	974	// This is a zero-bit field - we only needed it for the alignment.
986	975	continue;
987	976	}
...	...	@@ -1001,20 +990,24 @@ fn constant(cg: *CodeGen, ty: Type, val: Value, repr: Repr) Error!Id {
1001	990	else => unreachable,
1002	991	},
1003	992	.un => \|un\| {
	993	assert(ty.containerLayout(zcu) != .@"packed"); // packed unions use `bitpack`
1004	994	if (un.tag == .none) {
1005		assert(ty.containerLayout(zcu) == .@"packed"); // TODO
1006		const int_ty = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
1007		return try cg.constInt(int_ty, Value.toUnsignedInt(.fromInterned(un.val), zcu));
	995	@panic("TODO");
1008	996	}
1009	997	const active_field = ty.unionTagFieldIndex(.fromInterned(un.tag), zcu).?;
1010	998	const union_obj = zcu.typeToUnion(ty).?;
1011	999	const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[active_field]);
1012		const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
	1000	const payload = if (field_ty.hasRuntimeBits(zcu))
1013	1001	try cg.constant(field_ty, .fromInterned(un.val), .direct)
1014	1002	else
1015	1003	null;
1016	1004	return try cg.unionInit(ty, active_field, payload);
1017	1005	},
	1006	.bitpack => \|bitpack\| {
	1007	const int_val: Value = .fromInterned(bitpack.backing_int_val);
	1008	break :cache try cg.constant(int_val.typeOf(zcu), int_val, repr);
	1009	},
	1010
1018	1011	.memoized_call => unreachable,
1019	1012	}
1020	1013	};
...	...	@@ -1255,17 +1248,16 @@ fn resolveTypeName(cg: *CodeGen, ty: Type) ![]const u8 {
1255	1248	fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
1256	1249	const gpa = cg.module.gpa;
1257	1250	const zcu = cg.module.zcu;
1258		const ip = &zcu.intern_pool;
1259	1251	const union_obj = zcu.typeToUnion(ty).?;
1260	1252
1261		if (union_obj.flagsUnordered(ip).layout == .@"packed") {
	1253	if (union_obj.layout == .@"packed") {
1262	1254	return try cg.module.intType(.unsigned, @intCast(ty.bitSize(zcu)));
1263	1255	}
1264	1256
1265	1257	const layout = cg.unionLayout(ty);
1266	1258	if (!layout.has_payload) {
1267	1259	// No payload, so represent this as just the tag type.
1268		return try cg.resolveType(.fromInterned(union_obj.enum_tag_ty), .indirect);
	1260	return try cg.resolveType(.fromInterned(union_obj.enum_tag_type), .indirect);
1269	1261	}
1270	1262
1271	1263	var member_types: [4]Id = undefined;
...	...	@@ -1274,7 +1266,7 @@ fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
1274	1266	const u8_ty_id = try cg.resolveType(.u8, .direct);
1275	1267
1276	1268	if (layout.tag_size != 0) {
1277		const tag_ty_id = try cg.resolveType(.fromInterned(union_obj.enum_tag_ty), .indirect);
	1269	const tag_ty_id = try cg.resolveType(.fromInterned(union_obj.enum_tag_type), .indirect);
1278	1270	member_types[layout.tag_index] = tag_ty_id;
1279	1271	member_names[layout.tag_index] = "(tag)";
1280	1272	}
...	...	@@ -1315,7 +1307,7 @@ fn resolveUnionType(cg: *CodeGen, ty: Type) !Id {
1315	1307
1316	1308	fn resolveFnReturnType(cg: *CodeGen, ret_ty: Type) !Id {
1317	1309	const zcu = cg.module.zcu;
1318		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1310	if (!ret_ty.hasRuntimeBits(zcu)) {
1319	1311	// If the return type is an error set or an error union, then we make this
1320	1312	// anyerror return type instead, so that it can be coerced into a function
1321	1313	// pointer type which has anyerror as the return type.
...	...	@@ -1389,7 +1381,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
1389	1381	return cg.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(zcu)});
1390	1382	};
1391	1383
1392		if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1384	if (!elem_ty.hasRuntimeBits(zcu)) {
1393	1385	assert(repr == .indirect);
1394	1386	if (target.os.tag != .opencl) return cg.fail("cannot generate opaque type", .{});
1395	1387	return try cg.module.opaqueType("zero-sized-array");
...	...	@@ -1453,7 +1445,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
1453	1445	var param_index: usize = 0;
1454	1446	for (fn_info.param_types.get(ip)) \|param_ty_index\| {
1455	1447	const param_ty: Type = .fromInterned(param_ty_index);
1456		if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1448	if (!param_ty.hasRuntimeBits(zcu)) continue;
1457	1449
1458	1450	param_ty_ids[param_index] = try cg.resolveType(param_ty, .direct);
1459	1451	param_index += 1;
...	...	@@ -1518,7 +1510,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
1518	1510	};
1519	1511
1520	1512	if (struct_type.layout == .@"packed") {
1521		return try cg.resolveType(.fromInterned(struct_type.backingIntTypeUnordered(ip)), .direct);
	1513	return try cg.resolveType(.fromInterned(struct_type.packed_backing_int_type), .direct);
1522	1514	}
1523	1515
1524	1516	var member_types = std.array_list.Managed(Id).init(gpa);
...	...	@@ -1533,9 +1525,9 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
1533	1525	var it = struct_type.iterateRuntimeOrder(ip);
1534	1526	while (it.next()) \|field_index\| {
1535	1527	const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
1536		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	1528	if (!field_ty.hasRuntimeBits(zcu)) continue;
1537	1529
1538		const field_name = struct_type.fieldName(ip, field_index);
	1530	const field_name = struct_type.field_names.get(ip)[field_index];
1539	1531	try member_types.append(try cg.resolveType(field_ty, .indirect));
1540	1532	try member_names.append(field_name.toSlice(ip));
1541	1533	try member_offsets.append(@intCast(ty.structFieldOffset(field_index, zcu)));
...	...	@@ -1556,7 +1548,7 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id {
1556	1548	},
1557	1549	.optional => {
1558	1550	const payload_ty = ty.optionalChild(zcu);
1559		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1551	if (!payload_ty.hasRuntimeBits(zcu)) {
1560	1552	// Just use a bool.
1561	1553	// Note: Always generate the bool with indirect format, to save on some sanity
1562	1554	// Perform the conversion to a direct bool when the field is extracted.
...	...	@@ -1653,7 +1645,7 @@ fn errorUnionLayout(cg: *CodeGen, payload_ty: Type) ErrorUnionLayout {
1653	1645
1654	1646	const error_first = error_align.compare(.gt, payload_align);
1655	1647	return .{
1656		.payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu),
	1648	.payload_has_bits = payload_ty.hasRuntimeBits(zcu),
1657	1649	.error_first = error_first,
1658	1650	};
1659	1651	}
...	...	@@ -3724,7 +3716,6 @@ fn cmp(
3724	3716	const gpa = cg.module.gpa;
3725	3717	const pt = cg.pt;
3726	3718	const zcu = cg.module.zcu;
3727		const ip = &zcu.intern_pool;
3728	3719	const scalar_ty = lhs.ty.scalarType(zcu);
3729	3720	const is_vector = lhs.ty.isVector(zcu);
3730	3721
...	...	@@ -3737,7 +3728,7 @@ fn cmp(
3737	3728	},
3738	3729	.@"struct" => {
3739	3730	const struct_ty = zcu.typeToPackedStruct(scalar_ty).?;
3740		const ty: Type = .fromInterned(struct_ty.backingIntTypeUnordered(ip));
	3731	const ty: Type = .fromInterned(struct_ty.packed_backing_int_type);
3741	3732	return try cg.cmp(op, lhs.pun(ty), rhs.pun(ty));
3742	3733	},
3743	3734	.error_set => {
...	...	@@ -3778,7 +3769,7 @@ fn cmp(
3778	3769
3779	3770	const payload_ty = ty.optionalChild(zcu);
3780	3771	if (ty.optionalReprIsPayload(zcu)) {
3781		assert(payload_ty.hasRuntimeBitsIgnoreComptime(zcu));
	3772	assert(payload_ty.hasRuntimeBits(zcu));
3782	3773	assert(!payload_ty.isSlice(zcu));
3783	3774
3784	3775	return try cg.cmp(op, lhs.pun(payload_ty), rhs.pun(payload_ty));
...	...	@@ -3787,12 +3778,12 @@ fn cmp(
3787	3778	const lhs_id = try lhs.materialize(cg);
3788	3779	const rhs_id = try rhs.materialize(cg);
3789	3780
3790		const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
	3781	const lhs_valid_id = if (payload_ty.hasRuntimeBits(zcu))
3791	3782	try cg.extractField(.bool, lhs_id, 1)
3792	3783	else
3793	3784	try cg.convertToDirect(.bool, lhs_id);
3794	3785
3795		const rhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
	3786	const rhs_valid_id = if (payload_ty.hasRuntimeBits(zcu))
3796	3787	try cg.extractField(.bool, rhs_id, 1)
3797	3788	else
3798	3789	try cg.convertToDirect(.bool, rhs_id);
...	...	@@ -3800,7 +3791,7 @@ fn cmp(
3800	3791	const lhs_valid: Temporary = .init(.bool, lhs_valid_id);
3801	3792	const rhs_valid: Temporary = .init(.bool, rhs_valid_id);
3802	3793
3803		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	3794	if (!payload_ty.hasRuntimeBits(zcu)) {
3804	3795	return try cg.cmp(op, lhs_valid, rhs_valid);
3805	3796	}
3806	3797
...	...	@@ -4138,7 +4129,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4138	4129	const array_ptr_id = try cg.resolve(ty_op.operand);
4139	4130	const len_id = try cg.constInt(.usize, array_ty.arrayLen(zcu));
4140	4131
4141		const elem_ptr_id = if (!array_ty.hasRuntimeBitsIgnoreComptime(zcu))
	4132	const elem_ptr_id = if (!array_ty.hasRuntimeBits(zcu))
4142	4133	// Note: The pointer is something like *opaque{}, so we need to bitcast it to the element type.
4143	4134	try cg.bitCast(elem_ptr_ty, array_ptr_ty, array_ptr_id)
4144	4135	else
...	...	@@ -4174,12 +4165,12 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4174	4165	.@"struct" => {
4175	4166	if (zcu.typeToPackedStruct(result_ty)) \|struct_type\| {
4176	4167	comptime assert(Type.packed_struct_layout_version == 2);
4177		const backing_int_ty: Type = .fromInterned(struct_type.backingIntTypeUnordered(ip));
	4168	const backing_int_ty: Type = .fromInterned(struct_type.packed_backing_int_type);
4178	4169	var running_int_id = try cg.constInt(backing_int_ty, 0);
4179	4170	var running_bits: u16 = 0;
4180	4171	for (struct_type.field_types.get(ip), elements) \|field_ty_ip, element\| {
4181	4172	const field_ty: Type = .fromInterned(field_ty_ip);
4182		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	4173	if (!field_ty.hasRuntimeBits(zcu)) continue;
4183	4174	const field_id = try cg.resolve(element);
4184	4175	const ty_bit_size: u16 = @intCast(field_ty.bitSize(zcu));
4185	4176	const field_int_ty = try cg.pt.intType(.unsigned, ty_bit_size);
...	...	@@ -4239,7 +4230,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4239	4230	const field_index = it.next().?;
4240	4231	if ((try result_ty.structFieldValueComptime(pt, i)) != null) continue;
4241	4232	const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
4242		assert(field_ty.hasRuntimeBitsIgnoreComptime(zcu));
	4233	assert(field_ty.hasRuntimeBits(zcu));
4243	4234
4244	4235	const id = try cg.resolve(element);
4245	4236	types[index] = field_ty;
...	...	@@ -4399,10 +4390,7 @@ fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4399	4390	const elem_ty = src_ptr_ty.childType(zcu);
4400	4391	const ptr_id = try cg.resolve(bin_op.lhs);
4401	4392
4402		if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
4403		const dst_ptr_ty = cg.typeOfIndex(inst);
4404		return try cg.bitCast(dst_ptr_ty, src_ptr_ty, ptr_id);
4405		}
	4393	assert(elem_ty.hasRuntimeBits(zcu));
4406	4394
4407	4395	const index_id = try cg.resolve(bin_op.rhs);
4408	4396	return try cg.ptrElemPtr(src_ptr_ty, ptr_id, index_id);
...	...	@@ -4526,13 +4514,13 @@ fn unionInit(
4526	4514	const zcu = cg.module.zcu;
4527	4515	const ip = &zcu.intern_pool;
4528	4516	const union_ty = zcu.typeToUnion(ty).?;
4529		const tag_ty: Type = .fromInterned(union_ty.enum_tag_ty);
	4517	const tag_ty: Type = .fromInterned(union_ty.enum_tag_type);
4530	4518
4531	4519	const layout = cg.unionLayout(ty);
4532	4520	const payload_ty: Type = .fromInterned(union_ty.field_types.get(ip)[active_field]);
4533	4521
4534		if (union_ty.flagsUnordered(ip).layout == .@"packed") {
4535		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4522	if (union_ty.layout == .@"packed") {
	4523	if (!payload_ty.hasRuntimeBits(zcu)) {
4536	4524	const int_ty = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
4537	4525	return cg.constInt(int_ty, 0);
4538	4526	}
...	...	@@ -4558,7 +4546,7 @@ fn unionInit(
4558	4546
4559	4547	const tag_int = if (layout.tag_size != 0) blk: {
4560	4548	const tag_val = try pt.enumValueFieldIndex(tag_ty, active_field);
4561		const tag_int_val = try tag_val.intFromEnum(tag_ty, pt);
	4549	const tag_int_val = tag_val.intFromEnum(zcu);
4562	4550	break :blk tag_int_val.toUnsignedInt(zcu);
4563	4551	} else 0;
4564	4552
...	...	@@ -4577,7 +4565,7 @@ fn unionInit(
4577	4565	try cg.store(tag_ty, ptr_id, tag_id, .{});
4578	4566	}
4579	4567
4580		if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4568	if (payload_ty.hasRuntimeBits(zcu)) {
4581	4569	const layout_payload_ty_id = try cg.resolveType(layout.payload_ty, .indirect);
4582	4570	const pl_ptr_ty_id = try cg.module.ptrType(layout_payload_ty_id, .function);
4583	4571	const pl_ptr_id = try cg.accessChain(pl_ptr_ty_id, tmp_id, &.{layout.payload_index});
...	...	@@ -4613,7 +4601,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4613	4601
4614	4602	const union_obj = zcu.typeToUnion(ty).?;
4615	4603	const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
4616		const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
	4604	const payload = if (field_ty.hasRuntimeBits(zcu))
4617	4605	try cg.resolve(extra.init)
4618	4606	else
4619	4607	null;
...	...	@@ -4631,7 +4619,7 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
4631	4619	const field_index = struct_field.field_index;
4632	4620	const field_ty = object_ty.fieldType(field_index, zcu);
4633	4621
4634		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
	4622	assert(field_ty.hasRuntimeBits(zcu));
4635	4623
4636	4624	switch (object_ty.zigTypeTag(zcu)) {
4637	4625	.@"struct" => switch (object_ty.containerLayout(zcu)) {
...	...	@@ -5332,7 +5320,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) !void {
5332	5320	const zcu = cg.module.zcu;
5333	5321	const operand = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
5334	5322	const ret_ty = cg.typeOf(operand);
5335		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	5323	if (!ret_ty.hasRuntimeBits(zcu)) {
5336	5324	const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
5337	5325	if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
5338	5326	// Functions with an empty error set are emitted with an error code
...	...	@@ -5356,7 +5344,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void {
5356	5344	const ptr_ty = cg.typeOf(un_op);
5357	5345	const ret_ty = ptr_ty.childType(zcu);
5358	5346
5359		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	5347	if (!ret_ty.hasRuntimeBits(zcu)) {
5360	5348	const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
5361	5349	if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
5362	5350	// Functions with an empty error set are emitted with an error code
...	...	@@ -5573,7 +5561,7 @@ fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum {
5573	5561
5574	5562	const is_non_null_id = blk: {
5575	5563	if (is_pointer) {
5576		if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	5564	if (payload_ty.hasRuntimeBits(zcu)) {
5577	5565	const storage_class = cg.module.storageClass(operand_ty.ptrAddressSpace(zcu));
5578	5566	const bool_indirect_ty_id = try cg.resolveType(.bool, .indirect);
5579	5567	const bool_ptr_ty_id = try cg.module.ptrType(bool_indirect_ty_id, storage_class);
...	...	@@ -5584,7 +5572,7 @@ fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum {
5584	5572	break :blk try cg.load(.bool, operand_id, .{});
5585	5573	}
5586	5574
5587		break :blk if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
	5575	break :blk if (payload_ty.hasRuntimeBits(zcu))
5588	5576	try cg.extractField(.bool, operand_id, 1)
5589	5577	else
5590	5578	// Optional representation is bool indicating whether the optional is set
...	...	@@ -5653,7 +5641,7 @@ fn airUnwrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
5653	5641	const optional_ty = cg.typeOf(ty_op.operand);
5654	5642	const payload_ty = cg.typeOfIndex(inst);
5655	5643
5656		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
	5644	if (!payload_ty.hasRuntimeBits(zcu)) return null;
5657	5645
5658	5646	if (optional_ty.optionalReprIsPayload(zcu)) {
5659	5647	return operand_id;
...	...	@@ -5672,7 +5660,7 @@ fn airUnwrapOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
5672	5660	const result_ty = cg.typeOfIndex(inst);
5673	5661	const result_ty_id = try cg.resolveType(result_ty, .direct);
5674	5662
5675		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	5663	if (!payload_ty.hasRuntimeBits(zcu)) {
5676	5664	// There is no payload, but we still need to return a valid pointer.
5677	5665	// We can just return anything here, so just return a pointer to the operand.
5678	5666	return try cg.bitCast(result_ty, operand_ty, operand_id);
...	...	@@ -5691,9 +5679,7 @@ fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id {
5691	5679	const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
5692	5680	const payload_ty = cg.typeOf(ty_op.operand);
5693	5681
5694		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
5695		return try cg.constBool(true, .indirect);
5696		}
	5682	assert(payload_ty.hasRuntimeBits(zcu));
5697	5683
5698	5684	const operand_id = try cg.resolve(ty_op.operand);
5699	5685
...	...	@@ -5789,8 +5775,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void {
5789	5775	const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) {
5790	5776	.bool, .int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu),
5791	5777	.@"enum" => blk: {
5792		// TODO: figure out of cond_ty is correct (something with enum literals)
5793		break :blk (try value.intFromEnum(cond_ty, pt)).toUnsignedInt(zcu); // TODO: composite integer constants
	5778	break :blk value.intFromEnum(zcu).toUnsignedInt(zcu); // TODO: composite integer constants
5794	5779	},
5795	5780	.error_set => value.getErrorInt(zcu),
5796	5781	.pointer => value.toUnsignedInt(zcu),
...	...	@@ -6067,7 +6052,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
6067	6052	// before starting to emit OpFunctionCall instructions. Hence the
6068	6053	// temporary params buffer.
6069	6054	const arg_ty = cg.typeOf(arg);
6070		if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	6055	if (!arg_ty.hasRuntimeBits(zcu)) continue;
6071	6056	const arg_id = try cg.resolve(arg);
6072	6057
6073	6058	params[n_params] = arg_id;
...	...	@@ -6081,7 +6066,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
6081	6066	.id_ref_3 = params[0..n_params],
6082	6067	});
6083	6068
6084		if (cg.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
	6069	if (cg.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBits(zcu)) {
6085	6070	return null;
6086	6071	}
6087	6072

src/codegen/wasm/CodeGen.zig+77-142

...	...	@@ -759,7 +759,7 @@ fn resolveInst(cg: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
759	759	const zcu = pt.zcu;
760	760	const val = (try cg.air.value(ref, pt)).?;
761	761	const ty = cg.typeOf(ref);
762		if (!ty.hasRuntimeBitsIgnoreComptime(zcu) and !ty.isInt(zcu) and !ty.isError(zcu)) {
	762	if (!ty.hasRuntimeBits(zcu) and !ty.isInt(zcu) and !ty.isError(zcu)) {
763	763	gop.value_ptr.* = .none;
764	764	return .none;
765	765	}
...	...	@@ -773,7 +773,7 @@ fn resolveInst(cg: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
773	773	const result: WValue = if (isByRef(ty, zcu, cg.target))
774	774	.{ .uav_ref = .{ .ip_index = val.toIntern() } }
775	775	else
776		try cg.lowerConstant(val, ty);
	776	try cg.lowerConstant(val);
777	777
778	778	gop.value_ptr.* = result;
779	779	return result;
...	...	@@ -786,7 +786,7 @@ fn resolveValue(cg: *CodeGen, val: Value) InnerError!WValue {
786	786	return if (isByRef(ty, zcu, cg.target))
787	787	.{ .uav_ref = .{ .ip_index = val.toIntern() } }
788	788	else
789		try cg.lowerConstant(val, ty);
	789	try cg.lowerConstant(val);
790	790	}
791	791
792	792	/// NOTE: if result == .stack, it will be stored in .local
...	...	@@ -980,7 +980,6 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 {
980	980
981	981	/// For `std.builtin.CallingConvention.auto`.
982	982	pub fn typeToValtype(ty: Type, zcu: const Zcu, target: const std.Target) std.wasm.Valtype {
983		const ip = &zcu.intern_pool;
984	983	return switch (ty.zigTypeTag(zcu)) {
985	984	.float => switch (ty.floatBits(target)) {
986	985	16 => .i32, // stored/loaded as u16
...	...	@@ -994,25 +993,13 @@ pub fn typeToValtype(ty: Type, zcu: const Zcu, target: const std.Target) std.w
994	993	33...64 => .i64,
995	994	else => .i32,
996	995	},
997		.@"struct" => blk: {
998		if (zcu.typeToPackedStruct(ty)) \|packed_struct\| {
999		const backing_int_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
1000		break :blk typeToValtype(backing_int_ty, zcu, target);
1001		} else {
1002		break :blk .i32;
1003		}
1004		},
1005	996	.vector => switch (CodeGen.determineSimdStoreStrategy(ty, zcu, target)) {
1006	997	.direct => .v128,
1007	998	.unrolled => .i32,
1008	999	},
1009		.@"union" => switch (ty.containerLayout(zcu)) {
1010		.@"packed" => switch (ty.bitSize(zcu)) {
1011		0...32 => .i32,
1012		33...64 => .i64,
1013		else => .i32,
1014		},
1015		else => .i32,
	1000	.@"union", .@"struct" => switch (ty.containerLayout(zcu)) {
	1001	.@"packed" => typeToValtype(ty.bitpackBackingInt(zcu), zcu, target),
	1002	.auto, .@"extern" => .i32,
1016	1003	},
1017	1004	else => .i32, // all represented as reference/immediate
1018	1005	};
...	...	@@ -1185,7 +1172,7 @@ pub fn generate(
1185	1172	const fn_ty = zcu.navValue(cg.owner_nav).typeOf(zcu);
1186	1173	const fn_info = zcu.typeToFunc(fn_ty).?;
1187	1174	const ret_ty: Type = .fromInterned(fn_info.return_type);
1188		const any_returns = !firstParamSRet(fn_info.cc, ret_ty, zcu, target) and ret_ty.hasRuntimeBitsIgnoreComptime(zcu);
	1175	const any_returns = !firstParamSRet(fn_info.cc, ret_ty, zcu, target) and ret_ty.hasRuntimeBits(zcu);
1189	1176
1190	1177	var cc_result = try resolveCallingConventionValues(zcu, fn_ty, target);
1191	1178	defer cc_result.deinit(gpa);
...	...	@@ -1244,7 +1231,7 @@ fn generateInner(cg: *CodeGen, any_returns: bool) InnerError!Mir {
1244	1231	if (any_returns and cg.air.instructions.len > 0) {
1245	1232	const inst: Air.Inst.Index = @enumFromInt(cg.air.instructions.len - 1);
1246	1233	const last_inst_ty = cg.typeOfIndex(inst);
1247		if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1234	if (!last_inst_ty.hasRuntimeBits(zcu)) {
1248	1235	try cg.addTag(.@"unreachable");
1249	1236	}
1250	1237	}
...	...	@@ -1316,7 +1303,7 @@ fn resolveCallingConventionValues(
1316	1303	switch (cc) {
1317	1304	.auto => {
1318	1305	for (fn_info.param_types.get(ip)) \|ty\| {
1319		if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
	1306	if (!Type.fromInterned(ty).hasRuntimeBits(zcu)) {
1320	1307	continue;
1321	1308	}
1322	1309
...	...	@@ -1326,7 +1313,7 @@ fn resolveCallingConventionValues(
1326	1313	},
1327	1314	.wasm_mvp => {
1328	1315	for (fn_info.param_types.get(ip)) \|ty\| {
1329		if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
	1316	if (!Type.fromInterned(ty).hasRuntimeBits(zcu)) {
1330	1317	continue;
1331	1318	}
1332	1319	switch (abi.classifyType(.fromInterned(ty), zcu)) {
...	...	@@ -1357,7 +1344,7 @@ pub fn firstParamSRet(
1357	1344	zcu: *const Zcu,
1358	1345	target: *const std.Target,
1359	1346	) bool {
1360		if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false;
	1347	if (!return_type.hasRuntimeBits(zcu)) return false;
1361	1348	switch (cc) {
1362	1349	.@"inline" => unreachable,
1363	1350	.auto => return isByRef(return_type, zcu, target),
...	...	@@ -1457,7 +1444,7 @@ fn restoreStackPointer(cg: *CodeGen) !void {
1457	1444	fn allocStack(cg: *CodeGen, ty: Type) !WValue {
1458	1445	const pt = cg.pt;
1459	1446	const zcu = pt.zcu;
1460		assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
	1447	assert(ty.hasRuntimeBits(zcu));
1461	1448	if (cg.initial_stack_value == .none) {
1462	1449	try cg.initializeStack();
1463	1450	}
...	...	@@ -1491,7 +1478,7 @@ fn allocStackPtr(cg: *CodeGen, inst: Air.Inst.Index) !WValue {
1491	1478	try cg.initializeStack();
1492	1479	}
1493	1480
1494		if (!pointee_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1481	if (!pointee_ty.hasRuntimeBits(zcu)) {
1495	1482	return cg.allocStack(Type.usize); // create a value containing just the stack pointer.
1496	1483	}
1497	1484
...	...	@@ -1676,7 +1663,6 @@ fn ptrSize(cg: *const CodeGen) u16 {
1676	1663	/// For a given `Type`, will return true when the type will be passed
1677	1664	/// by reference, rather than by value
1678	1665	fn isByRef(ty: Type, zcu: const Zcu, target: const std.Target) bool {
1679		const ip = &zcu.intern_pool;
1680	1666	switch (ty.zigTypeTag(zcu)) {
1681	1667	.type,
1682	1668	.comptime_int,
...	...	@@ -1697,20 +1683,10 @@ fn isByRef(ty: Type, zcu: const Zcu, target: const std.Target) bool {
1697	1683
1698	1684	.array,
1699	1685	.frame,
1700		=> return ty.hasRuntimeBitsIgnoreComptime(zcu),
1701		.@"union" => {
1702		if (zcu.typeToUnion(ty)) \|union_obj\| {
1703		if (union_obj.flagsUnordered(ip).layout == .@"packed") {
1704		return ty.abiSize(zcu) > 8;
1705		}
1706		}
1707		return ty.hasRuntimeBitsIgnoreComptime(zcu);
1708		},
1709		.@"struct" => {
1710		if (zcu.typeToPackedStruct(ty)) \|packed_struct\| {
1711		return isByRef(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), zcu, target);
1712		}
1713		return ty.hasRuntimeBitsIgnoreComptime(zcu);
	1686	=> return ty.hasRuntimeBits(zcu),
	1687	.@"struct", .@"union" => switch (ty.containerLayout(zcu)) {
	1688	.@"packed" => return isByRef(ty.bitpackBackingInt(zcu), zcu, target),
	1689	.@"extern", .auto => return ty.hasRuntimeBits(zcu),
1714	1690	},
1715	1691	.vector => return determineSimdStoreStrategy(ty, zcu, target) == .unrolled,
1716	1692	.int => return ty.intInfo(zcu).bits > 64,
...	...	@@ -1718,7 +1694,7 @@ fn isByRef(ty: Type, zcu: const Zcu, target: const std.Target) bool {
1718	1694	.float => return ty.floatBits(target) > 64,
1719	1695	.error_union => {
1720	1696	const pl_ty = ty.errorUnionPayload(zcu);
1721		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	1697	if (!pl_ty.hasRuntimeBits(zcu)) {
1722	1698	return false;
1723	1699	}
1724	1700	return true;
...	...	@@ -1727,7 +1703,7 @@ fn isByRef(ty: Type, zcu: const Zcu, target: const std.Target) bool {
1727	1703	if (ty.isPtrLikeOptional(zcu)) return false;
1728	1704	const pl_type = ty.optionalChild(zcu);
1729	1705	if (pl_type.zigTypeTag(zcu) == .error_set) return false;
1730		return pl_type.hasRuntimeBitsIgnoreComptime(zcu);
	1706	return pl_type.hasRuntimeBits(zcu);
1731	1707	},
1732	1708	.pointer => {
1733	1709	// Slices act like struct and will be passed by reference
...	...	@@ -2069,7 +2045,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2069	2045	// to the stack instead
2070	2046	if (cg.return_value != .none) {
2071	2047	try cg.store(cg.return_value, operand, ret_ty, 0);
2072		} else if (fn_info.cc == .wasm_mvp and ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	2048	} else if (fn_info.cc == .wasm_mvp and ret_ty.hasRuntimeBits(zcu)) {
2073	2049	switch (abi.classifyType(ret_ty, zcu)) {
2074	2050	.direct => \|scalar_type\| {
2075	2051	assert(!abi.lowerAsDoubleI64(scalar_type, zcu));
...	...	@@ -2082,7 +2058,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2082	2058	.indirect => unreachable,
2083	2059	}
2084	2060	} else {
2085		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and ret_ty.isError(zcu)) {
	2061	if (!ret_ty.hasRuntimeBits(zcu) and ret_ty.isError(zcu)) {
2086	2062	try cg.addImm32(0);
2087	2063	} else {
2088	2064	try cg.emitWValue(operand);
...	...	@@ -2121,7 +2097,7 @@ fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2121	2097	const ret_ty = cg.typeOf(un_op).childType(zcu);
2122	2098
2123	2099	const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?;
2124		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	2100	if (!ret_ty.hasRuntimeBits(zcu)) {
2125	2101	if (ret_ty.isError(zcu)) {
2126	2102	try cg.addImm32(0);
2127	2103	}
...	...	@@ -2177,7 +2153,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
2177	2153	const arg_val = try cg.resolveInst(arg);
2178	2154
2179	2155	const arg_ty = cg.typeOf(arg);
2180		if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	2156	if (!arg_ty.hasRuntimeBits(zcu)) continue;
2181	2157
2182	2158	try cg.lowerArg(zcu.typeToFunc(fn_ty).?.cc, arg_ty, arg_val);
2183	2159	}
...	...	@@ -2199,7 +2175,7 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifie
2199	2175	}
2200	2176
2201	2177	const result_value = result_value: {
2202		if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
	2178	if (!ret_ty.hasRuntimeBits(zcu) and !ret_ty.isError(zcu)) {
2203	2179	break :result_value .none;
2204	2180	} else if (first_param_sret) {
2205	2181	break :result_value sret;
...	...	@@ -2320,12 +2296,12 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
2320	2296	const zcu = pt.zcu;
2321	2297	const abi_size = ty.abiSize(zcu);
2322	2298
2323		if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
	2299	if (!ty.hasRuntimeBits(zcu)) return;
2324	2300
2325	2301	switch (ty.zigTypeTag(zcu)) {
2326	2302	.error_union => {
2327	2303	const pl_ty = ty.errorUnionPayload(zcu);
2328		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	2304	if (!pl_ty.hasRuntimeBits(zcu)) {
2329	2305	return cg.store(lhs, rhs, Type.anyerror, offset);
2330	2306	}
2331	2307
...	...	@@ -2338,7 +2314,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr
2338	2314	return cg.store(lhs, rhs, Type.usize, offset);
2339	2315	}
2340	2316	const pl_ty = ty.optionalChild(zcu);
2341		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	2317	if (!pl_ty.hasRuntimeBits(zcu)) {
2342	2318	return cg.store(lhs, rhs, Type.u8, offset);
2343	2319	}
2344	2320	if (pl_ty.zigTypeTag(zcu) == .error_set) {
...	...	@@ -2438,7 +2414,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
2438	2414	const ptr_ty = cg.typeOf(ty_op.operand);
2439	2415	const ptr_info = ptr_ty.ptrInfo(zcu);
2440	2416
2441		if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
	2417	if (!ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{ty_op.operand});
2442	2418
2443	2419	const result = result: {
2444	2420	if (isByRef(ty, zcu, cg.target)) {
...	...	@@ -3089,7 +3065,7 @@ fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerErro
3089	3065	return switch (ptr.base_addr) {
3090	3066	.nav => \|nav\| return .{ .nav_ref = .{ .nav_index = nav, .offset = @intCast(offset) } },
3091	3067	.uav => \|uav\| return .{ .uav_ref = .{ .ip_index = uav.val, .offset = @intCast(offset), .orig_ptr_ty = uav.orig_ty } },
3092		.int => return cg.lowerConstant(try pt.intValue(Type.usize, offset), Type.usize),
	3068	.int => return cg.lowerConstant(try pt.intValue(.usize, offset)),
3093	3069	.eu_payload => \|eu_ptr\| try cg.lowerPtr(
3094	3070	eu_ptr,
3095	3071	offset + codegen.errUnionPayloadOffset(
...	...	@@ -3126,10 +3102,11 @@ fn lowerPtr(cg: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerErro
3126	3102	};
3127	3103	}
3128	3104
3129		/// Asserts that `isByRef` returns `false` for `ty`.
3130		fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
	3105	/// Asserts that `isByRef` returns `false` for `val.typeOf(zcu)`.
	3106	fn lowerConstant(cg: *CodeGen, val: Value) InnerError!WValue {
3131	3107	const pt = cg.pt;
3132	3108	const zcu = pt.zcu;
	3109	const ty = val.typeOf(zcu);
3133	3110	assert(!isByRef(ty, zcu, cg.target));
3134	3111	const ip = &zcu.intern_pool;
3135	3112	if (val.isUndef(zcu)) return cg.emitUndefined(ty);
...	...	@@ -3191,31 +3168,22 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
3191	3168	},
3192	3169	.error_union => \|error_union\| {
3193	3170	const err_int_ty = try pt.errorIntType();
3194		const err_ty, const err_val = switch (error_union.val) {
3195		.err_name => \|err_name\| .{
3196		ty.errorUnionSet(zcu),
3197		Value.fromInterned(try pt.intern(.{ .err = .{
3198		.ty = ty.errorUnionSet(zcu).toIntern(),
3199		.name = err_name,
3200		} })),
3201		},
3202		.payload => .{
3203		err_int_ty,
3204		try pt.intValue(err_int_ty, 0),
3205		},
	3171	const err_val: Value = switch (error_union.val) {
	3172	.err_name => \|err_name\| .fromInterned(try pt.intern(.{ .err = .{
	3173	.ty = ty.errorUnionSet(zcu).toIntern(),
	3174	.name = err_name,
	3175	} })),
	3176	.payload => try pt.intValue(err_int_ty, 0),
3206	3177	};
3207	3178	const payload_type = ty.errorUnionPayload(zcu);
3208		if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
	3179	if (!payload_type.hasRuntimeBits(zcu)) {
3209	3180	// We use the error type directly as the type.
3210		return cg.lowerConstant(err_val, err_ty);
	3181	return cg.lowerConstant(err_val);
3211	3182	}
3212	3183
3213	3184	return cg.fail("Wasm TODO: lowerConstant error union with non-zero-bit payload type", .{});
3214	3185	},
3215		.enum_tag => \|enum_tag\| {
3216		const int_tag_ty = ip.typeOf(enum_tag.int);
3217		return cg.lowerConstant(Value.fromInterned(enum_tag.int), Type.fromInterned(int_tag_ty));
3218		},
	3186	.enum_tag => \|enum_tag\| return cg.lowerConstant(.fromInterned(enum_tag.int)),
3219	3187	.float => \|float\| switch (float.storage) {
3220	3188	.f16 => \|f16_val\| return .{ .imm32 = @as(u16, @bitCast(f16_val)) },
3221	3189	.f32 => \|f32_val\| return .{ .float32 = f32_val },
...	...	@@ -3225,9 +3193,8 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
3225	3193	.slice => unreachable, // isByRef == true
3226	3194	.ptr => return cg.lowerPtr(val.toIntern(), 0),
3227	3195	.opt => if (ty.optionalReprIsPayload(zcu)) {
3228		const pl_ty = ty.optionalChild(zcu);
3229	3196	if (val.optionalValue(zcu)) \|payload\| {
3230		return cg.lowerConstant(payload, pl_ty);
	3197	return cg.lowerConstant(payload);
3231	3198	} else {
3232	3199	return .{ .imm32 = 0 };
3233	3200	}
...	...	@@ -3242,33 +3209,11 @@ fn lowerConstant(cg: *CodeGen, val: Value, ty: Type) InnerError!WValue {
3242	3209	val.writeToMemory(pt, &buf) catch unreachable;
3243	3210	return cg.storeSimdImmd(buf);
3244	3211	},
3245		.struct_type => {
3246		const struct_type = ip.loadStructType(ty.toIntern());
3247		// non-packed structs are not handled in this function because they
3248		// are by-ref types.
3249		assert(struct_type.layout == .@"packed");
3250		var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
3251		val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
3252		const backing_int_ty = Type.fromInterned(struct_type.backingIntTypeUnordered(ip));
3253		const int_val = try pt.intValue(
3254		backing_int_ty,
3255		mem.readInt(u64, &buf, .little),
3256		);
3257		return cg.lowerConstant(int_val, backing_int_ty);
3258		},
	3212	.struct_type => unreachable, // packed structs use `bitpack`
3259	3213	else => unreachable,
3260	3214	},
3261		.un => {
3262		const int_type = try pt.intType(.unsigned, @intCast(ty.bitSize(zcu)));
3263
3264		var buf: [8]u8 = .{0} ** 8; // zero the buffer so we do not read 0xaa as integer
3265		val.writeToPackedMemory(pt, &buf, 0) catch unreachable;
3266		const int_val = try pt.intValue(
3267		int_type,
3268		mem.readInt(u64, &buf, .little),
3269		);
3270		return cg.lowerConstant(int_val, int_type);
3271		},
	3215	.un => unreachable, // packed unions use `bitpack`
	3216	.bitpack => \|bitpack\| return cg.lowerConstant(.fromInterned(bitpack.backing_int_val)),
3272	3217	.memoized_call => unreachable,
3273	3218	}
3274	3219	}
...	...	@@ -3283,7 +3228,6 @@ fn storeSimdImmd(cg: *CodeGen, value: [16]u8) !WValue {
3283	3228
3284	3229	fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
3285	3230	const zcu = cg.pt.zcu;
3286		const ip = &zcu.intern_pool;
3287	3231	switch (ty.zigTypeTag(zcu)) {
3288	3232	.bool, .error_set => return .{ .imm32 = 0xaaaaaaaa },
3289	3233	.int, .@"enum" => switch (ty.intInfo(zcu).bits) {
...	...	@@ -3311,17 +3255,9 @@ fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue {
3311	3255	.error_union => {
3312	3256	return .{ .imm32 = 0xaaaaaaaa };
3313	3257	},
3314		.@"struct" => {
3315		const packed_struct = zcu.typeToPackedStruct(ty).?;
3316		return cg.emitUndefined(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)));
3317		},
3318		.@"union" => switch (ty.containerLayout(zcu)) {
3319		.@"packed" => switch (ty.bitSize(zcu)) {
3320		0...32 => return .{ .imm32 = 0xaaaaaaaa },
3321		33...64 => return .{ .imm64 = 0xaaaaaaaaaaaaaaaa },
3322		else => unreachable,
3323		},
3324		else => unreachable,
	3258	.@"struct", .@"union" => {
	3259	const backing_int_ty = ty.bitpackBackingInt(zcu);
	3260	return cg.emitUndefined(backing_int_ty);
3325	3261	},
3326	3262	else => return cg.fail("Wasm TODO: emitUndefined for type: {t}\n", .{ty.zigTypeTag(zcu)}),
3327	3263	}
...	...	@@ -3335,7 +3271,7 @@ fn airBlock(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
3335	3271	fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, block_ty: Type, body: []const Air.Inst.Index) InnerError!void {
3336	3272	const zcu = cg.pt.zcu;
3337	3273	// if wasm_block_ty is non-empty, we create a register to store the temporary value
3338		const block_result: WValue = if (block_ty.hasRuntimeBitsIgnoreComptime(zcu))
	3274	const block_result: WValue = if (block_ty.hasRuntimeBits(zcu))
3339	3275	try cg.allocLocal(block_ty)
3340	3276	else
3341	3277	.none;
...	...	@@ -3449,7 +3385,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe
3449	3385	const zcu = cg.pt.zcu;
3450	3386	if (ty.zigTypeTag(zcu) == .optional and !ty.optionalReprIsPayload(zcu)) {
3451	3387	const payload_ty = ty.optionalChild(zcu);
3452		if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	3388	if (payload_ty.hasRuntimeBits(zcu)) {
3453	3389	// When we hit this case, we must check the value of optionals
3454	3390	// that are not pointers. This means first checking against non-null for
3455	3391	// both lhs and rhs, as well as checking the payload are matching of lhs and rhs
...	...	@@ -3792,7 +3728,6 @@ fn structFieldPtr(
3792	3728	fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
3793	3729	const pt = cg.pt;
3794	3730	const zcu = pt.zcu;
3795		const ip = &zcu.intern_pool;
3796	3731	const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
3797	3732	const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data;
3798	3733
...	...	@@ -3800,14 +3735,14 @@ fn airStructFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
3800	3735	const operand = try cg.resolveInst(struct_field.struct_operand);
3801	3736	const field_index = struct_field.field_index;
3802	3737	const field_ty = struct_ty.fieldType(field_index, zcu);
3803		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return cg.finishAir(inst, .none, &.{struct_field.struct_operand});
	3738	if (!field_ty.hasRuntimeBits(zcu)) return cg.finishAir(inst, .none, &.{struct_field.struct_operand});
3804	3739
3805	3740	const result: WValue = switch (struct_ty.containerLayout(zcu)) {
3806	3741	.@"packed" => switch (struct_ty.zigTypeTag(zcu)) {
3807	3742	.@"struct" => result: {
3808	3743	const packed_struct = zcu.typeToPackedStruct(struct_ty).?;
3809	3744	const offset = zcu.structPackedFieldBitOffset(packed_struct, field_index);
3810		const backing_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
	3745	const backing_ty = Type.fromInterned(packed_struct.packed_backing_int_type);
3811	3746	const host_bits = backing_ty.intInfo(zcu).bits;
3812	3747
3813	3748	const const_wvalue: WValue = if (33 <= host_bits and host_bits <= 64)
...	...	@@ -3885,7 +3820,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Inner
3885	3820	const switch_br = cg.air.unwrapSwitch(inst);
3886	3821	const target_ty = cg.typeOf(switch_br.operand);
3887	3822
3888		assert(target_ty.hasRuntimeBitsIgnoreComptime(zcu));
	3823	assert(target_ty.hasRuntimeBits(zcu));
3889	3824
3890	3825	// swap target value with placeholder local, for dispatching
3891	3826	const target = if (is_dispatch_loop) target: {
...	...	@@ -4119,7 +4054,7 @@ fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind
4119	4054	}
4120	4055
4121	4056	try cg.emitWValue(operand);
4122		if (op_kind == .ptr or pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4057	if (op_kind == .ptr or pl_ty.hasRuntimeBits(zcu)) {
4123	4058	try cg.addMemArg(.i32_load16_u, .{
4124	4059	.offset = operand.offset() + @as(u32, @intCast(errUnionErrorOffset(pl_ty, zcu))),
4125	4060	.alignment = @intCast(Type.anyerror.abiAlignment(zcu).toByteUnits().?),
...	...	@@ -4146,7 +4081,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
4146	4081	const payload_ty = eu_ty.errorUnionPayload(zcu);
4147	4082
4148	4083	const result: WValue = result: {
4149		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4084	if (!payload_ty.hasRuntimeBits(zcu)) {
4150	4085	if (op_is_ptr) {
4151	4086	break :result cg.reuseOperand(ty_op.operand, operand);
4152	4087	} else {
...	...	@@ -4166,7 +4101,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
4166	4101	}
4167	4102
4168	4103	/// E!T -> E op_is_ptr == false
4169		/// *(E!T) -> E op_is_prt == true
	4104	/// *(E!T) -> E op_is_ptr == true
4170	4105	/// NOTE: op_is_ptr will not change return type
4171	4106	fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
4172	4107	const zcu = cg.pt.zcu;
...	...	@@ -4186,7 +4121,7 @@ fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) I
4186	4121	if (op_is_ptr or isByRef(eu_ty, zcu, cg.target)) {
4187	4122	break :result try cg.load(operand, Type.anyerror, err_offset);
4188	4123	} else {
4189		assert(!payload_ty.hasRuntimeBitsIgnoreComptime(zcu));
	4124	assert(!payload_ty.hasRuntimeBits(zcu));
4190	4125	break :result cg.reuseOperand(ty_op.operand, operand);
4191	4126	}
4192	4127	};
...	...	@@ -4202,7 +4137,7 @@ fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4202	4137
4203	4138	const pl_ty = cg.typeOf(ty_op.operand);
4204	4139	const result = result: {
4205		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4140	if (!pl_ty.hasRuntimeBits(zcu)) {
4206	4141	break :result cg.reuseOperand(ty_op.operand, operand);
4207	4142	}
4208	4143
...	...	@@ -4232,7 +4167,7 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4232	4167	const pl_ty = err_ty.errorUnionPayload(zcu);
4233	4168
4234	4169	const result = result: {
4235		if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4170	if (!pl_ty.hasRuntimeBits(zcu)) {
4236	4171	break :result cg.reuseOperand(ty_op.operand, operand);
4237	4172	}
4238	4173
...	...	@@ -4348,7 +4283,7 @@ fn isNull(cg: *CodeGen, operand: WValue, optional_ty: Type, opcode: std.wasm.Opc
4348	4283	if (!optional_ty.optionalReprIsPayload(zcu)) {
4349	4284	// When payload is zero-bits, we can treat operand as a value, rather than
4350	4285	// a pointer to the stack value
4351		if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4286	if (payload_ty.hasRuntimeBits(zcu)) {
4352	4287	const offset = std.math.cast(u32, payload_ty.abiSize(zcu)) orelse {
4353	4288	return cg.fail("Optional type {f} too big to fit into stack frame", .{optional_ty.fmt(pt)});
4354	4289	};
...	...	@@ -4373,7 +4308,7 @@ fn airOptionalPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4373	4308	const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
4374	4309	const opt_ty = cg.typeOf(ty_op.operand);
4375	4310	const payload_ty = cg.typeOfIndex(inst);
4376		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4311	if (!payload_ty.hasRuntimeBits(zcu)) {
4377	4312	return cg.finishAir(inst, .none, &.{ty_op.operand});
4378	4313	}
4379	4314
...	...	@@ -4398,7 +4333,7 @@ fn airOptionalPayloadPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4398	4333
4399	4334	const result = result: {
4400	4335	const payload_ty = opt_ty.optionalChild(zcu);
4401		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu) or opt_ty.optionalReprIsPayload(zcu)) {
	4336	if (!payload_ty.hasRuntimeBits(zcu) or opt_ty.optionalReprIsPayload(zcu)) {
4402	4337	break :result cg.reuseOperand(ty_op.operand, operand);
4403	4338	}
4404	4339
...	...	@@ -4438,7 +4373,7 @@ fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4438	4373	const zcu = pt.zcu;
4439	4374
4440	4375	const result = result: {
4441		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4376	if (!payload_ty.hasRuntimeBits(zcu)) {
4442	4377	const non_null_bit = try cg.allocStack(Type.u1);
4443	4378	try cg.emitWValue(non_null_bit);
4444	4379	try cg.addImm32(1);
...	...	@@ -4606,7 +4541,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
4606	4541	const slice_local = try cg.allocStack(slice_ty);
4607	4542
4608	4543	// store the array ptr in the slice
4609		if (array_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	4544	if (array_ty.hasRuntimeBits(zcu)) {
4610	4545	try cg.store(slice_local, operand, Type.usize, 0);
4611	4546	}
4612	4547
...	...	@@ -5105,7 +5040,7 @@ fn airShuffleOne(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5105	5040	try cg.emitWValue(dest_alloc);
5106	5041	const elem_val = switch (mask_elem.unwrap()) {
5107	5042	.elem => \|idx\| try cg.load(operand, elem_ty, @intCast(elem_size * idx)),
5108		.value => \|val\| try cg.lowerConstant(.fromInterned(val), elem_ty),
	5043	.value => \|val\| try cg.lowerConstant(.fromInterned(val)),
5109	5044	};
5110	5045	try cg.store(.stack, elem_val, elem_ty, @intCast(dest_alloc.offset() + elem_size * out_idx));
5111	5046	}
...	...	@@ -5246,7 +5181,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5246	5181	}
5247	5182	const packed_struct = zcu.typeToPackedStruct(result_ty).?;
5248	5183	const field_types = packed_struct.field_types;
5249		const backing_type = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
	5184	const backing_type = Type.fromInterned(packed_struct.packed_backing_int_type);
5250	5185
5251	5186	// ensure the result is zero'd
5252	5187	const result = try cg.allocLocal(backing_type);
...	...	@@ -5259,7 +5194,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5259	5194	var current_bit: u16 = 0;
5260	5195	for (elements, 0..) \|elem, elem_index\| {
5261	5196	const field_ty = Type.fromInterned(field_types.get(ip)[elem_index]);
5262		if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	5197	if (!field_ty.hasRuntimeBits(zcu)) continue;
5263	5198
5264	5199	const shift_val: WValue = if (backing_type.bitSize(zcu) <= 32)
5265	5200	.{ .imm32 = current_bit }
...	...	@@ -5332,13 +5267,13 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5332	5267	const layout = union_ty.unionGetLayout(zcu);
5333	5268	const union_obj = zcu.typeToUnion(union_ty).?;
5334	5269	const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
5335		const field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
	5270	const field_name = ip.loadEnumType(union_obj.enum_tag_type).field_names.get(ip)[extra.field_index];
5336	5271
5337	5272	const tag_int = blk: {
5338		const tag_ty = union_ty.unionTagTypeRuntime(zcu).?;
	5273	const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
5339	5274	const enum_field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
5340	5275	const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
5341		break :blk try cg.lowerConstant(tag_val, tag_ty);
	5276	break :blk try cg.lowerConstant(tag_val);
5342	5277	};
5343	5278	if (layout.payload_size == 0) {
5344	5279	if (layout.tag_size == 0) {
...	...	@@ -5360,7 +5295,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5360	5295	}
5361	5296
5362	5297	if (layout.tag_size > 0) {
5363		try cg.store(result_ptr, tag_int, Type.fromInterned(union_obj.enum_tag_ty), 0);
	5298	try cg.store(result_ptr, tag_int, .fromInterned(union_obj.enum_tag_type), 0);
5364	5299	}
5365	5300	} else {
5366	5301	try cg.store(result_ptr, payload, field_ty, 0);
...	...	@@ -5368,7 +5303,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void {
5368	5303	try cg.store(
5369	5304	result_ptr,
5370	5305	tag_int,
5371		Type.fromInterned(union_obj.enum_tag_ty),
	5306	.fromInterned(union_obj.enum_tag_type),
5372	5307	@intCast(layout.payload_size),
5373	5308	);
5374	5309	}
...	...	@@ -5415,7 +5350,7 @@ fn airWasmMemoryGrow(cg: *CodeGen, inst: Air.Inst.Index) !void {
5415	5350
5416	5351	fn cmpOptionals(cg: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
5417	5352	const zcu = cg.pt.zcu;
5418		assert(operand_ty.hasRuntimeBitsIgnoreComptime(zcu));
	5353	assert(operand_ty.hasRuntimeBits(zcu));
5419	5354	assert(op == .eq or op == .neq);
5420	5355	const payload_ty = operand_ty.optionalChild(zcu);
5421	5356	assert(!isByRef(payload_ty, zcu, cg.target));
...	...	@@ -5669,7 +5604,7 @@ fn airErrUnionPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void
5669	5604	);
5670	5605
5671	5606	const result = result: {
5672		if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
	5607	if (!payload_ty.hasRuntimeBits(zcu)) {
5673	5608	break :result cg.reuseOperand(ty_op.operand, operand);
5674	5609	}
5675	5610
...	...	@@ -6458,7 +6393,7 @@ fn lowerTry(
6458	6393	const zcu = cg.pt.zcu;
6459	6394
6460	6395	const pl_ty = err_union_ty.errorUnionPayload(zcu);
6461		const pl_has_bits = pl_ty.hasRuntimeBitsIgnoreComptime(zcu);
	6396	const pl_has_bits = pl_ty.hasRuntimeBits(zcu);
6462	6397
6463	6398	if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
6464	6399	// Block we can jump out of when error is not set
...	...	@@ -7096,13 +7031,13 @@ fn callIntrinsic(
7096	7031	// Lower all arguments to the stack before we call our function
7097	7032	for (args, 0..) \|arg, arg_i\| {
7098	7033	assert(!(want_sret_param and arg == .stack));
7099		assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBitsIgnoreComptime(zcu));
	7034	assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBits(zcu));
7100	7035	try cg.lowerArg(.{ .wasm_mvp = .{} }, Type.fromInterned(param_types[arg_i]), arg);
7101	7036	}
7102	7037
7103	7038	try cg.addInst(.{ .tag = .call_intrinsic, .data = .{ .intrinsic = intrinsic } });
7104	7039
7105		if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
	7040	if (!return_type.hasRuntimeBits(zcu)) {
7106	7041	return .none;
7107	7042	} else if (want_sret_param) {
7108	7043	return sret;

src/link/MachO/Atom.zig+1-1

...	...	@@ -561,7 +561,7 @@ fn reportUndefSymbol(self: Atom, rel: Relocation, macho_file: *MachO) !bool {
561	561	defer macho_file.undefs_mutex.unlock(io);
562	562	const gop = try macho_file.undefs.getOrPut(gpa, file.getGlobals()[rel.target]);
563	563	if (!gop.found_existing) {
564		gop.value_ptr.* = .{ .refs = .{} };
	564	gop.value_ptr.* = .{ .refs = .empty };
565	565	}
566	566	try gop.value_ptr.refs.append(gpa, .{ .index = self.atom_index, .file = self.file });
567	567	return true;

src/link/MachO/ZigObject.zig+1-1

...	...	@@ -150,7 +150,7 @@ fn newAtom(self: *ZigObject, allocator: Allocator, name: MachO.String, macho_fil
150	150	atom.name = name;
151	151
152	152	const relocs_index = @as(u32, @intCast(self.relocs.items.len));
153		self.relocs.addOneAssumeCapacity().* = .{};
	153	self.relocs.addOneAssumeCapacity().* = .empty;
154	154	atom.addExtra(.{ .rel_index = relocs_index, .rel_count = 0 }, macho_file);
155	155
156	156	return index;

src/link/MachO/file.zig+1-1

...	...	@@ -258,7 +258,7 @@ pub const File = union(enum) {
258	258
259	259	const gop = try macho_file.dupes.getOrPut(gpa, file.getGlobals()[i]);
260	260	if (!gop.found_existing) {
261		gop.value_ptr.* = .{};
	261	gop.value_ptr.* = .empty;
262	262	}
263	263	try gop.value_ptr.append(gpa, file.getIndex());
264	264	}

src/link/Wasm.zig+2-2

...	...	@@ -4226,7 +4226,7 @@ fn convertZcuFnType(
4226	4226
4227	4227	if (CodeGen.firstParamSRet(cc, return_type, zcu, target)) {
4228	4228	try params_buffer.append(gpa, .i32); // memory address is always a 32-bit handle
4229		} else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
	4229	} else if (return_type.hasRuntimeBits(zcu)) {
4230	4230	if (cc == .wasm_mvp) {
4231	4231	switch (abi.classifyType(return_type, zcu)) {
4232	4232	.direct => \|scalar_ty\| {
...	...	@@ -4245,7 +4245,7 @@ fn convertZcuFnType(
4245	4245	// param types
4246	4246	for (params) \|param_type_ip\| {
4247	4247	const param_type = Zcu.Type.fromInterned(param_type_ip);
4248		if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
	4248	if (!param_type.hasRuntimeBits(zcu)) continue;
4249	4249
4250	4250	switch (cc) {
4251	4251	.wasm_mvp => {

src/link/Wasm/Flush.zig+3-3

...	...	@@ -154,7 +154,7 @@ pub fn finish(f: Flush, wasm: Wasm) !void {
154	154	.type_index = try wasm.internFunctionType(.auto, &.{int_tag_ty.ip_index}, .slice_const_u8_sentinel_0, target),
155	155	.table_index = @intCast(wasm.tag_name_offs.items.len),
156	156	} };
157		const tag_names = ip.loadEnumType(data.ip_index).names;
	157	const tag_names = ip.loadEnumType(data.ip_index).field_names;
158	158	for (tag_names.get(ip)) \|tag_name\| {
159	159	const slice = tag_name.toSlice(ip);
160	160	try wasm.tag_name_offs.append(gpa, @intCast(wasm.tag_name_bytes.items.len));
...	...	@@ -1869,7 +1869,7 @@ fn emitTagNameFunction(
1869	1869	const zcu = comp.zcu.?;
1870	1870	const ip = &zcu.intern_pool;
1871	1871	const enum_type = ip.loadEnumType(enum_type_ip);
1872		const tag_values = enum_type.values.get(ip);
	1872	const tag_values = enum_type.field_values.get(ip);
1873	1873
1874	1874	const slice_abi_size = 8;
1875	1875	const encoded_alignment = @ctz(@as(u32, 4));
...	...	@@ -1908,7 +1908,7 @@ fn emitTagNameFunction(
1908	1908	return;
1909	1909	}
1910	1910
1911		const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.tag_ty), zcu);
	1911	const int_info = Zcu.Type.intInfo(.fromInterned(enum_type.int_tag_type), zcu);
1912	1912	const outer_block_type: std.wasm.BlockType = switch (int_info.bits) {
1913	1913	0...32 => .i32,
1914	1914	33...64 => .i64,

src/link/tapi/parse.zig+1-1

...	...	@@ -530,7 +530,7 @@ const Parser = struct {
530	530	fn leaf_value(self: Parser) ParseError!Node {
531	531	const node = try self.allocator.create(Node.Value);
532	532	errdefer self.allocator.destroy(node);
533		node.* = .{ .string_value = .{} };
	533	node.* = .{ .string_value = .empty };
534	534	node.base.tree = self.tree;
535	535	node.base.start = self.token_it.pos;
536	536	errdefer node.string_value.deinit(self.allocator);

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-02-12 12:30:21+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-03-10 10:26:12+00:00
log	b27c56fe5087872800f6b340ec3d1fc219d0d77b
tree	ba7183c61999deedacd513dd52c1c6f1072505fc
parent	f7a1ccfc56ed2d5605aa6ee25ac8d609f4c0d2a5
signature	Commit is signed but in an unrecognized format.

compiler: get everything building