Commit 492cc2ef8d1d21d96e25541c22ab885a31c62770 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-08-26 23:53:01+01:00
committer	GitHub <noreply@github.com> 2024-08-26 23:53:01+01:00
log	492cc2ef8d1d21d96e25541c22ab885a31c62770
tree	68a56acd898e308845054123f0cf6816761d3fa1
parent	849c31a6cc3d1e554f97c2ccf7aaa886070cfadd
parent	61e8a6c0082778e9d7a120fb5b9c30ebf85d586b
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #21208 from Rexicon226/pt-begone

Cleanup type resolution and finish `zcu` rename

46 files changed, 7794 insertions(+), 7609 deletions(-)

src
- Compilation.zig
- InternPool.zig
- RangeSet.zig
- Sema.zig
- Sema
  - bitcast.zig
  - comptime_ptr_access.zig
- Type.zig
- Value.zig
- Zcu.zig
- Zcu
  - PerThread.zig
- arch
  - aarch64
    CodeGen.zig
    abi.zig
  - arm
    CodeGen.zig
    abi.zig
  - riscv64
    CodeGen.zig
    Lower.zig
    abi.zig
  - sparc64
    CodeGen.zig
  - wasm
    CodeGen.zig
    Emit.zig
    abi.zig
  - x86_64
    CodeGen.zig
    Emit.zig
    abi.zig
- codegen.zig
- codegen
- link.zig
- link
  - C.zig
  - Coff.zig
  - Coff
    lld.zig
  - Dwarf.zig
  - Elf.zig
  - Elf
    ZigObject.zig
  - MachO.zig
  - MachO
    ZigObject.zig
  - Plan9.zig
  - SpirV.zig
  - Wasm.zig
  - Wasm
    ZigObject.zig
- mutable_value.zig
- print_air.zig
- print_value.zig
- target.zig

src/Compilation.zig+37-39

src/InternPool.zig+2-2

...	@@ -3483,7 +3483,7 @@ pub const LoadedStructType = struct {	...	@@ -3483,7 +3483,7 @@ pub const LoadedStructType = struct {
3483	return s.field_aligns.get(ip)[i];	3483	return s.field_aligns.get(ip)[i];
3484	}	3484	}
3485		3485
3486	pub fn fieldInit(s: LoadedStructType, ip: *InternPool, i: usize) Index {	3486	pub fn fieldInit(s: LoadedStructType, ip: *const InternPool, i: usize) Index {
3487	if (s.field_inits.len == 0) return .none;	3487	if (s.field_inits.len == 0) return .none;
3488	assert(s.haveFieldInits(ip));	3488	assert(s.haveFieldInits(ip));
3489	return s.field_inits.get(ip)[i];	3489	return s.field_inits.get(ip)[i];
...	@@ -11066,7 +11066,7 @@ pub fn destroyNamespace(	...	@@ -11066,7 +11066,7 @@ pub fn destroyNamespace(
11066	local.mutate.namespaces.free_list = @intFromEnum(namespace_index);	11066	local.mutate.namespaces.free_list = @intFromEnum(namespace_index);
11067	}	11067	}
11068		11068
11069	pub fn filePtr(ip: InternPool, file_index: FileIndex) Zcu.File {	11069	pub fn filePtr(ip: const InternPool, file_index: FileIndex) Zcu.File {
11070	const file_index_unwrapped = file_index.unwrap(ip);	11070	const file_index_unwrapped = file_index.unwrap(ip);
11071	const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();	11071	const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();
11072	return files.view().items(.file)[file_index_unwrapped.index];	11072	return files.view().items(.file)[file_index_unwrapped.index];

src/RangeSet.zig+15-15

...	@@ -9,7 +9,7 @@ const Zcu = @import("Zcu.zig");	...	@@ -9,7 +9,7 @@ const Zcu = @import("Zcu.zig");
9	const RangeSet = @This();	9	const RangeSet = @This();
10	const LazySrcLoc = Zcu.LazySrcLoc;	10	const LazySrcLoc = Zcu.LazySrcLoc;
11		11
12	pt: Zcu.PerThread,	12	zcu: *Zcu,
13	ranges: std.ArrayList(Range),	13	ranges: std.ArrayList(Range),
14		14
15	pub const Range = struct {	15	pub const Range = struct {
...	@@ -18,9 +18,9 @@ pub const Range = struct {	...	@@ -18,9 +18,9 @@ pub const Range = struct {
18	src: LazySrcLoc,	18	src: LazySrcLoc,
19	};	19	};
20		20
21	pub fn init(allocator: std.mem.Allocator, pt: Zcu.PerThread) RangeSet {	21	pub fn init(allocator: std.mem.Allocator, zcu: *Zcu) RangeSet {
22	return .{	22	return .{
23	.pt = pt,	23	.zcu = zcu,
24	.ranges = std.ArrayList(Range).init(allocator),	24	.ranges = std.ArrayList(Range).init(allocator),
25	};	25	};
26	}	26	}
...	@@ -35,8 +35,8 @@ pub fn add(	...	@@ -35,8 +35,8 @@ pub fn add(
35	last: InternPool.Index,	35	last: InternPool.Index,
36	src: LazySrcLoc,	36	src: LazySrcLoc,
37	) !?LazySrcLoc {	37	) !?LazySrcLoc {
38	const pt = self.pt;	38	const zcu = self.zcu;
39	const ip = &pt.zcu.intern_pool;	39	const ip = &zcu.intern_pool;
40		40
41	const ty = ip.typeOf(first);	41	const ty = ip.typeOf(first);
42	assert(ty == ip.typeOf(last));	42	assert(ty == ip.typeOf(last));
...	@@ -45,8 +45,8 @@ pub fn add(	...	@@ -45,8 +45,8 @@ pub fn add(
45	assert(ty == ip.typeOf(range.first));	45	assert(ty == ip.typeOf(range.first));
46	assert(ty == ip.typeOf(range.last));	46	assert(ty == ip.typeOf(range.last));
47		47
48	if (Value.fromInterned(last).compareScalar(.gte, Value.fromInterned(range.first), Type.fromInterned(ty), pt) and	48	if (Value.fromInterned(last).compareScalar(.gte, Value.fromInterned(range.first), Type.fromInterned(ty), zcu) and
49	Value.fromInterned(first).compareScalar(.lte, Value.fromInterned(range.last), Type.fromInterned(ty), pt))	49	Value.fromInterned(first).compareScalar(.lte, Value.fromInterned(range.last), Type.fromInterned(ty), zcu))
50	{	50	{
51	return range.src; // They overlap.	51	return range.src; // They overlap.
52	}	52	}
...	@@ -61,20 +61,20 @@ pub fn add(	...	@@ -61,20 +61,20 @@ pub fn add(
61	}	61	}
62		62
63	/// Assumes a and b do not overlap	63	/// Assumes a and b do not overlap
64	fn lessThan(pt: Zcu.PerThread, a: Range, b: Range) bool {	64	fn lessThan(zcu: *Zcu, a: Range, b: Range) bool {
65	const ty = Type.fromInterned(pt.zcu.intern_pool.typeOf(a.first));	65	const ty = Type.fromInterned(zcu.intern_pool.typeOf(a.first));
66	return Value.fromInterned(a.first).compareScalar(.lt, Value.fromInterned(b.first), ty, pt);	66	return Value.fromInterned(a.first).compareScalar(.lt, Value.fromInterned(b.first), ty, zcu);
67	}	67	}
68		68
69	pub fn spans(self: *RangeSet, first: InternPool.Index, last: InternPool.Index) !bool {	69	pub fn spans(self: *RangeSet, first: InternPool.Index, last: InternPool.Index) !bool {
70	const pt = self.pt;	70	const zcu = self.zcu;
71	const ip = &pt.zcu.intern_pool;	71	const ip = &zcu.intern_pool;
72	assert(ip.typeOf(first) == ip.typeOf(last));	72	assert(ip.typeOf(first) == ip.typeOf(last));
73		73
74	if (self.ranges.items.len == 0)	74	if (self.ranges.items.len == 0)
75	return false;	75	return false;
76		76
77	std.mem.sort(Range, self.ranges.items, pt, lessThan);	77	std.mem.sort(Range, self.ranges.items, zcu, lessThan);
78		78
79	if (self.ranges.items[0].first != first or	79	if (self.ranges.items[0].first != first or
80	self.ranges.items[self.ranges.items.len - 1].last != last)	80	self.ranges.items[self.ranges.items.len - 1].last != last)
...	@@ -93,10 +93,10 @@ pub fn spans(self: *RangeSet, first: InternPool.Index, last: InternPool.Index) !	...	@@ -93,10 +93,10 @@ pub fn spans(self: *RangeSet, first: InternPool.Index, last: InternPool.Index) !
93	const prev = self.ranges.items[i];	93	const prev = self.ranges.items[i];
94		94
95	// prev.last + 1 == cur.first	95	// prev.last + 1 == cur.first
96	try counter.copy(Value.fromInterned(prev.last).toBigInt(&space, pt));	96	try counter.copy(Value.fromInterned(prev.last).toBigInt(&space, zcu));
97	try counter.addScalar(&counter, 1);	97	try counter.addScalar(&counter, 1);
98		98
99	const cur_start_int = Value.fromInterned(cur.first).toBigInt(&space, pt);	99	const cur_start_int = Value.fromInterned(cur.first).toBigInt(&space, zcu);
100	if (!cur_start_int.eql(counter.toConst())) {	100	if (!cur_start_int.eql(counter.toConst())) {
101	return false;	101	return false;
102	}	102	}

src/Sema.zig+2181-2266

 @@ -6,7 +6,7 @@
 //! This is the the heart of the Zig compiler.
 pt: Zcu.PerThread,
-/// Alias to `mod.gpa`.
+/// Alias to `zcu.gpa`.
 gpa: Allocator,
 /// Points to the temporary arena allocator of the Sema.
 /// This arena will be cleared when the sema is destroyed.
 @@ -67,7 +67,7 @@ generic_call_src: LazySrcLoc = LazySrcLoc.unneeded,
 /// breaking from a block.
 post_hoc_blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *LabeledBlock) = .{},
 /// Populated with the last compile error created.
-err: ?*Module.ErrorMsg = null,
+err: ?*Zcu.ErrorMsg = null,
 /// Set to true when analyzing a func type instruction so that nested generic
 /// function types will emit generic poison instead of a partial type.
 no_partial_func_ty: bool = false,
 @@ -172,11 +172,10 @@ const Type = @import("Type.zig");
 const Air = @import("Air.zig");
 const Zir = std.zig.Zir;
 const Zcu = @import("Zcu.zig");
-const Module = Zcu;
 const trace = @import("tracy.zig").trace;
-const Namespace = Module.Namespace;
+const Namespace = Zcu.Namespace;
-const CompileError = Module.CompileError;
+const CompileError = Zcu.CompileError;
-const SemaError = Module.SemaError;
+const SemaError = Zcu.SemaError;
 const LazySrcLoc = Zcu.LazySrcLoc;
 const RangeSet = @import("RangeSet.zig");
 const target_util = @import("target.zig");
 @@ -431,7 +430,7 @@ pub const Block = struct {
             return_ty: Type,
         },
-        fn explain(cr: ComptimeReason, sema: *Sema, msg: ?*Module.ErrorMsg) !void {
+        fn explain(cr: ComptimeReason, sema: *Sema, msg: ?*Zcu.ErrorMsg) !void {
             const parent = msg orelse return;
             const pt = sema.pt;
             const prefix = "expression is evaluated at comptime because ";
 @@ -733,12 +732,12 @@ pub const Block = struct {
     fn addCmpVector(block: *Block, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref, cmp_op: std.math.CompareOperator) !Air.Inst.Ref {
         const sema = block.sema;
         const pt = sema.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         return block.addInst(.{
             .tag = if (block.float_mode == .optimized) .cmp_vector_optimized else .cmp_vector,
             .data = .{ .ty_pl = .{
                 .ty = Air.internedToRef((try pt.vectorType(.{
-                    .len = sema.typeOf(lhs).vectorLen(mod),
+                    .len = sema.typeOf(lhs).vectorLen(zcu),
                     .child = .bool_type,
                 })).toIntern()),
                 .payload = try sema.addExtra(Air.VectorCmp{
 @@ -852,7 +851,7 @@ const LabeledBlock = struct {
 /// The value stored in the inferred allocation. This will go into
 /// peer type resolution. This is stored in a separate list so that
 /// the items are contiguous in memory and thus can be passed to
-/// `Module.resolvePeerTypes`.
+/// `Zcu.resolvePeerTypes`.
 const InferredAlloc = struct {
     /// The placeholder `store` instructions used before the result pointer type
     /// is known. These should be rewritten to perform any required coercions
 @@ -1950,7 +1949,7 @@ fn resolveDestType(
     builtin_name: []const u8,
 ) !Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const remove_eu = switch (strat) {
         .remove_eu_opt, .remove_eu => true,
         .remove_opt => false,
 @@ -1980,15 +1979,15 @@ fn resolveDestType(
         else => |e| return e,
     };
-    if (remove_eu and raw_ty.zigTypeTag(mod) == .ErrorUnion) {
+    if (remove_eu and raw_ty.zigTypeTag(zcu) == .ErrorUnion) {
-        const eu_child = raw_ty.errorUnionPayload(mod);
+        const eu_child = raw_ty.errorUnionPayload(zcu);
-        if (remove_opt and eu_child.zigTypeTag(mod) == .Optional) {
+        if (remove_opt and eu_child.zigTypeTag(zcu) == .Optional) {
-            return eu_child.childType(mod);
+            return eu_child.childType(zcu);
         }
         return eu_child;
     }
-    if (remove_opt and raw_ty.zigTypeTag(mod) == .Optional) {
+    if (remove_opt and raw_ty.zigTypeTag(zcu) == .Optional) {
-        return raw_ty.childType(mod);
+        return raw_ty.childType(zcu);
     }
     return raw_ty;
 }
 @@ -2068,10 +2067,10 @@ fn analyzeAsType(
 pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const comp = mod.comp;
+    const comp = zcu.comp;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     if (!comp.config.any_error_tracing) return;
     assert(!block.is_comptime);
 @@ -2140,9 +2139,9 @@ fn resolveDefinedValue(
     air_ref: Air.Inst.Ref,
 ) CompileError!?Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const val = try sema.resolveValue(air_ref) orelse return null;
-    if (val.isUndef(mod)) {
+    if (val.isUndef(zcu)) {
         return sema.failWithUseOfUndef(block, src);
     }
     return val;
 @@ -2340,12 +2339,12 @@ fn failWithIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc, int_ty:
 fn failWithInvalidComptimeFieldStore(sema: *Sema, block: *Block, init_src: LazySrcLoc, container_ty: Type, field_index: usize) CompileError {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const msg = msg: {
         const msg = try sema.errMsg(init_src, "value stored in comptime field does not match the default value of the field", .{});
         errdefer msg.destroy(sema.gpa);
-        const struct_type = mod.typeToStruct(container_ty) orelse break :msg msg;
+        const struct_type = zcu.typeToStruct(container_ty) orelse break :msg msg;
         try sema.errNote(.{
             .base_node_inst = struct_type.zir_index.unwrap().?,
             .offset = .{ .container_field_value = @intCast(field_index) },
 @@ -2372,12 +2371,12 @@ fn failWithInvalidFieldAccess(
     field_name: InternPool.NullTerminatedString,
 ) CompileError {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const inner_ty = if (object_ty.isSinglePointer(mod)) object_ty.childType(mod) else object_ty;
+    const inner_ty = if (object_ty.isSinglePointer(zcu)) object_ty.childType(zcu) else object_ty;
-    if (inner_ty.zigTypeTag(mod) == .Optional) opt: {
+    if (inner_ty.zigTypeTag(zcu) == .Optional) opt: {
-        const child_ty = inner_ty.optionalChild(mod);
+        const child_ty = inner_ty.optionalChild(zcu);
-        if (!typeSupportsFieldAccess(mod, child_ty, field_name)) break :opt;
+        if (!typeSupportsFieldAccess(zcu, child_ty, field_name)) break :opt;
         const msg = msg: {
             const msg = try sema.errMsg(src, "optional type '{}' does not support field access", .{object_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -2385,9 +2384,9 @@ fn failWithInvalidFieldAccess(
             break :msg msg;
         };
         return sema.failWithOwnedErrorMsg(block, msg);
-    } else if (inner_ty.zigTypeTag(mod) == .ErrorUnion) err: {
+    } else if (inner_ty.zigTypeTag(zcu) == .ErrorUnion) err: {
-        const child_ty = inner_ty.errorUnionPayload(mod);
+        const child_ty = inner_ty.errorUnionPayload(zcu);
-        if (!typeSupportsFieldAccess(mod, child_ty, field_name)) break :err;
+        if (!typeSupportsFieldAccess(zcu, child_ty, field_name)) break :err;
         const msg = msg: {
             const msg = try sema.errMsg(src, "error union type '{}' does not support field access", .{object_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -2399,15 +2398,15 @@ fn failWithInvalidFieldAccess(
     return sema.fail(block, src, "type '{}' does not support field access", .{object_ty.fmt(pt)});
 }
-fn typeSupportsFieldAccess(mod: *const Module, ty: Type, field_name: InternPool.NullTerminatedString) bool {
+fn typeSupportsFieldAccess(zcu: *const Zcu, ty: Type, field_name: InternPool.NullTerminatedString) bool {
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Array => return field_name.eqlSlice("len", ip),
         .Pointer => {
-            const ptr_info = ty.ptrInfo(mod);
+            const ptr_info = ty.ptrInfo(zcu);
             if (ptr_info.flags.size == .Slice) {
                 return field_name.eqlSlice("ptr", ip) or field_name.eqlSlice("len", ip);
-            } else if (Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Array) {
+            } else if (Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .Array) {
                 return field_name.eqlSlice("len", ip);
             } else return false;
         },
 @@ -2423,9 +2422,9 @@ fn failWithComptimeErrorRetTrace(
     name: InternPool.NullTerminatedString,
 ) CompileError {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const msg = msg: {
-        const msg = try sema.errMsg(src, "caught unexpected error '{}'", .{name.fmt(&mod.intern_pool)});
+        const msg = try sema.errMsg(src, "caught unexpected error '{}'", .{name.fmt(&zcu.intern_pool)});
         errdefer msg.destroy(sema.gpa);
         for (sema.comptime_err_ret_trace.items) |src_loc| {
 @@ -2451,7 +2450,7 @@ fn failWithInvalidPtrArithmetic(sema: *Sema, block: *Block, src: LazySrcLoc, ari
 pub fn errNote(
     sema: *Sema,
     src: LazySrcLoc,
-    parent: *Module.ErrorMsg,
+    parent: *Zcu.ErrorMsg,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
 @@ -2462,7 +2461,7 @@ fn addFieldErrNote(
     sema: *Sema,
     container_ty: Type,
     field_index: usize,
-    parent: *Module.ErrorMsg,
+    parent: *Zcu.ErrorMsg,
     comptime format: []const u8,
     args: anytype,
 ) !void {
 @@ -2480,9 +2479,9 @@ pub fn errMsg(
     src: LazySrcLoc,
     comptime format: []const u8,
     args: anytype,
-) Allocator.Error!*Module.ErrorMsg {
+) Allocator.Error!*Zcu.ErrorMsg {
     assert(src.offset != .unneeded);
-    return Module.ErrorMsg.create(sema.gpa, src, format, args);
+    return Zcu.ErrorMsg.create(sema.gpa, src, format, args);
 }
 pub fn fail(
 @@ -2501,16 +2500,16 @@ pub fn fail(
     return sema.failWithOwnedErrorMsg(block, err_msg);
 }
-pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Module.ErrorMsg) error{ AnalysisFail, OutOfMemory } {
+pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Zcu.ErrorMsg) error{ AnalysisFail, OutOfMemory } {
     @setCold(true);
     const gpa = sema.gpa;
-    const mod = sema.pt.zcu;
+    const zcu = sema.pt.zcu;
-    if (build_options.enable_debug_extensions and mod.comp.debug_compile_errors) {
+    if (build_options.enable_debug_extensions and zcu.comp.debug_compile_errors) {
         var all_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?Zcu.ResolvedReference) = null;
         var wip_errors: std.zig.ErrorBundle.Wip = undefined;
         wip_errors.init(gpa) catch @panic("out of memory");
-        Compilation.addModuleErrorMsg(mod, &wip_errors, err_msg.*, &all_references) catch @panic("out of memory");
+        Compilation.addModuleErrorMsg(zcu, &wip_errors, err_msg.*, &all_references) catch @panic("out of memory");
         std.debug.print("compile error during Sema:\n", .{});
         var error_bundle = wip_errors.toOwnedBundle("") catch @panic("out of memory");
         error_bundle.renderToStdErr(.{ .ttyconf = .no_color });
 @@ -2530,12 +2529,12 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Module.Error
         }
     }
-    const use_ref_trace = if (mod.comp.reference_trace) |n| n > 0 else mod.failed_analysis.count() == 0;
+    const use_ref_trace = if (zcu.comp.reference_trace) |n| n > 0 else zcu.failed_analysis.count() == 0;
     if (use_ref_trace) {
         err_msg.reference_trace_root = sema.owner.toOptional();
     }
-    const gop = try mod.failed_analysis.getOrPut(gpa, sema.owner);
+    const gop = try zcu.failed_analysis.getOrPut(gpa, sema.owner);
     if (gop.found_existing) {
         // If there are multiple errors for the same Decl, prefer the first one added.
         sema.err = null;
 @@ -2554,7 +2553,7 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Module.Error
 fn reparentOwnedErrorMsg(
     sema: *Sema,
     src: LazySrcLoc,
-    msg: *Module.ErrorMsg,
+    msg: *Zcu.ErrorMsg,
     comptime format: []const u8,
     args: anytype,
 ) !void {
 @@ -2562,7 +2561,7 @@ fn reparentOwnedErrorMsg(
     const orig_notes = msg.notes.len;
     msg.notes = try sema.gpa.realloc(msg.notes, orig_notes + 1);
-    std.mem.copyBackwards(Module.ErrorMsg, msg.notes[1..], msg.notes[0..orig_notes]);
+    std.mem.copyBackwards(Zcu.ErrorMsg, msg.notes[1..], msg.notes[0..orig_notes]);
     msg.notes[0] = .{
         .src_loc = msg.src_loc,
         .msg = msg.msg,
 @@ -2644,7 +2643,7 @@ fn analyzeAsInt(
 ) !u64 {
     const coerced = try sema.coerce(block, dest_ty, air_ref, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
-    return (try val.getUnsignedIntAdvanced(sema.pt, .sema)).?;
+    return try val.toUnsignedIntSema(sema.pt);
 }
 /// Given a ZIR extra index which points to a list of `Zir.Inst.Capture`,
 @@ -2722,9 +2721,9 @@ fn zirStructDecl(
     inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
     const extra = sema.code.extraData(Zir.Inst.StructDecl, extended.operand);
 @@ -2786,7 +2785,7 @@ fn zirStructDecl(
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
             // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(mod));
+            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
             try sema.declareDependency(.{ .interned = new_ty });
             try sema.addTypeReferenceEntry(src, new_ty);
 @@ -2807,8 +2806,8 @@ fn zirStructDecl(
     const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     errdefer pt.destroyNamespace(new_namespace_index);
 @@ -2825,11 +2824,11 @@ fn zirStructDecl(
     const decls = sema.code.bodySlice(extra_index, decls_len);
     try pt.scanNamespace(new_namespace_index, decls);
-    try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
+    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
     try sema.addTypeReferenceEntry(src, wip_ty.index);
 @@ -2938,9 +2937,9 @@ fn zirEnumDecl(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const small: Zir.Inst.EnumDecl.Small = @bitCast(extended.small);
     const extra = sema.code.extraData(Zir.Inst.EnumDecl, extended.operand);
     var extra_index: usize = extra.end;
 @@ -3015,7 +3014,7 @@ fn zirEnumDecl(
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
             // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(mod));
+            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
             try sema.declareDependency(.{ .interned = new_ty });
             try sema.addTypeReferenceEntry(src, new_ty);
 @@ -3042,8 +3041,8 @@ fn zirEnumDecl(
     const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     errdefer if (!done) pt.destroyNamespace(new_namespace_index);
 @@ -3077,9 +3076,9 @@ fn zirEnumDecl(
     );
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     return Air.internedToRef(wip_ty.index);
 }
 @@ -3094,9 +3093,9 @@ fn zirUnionDecl(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const small: Zir.Inst.UnionDecl.Small = @bitCast(extended.small);
     const extra = sema.code.extraData(Zir.Inst.UnionDecl, extended.operand);
     var extra_index: usize = extra.end;
 @@ -3159,7 +3158,7 @@ fn zirUnionDecl(
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
             // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(mod));
+            try pt.ensureNamespaceUpToDate(Type.fromInterned(new_ty).getNamespaceIndex(zcu));
             try sema.declareDependency(.{ .interned = new_ty });
             try sema.addTypeReferenceEntry(src, new_ty);
 @@ -3180,15 +3179,15 @@ fn zirUnionDecl(
     const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     errdefer pt.destroyNamespace(new_namespace_index);
     const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
     if (pt.zcu.comp.incremental) {
-        try mod.intern_pool.addDependency(
+        try zcu.intern_pool.addDependency(
             gpa,
             AnalUnit.wrap(.{ .cau = new_cau_index }),
             .{ .src_hash = tracked_inst },
 @@ -3198,11 +3197,11 @@ fn zirUnionDecl(
     const decls = sema.code.bodySlice(extra_index, decls_len);
     try pt.scanNamespace(new_namespace_index, decls);
-    try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
+    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
     try sema.addTypeReferenceEntry(src, wip_ty.index);
 @@ -3219,9 +3218,9 @@ fn zirOpaqueDecl(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const small: Zir.Inst.OpaqueDecl.Small = @bitCast(extended.small);
     const extra = sema.code.extraData(Zir.Inst.OpaqueDecl, extended.operand);
 @@ -3255,7 +3254,7 @@ fn zirOpaqueDecl(
         .existing => |ty| {
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
             // up on e.g. changed comptime decls.
-            try pt.ensureNamespaceUpToDate(Type.fromInterned(ty).getNamespaceIndex(mod));
+            try pt.ensureNamespaceUpToDate(Type.fromInterned(ty).getNamespaceIndex(zcu));
             try sema.declareDependency(.{ .interned = ty });
             try sema.addTypeReferenceEntry(src, ty);
 @@ -3276,8 +3275,8 @@ fn zirOpaqueDecl(
     const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     errdefer pt.destroyNamespace(new_namespace_index);
 @@ -3285,9 +3284,9 @@ fn zirOpaqueDecl(
     try pt.scanNamespace(new_namespace_index, decls);
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.addTypeReferenceEntry(src, wip_ty.index);
     return Air.internedToRef(wip_ty.finish(ip, .none, new_namespace_index));
 @@ -3301,7 +3300,7 @@ fn zirErrorSetDecl(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.ErrorSetDecl, inst_data.payload_index);
 @@ -3314,7 +3313,7 @@ fn zirErrorSetDecl(
     while (extra_index < extra_index_end) : (extra_index += 2) { // +2 to skip over doc_string
         const name_index: Zir.NullTerminatedString = @enumFromInt(sema.code.extra[extra_index]);
         const name = sema.code.nullTerminatedString(name_index);
-        const name_ip = try mod.intern_pool.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
+        const name_ip = try zcu.intern_pool.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
         _ = try pt.getErrorValue(name_ip);
         const result = names.getOrPutAssumeCapacity(name_ip);
         assert(!result.found_existing); // verified in AstGen
 @@ -3329,7 +3328,7 @@ fn zirRetPtr(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    if (block.is_comptime or try sema.typeRequiresComptime(sema.fn_ret_ty)) {
+    if (block.is_comptime or try sema.fn_ret_ty.comptimeOnlySema(pt)) {
         try sema.fn_ret_ty.resolveFields(pt);
         return sema.analyzeComptimeAlloc(block, sema.fn_ret_ty, .none);
     }
 @@ -3377,8 +3376,8 @@ fn ensureResultUsed(
     src: LazySrcLoc,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Void, .NoReturn => return,
         .ErrorSet => return sema.fail(block, src, "error set is ignored", .{}),
         .ErrorUnion => {
 @@ -3408,12 +3407,12 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand = try sema.resolveInst(inst_data.operand);
     const src = block.nodeOffset(inst_data.src_node);
     const operand_ty = sema.typeOf(operand);
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .ErrorSet => return sema.fail(block, src, "error set is discarded", .{}),
         .ErrorUnion => {
             const msg = msg: {
 @@ -3433,17 +3432,17 @@ fn zirEnsureErrUnionPayloadVoid(sema: *Sema, block: *Block, inst: Zir.Inst.Index
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    const err_union_ty = if (operand_ty.zigTypeTag(mod) == .Pointer)
+    const err_union_ty = if (operand_ty.zigTypeTag(zcu) == .Pointer)
-        operand_ty.childType(mod)
+        operand_ty.childType(zcu)
     else
         operand_ty;
-    if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) return;
+    if (err_union_ty.zigTypeTag(zcu) != .ErrorUnion) return;
-    const payload_ty = err_union_ty.errorUnionPayload(mod).zigTypeTag(mod);
+    const payload_ty = err_union_ty.errorUnionPayload(zcu).zigTypeTag(zcu);
     if (payload_ty != .Void and payload_ty != .NoReturn) {
         const msg = msg: {
             const msg = try sema.errMsg(src, "error union payload is ignored", .{});
 @@ -3473,12 +3472,12 @@ fn indexablePtrLen(
     object: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const object_ty = sema.typeOf(object);
-    const is_pointer_to = object_ty.isSinglePointer(mod);
+    const is_pointer_to = object_ty.isSinglePointer(zcu);
-    const indexable_ty = if (is_pointer_to) object_ty.childType(mod) else object_ty;
+    const indexable_ty = if (is_pointer_to) object_ty.childType(zcu) else object_ty;
     try checkIndexable(sema, block, src, indexable_ty);
-    const field_name = try mod.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);
+    const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);
     return sema.fieldVal(block, src, object, field_name, src);
 }
 @@ -3489,11 +3488,11 @@ fn indexablePtrLenOrNone(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     try checkMemOperand(sema, block, src, operand_ty);
-    if (operand_ty.ptrSize(mod) == .Many) return .none;
+    if (operand_ty.ptrSize(zcu) == .Many) return .none;
-    const field_name = try mod.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);
+    const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "len", .no_embedded_nulls);
     return sema.fieldVal(block, src, operand, field_name, src);
 }
 @@ -3545,7 +3544,7 @@ fn zirAllocExtended(
         }
         const target = pt.zcu.getTarget();
         try var_ty.resolveLayout(pt);
-        if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) {
+        if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
             const var_src = block.src(.{ .node_offset_store_ptr = extra.data.src_node });
             return sema.fail(block, var_src, "local variable in naked function", .{});
         }
 @@ -3592,11 +3591,11 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const alloc = try sema.resolveInst(inst_data.operand);
     const alloc_ty = sema.typeOf(alloc);
-    const ptr_info = alloc_ty.ptrInfo(mod);
+    const ptr_info = alloc_ty.ptrInfo(zcu);
     const elem_ty = Type.fromInterned(ptr_info.child);
     // If the alloc was created in a comptime scope, we already created a comptime alloc for it.
 @@ -3607,7 +3606,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         // If this was a comptime inferred alloc, then `storeToInferredAllocComptime`
         // might have already done our job and created an anon decl ref.
-        switch (mod.intern_pool.indexToKey(ptr_val.toIntern())) {
+        switch (zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
             .ptr => |ptr| switch (ptr.base_addr) {
                 .uav => {
                     // The comptime-ification was already done for us.
 @@ -3620,12 +3619,12 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         }
         if (!sema.isComptimeMutablePtr(ptr_val)) break :already_ct;
-        const ptr = mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
+        const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
         assert(ptr.byte_offset == 0);
         const alloc_index = ptr.base_addr.comptime_alloc;
         const ct_alloc = sema.getComptimeAlloc(alloc_index);
         const interned = try ct_alloc.val.intern(pt, sema.arena);
-        if (interned.canMutateComptimeVarState(mod)) {
+        if (interned.canMutateComptimeVarState(zcu)) {
             // Preserve the comptime alloc, just make the pointer const.
             ct_alloc.val = .{ .interned = interned.toIntern() };
             ct_alloc.is_const = true;
 @@ -3649,7 +3648,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         return sema.makePtrConst(block, Air.internedToRef(ptr_val));
     }
-    if (try sema.typeRequiresComptime(elem_ty)) {
+    if (try elem_ty.comptimeOnlySema(pt)) {
         // The value was initialized through RLS, so we didn't detect the runtime condition earlier.
         // TODO: source location of runtime control flow
         const init_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
 @@ -3918,7 +3917,7 @@ fn finishResolveComptimeKnownAllocPtr(
     if (Value.fromInterned(result_val).canMutateComptimeVarState(zcu)) {
         const alloc_index = existing_comptime_alloc orelse a: {
-            const idx = try sema.newComptimeAlloc(block, alloc_ty.childType(zcu), alloc_ty.ptrAlignment(pt));
+            const idx = try sema.newComptimeAlloc(block, alloc_ty.childType(zcu), alloc_ty.ptrAlignment(zcu));
             const alloc = sema.getComptimeAlloc(idx);
             alloc.val = .{ .interned = result_val };
             break :a idx;
 @@ -3989,7 +3988,7 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     if (block.is_comptime) {
         return sema.analyzeComptimeAlloc(block, var_ty, .none);
     }
-    if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) {
+    if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
         const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
         return sema.fail(block, mut_src, "local variable in naked function", .{});
     }
 @@ -4017,7 +4016,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     if (block.is_comptime) {
         return sema.analyzeComptimeAlloc(block, var_ty, .none);
     }
-    if (sema.func_is_naked and try sema.typeHasRuntimeBits(var_ty)) {
+    if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
         const var_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
         return sema.fail(block, var_src, "local variable in naked function", .{});
     }
 @@ -4072,14 +4071,14 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
     const ptr = try sema.resolveInst(inst_data.operand);
     const ptr_inst = ptr.toIndex().?;
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) {
         .inferred_alloc_comptime => {
 @@ -4093,7 +4092,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 sema.air_instructions.set(@intFromEnum(ptr_inst), .{ .tag = undefined, .data = undefined });
             }
-            const val = switch (mod.intern_pool.indexToKey(resolved_ptr).ptr.base_addr) {
+            const val = switch (zcu.intern_pool.indexToKey(resolved_ptr).ptr.base_addr) {
                 .uav => |a| a.val,
                 .comptime_alloc => |i| val: {
                     const alloc = sema.getComptimeAlloc(i);
 @@ -4101,11 +4100,11 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 },
                 else => unreachable,
             };
-            if (mod.intern_pool.isFuncBody(val)) {
+            if (zcu.intern_pool.isFuncBody(val)) {
-                const ty = Type.fromInterned(mod.intern_pool.typeOf(val));
+                const ty = Type.fromInterned(zcu.intern_pool.typeOf(val));
-                if (try sema.fnHasRuntimeBits(ty)) {
+                if (try ty.fnHasRuntimeBitsSema(pt)) {
                     try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = val }));
-                    try mod.ensureFuncBodyAnalysisQueued(val);
+                    try zcu.ensureFuncBodyAnalysisQueued(val);
                 }
             }
 @@ -4148,13 +4147,13 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
                 return;
             }
-            if (try sema.typeRequiresComptime(final_elem_ty)) {
+            if (try final_elem_ty.comptimeOnlySema(pt)) {
                 // The alloc wasn't comptime-known per the above logic, so the
                 // type cannot be comptime-only.
                 // TODO: source location of runtime control flow
                 return sema.fail(block, src, "value with comptime-only type '{}' depends on runtime control flow", .{final_elem_ty.fmt(pt)});
             }
-            if (sema.func_is_naked and try sema.typeHasRuntimeBits(final_elem_ty)) {
+            if (sema.func_is_naked and try final_elem_ty.hasRuntimeBitsSema(pt)) {
                 const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
                 return sema.fail(block, mut_src, "local variable in naked function", .{});
             }
 @@ -4213,9 +4212,9 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
 fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index);
     const args = sema.code.refSlice(extra.end, extra.data.operands_len);
 @@ -4238,7 +4237,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         const object_ty = sema.typeOf(object);
         // Each arg could be an indexable, or a range, in which case the length
         // is passed directly as an integer.
-        const is_int = switch (object_ty.zigTypeTag(mod)) {
+        const is_int = switch (object_ty.zigTypeTag(zcu)) {
             .Int, .ComptimeInt => true,
             else => false,
         };
 @@ -4247,14 +4246,14 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             .input_index = i,
         } });
         const arg_len_uncoerced = if (is_int) object else l: {
-            if (!object_ty.isIndexable(mod)) {
+            if (!object_ty.isIndexable(zcu)) {
                 // Instead of using checkIndexable we customize this error.
                 const msg = msg: {
                     const msg = try sema.errMsg(arg_src, "type '{}' is not indexable and not a range", .{object_ty.fmt(pt)});
                     errdefer msg.destroy(sema.gpa);
                     try sema.errNote(arg_src, msg, "for loop operand must be a range, array, slice, tuple, or vector", .{});
-                    if (object_ty.zigTypeTag(mod) == .ErrorUnion) {
+                    if (object_ty.zigTypeTag(zcu) == .ErrorUnion) {
                         try sema.errNote(arg_src, msg, "consider using 'try', 'catch', or 'if'", .{});
                     }
 @@ -4262,7 +4261,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 };
                 return sema.failWithOwnedErrorMsg(block, msg);
             }
-            if (!object_ty.indexableHasLen(mod)) continue;
+            if (!object_ty.indexableHasLen(zcu)) continue;
             break :l try sema.fieldVal(block, arg_src, object, try ip.getOrPutString(gpa, pt.tid, "len", .no_embedded_nulls), arg_src);
         };
 @@ -4313,7 +4312,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 const object_ty = sema.typeOf(object);
                 // Each arg could be an indexable, or a range, in which case the length
                 // is passed directly as an integer.
-                switch (object_ty.zigTypeTag(mod)) {
+                switch (object_ty.zigTypeTag(zcu)) {
                     .Int, .ComptimeInt => continue,
                     else => {},
                 }
 @@ -4349,9 +4348,9 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 /// May invalidate already-stored payload data.
 fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcLoc) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     var base_ptr = ptr;
-    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
+    while (true) switch (sema.typeOf(base_ptr).childType(zcu).zigTypeTag(zcu)) {
         .ErrorUnion => base_ptr = try sema.analyzeErrUnionPayloadPtr(block, src, base_ptr, false, true),
         .Optional => base_ptr = try sema.analyzeOptionalPayloadPtr(block, src, base_ptr, false, true),
         else => break,
 @@ -4368,7 +4367,7 @@ fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
 fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(pl_node.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
 @@ -4377,13 +4376,13 @@ fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
         error.GenericPoison => return uncoerced_val,
         else => |e| return e,
     };
-    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu);
-    assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+    assert(ptr_ty.zigTypeTag(zcu) == .Pointer); // validated by a previous instruction
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
-    switch (ptr_ty.ptrSize(mod)) {
+    switch (ptr_ty.ptrSize(zcu)) {
         .One => {
             const uncoerced_ty = sema.typeOf(uncoerced_val);
-            if (elem_ty.zigTypeTag(mod) == .Array and elem_ty.childType(mod).toIntern() == uncoerced_ty.toIntern()) {
+            if (elem_ty.zigTypeTag(zcu) == .Array and elem_ty.childType(zcu).toIntern() == uncoerced_ty.toIntern()) {
                 // We're trying to initialize a *[1]T with a reference to a T - don't perform any coercion.
                 return uncoerced_val;
             }
 @@ -4397,16 +4396,16 @@ fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
         .Slice, .Many => {
             // Our goal is to coerce `uncoerced_val` to an array of `elem_ty`.
             const val_ty = sema.typeOf(uncoerced_val);
-            switch (val_ty.zigTypeTag(mod)) {
+            switch (val_ty.zigTypeTag(zcu)) {
                 .Array, .Vector => {},
-                else => if (!val_ty.isTuple(mod)) {
+                else => if (!val_ty.isTuple(zcu)) {
                     return sema.fail(block, src, "expected array of '{}', found '{}'", .{ elem_ty.fmt(pt), val_ty.fmt(pt) });
                 },
             }
             const want_ty = try pt.arrayType(.{
-                .len = val_ty.arrayLen(mod),
+                .len = val_ty.arrayLen(zcu),
                 .child = elem_ty.toIntern(),
-                .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                .sentinel = if (ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
             });
             return sema.coerce(block, want_ty, uncoerced_val, src);
         },
 @@ -4420,7 +4419,7 @@ fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
 fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_tok = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
     const src = block.tokenOffset(un_tok.src_tok);
     // In case of GenericPoison, we don't actually have a type, so this will be
 @@ -4434,7 +4433,7 @@ fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
         else => |e| return e,
     };
     if (ty_operand.isGenericPoison()) return;
-    if (ty_operand.optEuBaseType(mod).zigTypeTag(mod) != .Pointer) {
+    if (ty_operand.optEuBaseType(zcu).zigTypeTag(zcu) != .Pointer) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "expected type '{}', found pointer", .{ty_operand.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -4450,7 +4449,7 @@ fn zirValidateArrayInitRefTy(
     inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(pl_node.src_node);
     const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data;
 @@ -4458,16 +4457,16 @@ fn zirValidateArrayInitRefTy(
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu);
-    assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+    assert(ptr_ty.zigTypeTag(zcu) == .Pointer); // validated by a previous instruction
-    switch (mod.intern_pool.indexToKey(ptr_ty.toIntern())) {
+    switch (zcu.intern_pool.indexToKey(ptr_ty.toIntern())) {
         .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
             .Slice, .Many => {
                 // Use array of correct length
                 const arr_ty = try pt.arrayType(.{
                     .len = extra.elem_count,
-                    .child = ptr_ty.childType(mod).toIntern(),
+                    .child = ptr_ty.childType(zcu).toIntern(),
-                    .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                    .sentinel = if (ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                 });
                 return Air.internedToRef(arr_ty.toIntern());
             },
 @@ -4476,12 +4475,12 @@ fn zirValidateArrayInitRefTy(
         else => {},
     }
     // Otherwise, we just want the pointer child type
-    const ret_ty = ptr_ty.childType(mod);
+    const ret_ty = ptr_ty.childType(zcu);
     if (ret_ty.toIntern() == .anyopaque_type) {
         // The actual array type is unknown, which we represent with a generic poison.
         return .generic_poison_type;
     }
-    const arr_ty = ret_ty.optEuBaseType(mod);
+    const arr_ty = ret_ty.optEuBaseType(zcu);
     try sema.validateArrayInitTy(block, src, src, extra.elem_count, arr_ty);
     return Air.internedToRef(ret_ty.toIntern());
 }
 @@ -4493,7 +4492,7 @@ fn zirValidateArrayInitTy(
     is_result_ty: bool,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty_src: LazySrcLoc = if (is_result_ty) src else block.src(.{ .node_offset_init_ty = inst_data.src_node });
 @@ -4503,7 +4502,7 @@ fn zirValidateArrayInitTy(
         error.GenericPoison => return,
         else => |e| return e,
     };
-    const arr_ty = if (is_result_ty) ty.optEuBaseType(mod) else ty;
+    const arr_ty = if (is_result_ty) ty.optEuBaseType(zcu) else ty;
     return sema.validateArrayInitTy(block, src, ty_src, extra.init_count, arr_ty);
 }
 @@ -4516,10 +4515,10 @@ fn validateArrayInitTy(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Array => {
-            const array_len = ty.arrayLen(mod);
+            const array_len = ty.arrayLen(zcu);
             if (init_count != array_len) {
                 return sema.fail(block, src, "expected {d} array elements; found {d}", .{
                     array_len, init_count,
 @@ -4528,7 +4527,7 @@ fn validateArrayInitTy(
             return;
         },
         .Vector => {
-            const array_len = ty.arrayLen(mod);
+            const array_len = ty.arrayLen(zcu);
             if (init_count != array_len) {
                 return sema.fail(block, src, "expected {d} vector elements; found {d}", .{
                     array_len, init_count,
 @@ -4536,9 +4535,9 @@ fn validateArrayInitTy(
             }
             return;
         },
-        .Struct => if (ty.isTuple(mod)) {
+        .Struct => if (ty.isTuple(zcu)) {
             try ty.resolveFields(pt);
-            const array_len = ty.arrayLen(mod);
+            const array_len = ty.arrayLen(zcu);
             if (init_count > array_len) {
                 return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
                     array_len, init_count,
 @@ -4558,7 +4557,7 @@ fn zirValidateStructInitTy(
     is_result_ty: bool,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty = sema.resolveType(block, src, inst_data.operand) catch |err| switch (err) {
 @@ -4566,9 +4565,9 @@ fn zirValidateStructInitTy(
         error.GenericPoison => return,
         else => |e| return e,
     };
-    const struct_ty = if (is_result_ty) ty.optEuBaseType(mod) else ty;
+    const struct_ty = if (is_result_ty) ty.optEuBaseType(zcu) else ty;
-    switch (struct_ty.zigTypeTag(mod)) {
+    switch (struct_ty.zigTypeTag(zcu)) {
         .Struct, .Union => return,
         else => {},
     }
 @@ -4584,7 +4583,7 @@ fn zirValidatePtrStructInit(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const validate_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const init_src = block.nodeOffset(validate_inst.src_node);
     const validate_extra = sema.code.extraData(Zir.Inst.Block, validate_inst.payload_index);
 @@ -4592,8 +4591,8 @@ fn zirValidatePtrStructInit(
     const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node;
     const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data;
     const object_ptr = try sema.resolveInst(field_ptr_extra.lhs);
-    const agg_ty = sema.typeOf(object_ptr).childType(mod).optEuBaseType(mod);
+    const agg_ty = sema.typeOf(object_ptr).childType(zcu).optEuBaseType(zcu);
-    switch (agg_ty.zigTypeTag(mod)) {
+    switch (agg_ty.zigTypeTag(zcu)) {
         .Struct => return sema.validateStructInit(
             block,
             agg_ty,
 @@ -4620,7 +4619,7 @@ fn validateUnionInit(
     union_ptr: Air.Inst.Ref,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     if (instrs.len != 1) {
 @@ -4654,7 +4653,7 @@ fn validateUnionInit(
     const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(field_ptr)].pl_node;
     const field_src = block.src(.{ .node_offset_initializer = field_ptr_data.src_node });
     const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data;
-    const field_name = try mod.intern_pool.getOrPutString(
+    const field_name = try zcu.intern_pool.getOrPutString(
         gpa,
         pt.tid,
         sema.code.nullTerminatedString(field_ptr_extra.field_name_start),
 @@ -4718,9 +4717,9 @@ fn validateUnionInit(
         break;
     }
-    const tag_ty = union_ty.unionTagTypeHypothetical(mod);
+    const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
     const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-    const field_type = union_ty.unionFieldType(tag_val, mod).?;
+    const field_type = union_ty.unionFieldType(tag_val, zcu).?;
     if (try sema.typeHasOnePossibleValue(field_type)) |field_only_value| {
         init_val = field_only_value;
 @@ -4761,7 +4760,7 @@ fn validateUnionInit(
         const union_init = Air.internedToRef(union_val);
         try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
         return;
-    } else if (try sema.typeRequiresComptime(union_ty)) {
+    } else if (try union_ty.comptimeOnlySema(pt)) {
         return sema.failWithNeededComptime(block, block.nodeOffset(field_ptr_data.src_node), .{
             .needed_comptime_reason = "initializer of comptime only union must be comptime-known",
         });
 @@ -4781,15 +4780,15 @@ fn validateStructInit(
     instrs: []const Zir.Inst.Index,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const field_indices = try gpa.alloc(u32, instrs.len);
     defer gpa.free(field_indices);
     // Maps field index to field_ptr index of where it was already initialized.
-    const found_fields = try gpa.alloc(Zir.Inst.OptionalIndex, struct_ty.structFieldCount(mod));
+    const found_fields = try gpa.alloc(Zir.Inst.OptionalIndex, struct_ty.structFieldCount(zcu));
     defer gpa.free(found_fields);
     @memset(found_fields, .none);
 @@ -4806,7 +4805,7 @@ fn validateStructInit(
             sema.code.nullTerminatedString(field_ptr_extra.field_name_start),
             .no_embedded_nulls,
         );
-        field_index.* = if (struct_ty.isTuple(mod))
+        field_index.* = if (struct_ty.isTuple(zcu))
             try sema.tupleFieldIndex(block, struct_ty, field_name, field_src)
         else
             try sema.structFieldIndex(block, struct_ty, field_name, field_src);
 @@ -4814,7 +4813,7 @@ fn validateStructInit(
         found_fields[field_index.*] = field_ptr.toOptional();
     }
-    var root_msg: ?*Module.ErrorMsg = null;
+    var root_msg: ?*Zcu.ErrorMsg = null;
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
     const struct_ptr = try sema.resolveInst(struct_ptr_zir_ref);
 @@ -4830,9 +4829,9 @@ fn validateStructInit(
             if (field_ptr != .none) continue;
             try struct_ty.resolveStructFieldInits(pt);
-            const default_val = struct_ty.structFieldDefaultValue(i, mod);
+            const default_val = struct_ty.structFieldDefaultValue(i, zcu);
             if (default_val.toIntern() == .unreachable_value) {
-                const field_name = struct_ty.structFieldName(i, mod).unwrap() orelse {
+                const field_name = struct_ty.structFieldName(i, zcu).unwrap() orelse {
                     const template = "missing tuple field with index {d}";
                     if (root_msg) |msg| {
                         try sema.errNote(init_src, msg, template, .{i});
 @@ -4852,7 +4851,7 @@ fn validateStructInit(
             }
             const field_src = init_src; // TODO better source location
-            const default_field_ptr = if (struct_ty.isTuple(mod))
+            const default_field_ptr = if (struct_ty.isTuple(zcu))
                 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(i), true)
             else
                 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), field_src, struct_ty, true);
 @@ -4874,7 +4873,7 @@ fn validateStructInit(
     var struct_is_comptime = true;
     var first_block_index = block.instructions.items.len;
-    const require_comptime = try sema.typeRequiresComptime(struct_ty);
+    const require_comptime = try struct_ty.comptimeOnlySema(pt);
     const air_tags = sema.air_instructions.items(.tag);
     const air_datas = sema.air_instructions.items(.data);
 @@ -4882,13 +4881,13 @@ fn validateStructInit(
     // We collect the comptime field values in case the struct initialization
     // ends up being comptime-known.
-    const field_values = try sema.arena.alloc(InternPool.Index, struct_ty.structFieldCount(mod));
+    const field_values = try sema.arena.alloc(InternPool.Index, struct_ty.structFieldCount(zcu));
     field: for (found_fields, 0..) |opt_field_ptr, i_usize| {
         const i: u32 = @intCast(i_usize);
         if (opt_field_ptr.unwrap()) |field_ptr| {
             // Determine whether the value stored to this pointer is comptime-known.
-            const field_ty = struct_ty.structFieldType(i, mod);
+            const field_ty = struct_ty.fieldType(i, zcu);
             if (try sema.typeHasOnePossibleValue(field_ty)) |opv| {
                 field_values[i] = opv.toIntern();
                 continue;
 @@ -4958,9 +4957,9 @@ fn validateStructInit(
             continue :field;
         }
-        const default_val = struct_ty.structFieldDefaultValue(i, mod);
+        const default_val = struct_ty.structFieldDefaultValue(i, zcu);
         if (default_val.toIntern() == .unreachable_value) {
-            const field_name = struct_ty.structFieldName(i, mod).unwrap() orelse {
+            const field_name = struct_ty.structFieldName(i, zcu).unwrap() orelse {
                 const template = "missing tuple field with index {d}";
                 if (root_msg) |msg| {
                     try sema.errNote(init_src, msg, template, .{i});
 @@ -5000,7 +4999,7 @@ fn validateStructInit(
         var block_index = first_block_index;
         for (block.instructions.items[first_block_index..]) |cur_inst| {
             while (field_ptr_ref == .none and init_index < instrs.len) : (init_index += 1) {
-                const field_ty = struct_ty.structFieldType(field_indices[init_index], mod);
+                const field_ty = struct_ty.fieldType(field_indices[init_index], zcu);
                 if (try field_ty.onePossibleValue(pt)) |_| continue;
                 field_ptr_ref = sema.inst_map.get(instrs[init_index]).?;
             }
 @@ -5044,7 +5043,7 @@ fn validateStructInit(
         if (field_ptr != .none) continue;
         const field_src = init_src; // TODO better source location
-        const default_field_ptr = if (struct_ty.isTuple(mod))
+        const default_field_ptr = if (struct_ty.isTuple(zcu))
             try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(i), true)
         else
             try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), field_src, struct_ty, true);
 @@ -5060,7 +5059,7 @@ fn zirValidatePtrArrayInit(
     inst: Zir.Inst.Index,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const validate_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const init_src = block.nodeOffset(validate_inst.src_node);
     const validate_extra = sema.code.extraData(Zir.Inst.Block, validate_inst.payload_index);
 @@ -5068,8 +5067,8 @@ fn zirValidatePtrArrayInit(
     const first_elem_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node;
     const elem_ptr_extra = sema.code.extraData(Zir.Inst.ElemPtrImm, first_elem_ptr_data.payload_index).data;
     const array_ptr = try sema.resolveInst(elem_ptr_extra.ptr);
-    const array_ty = sema.typeOf(array_ptr).childType(mod).optEuBaseType(mod);
+    const array_ty = sema.typeOf(array_ptr).childType(zcu).optEuBaseType(zcu);
-    const array_len = array_ty.arrayLen(mod);
+    const array_len = array_ty.arrayLen(zcu);
     // Collect the comptime element values in case the array literal ends up
     // being comptime-known.
 @@ -5078,15 +5077,15 @@ fn zirValidatePtrArrayInit(
         try sema.usizeCast(block, init_src, array_len),
     );
-    if (instrs.len != array_len) switch (array_ty.zigTypeTag(mod)) {
+    if (instrs.len != array_len) switch (array_ty.zigTypeTag(zcu)) {
         .Struct => {
-            var root_msg: ?*Module.ErrorMsg = null;
+            var root_msg: ?*Zcu.ErrorMsg = null;
             errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
             try array_ty.resolveStructFieldInits(pt);
             var i = instrs.len;
             while (i < array_len) : (i += 1) {
-                const default_val = array_ty.structFieldDefaultValue(i, mod).toIntern();
+                const default_val = array_ty.structFieldDefaultValue(i, zcu).toIntern();
                 if (default_val == .unreachable_value) {
                     const template = "missing tuple field with index {d}";
                     if (root_msg) |msg| {
 @@ -5125,7 +5124,7 @@ fn zirValidatePtrArrayInit(
         // at comptime so we have almost nothing to do here. However, in case of a
         // sentinel-terminated array, the sentinel will not have been populated by
         // any ZIR instructions at comptime; we need to do that here.
-        if (array_ty.sentinel(mod)) |sentinel_val| {
+        if (array_ty.sentinel(zcu)) |sentinel_val| {
             const array_len_ref = try pt.intRef(Type.usize, array_len);
             const sentinel_ptr = try sema.elemPtrArray(block, init_src, init_src, array_ptr, init_src, array_len_ref, true, true);
             const sentinel = Air.internedToRef(sentinel_val.toIntern());
 @@ -5150,8 +5149,8 @@ fn zirValidatePtrArrayInit(
     outer: for (instrs, 0..) |elem_ptr, i| {
         // Determine whether the value stored to this pointer is comptime-known.
-        if (array_ty.isTuple(mod)) {
+        if (array_ty.isTuple(zcu)) {
-            if (array_ty.structFieldIsComptime(i, mod))
+            if (array_ty.structFieldIsComptime(i, zcu))
                 try array_ty.resolveStructFieldInits(pt);
             if (try array_ty.structFieldValueComptime(pt, i)) |opv| {
                 element_vals[i] = opv.toIntern();
 @@ -5216,7 +5215,7 @@ fn zirValidatePtrArrayInit(
     if (array_is_comptime) {
         if (try sema.resolveDefinedValue(block, init_src, array_ptr)) |ptr_val| {
-            switch (mod.intern_pool.indexToKey(ptr_val.toIntern())) {
+            switch (zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
                 .ptr => |ptr| switch (ptr.base_addr) {
                     .comptime_field => return, // This store was validated by the individual elem ptrs.
                     else => {},
 @@ -5232,7 +5231,7 @@ fn zirValidatePtrArrayInit(
         var block_index = first_block_index;
         for (block.instructions.items[first_block_index..]) |cur_inst| {
             while (elem_ptr_ref == .none and elem_index < instrs.len) : (elem_index += 1) {
-                if (array_ty.isTuple(mod) and array_ty.structFieldIsComptime(elem_index, mod)) continue;
+                if (array_ty.isTuple(zcu) and array_ty.structFieldIsComptime(elem_index, zcu)) continue;
                 elem_ptr_ref = sema.inst_map.get(instrs[elem_index]).?;
             }
             switch (air_tags[@intFromEnum(cur_inst)]) {
 @@ -5266,31 +5265,31 @@ fn zirValidatePtrArrayInit(
 fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    if (operand_ty.zigTypeTag(mod) != .Pointer) {
+    if (operand_ty.zigTypeTag(zcu) != .Pointer) {
         return sema.fail(block, src, "cannot dereference non-pointer type '{}'", .{operand_ty.fmt(pt)});
-    } else switch (operand_ty.ptrSize(mod)) {
+    } else switch (operand_ty.ptrSize(zcu)) {
         .One, .C => {},
         .Many => return sema.fail(block, src, "index syntax required for unknown-length pointer type '{}'", .{operand_ty.fmt(pt)}),
         .Slice => return sema.fail(block, src, "index syntax required for slice type '{}'", .{operand_ty.fmt(pt)}),
     }
-    if ((try sema.typeHasOnePossibleValue(operand_ty.childType(mod))) != null) {
+    if ((try sema.typeHasOnePossibleValue(operand_ty.childType(zcu))) != null) {
         // No need to validate the actual pointer value, we don't need it!
         return;
     }
-    const elem_ty = operand_ty.elemType2(mod);
+    const elem_ty = operand_ty.elemType2(zcu);
     if (try sema.resolveValue(operand)) |val| {
-        if (val.isUndef(mod)) {
+        if (val.isUndef(zcu)) {
             return sema.fail(block, src, "cannot dereference undefined value", .{});
         }
-    } else if (try sema.typeRequiresComptime(elem_ty)) {
+    } else if (try elem_ty.comptimeOnlySema(pt)) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 src,
 @@ -5308,7 +5307,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -5316,9 +5315,9 @@ fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const operand = try sema.resolveInst(extra.operand);
     const operand_ty = sema.typeOf(operand);
-    const can_destructure = switch (operand_ty.zigTypeTag(mod)) {
+    const can_destructure = switch (operand_ty.zigTypeTag(zcu)) {
         .Array, .Vector => true,
-        .Struct => operand_ty.isTuple(mod),
+        .Struct => operand_ty.isTuple(zcu),
         else => false,
     };
 @@ -5331,11 +5330,11 @@ fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
         });
     }
-    if (operand_ty.arrayLen(mod) != extra.expect_len) {
+    if (operand_ty.arrayLen(zcu) != extra.expect_len) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "expected {} elements for destructure, found {}", .{
                 extra.expect_len,
-                operand_ty.arrayLen(mod),
+                operand_ty.arrayLen(zcu),
             });
             errdefer msg.destroy(sema.gpa);
             try sema.errNote(destructure_src, msg, "result destructured here", .{});
 @@ -5423,7 +5422,7 @@ fn failWithBadUnionFieldAccess(
     return sema.failWithOwnedErrorMsg(block, msg);
 }
-fn addDeclaredHereNote(sema: *Sema, parent: *Module.ErrorMsg, decl_ty: Type) !void {
+fn addDeclaredHereNote(sema: *Sema, parent: *Zcu.ErrorMsg, decl_ty: Type) !void {
     const zcu = sema.pt.zcu;
     const src_loc = decl_ty.srcLocOrNull(zcu) orelse return;
     const category = switch (decl_ty.zigTypeTag(zcu)) {
 @@ -5537,7 +5536,7 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const zir_tags = sema.code.instructions.items(.tag);
     const zir_datas = sema.code.instructions.items(.data);
     const inst_data = zir_datas[@intFromEnum(inst)].pl_node;
 @@ -5556,7 +5555,7 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v
     //   %b = store(%a, %c)
     // Where %c is an error union or error set. In such case we need to add
     // to the current function's inferred error set, if any.
-    if (is_ret and sema.fn_ret_ty_ies != null) switch (sema.typeOf(operand).zigTypeTag(mod)) {
+    if (is_ret and sema.fn_ret_ty_ies != null) switch (sema.typeOf(operand).zigTypeTag(zcu)) {
         .ErrorUnion, .ErrorSet => try sema.addToInferredErrorSet(operand),
         else => {},
     };
 @@ -5688,9 +5687,9 @@ fn zirCompileLog(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    var managed = mod.compile_log_text.toManaged(sema.gpa);
+    var managed = zcu.compile_log_text.toManaged(sema.gpa);
     defer pt.zcu.compile_log_text = managed.moveToUnmanaged();
     const writer = managed.writer();
 @@ -5713,7 +5712,7 @@ fn zirCompileLog(
     }
     try writer.print("\n", .{});
-    const gop = try mod.compile_log_sources.getOrPut(sema.gpa, sema.owner);
+    const gop = try zcu.compile_log_sources.getOrPut(sema.gpa, sema.owner);
     if (!gop.found_existing) gop.value_ptr.* = .{
         .base_node_inst = block.src_base_inst,
         .node_offset = src_node,
 @@ -5749,7 +5748,7 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = parent_block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);
 @@ -5800,7 +5799,7 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError
     try sema.analyzeBodyInner(&loop_block, body);
     const loop_block_len = loop_block.instructions.items.len;
-    if (loop_block_len > 0 and sema.typeOf(loop_block.instructions.items[loop_block_len - 1].toRef()).isNoReturn(mod)) {
+    if (loop_block_len > 0 and sema.typeOf(loop_block.instructions.items[loop_block_len - 1].toRef()).isNoReturn(zcu)) {
         // If the loop ended with a noreturn terminator, then there is no way for it to loop,
         // so we can just use the block instead.
         try child_block.instructions.appendSlice(gpa, loop_block.instructions.items);
 @@ -6069,11 +6068,11 @@ fn resolveAnalyzedBlock(
     const gpa = sema.gpa;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // Blocks must terminate with noreturn instruction.
     assert(child_block.instructions.items.len != 0);
-    assert(sema.typeOf(child_block.instructions.items[child_block.instructions.items.len - 1].toRef()).isNoReturn(mod));
+    assert(sema.typeOf(child_block.instructions.items[child_block.instructions.items.len - 1].toRef()).isNoReturn(zcu));
     const block_tag = sema.air_instructions.items(.tag)[@intFromEnum(merges.block_inst)];
     switch (block_tag) {
 @@ -6178,7 +6177,7 @@ fn resolveAnalyzedBlock(
     // TODO add note "missing else causes void value"
     const type_src = src; // TODO: better source location
-    if (try sema.typeRequiresComptime(resolved_ty)) {
+    if (try resolved_ty.comptimeOnlySema(pt)) {
         const msg = msg: {
             const msg = try sema.errMsg(type_src, "value with comptime-only type '{}' depends on runtime control flow", .{resolved_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -6227,7 +6226,7 @@ fn resolveAnalyzedBlock(
         const br_operand = sema.air_instructions.items(.data)[@intFromEnum(br)].br.operand;
         const br_operand_src = src;
         const br_operand_ty = sema.typeOf(br_operand);
-        if (br_operand_ty.eql(resolved_ty, mod)) {
+        if (br_operand_ty.eql(resolved_ty, zcu)) {
             // No type coercion needed.
             continue;
         }
 @@ -6354,7 +6353,7 @@ pub fn analyzeExport(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
-    options: Module.Export.Options,
+    options: Zcu.Export.Options,
     exported_nav_index: InternPool.Nav.Index,
 ) !void {
     const gpa = sema.gpa;
 @@ -6427,8 +6426,8 @@ fn zirSetAlignStack(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
 fn zirSetCold(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
     const is_cold = try sema.resolveConstBool(block, operand_src, extra.operand, .{
 @@ -6446,8 +6445,8 @@ fn zirSetCold(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData)
 fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const func = switch (sema.owner.unwrap()) {
         .func => |func| func,
         .cau => return, // does nothing outside a function
 @@ -6572,17 +6571,17 @@ fn addDbgVar(
     if (block.is_comptime or block.ownerModule().strip) return;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     const val_ty = switch (air_tag) {
-        .dbg_var_ptr => operand_ty.childType(mod),
+        .dbg_var_ptr => operand_ty.childType(zcu),
         .dbg_var_val, .dbg_arg_inline => operand_ty,
         else => unreachable,
     };
-    if (try sema.typeRequiresComptime(val_ty)) return;
+    if (try val_ty.comptimeOnlySema(pt)) return;
-    if (!(try sema.typeHasRuntimeBits(val_ty))) return;
+    if (!(try val_ty.hasRuntimeBitsSema(pt))) return;
     if (try sema.resolveValue(operand)) |operand_val| {
-        if (operand_val.canMutateComptimeVarState(mod)) return;
+        if (operand_val.canMutateComptimeVarState(zcu)) return;
     }
     // To ensure the lexical scoping is known to backends, this alloc must be
 @@ -6619,10 +6618,10 @@ pub fn appendAirString(sema: *Sema, str: []const u8) Allocator.Error!Air.NullTer
 fn zirDeclRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
     const src = block.tokenOffset(inst_data.src_tok);
-    const decl_name = try mod.intern_pool.getOrPutString(
+    const decl_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         inst_data.get(sema.code),
 @@ -6634,10 +6633,10 @@ fn zirDeclRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
 fn zirDeclVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
     const src = block.tokenOffset(inst_data.src_tok);
-    const decl_name = try mod.intern_pool.getOrPutString(
+    const decl_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         inst_data.get(sema.code),
 @@ -6649,14 +6648,14 @@ fn zirDeclVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
 fn lookupIdentifier(sema: *Sema, block: *Block, src: LazySrcLoc, name: InternPool.NullTerminatedString) !InternPool.Nav.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     var namespace = block.namespace;
     while (true) {
         if (try sema.lookupInNamespace(block, src, namespace, name, false)) |lookup| {
             assert(lookup.accessible);
             return lookup.nav;
         }
-        namespace = mod.namespacePtr(namespace).parent.unwrap() orelse break;
+        namespace = zcu.namespacePtr(namespace).parent.unwrap() orelse break;
     }
     unreachable; // AstGen detects use of undeclared identifiers.
 }
 @@ -6801,7 +6800,7 @@ fn funcDeclSrcInst(sema: *Sema, func_inst: Air.Inst.Ref) !?InternPool.TrackedIns
 pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     if (block.is_comptime or block.is_typeof) {
 @@ -6813,7 +6812,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
     const stack_trace_ty = try pt.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
-    const field_name = try mod.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
+    const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
     const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) {
         error.AnalysisFail => @panic("std.builtin.StackTrace is corrupt"),
         error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
 @@ -6839,7 +6838,7 @@ fn popErrorReturnTrace(
     saved_error_trace_index: Air.Inst.Ref,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     var is_non_error: ?bool = null;
     var is_non_error_inst: Air.Inst.Ref = undefined;
 @@ -6857,7 +6856,7 @@ fn popErrorReturnTrace(
         try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
-        const field_name = try mod.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
+        const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
         const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_trace_ty, true);
         try sema.storePtr2(block, src, field_ptr, src, saved_error_trace_index, src, .store);
     } else if (is_non_error == null) {
 @@ -6883,7 +6882,7 @@ fn popErrorReturnTrace(
         try stack_trace_ty.resolveFields(pt);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
-        const field_name = try mod.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
+        const field_name = try zcu.intern_pool.getOrPutString(gpa, pt.tid, "index", .no_embedded_nulls);
         const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_trace_ty, true);
         try sema.storePtr2(&then_block, src, field_ptr, src, saved_error_trace_index, src, .store);
         _ = try then_block.addBr(cond_block_inst, .void_value);
 @@ -6923,7 +6922,7 @@ fn zirCall(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const callee_src = block.src(.{ .node_offset_call_func = inst_data.src_node });
     const call_src = block.nodeOffset(inst_data.src_node);
 @@ -6942,7 +6941,7 @@ fn zirCall(
         .direct => .{ .direct = try sema.resolveInst(extra.data.callee) },
         .field => blk: {
             const object_ptr = try sema.resolveInst(extra.data.obj_ptr);
-            const field_name = try mod.intern_pool.getOrPutString(
+            const field_name = try zcu.intern_pool.getOrPutString(
                 sema.gpa,
                 pt.tid,
                 sema.code.nullTerminatedString(extra.data.field_name_start),
 @@ -6987,7 +6986,7 @@ fn zirCall(
     switch (sema.owner.unwrap()) {
         .cau => input_is_error = false,
-        .func => |owner_func| if (!mod.intern_pool.funcAnalysisUnordered(owner_func).calls_or_awaits_errorable_fn) {
+        .func => |owner_func| if (!zcu.intern_pool.funcAnalysisUnordered(owner_func).calls_or_awaits_errorable_fn) {
             // No errorable fn actually called; we have no error return trace
             input_is_error = false;
         },
 @@ -6997,7 +6996,7 @@ fn zirCall(
         !block.is_comptime and !block.is_typeof and (input_is_error or pop_error_return_trace))
     {
         const return_ty = sema.typeOf(call_inst);
-        if (modifier != .always_tail and return_ty.isNoReturn(mod))
+        if (modifier != .always_tail and return_ty.isNoReturn(zcu))
             return call_inst; // call to "fn (...) noreturn", don't pop
         // TODO: we don't fix up the error trace for always_tail correctly, we should be doing it
 @@ -7008,10 +7007,10 @@ fn zirCall(
         // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only
         // need to clean-up our own trace if we were passed to a non-error-handling expression.
-        if (input_is_error or (pop_error_return_trace and return_ty.isError(mod))) {
+        if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) {
             const stack_trace_ty = try pt.getBuiltinType("StackTrace");
             try stack_trace_ty.resolveFields(pt);
-            const field_name = try mod.intern_pool.getOrPutString(sema.gpa, pt.tid, "index", .no_embedded_nulls);
+            const field_name = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, "index", .no_embedded_nulls);
             const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src);
             // Insert a save instruction before the arg resolution + call instructions we just generated
 @@ -7044,20 +7043,20 @@ fn checkCallArgumentCount(
     member_fn: bool,
 ) !Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const func_ty = func_ty: {
-        switch (callee_ty.zigTypeTag(mod)) {
+        switch (callee_ty.zigTypeTag(zcu)) {
             .Fn => break :func_ty callee_ty,
             .Pointer => {
-                const ptr_info = callee_ty.ptrInfo(mod);
+                const ptr_info = callee_ty.ptrInfo(zcu);
-                if (ptr_info.flags.size == .One and Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Fn) {
+                if (ptr_info.flags.size == .One and Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .Fn) {
                     break :func_ty Type.fromInterned(ptr_info.child);
                 }
             },
             .Optional => {
-                const opt_child = callee_ty.optionalChild(mod);
+                const opt_child = callee_ty.optionalChild(zcu);
-                if (opt_child.zigTypeTag(mod) == .Fn or (opt_child.isSinglePointer(mod) and
+                if (opt_child.zigTypeTag(zcu) == .Fn or (opt_child.isSinglePointer(zcu) and
-                    opt_child.childType(mod).zigTypeTag(mod) == .Fn))
+                    opt_child.childType(zcu).zigTypeTag(zcu) == .Fn))
                 {
                     const msg = msg: {
                         const msg = try sema.errMsg(func_src, "cannot call optional type '{}'", .{
 @@ -7075,7 +7074,7 @@ fn checkCallArgumentCount(
         return sema.fail(block, func_src, "type '{}' not a function", .{callee_ty.fmt(pt)});
     };
-    const func_ty_info = mod.typeToFunc(func_ty).?;
+    const func_ty_info = zcu.typeToFunc(func_ty).?;
     const fn_params_len = func_ty_info.param_types.len;
     const args_len = total_args - @intFromBool(member_fn);
     if (func_ty_info.is_var_args) {
 @@ -7122,14 +7121,14 @@ fn callBuiltin(
     operation: CallOperation,
 ) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const callee_ty = sema.typeOf(builtin_fn);
     const func_ty = func_ty: {
-        switch (callee_ty.zigTypeTag(mod)) {
+        switch (callee_ty.zigTypeTag(zcu)) {
             .Fn => break :func_ty callee_ty,
             .Pointer => {
-                const ptr_info = callee_ty.ptrInfo(mod);
+                const ptr_info = callee_ty.ptrInfo(zcu);
-                if (ptr_info.flags.size == .One and Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Fn) {
+                if (ptr_info.flags.size == .One and Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .Fn) {
                     break :func_ty Type.fromInterned(ptr_info.child);
                 }
             },
 @@ -7138,7 +7137,7 @@ fn callBuiltin(
         std.debug.panic("type '{}' is not a function calling builtin fn", .{callee_ty.fmt(pt)});
     };
-    const func_ty_info = mod.typeToFunc(func_ty).?;
+    const func_ty_info = zcu.typeToFunc(func_ty).?;
     const fn_params_len = func_ty_info.param_types.len;
     if (args.len != fn_params_len or (func_ty_info.is_var_args and args.len < fn_params_len)) {
         std.debug.panic("parameter count mismatch calling builtin fn, expected {d}, found {d}", .{ fn_params_len, args.len });
 @@ -7242,7 +7241,7 @@ const CallArgsInfo = union(enum) {
         func_inst: Air.Inst.Ref,
     ) CompileError!Air.Inst.Ref {
         const pt = sema.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const param_count = func_ty_info.param_types.len;
         const uncoerced_arg: Air.Inst.Ref = switch (cai) {
             inline .resolved, .call_builtin => |resolved| resolved.args[arg_index],
 @@ -7277,13 +7276,13 @@ const CallArgsInfo = union(enum) {
                 // Resolve the arg!
                 const uncoerced_arg = try sema.resolveInlineBody(block, arg_body, zir_call.call_inst);
-                if (sema.typeOf(uncoerced_arg).zigTypeTag(mod) == .NoReturn) {
+                if (sema.typeOf(uncoerced_arg).zigTypeTag(zcu) == .NoReturn) {
                     // This terminates resolution of arguments. The caller should
                     // propagate this.
                     return uncoerced_arg;
                 }
-                if (sema.typeOf(uncoerced_arg).isError(mod)) {
+                if (sema.typeOf(uncoerced_arg).isError(zcu)) {
                     zir_call.any_arg_is_error.* = true;
                 }
 @@ -7476,7 +7475,7 @@ fn analyzeCall(
     var is_inline_call = is_comptime_call or modifier == .always_inline or func_ty_info.cc == .Inline;
     var comptime_reason: ?*const Block.ComptimeReason = null;
     if (!is_inline_call and !is_comptime_call) {
-        if (try sema.typeRequiresComptime(Type.fromInterned(func_ty_info.return_type))) {
+        if (try Type.fromInterned(func_ty_info.return_type).comptimeOnlySema(pt)) {
             is_comptime_call = true;
             is_inline_call = true;
             comptime_reason = &.{ .comptime_ret_ty = .{
 @@ -7968,8 +7967,8 @@ fn analyzeInlineCallArg(
     func_ty_info: InternPool.Key.FuncType,
     func_inst: Air.Inst.Ref,
 ) !?Air.Inst.Ref {
-    const mod = ics.sema.pt.zcu;
+    const zcu = ics.sema.pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const zir_tags = ics.callee().code.instructions.items(.tag);
     switch (zir_tags[@intFromEnum(inst)]) {
         .param_comptime, .param_anytype_comptime => param_block.inlining.?.has_comptime_args = true,
 @@ -7992,11 +7991,11 @@ fn analyzeInlineCallArg(
             };
             new_param_types[arg_i.*] = param_ty;
             const casted_arg = try args_info.analyzeArg(ics.caller(), arg_block, arg_i.*, Type.fromInterned(param_ty), func_ty_info, func_inst);
-            if (ics.caller().typeOf(casted_arg).zigTypeTag(mod) == .NoReturn) {
+            if (ics.caller().typeOf(casted_arg).zigTypeTag(zcu) == .NoReturn) {
                 return casted_arg;
             }
             const arg_src = args_info.argSrc(arg_block, arg_i.*);
-            if (try ics.callee().typeRequiresComptime(Type.fromInterned(param_ty))) {
+            if (try Type.fromInterned(param_ty).comptimeOnlySema(ics.callee().pt)) {
                 _ = try ics.caller().resolveConstValue(arg_block, arg_src, casted_arg, .{
                     .needed_comptime_reason = "argument to parameter with comptime-only type must be comptime-known",
                     .block_comptime_reason = param_block.comptime_reason,
 @@ -8025,7 +8024,7 @@ fn analyzeInlineCallArg(
                 // assertion due to type not being resolved
                 // when the hash function is called.
                 const resolved_arg_val = try ics.caller().resolveLazyValue(arg_val);
-                should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(mod);
+                should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(zcu);
                 memoized_arg_values[arg_i.*] = resolved_arg_val.toIntern();
             } else {
                 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, casted_arg);
 @@ -8040,7 +8039,7 @@ fn analyzeInlineCallArg(
         .param_anytype, .param_anytype_comptime => {
             // No coercion needed.
             const uncasted_arg = try args_info.analyzeArg(ics.caller(), arg_block, arg_i.*, Type.generic_poison, func_ty_info, func_inst);
-            if (ics.caller().typeOf(uncasted_arg).zigTypeTag(mod) == .NoReturn) {
+            if (ics.caller().typeOf(uncasted_arg).zigTypeTag(zcu) == .NoReturn) {
                 return uncasted_arg;
             }
             const arg_src = args_info.argSrc(arg_block, arg_i.*);
 @@ -8064,7 +8063,7 @@ fn analyzeInlineCallArg(
                 // assertion due to type not being resolved
                 // when the hash function is called.
                 const resolved_arg_val = try ics.caller().resolveLazyValue(arg_val);
-                should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(mod);
+                should_memoize.* = should_memoize.* and !resolved_arg_val.canMutateComptimeVarState(zcu);
                 memoized_arg_values[arg_i.*] = resolved_arg_val.toIntern();
             } else {
                 if (zir_tags[@intFromEnum(inst)] == .param_anytype_comptime) {
 @@ -8236,7 +8235,7 @@ fn instantiateGenericCall(
         const arg_is_comptime = switch (param_tag) {
             .param_comptime, .param_anytype_comptime => true,
-            .param, .param_anytype => try sema.typeRequiresComptime(arg_ty),
+            .param, .param_anytype => try arg_ty.comptimeOnlySema(pt),
             else => unreachable,
         };
 @@ -8325,7 +8324,7 @@ fn instantiateGenericCall(
     // If the call evaluated to a return type that requires comptime, never mind
     // our generic instantiation. Instead we need to perform a comptime call.
-    if (try sema.typeRequiresComptime(Type.fromInterned(func_ty_info.return_type))) {
+    if (try Type.fromInterned(func_ty_info.return_type).comptimeOnlySema(pt)) {
         return error.ComptimeReturn;
     }
     // Similarly, if the call evaluated to a generic type we need to instead
 @@ -8376,8 +8375,8 @@ fn instantiateGenericCall(
 fn resolveTupleLazyValues(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const tuple = switch (ip.indexToKey(ty.toIntern())) {
         .anon_struct_type => |tuple| tuple,
         else => return,
 @@ -8401,13 +8400,13 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
     const child_type = try sema.resolveType(block, operand_src, inst_data.operand);
-    if (child_type.zigTypeTag(mod) == .Opaque) {
+    if (child_type.zigTypeTag(zcu) == .Opaque) {
         return sema.fail(block, operand_src, "opaque type '{}' cannot be optional", .{child_type.fmt(pt)});
-    } else if (child_type.zigTypeTag(mod) == .Null) {
+    } else if (child_type.zigTypeTag(zcu) == .Null) {
         return sema.fail(block, operand_src, "type '{}' cannot be optional", .{child_type.fmt(pt)});
     }
     const opt_type = try pt.optionalType(child_type.toIntern());
 @@ -8417,7 +8416,7 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
     const maybe_wrapped_indexable_ty = sema.resolveType(block, LazySrcLoc.unneeded, bin.lhs) catch |err| switch (err) {
         // Since this is a ZIR instruction that returns a type, encountering
 @@ -8427,40 +8426,40 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(mod);
+    const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(zcu);
     try indexable_ty.resolveFields(pt);
-    assert(indexable_ty.isIndexable(mod)); // validated by a previous instruction
+    assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction
-    if (indexable_ty.zigTypeTag(mod) == .Struct) {
+    if (indexable_ty.zigTypeTag(zcu) == .Struct) {
-        const elem_type = indexable_ty.structFieldType(@intFromEnum(bin.rhs), mod);
+        const elem_type = indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu);
         return Air.internedToRef(elem_type.toIntern());
     } else {
-        const elem_type = indexable_ty.elemType2(mod);
+        const elem_type = indexable_ty.elemType2(zcu);
         return Air.internedToRef(elem_type.toIntern());
     }
 }
 fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const maybe_wrapped_ptr_ty = sema.resolveType(block, LazySrcLoc.unneeded, un_node.operand) catch |err| switch (err) {
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(mod);
+    const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu);
-    assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+    assert(ptr_ty.zigTypeTag(zcu) == .Pointer); // validated by a previous instruction
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
     if (elem_ty.toIntern() == .anyopaque_type) {
         // The pointer's actual child type is effectively unknown, so it makes
         // sense to represent it with a generic poison.
         return .generic_poison_type;
     }
-    return Air.internedToRef(ptr_ty.childType(mod).toIntern());
+    return Air.internedToRef(ptr_ty.childType(zcu).toIntern());
 }
 fn zirIndexablePtrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(un_node.src_node);
     const ptr_ty = sema.resolveType(block, src, un_node.operand) catch |err| switch (err) {
 @@ -8468,16 +8467,16 @@ fn zirIndexablePtrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
         else => |e| return e,
     };
     try sema.checkMemOperand(block, src, ptr_ty);
-    const elem_ty = switch (ptr_ty.ptrSize(mod)) {
+    const elem_ty = switch (ptr_ty.ptrSize(zcu)) {
-        .Slice, .Many, .C => ptr_ty.childType(mod),
+        .Slice, .Many, .C => ptr_ty.childType(zcu),
-        .One => ptr_ty.childType(mod).childType(mod),
+        .One => ptr_ty.childType(zcu).childType(zcu),
     };
     return Air.internedToRef(elem_ty.toIntern());
 }
 fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const vec_ty = sema.resolveType(block, LazySrcLoc.unneeded, un_node.operand) catch |err| switch (err) {
         // Since this is a ZIR instruction that returns a type, encountering
 @@ -8487,10 +8486,10 @@ fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    if (!vec_ty.isVector(mod)) {
+    if (!vec_ty.isVector(zcu)) {
         return sema.fail(block, block.nodeOffset(un_node.src_node), "expected vector type, found '{}'", .{vec_ty.fmt(pt)});
     }
-    return Air.internedToRef(vec_ty.childType(mod).toIntern());
+    return Air.internedToRef(vec_ty.childType(zcu).toIntern());
 }
 fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -8561,10 +8560,10 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
 fn validateArrayElemType(sema: *Sema, block: *Block, elem_type: Type, elem_src: LazySrcLoc) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (elem_type.zigTypeTag(mod) == .Opaque) {
+    if (elem_type.zigTypeTag(zcu) == .Opaque) {
         return sema.fail(block, elem_src, "array of opaque type '{}' not allowed", .{elem_type.fmt(pt)});
-    } else if (elem_type.zigTypeTag(mod) == .NoReturn) {
+    } else if (elem_type.zigTypeTag(zcu) == .NoReturn) {
         return sema.fail(block, elem_src, "array of 'noreturn' not allowed", .{});
     }
 }
 @@ -8577,10 +8576,10 @@ fn zirAnyframeType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     if (true) {
         return sema.failWithUseOfAsync(block, block.nodeOffset(inst_data.src_node));
     }
-    const mod = sema.mod;
+    const zcu = sema.zcu;
     const operand_src = block.src(.{ .node_offset_anyframe_type = inst_data.src_node });
     const return_type = try sema.resolveType(block, operand_src, inst_data.operand);
-    const anyframe_type = try mod.anyframeType(return_type);
+    const anyframe_type = try zcu.anyframeType(return_type);
     return Air.internedToRef(anyframe_type.toIntern());
 }
 @@ -8590,7 +8589,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -8598,7 +8597,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     const error_set = try sema.resolveType(block, lhs_src, extra.lhs);
     const payload = try sema.resolveType(block, rhs_src, extra.rhs);
-    if (error_set.zigTypeTag(mod) != .ErrorSet) {
+    if (error_set.zigTypeTag(zcu) != .ErrorSet) {
         return sema.fail(block, lhs_src, "expected error set type, found '{}'", .{
             error_set.fmt(pt),
         });
 @@ -8610,12 +8609,12 @@ fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
 fn validateErrorUnionPayloadType(sema: *Sema, block: *Block, payload_ty: Type, payload_src: LazySrcLoc) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (payload_ty.zigTypeTag(mod) == .Opaque) {
+    if (payload_ty.zigTypeTag(zcu) == .Opaque) {
         return sema.fail(block, payload_src, "error union with payload of opaque type '{}' not allowed", .{
             payload_ty.fmt(pt),
         });
-    } else if (payload_ty.zigTypeTag(mod) == .ErrorSet) {
+    } else if (payload_ty.zigTypeTag(zcu) == .ErrorSet) {
         return sema.fail(block, payload_src, "error union with payload of error set type '{}' not allowed", .{
             payload_ty.fmt(pt),
         });
 @@ -8646,8 +8645,8 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 @@ -8656,7 +8655,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const err_int_ty = try pt.errorIntType();
     if (try sema.resolveValue(operand)) |val| {
-        if (val.isUndef(mod)) {
+        if (val.isUndef(zcu)) {
             return pt.undefRef(err_int_ty);
         }
         const err_name = ip.indexToKey(val.toIntern()).err.name;
 @@ -8688,8 +8687,8 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 @@ -8733,8 +8732,8 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
 @@ -8742,7 +8741,7 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node });
     const lhs = try sema.resolveInst(extra.lhs);
     const rhs = try sema.resolveInst(extra.rhs);
-    if (sema.typeOf(lhs).zigTypeTag(mod) == .Bool and sema.typeOf(rhs).zigTypeTag(mod) == .Bool) {
+    if (sema.typeOf(lhs).zigTypeTag(zcu) == .Bool and sema.typeOf(rhs).zigTypeTag(zcu) == .Bool) {
         const msg = msg: {
             const msg = try sema.errMsg(lhs_src, "expected error set type, found 'bool'", .{});
             errdefer msg.destroy(sema.gpa);
 @@ -8753,9 +8752,9 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     }
     const lhs_ty = try sema.analyzeAsType(block, lhs_src, lhs);
     const rhs_ty = try sema.analyzeAsType(block, rhs_src, rhs);
-    if (lhs_ty.zigTypeTag(mod) != .ErrorSet)
+    if (lhs_ty.zigTypeTag(zcu) != .ErrorSet)
         return sema.fail(block, lhs_src, "expected error set type, found '{}'", .{lhs_ty.fmt(pt)});
-    if (rhs_ty.zigTypeTag(mod) != .ErrorSet)
+    if (rhs_ty.zigTypeTag(zcu) != .ErrorSet)
         return sema.fail(block, rhs_src, "expected error set type, found '{}'", .{rhs_ty.fmt(pt)});
     // Anything merged with anyerror is anyerror.
 @@ -8790,28 +8789,28 @@ fn zirEnumLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
     const name = inst_data.get(sema.code);
     return Air.internedToRef((try pt.intern(.{
-        .enum_literal = try mod.intern_pool.getOrPutString(sema.gpa, pt.tid, name, .no_embedded_nulls),
+        .enum_literal = try zcu.intern_pool.getOrPutString(sema.gpa, pt.tid, name, .no_embedded_nulls),
     })));
 }
 fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    const enum_tag: Air.Inst.Ref = switch (operand_ty.zigTypeTag(mod)) {
+    const enum_tag: Air.Inst.Ref = switch (operand_ty.zigTypeTag(zcu)) {
         .Enum => operand,
         .Union => blk: {
             try operand_ty.resolveFields(pt);
-            const tag_ty = operand_ty.unionTagType(mod) orelse {
+            const tag_ty = operand_ty.unionTagType(zcu) orelse {
                 return sema.fail(
                     block,
                     operand_src,
 @@ -8829,11 +8828,11 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         },
     };
     const enum_tag_ty = sema.typeOf(enum_tag);
-    const int_tag_ty = enum_tag_ty.intTagType(mod);
+    const int_tag_ty = enum_tag_ty.intTagType(zcu);
     // TODO: use correct solution
     // https://github.com/ziglang/zig/issues/15909
-    if (enum_tag_ty.enumFieldCount(mod) == 0 and !enum_tag_ty.isNonexhaustiveEnum(mod)) {
+    if (enum_tag_ty.enumFieldCount(zcu) == 0 and !enum_tag_ty.isNonexhaustiveEnum(zcu)) {
         return sema.fail(block, operand_src, "cannot use @intFromEnum on empty enum '{}'", .{
             enum_tag_ty.fmt(pt),
         });
 @@ -8844,7 +8843,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     }
     if (try sema.resolveValue(enum_tag)) |enum_tag_val| {
-        if (enum_tag_val.isUndef(mod)) {
+        if (enum_tag_val.isUndef(zcu)) {
             return pt.undefRef(int_tag_ty);
         }
 @@ -8858,7 +8857,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
 fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -8866,14 +8865,14 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@enumFromInt");
     const operand = try sema.resolveInst(extra.rhs);
-    if (dest_ty.zigTypeTag(mod) != .Enum) {
+    if (dest_ty.zigTypeTag(zcu) != .Enum) {
         return sema.fail(block, src, "expected enum, found '{}'", .{dest_ty.fmt(pt)});
     }
     _ = try sema.checkIntType(block, operand_src, sema.typeOf(operand));
     if (try sema.resolveValue(operand)) |int_val| {
-        if (dest_ty.isNonexhaustiveEnum(mod)) {
+        if (dest_ty.isNonexhaustiveEnum(zcu)) {
-            const int_tag_ty = dest_ty.intTagType(mod);
+            const int_tag_ty = dest_ty.intTagType(zcu);
             if (try sema.intFitsInType(int_val, int_tag_ty, null)) {
                 return Air.internedToRef((try pt.getCoerced(int_val, dest_ty)).toIntern());
             }
 @@ -8881,7 +8880,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
                 int_val.fmtValueSema(pt, sema), dest_ty.fmt(pt),
             });
         }
-        if (int_val.isUndef(mod)) {
+        if (int_val.isUndef(zcu)) {
             return sema.failWithUseOfUndef(block, operand_src);
         }
         if (!(try sema.enumHasInt(dest_ty, int_val))) {
 @@ -8892,7 +8891,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         return Air.internedToRef((try pt.getCoerced(int_val, dest_ty)).toIntern());
     }
-    if (dest_ty.intTagType(mod).zigTypeTag(mod) == .ComptimeInt) {
+    if (dest_ty.intTagType(zcu).zigTypeTag(zcu) == .ComptimeInt) {
         return sema.failWithNeededComptime(block, operand_src, .{
             .needed_comptime_reason = "value being casted to enum with 'comptime_int' tag type must be comptime-known",
         });
 @@ -8909,8 +8908,8 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     try sema.requireRuntimeBlock(block, src, operand_src);
     const result = try block.addTyOp(.intcast, dest_ty, operand);
-    if (block.wantSafety() and !dest_ty.isNonexhaustiveEnum(mod) and
+    if (block.wantSafety() and !dest_ty.isNonexhaustiveEnum(zcu) and
-        mod.backendSupportsFeature(.is_named_enum_value))
+        zcu.backendSupportsFeature(.is_named_enum_value))
     {
         const ok = try block.addUnOp(.is_named_enum_value, result);
         try sema.addSafetyCheck(block, src, ok, .invalid_enum_value);
 @@ -9014,20 +9013,20 @@ fn zirOptionalPayload(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    const result_ty = switch (operand_ty.zigTypeTag(mod)) {
+    const result_ty = switch (operand_ty.zigTypeTag(zcu)) {
-        .Optional => operand_ty.optionalChild(mod),
+        .Optional => operand_ty.optionalChild(zcu),
         .Pointer => t: {
-            if (operand_ty.ptrSize(mod) != .C) {
+            if (operand_ty.ptrSize(zcu) != .C) {
                 return sema.failWithExpectedOptionalType(block, src, operand_ty);
             }
             // TODO https://github.com/ziglang/zig/issues/6597
             if (true) break :t operand_ty;
-            const ptr_info = operand_ty.ptrInfo(mod);
+            const ptr_info = operand_ty.ptrInfo(zcu);
             break :t try pt.ptrTypeSema(.{
                 .child = ptr_info.child,
                 .flags = .{
 @@ -9043,7 +9042,7 @@ fn zirOptionalPayload(
     };
     if (try sema.resolveDefinedValue(block, src, operand)) |val| {
-        return if (val.optionalValue(mod)) |payload|
+        return if (val.optionalValue(zcu)) |payload|
             Air.internedToRef(payload.toIntern())
         else
             sema.fail(block, src, "unable to unwrap null", .{});
 @@ -9067,13 +9066,13 @@ fn zirErrUnionPayload(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_src = src;
     const err_union_ty = sema.typeOf(operand);
-    if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) {
+    if (err_union_ty.zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(block, operand_src, "expected error union type, found '{}'", .{
             err_union_ty.fmt(pt),
         });
 @@ -9091,20 +9090,20 @@ fn analyzeErrUnionPayload(
     safety_check: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const payload_ty = err_union_ty.errorUnionPayload(mod);
+    const payload_ty = err_union_ty.errorUnionPayload(zcu);
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |val| {
-        if (val.getErrorName(mod).unwrap()) |name| {
+        if (val.getErrorName(zcu).unwrap()) |name| {
             return sema.failWithComptimeErrorRetTrace(block, src, name);
         }
-        return Air.internedToRef(mod.intern_pool.indexToKey(val.toIntern()).error_union.val.payload);
+        return Air.internedToRef(zcu.intern_pool.indexToKey(val.toIntern()).error_union.val.payload);
     }
     try sema.requireRuntimeBlock(block, src, null);
     // If the error set has no fields then no safety check is needed.
     if (safety_check and block.wantSafety() and
-        !err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod))
+        !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu))
     {
         try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err);
     }
 @@ -9215,20 +9214,20 @@ fn zirErrUnionCode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Inst.Ref) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
-    if (operand_ty.zigTypeTag(mod) != .ErrorUnion) {
+    if (operand_ty.zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(block, src, "expected error union type, found '{}'", .{
             operand_ty.fmt(pt),
         });
     }
-    const result_ty = operand_ty.errorUnionSet(mod);
+    const result_ty = operand_ty.errorUnionSet(zcu);
     if (try sema.resolveDefinedValue(block, src, operand)) |val| {
         return Air.internedToRef((try pt.intern(.{ .err = .{
             .ty = result_ty.toIntern(),
-            .name = mod.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
+            .name = zcu.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
         } })));
     }
 @@ -9249,24 +9248,24 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
 fn analyzeErrUnionCodePtr(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Inst.Ref) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
-    assert(operand_ty.zigTypeTag(mod) == .Pointer);
+    assert(operand_ty.zigTypeTag(zcu) == .Pointer);
-    if (operand_ty.childType(mod).zigTypeTag(mod) != .ErrorUnion) {
+    if (operand_ty.childType(zcu).zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(block, src, "expected error union type, found '{}'", .{
-            operand_ty.childType(mod).fmt(pt),
+            operand_ty.childType(zcu).fmt(pt),
         });
     }
-    const result_ty = operand_ty.childType(mod).errorUnionSet(mod);
+    const result_ty = operand_ty.childType(zcu).errorUnionSet(zcu);
     if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
         if (try sema.pointerDeref(block, src, pointer_val, operand_ty)) |val| {
-            assert(val.getErrorName(mod) != .none);
+            assert(val.getErrorName(zcu) != .none);
             return Air.internedToRef((try pt.intern(.{ .err = .{
                 .ty = result_ty.toIntern(),
-                .name = mod.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
+                .name = zcu.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
             } })));
         }
     }
 @@ -9412,7 +9411,7 @@ fn resolveGenericBody(
 /// and puts it there if it doesn't exist.
 /// It also dupes the library name which can then be saved as part of the
 /// respective `Decl` (either `ExternFn` or `Var`).
-/// The liveness of the duped library name is tied to liveness of `Module`.
+/// The liveness of the duped library name is tied to liveness of `Zcu`.
 /// To deallocate, call `deinit` on the respective `Decl` (`ExternFn` or `Var`).
 fn handleExternLibName(
     sema: *Sema,
 @@ -9422,9 +9421,9 @@ fn handleExternLibName(
 ) CompileError!void {
     blk: {
         const pt = sema.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const comp = mod.comp;
+        const comp = zcu.comp;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         log.debug("extern fn symbol expected in lib '{s}'", .{lib_name});
         if (target.is_libc_lib_name(lib_name)) {
             if (!comp.config.link_libc) {
 @@ -9575,7 +9574,7 @@ fn funcCommon(
             .fn_proto_node_offset = src_node_offset,
             .param_index = @intCast(i),
         } });
-        const requires_comptime = try sema.typeRequiresComptime(param_ty);
+        const requires_comptime = try param_ty.comptimeOnlySema(pt);
         if (param_is_comptime or requires_comptime) {
             comptime_bits |= @as(u32, 1) << @intCast(i); // TODO: handle cast error
         }
 @@ -9631,7 +9630,7 @@ fn funcCommon(
                 const err_code_size = target.ptrBitWidth();
                 switch (i) {
                     0 => if (param_ty.zigTypeTag(zcu) != .Pointer) return sema.fail(block, param_src, "first parameter of function with 'Interrupt' calling convention must be a pointer type", .{}),
-                    1 => if (param_ty.bitSize(pt) != err_code_size) return sema.fail(block, param_src, "second parameter of function with 'Interrupt' calling convention must be a {d}-bit integer", .{err_code_size}),
+                    1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with 'Interrupt' calling convention must be a {d}-bit integer", .{err_code_size}),
                     else => return sema.fail(block, param_src, "'Interrupt' calling convention supports up to 2 parameters, found {d}", .{i + 1}),
                 }
             } else return sema.fail(block, param_src, "parameters are not allowed with 'Interrupt' calling convention", .{}),
 @@ -9640,7 +9639,7 @@ fn funcCommon(
         }
     }
-    const ret_ty_requires_comptime = try sema.typeRequiresComptime(bare_return_type);
+    const ret_ty_requires_comptime = try bare_return_type.comptimeOnlySema(pt);
     const ret_poison = bare_return_type.isGenericPoison();
     const final_is_generic = is_generic or comptime_bits != 0 or ret_ty_requires_comptime;
 @@ -9881,18 +9880,18 @@ fn finishFunc(
     final_is_generic: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const gpa = sema.gpa;
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     const return_type: Type = if (opt_func_index == .none or ret_poison)
         bare_return_type
     else
         Type.fromInterned(ip.funcTypeReturnType(ip.typeOf(opt_func_index)));
-    if (!return_type.isValidReturnType(mod)) {
+    if (!return_type.isValidReturnType(zcu)) {
-        const opaque_str = if (return_type.zigTypeTag(mod) == .Opaque) "opaque " else "";
+        const opaque_str = if (return_type.zigTypeTag(zcu) == .Opaque) "opaque " else "";
         return sema.fail(block, ret_ty_src, "{s}return type '{}' not allowed", .{
             opaque_str, return_type.fmt(pt),
         });
 @@ -9954,7 +9953,7 @@ fn finishFunc(
     }
     switch (cc_resolved) {
-        .Interrupt, .Signal => if (return_type.zigTypeTag(mod) != .Void and return_type.zigTypeTag(mod) != .NoReturn) {
+        .Interrupt, .Signal => if (return_type.zigTypeTag(zcu) != .Void and return_type.zigTypeTag(zcu) != .NoReturn) {
             return sema.fail(block, ret_ty_src, "function with calling convention '{s}' must return 'void' or 'noreturn'", .{@tagName(cc_resolved)});
         },
         .Inline => if (is_noinline) {
 @@ -10070,7 +10069,7 @@ fn zirParam(
         }
     };
-    const is_comptime = try sema.typeRequiresComptime(param_ty) or comptime_syntax;
+    const is_comptime = try param_ty.comptimeOnlySema(sema.pt) or comptime_syntax;
     try block.params.append(sema.arena, .{
         .ty = param_ty.toIntern(),
 @@ -10141,7 +10140,7 @@ fn analyzeAs(
     no_cast_to_comptime_int: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand = try sema.resolveInst(zir_operand);
     const operand_air_inst = sema.resolveInst(zir_dest_type) catch |err| switch (err) {
         error.GenericPoison => return operand,
 @@ -10151,7 +10150,7 @@ fn analyzeAs(
         error.GenericPoison => return operand,
         else => |e| return e,
     };
-    const dest_ty_tag = dest_ty.zigTypeTagOrPoison(mod) catch |err| switch (err) {
+    const dest_ty_tag = dest_ty.zigTypeTagOrPoison(zcu) catch |err| switch (err) {
         error.GenericPoison => return operand,
     };
 @@ -10189,7 +10188,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ty.fmt(pt)});
     }
     const pointee_ty = ptr_ty.childType(zcu);
-    if (try sema.typeRequiresComptime(ptr_ty)) {
+    if (try ptr_ty.comptimeOnlySema(pt)) {
         const msg = msg: {
             const msg = try sema.errMsg(ptr_src, "comptime-only type '{}' has no pointer address", .{pointee_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -10205,7 +10204,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
             }
             return Air.internedToRef((try pt.intValue(
                 Type.usize,
-                (try operand_val.getUnsignedIntAdvanced(pt, .sema)).?,
+                (try operand_val.toUnsignedIntSema(pt)),
             )).toIntern());
         }
         const len = operand_ty.vectorLen(zcu);
 @@ -10217,7 +10216,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
                 new_elem.* = (try pt.undefValue(Type.usize)).toIntern();
                 continue;
             }
-            const addr = try ptr_val.getUnsignedIntAdvanced(pt, .sema) orelse {
+            const addr = try ptr_val.getUnsignedIntSema(pt) orelse {
                 // A vector element wasn't an integer pointer. This is a runtime operation.
                 break :ct;
             };
 @@ -10252,12 +10251,12 @@ fn zirFieldVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const field_name_src = block.src(.{ .node_offset_field_name = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
-    const field_name = try mod.intern_pool.getOrPutString(
+    const field_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         sema.code.nullTerminatedString(extra.field_name_start),
 @@ -10272,12 +10271,12 @@ fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const field_name_src = block.src(.{ .node_offset_field_name = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
-    const field_name = try mod.intern_pool.getOrPutString(
+    const field_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         sema.code.nullTerminatedString(extra.field_name_start),
 @@ -10292,20 +10291,20 @@ fn zirStructInitFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const field_name_src = block.src(.{ .node_offset_field_name_init = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data;
-    const field_name = try mod.intern_pool.getOrPutString(
+    const field_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         sema.code.nullTerminatedString(extra.field_name_start),
         .no_embedded_nulls,
     );
     const object_ptr = try sema.resolveInst(extra.lhs);
-    const struct_ty = sema.typeOf(object_ptr).childType(mod);
+    const struct_ty = sema.typeOf(object_ptr).childType(zcu);
-    switch (struct_ty.zigTypeTag(mod)) {
+    switch (struct_ty.zigTypeTag(zcu)) {
         .Struct, .Union => {
             return sema.fieldPtr(block, src, object_ptr, field_name, field_name_src, true);
         },
 @@ -10371,25 +10370,25 @@ fn intCast(
     runtime_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     const dest_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, dest_ty, dest_ty_src);
     const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
     if (try sema.isComptimeKnown(operand)) {
         return sema.coerce(block, dest_ty, operand, operand_src);
-    } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
+    } else if (dest_scalar_ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.fail(block, operand_src, "unable to cast runtime value to 'comptime_int'", .{});
     }
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, dest_ty_src, operand_src);
-    const is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
     if ((try sema.typeHasOnePossibleValue(dest_ty))) |opv| {
         // requirement: intCast(u0, input) iff input == 0
         if (runtime_safety and block.wantSafety()) {
             try sema.requireRuntimeBlock(block, src, operand_src);
-            const wanted_info = dest_scalar_ty.intInfo(mod);
+            const wanted_info = dest_scalar_ty.intInfo(zcu);
             const wanted_bits = wanted_info.bits;
             if (wanted_bits == 0) {
 @@ -10416,8 +10415,8 @@ fn intCast(
     try sema.requireRuntimeBlock(block, src, operand_src);
     if (runtime_safety and block.wantSafety()) {
-        const actual_info = operand_scalar_ty.intInfo(mod);
+        const actual_info = operand_scalar_ty.intInfo(zcu);
-        const wanted_info = dest_scalar_ty.intInfo(mod);
+        const wanted_info = dest_scalar_ty.intInfo(zcu);
         const actual_bits = actual_info.bits;
         const wanted_bits = wanted_info.bits;
         const actual_value_bits = actual_bits - @intFromBool(actual_info.signedness == .signed);
 @@ -10437,7 +10436,7 @@ fn intCast(
                 // negative differences (`operand` > `dest_max`) appear too big.
                 const unsigned_scalar_operand_ty = try pt.intType(.unsigned, actual_bits);
                 const unsigned_operand_ty = if (is_vector) try pt.vectorType(.{
-                    .len = dest_ty.vectorLen(mod),
+                    .len = dest_ty.vectorLen(zcu),
                     .child = unsigned_scalar_operand_ty.toIntern(),
                 }) else unsigned_scalar_operand_ty;
                 const diff_unsigned = try block.addBitCast(unsigned_operand_ty, diff);
 @@ -10520,7 +10519,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
 @@ -10529,7 +10528,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@bitCast");
     const operand = try sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
-    switch (dest_ty.zigTypeTag(mod)) {
+    switch (dest_ty.zigTypeTag(zcu)) {
         .AnyFrame,
         .ComptimeFloat,
         .ComptimeInt,
 @@ -10551,7 +10550,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             const msg = msg: {
                 const msg = try sema.errMsg(src, "cannot @bitCast to '{}'", .{dest_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
-                switch (operand_ty.zigTypeTag(mod)) {
+                switch (operand_ty.zigTypeTag(zcu)) {
                     .Int, .ComptimeInt => try sema.errNote(src, msg, "use @enumFromInt to cast from '{}'", .{operand_ty.fmt(pt)}),
                     else => {},
                 }
 @@ -10565,7 +10564,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             const msg = msg: {
                 const msg = try sema.errMsg(src, "cannot @bitCast to '{}'", .{dest_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
-                switch (operand_ty.zigTypeTag(mod)) {
+                switch (operand_ty.zigTypeTag(zcu)) {
                     .Int, .ComptimeInt => try sema.errNote(src, msg, "use @ptrFromInt to cast from '{}'", .{operand_ty.fmt(pt)}),
                     .Pointer => try sema.errNote(src, msg, "use @ptrCast to cast from '{}'", .{operand_ty.fmt(pt)}),
                     else => {},
 @@ -10575,8 +10574,8 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         },
-        .Struct, .Union => if (dest_ty.containerLayout(mod) == .auto) {
+        .Struct, .Union => if (dest_ty.containerLayout(zcu) == .auto) {
-            const container = switch (dest_ty.zigTypeTag(mod)) {
+            const container = switch (dest_ty.zigTypeTag(zcu)) {
                 .Struct => "struct",
                 .Union => "union",
                 else => unreachable,
 @@ -10593,7 +10592,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         .Vector,
         => {},
     }
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .AnyFrame,
         .ComptimeFloat,
         .ComptimeInt,
 @@ -10615,7 +10614,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             const msg = msg: {
                 const msg = try sema.errMsg(operand_src, "cannot @bitCast from '{}'", .{operand_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
-                switch (dest_ty.zigTypeTag(mod)) {
+                switch (dest_ty.zigTypeTag(zcu)) {
                     .Int, .ComptimeInt => try sema.errNote(operand_src, msg, "use @intFromEnum to cast to '{}'", .{dest_ty.fmt(pt)}),
                     else => {},
                 }
 @@ -10628,7 +10627,7 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             const msg = msg: {
                 const msg = try sema.errMsg(operand_src, "cannot @bitCast from '{}'", .{operand_ty.fmt(pt)});
                 errdefer msg.destroy(sema.gpa);
-                switch (dest_ty.zigTypeTag(mod)) {
+                switch (dest_ty.zigTypeTag(zcu)) {
                     .Int, .ComptimeInt => try sema.errNote(operand_src, msg, "use @intFromPtr to cast to '{}'", .{dest_ty.fmt(pt)}),
                     .Pointer => try sema.errNote(operand_src, msg, "use @ptrCast to cast to '{}'", .{dest_ty.fmt(pt)}),
                     else => {},
 @@ -10638,8 +10637,8 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         },
-        .Struct, .Union => if (operand_ty.containerLayout(mod) == .auto) {
+        .Struct, .Union => if (operand_ty.containerLayout(zcu) == .auto) {
-            const container = switch (operand_ty.zigTypeTag(mod)) {
+            const container = switch (operand_ty.zigTypeTag(zcu)) {
                 .Struct => "struct",
                 .Union => "union",
                 else => unreachable,
 @@ -10664,24 +10663,24 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@floatCast");
-    const dest_scalar_ty = dest_ty.scalarType(mod);
+    const dest_scalar_ty = dest_ty.scalarType(zcu);
     const operand = try sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
-    const operand_scalar_ty = operand_ty.scalarType(mod);
+    const operand_scalar_ty = operand_ty.scalarType(zcu);
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, src, operand_src);
-    const is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
-    const dest_is_comptime_float = switch (dest_scalar_ty.zigTypeTag(mod)) {
+    const dest_is_comptime_float = switch (dest_scalar_ty.zigTypeTag(zcu)) {
         .ComptimeFloat => true,
         .Float => false,
         else => return sema.fail(
 @@ -10692,7 +10691,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         ),
     };
-    switch (operand_scalar_ty.zigTypeTag(mod)) {
+    switch (operand_scalar_ty.zigTypeTag(zcu)) {
         .ComptimeFloat, .Float, .ComptimeInt => {},
         else => return sema.fail(
             block,
 @@ -10706,7 +10705,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         if (!is_vector) {
             return Air.internedToRef((try operand_val.floatCast(dest_ty, pt)).toIntern());
         }
-        const vec_len = operand_ty.vectorLen(mod);
+        const vec_len = operand_ty.vectorLen(zcu);
         const new_elems = try sema.arena.alloc(InternPool.Index, vec_len);
         for (new_elems, 0..) |*new_elem, i| {
             const old_elem = try operand_val.elemValue(pt, i);
 @@ -10730,7 +10729,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     if (!is_vector) {
         return block.addTyOp(.fptrunc, dest_ty, operand);
     }
-    const vec_len = operand_ty.vectorLen(mod);
+    const vec_len = operand_ty.vectorLen(zcu);
     const new_elems = try sema.arena.alloc(Air.Inst.Ref, vec_len);
     for (new_elems, 0..) |*new_elem, i| {
         const idx_ref = try pt.intRef(Type.usize, i);
 @@ -10781,21 +10780,21 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const array_ptr = try sema.resolveInst(extra.lhs);
     const elem_index = try sema.resolveInst(extra.rhs);
     const indexable_ty = sema.typeOf(array_ptr);
-    if (indexable_ty.zigTypeTag(mod) != .Pointer) {
+    if (indexable_ty.zigTypeTag(zcu) != .Pointer) {
         const capture_src = block.src(.{ .for_capture_from_input = inst_data.src_node });
         const msg = msg: {
             const msg = try sema.errMsg(capture_src, "pointer capture of non pointer type '{}'", .{
                 indexable_ty.fmt(pt),
             });
             errdefer msg.destroy(sema.gpa);
-            if (indexable_ty.isIndexable(mod)) {
+            if (indexable_ty.isIndexable(zcu)) {
                 try sema.errNote(src, msg, "consider using '&' here", .{});
             }
             break :msg msg;
 @@ -10824,16 +10823,16 @@ fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
     const array_ptr = try sema.resolveInst(extra.ptr);
     const elem_index = try pt.intRef(Type.usize, extra.index);
-    const array_ty = sema.typeOf(array_ptr).childType(mod);
+    const array_ty = sema.typeOf(array_ptr).childType(zcu);
-    switch (array_ty.zigTypeTag(mod)) {
+    switch (array_ty.zigTypeTag(zcu)) {
         .Array, .Vector => {},
-        else => if (!array_ty.isTuple(mod)) {
+        else => if (!array_ty.isTuple(zcu)) {
             return sema.failWithArrayInitNotSupported(block, src, array_ty);
         },
     }
 @@ -11059,9 +11058,9 @@ const SwitchProngAnalysis = struct {
     ) CompileError!Air.Inst.Ref {
         const sema = spa.sema;
         const pt = sema.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const operand_ty = sema.typeOf(spa.operand);
-        if (operand_ty.zigTypeTag(mod) != .Union) {
+        if (operand_ty.zigTypeTag(zcu) != .Union) {
             const tag_capture_src: LazySrcLoc = .{
                 .base_node_inst = capture_src.base_node_inst,
                 .offset = .{ .switch_tag_capture = capture_src.offset.switch_capture },
 @@ -11429,9 +11428,9 @@ fn switchCond(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Type,
         .Void,
         .Bool,
 @@ -11445,7 +11444,7 @@ fn switchCond(
         .ErrorSet,
         .Enum,
         => {
-            if (operand_ty.isSlice(mod)) {
+            if (operand_ty.isSlice(zcu)) {
                 return sema.fail(block, src, "switch on type '{}'", .{operand_ty.fmt(pt)});
             }
             if ((try sema.typeHasOnePossibleValue(operand_ty))) |opv| {
 @@ -11456,11 +11455,11 @@ fn switchCond(
         .Union => {
             try operand_ty.resolveFields(pt);
-            const enum_ty = operand_ty.unionTagType(mod) orelse {
+            const enum_ty = operand_ty.unionTagType(zcu) orelse {
                 const msg = msg: {
                     const msg = try sema.errMsg(src, "switch on union with no attached enum", .{});
                     errdefer msg.destroy(sema.gpa);
-                    if (operand_ty.srcLocOrNull(mod)) |union_src| {
+                    if (operand_ty.srcLocOrNull(zcu)) |union_src| {
                         try sema.errNote(union_src, msg, "consider 'union(enum)' here", .{});
                     }
                     break :msg msg;
 @@ -11492,7 +11491,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const switch_src = block.nodeOffset(inst_data.src_node);
 @@ -11577,17 +11576,17 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     const operand_ty = sema.typeOf(raw_operand_val);
     const operand_err_set = if (extra.data.bits.payload_is_ref)
-        operand_ty.childType(mod)
+        operand_ty.childType(zcu)
     else
         operand_ty;
-    if (operand_err_set.zigTypeTag(mod) != .ErrorUnion) {
+    if (operand_err_set.zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(block, switch_src, "expected error union type, found '{}'", .{
             operand_ty.fmt(pt),
         });
     }
-    const operand_err_set_ty = operand_err_set.errorUnionSet(mod);
+    const operand_err_set_ty = operand_err_set.errorUnionSet(zcu);
     const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len);
     try sema.air_instructions.append(gpa, .{
 @@ -11628,7 +11627,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     defer merges.deinit(gpa);
     const resolved_err_set = try sema.resolveInferredErrorSetTy(block, main_src, operand_err_set_ty.toIntern());
-    if (Type.fromInterned(resolved_err_set).errorSetIsEmpty(mod)) {
+    if (Type.fromInterned(resolved_err_set).errorSetIsEmpty(zcu)) {
         return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges);
     }
 @@ -11662,13 +11661,13 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
         else
             ov;
-        if (operand_val.errorUnionIsPayload(mod)) {
+        if (operand_val.errorUnionIsPayload(zcu)) {
             return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges);
         } else {
             const err_val = Value.fromInterned(try pt.intern(.{
                 .err = .{
                     .ty = operand_err_set_ty.toIntern(),
-                    .name = operand_val.getErrorName(mod).unwrap().?,
+                    .name = operand_val.getErrorName(zcu).unwrap().?,
                 },
             }));
             spa.operand = if (extra.data.bits.payload_is_ref)
 @@ -11706,7 +11705,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     }
     if (scalar_cases_len + multi_cases_len == 0) {
-        if (else_error_ty) |ty| if (ty.errorSetIsEmpty(mod)) {
+        if (else_error_ty) |ty| if (ty.errorSetIsEmpty(zcu)) {
             return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges);
         };
     }
 @@ -11720,7 +11719,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
     }
     const cond = if (extra.data.bits.payload_is_ref) blk: {
-        try sema.checkErrorType(block, main_src, sema.typeOf(raw_operand_val).elemType2(mod));
+        try sema.checkErrorType(block, main_src, sema.typeOf(raw_operand_val).elemType2(zcu));
         const loaded = try sema.analyzeLoad(block, main_src, raw_operand_val, main_src);
         break :blk try sema.analyzeIsNonErr(block, main_src, loaded);
     } else blk: {
 @@ -11803,7 +11802,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -11873,12 +11872,12 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
     };
     const maybe_union_ty = sema.typeOf(raw_operand_val);
-    const union_originally = maybe_union_ty.zigTypeTag(mod) == .Union;
+    const union_originally = maybe_union_ty.zigTypeTag(zcu) == .Union;
     // Duplicate checking variables later also used for `inline else`.
     var seen_enum_fields: []?LazySrcLoc = &.{};
     var seen_errors = SwitchErrorSet.init(gpa);
-    var range_set = RangeSet.init(gpa, pt);
+    var range_set = RangeSet.init(gpa, zcu);
     var true_count: u8 = 0;
     var false_count: u8 = 0;
 @@ -11891,12 +11890,12 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
     var empty_enum = false;
     const operand_ty = sema.typeOf(operand);
-    const err_set = operand_ty.zigTypeTag(mod) == .ErrorSet;
+    const err_set = operand_ty.zigTypeTag(zcu) == .ErrorSet;
     var else_error_ty: ?Type = null;
     // Validate usage of '_' prongs.
-    if (special_prong == .under and (!operand_ty.isNonexhaustiveEnum(mod) or union_originally)) {
+    if (special_prong == .under and (!operand_ty.isNonexhaustiveEnum(zcu) or union_originally)) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 src,
 @@ -11922,11 +11921,11 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
     }
     // Validate for duplicate items, missing else prong, and invalid range.
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Union => unreachable, // handled in `switchCond`
         .Enum => {
-            seen_enum_fields = try gpa.alloc(?LazySrcLoc, operand_ty.enumFieldCount(mod));
+            seen_enum_fields = try gpa.alloc(?LazySrcLoc, operand_ty.enumFieldCount(zcu));
-            empty_enum = seen_enum_fields.len == 0 and !operand_ty.isNonexhaustiveEnum(mod);
+            empty_enum = seen_enum_fields.len == 0 and !operand_ty.isNonexhaustiveEnum(zcu);
             @memset(seen_enum_fields, null);
             // `range_set` is used for non-exhaustive enum values that do not correspond to any tags.
 @@ -11989,7 +11988,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
             } else true;
             if (special_prong == .@"else") {
-                if (all_tags_handled and !operand_ty.isNonexhaustiveEnum(mod)) return sema.fail(
+                if (all_tags_handled and !operand_ty.isNonexhaustiveEnum(zcu)) return sema.fail(
                     block,
                     special_prong_src,
                     "unreachable else prong; all cases already handled",
 @@ -12006,17 +12005,17 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
                     for (seen_enum_fields, 0..) |seen_src, i| {
                         if (seen_src != null) continue;
-                        const field_name = operand_ty.enumFieldName(i, mod);
+                        const field_name = operand_ty.enumFieldName(i, zcu);
                         try sema.addFieldErrNote(
                             operand_ty,
                             i,
                             msg,
                             "unhandled enumeration value: '{}'",
-                            .{field_name.fmt(&mod.intern_pool)},
+                            .{field_name.fmt(&zcu.intern_pool)},
                         );
                     }
                     try sema.errNote(
-                        operand_ty.srcLoc(mod),
+                        operand_ty.srcLoc(zcu),
                         msg,
                         "enum '{}' declared here",
                         .{operand_ty.fmt(pt)},
 @@ -12024,7 +12023,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
                     break :msg msg;
                 };
                 return sema.failWithOwnedErrorMsg(block, msg);
-            } else if (special_prong == .none and operand_ty.isNonexhaustiveEnum(mod) and !union_originally) {
+            } else if (special_prong == .none and operand_ty.isNonexhaustiveEnum(zcu) and !union_originally) {
                 return sema.fail(
                     block,
                     src,
 @@ -12124,7 +12123,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
             }
             check_range: {
-                if (operand_ty.zigTypeTag(mod) == .Int) {
+                if (operand_ty.zigTypeTag(zcu) == .Int) {
                     const min_int = try operand_ty.minInt(pt, operand_ty);
                     const max_int = try operand_ty.maxInt(pt, operand_ty);
                     if (try range_set.spans(min_int.toIntern(), max_int.toIntern())) {
 @@ -12388,8 +12387,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
         if (err_set and try sema.maybeErrorUnwrap(block, special.body, operand, operand_src, false)) {
             return .unreachable_value;
         }
-        if (mod.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and operand_ty.zigTypeTag(mod) == .Enum and
+        if (zcu.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and operand_ty.zigTypeTag(zcu) == .Enum and
-            (!operand_ty.isNonexhaustiveEnum(mod) or union_originally))
+            (!operand_ty.isNonexhaustiveEnum(zcu) or union_originally))
         {
             try sema.zirDbgStmt(block, cond_dbg_node_index);
             const ok = try block.addUnOp(.is_named_enum_value, operand);
 @@ -12482,9 +12481,9 @@ fn analyzeSwitchRuntimeBlock(
     allow_err_code_unwrap: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const block = child_block.parent.?;
 @@ -12519,8 +12518,8 @@ fn analyzeSwitchRuntimeBlock(
         const analyze_body = if (union_originally) blk: {
             const unresolved_item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable;
             const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable;
-            const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
+            const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?;
-            break :blk field_ty.zigTypeTag(mod) != .NoReturn;
+            break :blk field_ty.zigTypeTag(zcu) != .NoReturn;
         } else true;
         if (err_set and try sema.maybeErrorUnwrap(&case_block, body, operand, operand_src, allow_err_code_unwrap)) {
 @@ -12592,7 +12591,7 @@ fn analyzeSwitchRuntimeBlock(
                 var item = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item_first_ref, undefined) catch unreachable;
                 const item_last = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item_last_ref, undefined) catch unreachable;
-                while (item.compareScalar(.lte, item_last, operand_ty, pt)) : ({
+                while (item.compareScalar(.lte, item_last, operand_ty, zcu)) : ({
                     // Previous validation has resolved any possible lazy values.
                     item = sema.intAddScalar(item, try pt.intValue(operand_ty, 1), operand_ty) catch |err| switch (err) {
                         error.Overflow => unreachable,
 @@ -12633,7 +12632,7 @@ fn analyzeSwitchRuntimeBlock(
                     cases_extra.appendAssumeCapacity(@intFromEnum(item_ref));
                     cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items));
-                    if (item.compareScalar(.eq, item_last, operand_ty, pt)) break;
+                    if (item.compareScalar(.eq, item_last, operand_ty, zcu)) break;
                 }
             }
 @@ -12645,8 +12644,8 @@ fn analyzeSwitchRuntimeBlock(
                 const analyze_body = if (union_originally) blk: {
                     const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable;
-                    const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
+                    const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?;
-                    break :blk field_ty.zigTypeTag(mod) != .NoReturn;
+                    break :blk field_ty.zigTypeTag(zcu) != .NoReturn;
                 } else true;
                 if (emit_bb) try sema.emitBackwardBranch(block, block.src(.{ .switch_case_item = .{
 @@ -12696,8 +12695,8 @@ fn analyzeSwitchRuntimeBlock(
             const analyze_body = if (union_originally)
                 for (items) |item| {
                     const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable;
-                    const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
+                    const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?;
-                    if (field_ty.zigTypeTag(mod) != .NoReturn) break true;
+                    if (field_ty.zigTypeTag(zcu) != .NoReturn) break true;
                 } else false
             else
                 true;
 @@ -12836,9 +12835,9 @@ fn analyzeSwitchRuntimeBlock(
     var final_else_body: []const Air.Inst.Index = &.{};
     if (special.body.len != 0 or !is_first or case_block.wantSafety()) {
         var emit_bb = false;
-        if (special.is_inline) switch (operand_ty.zigTypeTag(mod)) {
+        if (special.is_inline) switch (operand_ty.zigTypeTag(zcu)) {
             .Enum => {
-                if (operand_ty.isNonexhaustiveEnum(mod) and !union_originally) {
+                if (operand_ty.isNonexhaustiveEnum(zcu) and !union_originally) {
                     return sema.fail(block, special_prong_src, "cannot enumerate values of type '{}' for 'inline else'", .{
                         operand_ty.fmt(pt),
                     });
 @@ -12854,8 +12853,8 @@ fn analyzeSwitchRuntimeBlock(
                     case_block.error_return_trace_index = child_block.error_return_trace_index;
                     const analyze_body = if (union_originally) blk: {
-                        const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
+                        const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?;
-                        break :blk field_ty.zigTypeTag(mod) != .NoReturn;
+                        break :blk field_ty.zigTypeTag(zcu) != .NoReturn;
                     } else true;
                     if (emit_bb) try sema.emitBackwardBranch(block, special_prong_src);
 @@ -12887,12 +12886,12 @@ fn analyzeSwitchRuntimeBlock(
                 }
             },
             .ErrorSet => {
-                if (operand_ty.isAnyError(mod)) {
+                if (operand_ty.isAnyError(zcu)) {
                     return sema.fail(block, special_prong_src, "cannot enumerate values of type '{}' for 'inline else'", .{
                         operand_ty.fmt(pt),
                     });
                 }
-                const error_names = operand_ty.errorSetNames(mod);
+                const error_names = operand_ty.errorSetNames(zcu);
                 for (0..error_names.len) |name_index| {
                     const error_name = error_names.get(ip)[name_index];
                     if (seen_errors.contains(error_name)) continue;
 @@ -13033,10 +13032,10 @@ fn analyzeSwitchRuntimeBlock(
         case_block.instructions.shrinkRetainingCapacity(0);
         case_block.error_return_trace_index = child_block.error_return_trace_index;
-        if (mod.backendSupportsFeature(.is_named_enum_value) and
+        if (zcu.backendSupportsFeature(.is_named_enum_value) and
             special.body.len != 0 and block.wantSafety() and
-            operand_ty.zigTypeTag(mod) == .Enum and
+            operand_ty.zigTypeTag(zcu) == .Enum and
-            (!operand_ty.isNonexhaustiveEnum(mod) or union_originally))
+            (!operand_ty.isNonexhaustiveEnum(zcu) or union_originally))
         {
             try sema.zirDbgStmt(&case_block, cond_dbg_node_index);
             const ok = try case_block.addUnOp(.is_named_enum_value, operand);
 @@ -13046,9 +13045,9 @@ fn analyzeSwitchRuntimeBlock(
         const analyze_body = if (union_originally and !special.is_inline)
             for (seen_enum_fields, 0..) |seen_field, index| {
                 if (seen_field != null) continue;
-                const union_obj = mod.typeToUnion(maybe_union_ty).?;
+                const union_obj = zcu.typeToUnion(maybe_union_ty).?;
                 const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[index]);
-                if (field_ty.zigTypeTag(mod) != .NoReturn) break true;
+                if (field_ty.zigTypeTag(zcu) != .NoReturn) break true;
             } else false
         else
             true;
 @@ -13371,8 +13370,8 @@ fn validateErrSetSwitch(
 ) CompileError!?Type {
     const gpa = sema.gpa;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const src_node_offset = inst_data.src_node;
     const src = block.nodeOffset(src_node_offset);
 @@ -13444,7 +13443,7 @@ fn validateErrSetSwitch(
         },
         else => |err_set_ty_index| else_validation: {
             const error_names = ip.indexToKey(err_set_ty_index).error_set_type.names;
-            var maybe_msg: ?*Module.ErrorMsg = null;
+            var maybe_msg: ?*Zcu.ErrorMsg = null;
             errdefer if (maybe_msg) |msg| msg.destroy(sema.gpa);
             for (error_names.get(ip)) |error_name| {
 @@ -13711,8 +13710,8 @@ fn maybeErrorUnwrap(
     allow_err_code_inst: bool,
 ) !bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (!mod.backendSupportsFeature(.panic_unwrap_error)) return false;
+    if (!zcu.backendSupportsFeature(.panic_unwrap_error)) return false;
     const tags = sema.code.instructions.items(.tag);
     for (body) |inst| {
 @@ -13745,7 +13744,7 @@ fn maybeErrorUnwrap(
             .as_node => try sema.zirAsNode(block, inst),
             .field_val => try sema.zirFieldVal(block, inst),
             .@"unreachable" => {
-                if (!mod.comp.formatted_panics) {
+                if (!zcu.comp.formatted_panics) {
                     try sema.safetyPanic(block, operand_src, .unwrap_error);
                     return true;
                 }
 @@ -13768,7 +13767,7 @@ fn maybeErrorUnwrap(
             },
             else => unreachable,
         };
-        if (sema.typeOf(air_inst).isNoReturn(mod))
+        if (sema.typeOf(air_inst).isNoReturn(zcu))
             return true;
         sema.inst_map.putAssumeCapacity(inst, air_inst);
     }
 @@ -13777,20 +13776,20 @@ fn maybeErrorUnwrap(
 fn maybeErrorUnwrapCondbr(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, cond: Zir.Inst.Ref, cond_src: LazySrcLoc) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const index = cond.toIndex() orelse return;
     if (sema.code.instructions.items(.tag)[@intFromEnum(index)] != .is_non_err) return;
     const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node;
     const err_operand = try sema.resolveInst(err_inst_data.operand);
     const operand_ty = sema.typeOf(err_operand);
-    if (operand_ty.zigTypeTag(mod) == .ErrorSet) {
+    if (operand_ty.zigTypeTag(zcu) == .ErrorSet) {
         try sema.maybeErrorUnwrapComptime(block, body, err_operand);
         return;
     }
     if (try sema.resolveDefinedValue(block, cond_src, err_operand)) |val| {
-        if (!operand_ty.isError(mod)) return;
+        if (!operand_ty.isError(zcu)) return;
-        if (val.getErrorName(mod) == .none) return;
+        if (val.getErrorName(zcu) == .none) return;
         try sema.maybeErrorUnwrapComptime(block, body, err_operand);
     }
 }
 @@ -13818,7 +13817,7 @@ fn maybeErrorUnwrapComptime(sema: *Sema, block: *Block, body: []const Zir.Inst.I
 fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0);
 @@ -13828,7 +13827,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .needed_comptime_reason = "field name must be comptime-known",
     });
     try ty.resolveFields(pt);
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const has_field = hf: {
         switch (ip.indexToKey(ty.toIntern())) {
 @@ -13845,7 +13844,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     break :hf mem.indexOfScalar(InternPool.NullTerminatedString, anon_struct.names.get(ip), field_name) != null;
                 } else {
                     const field_index = field_name.toUnsigned(ip) orelse break :hf false;
-                    break :hf field_index < ty.structFieldCount(mod);
+                    break :hf field_index < ty.structFieldCount(zcu);
                 }
             },
             .struct_type => {
 @@ -13870,7 +13869,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirHasDecl(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -13883,7 +13882,7 @@ fn zirHasDecl(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     try sema.checkNamespaceType(block, lhs_src, container_type);
-    const namespace = container_type.getNamespace(mod).unwrap() orelse return .bool_false;
+    const namespace = container_type.getNamespace(zcu).unwrap() orelse return .bool_false;
     if (try sema.lookupInNamespace(block, src, namespace, decl_name, true)) |lookup| {
         if (lookup.accessible) {
             return .bool_true;
 @@ -13958,9 +13957,9 @@ fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
 fn zirRetErrValueCode(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
-    const name = try mod.intern_pool.getOrPutString(
+    const name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         inst_data.get(sema.code),
 @@ -13984,7 +13983,7 @@ fn zirShl(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -13996,8 +13995,8 @@ fn zirShl(
     const rhs_ty = sema.typeOf(rhs);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
-    const scalar_ty = lhs_ty.scalarType(mod);
+    const scalar_ty = lhs_ty.scalarType(zcu);
-    const scalar_rhs_ty = rhs_ty.scalarType(mod);
+    const scalar_rhs_ty = rhs_ty.scalarType(zcu);
     // TODO coerce rhs if air_tag is not shl_sat
     const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
 @@ -14006,20 +14005,20 @@ fn zirShl(
     const maybe_rhs_val = try sema.resolveValueIntable(rhs);
     if (maybe_rhs_val) |rhs_val| {
-        if (rhs_val.isUndef(mod)) {
+        if (rhs_val.isUndef(zcu)) {
             return pt.undefRef(sema.typeOf(lhs));
         }
         // If rhs is 0, return lhs without doing any calculations.
         if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
             return lhs;
         }
-        if (scalar_ty.zigTypeTag(mod) != .ComptimeInt and air_tag != .shl_sat) {
+        if (scalar_ty.zigTypeTag(zcu) != .ComptimeInt and air_tag != .shl_sat) {
-            const bit_value = try pt.intValue(Type.comptime_int, scalar_ty.intInfo(mod).bits);
+            const bit_value = try pt.intValue(Type.comptime_int, scalar_ty.intInfo(zcu).bits);
-            if (rhs_ty.zigTypeTag(mod) == .Vector) {
+            if (rhs_ty.zigTypeTag(zcu) == .Vector) {
                 var i: usize = 0;
-                while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
+                while (i < rhs_ty.vectorLen(zcu)) : (i += 1) {
                     const rhs_elem = try rhs_val.elemValue(pt, i);
-                    if (rhs_elem.compareHetero(.gte, bit_value, pt)) {
+                    if (rhs_elem.compareHetero(.gte, bit_value, zcu)) {
                         return sema.fail(block, rhs_src, "shift amount '{}' at index '{d}' is too large for operand type '{}'", .{
                             rhs_elem.fmtValueSema(pt, sema),
                             i,
 @@ -14027,25 +14026,25 @@ fn zirShl(
                         });
                     }
                 }
-            } else if (rhs_val.compareHetero(.gte, bit_value, pt)) {
+            } else if (rhs_val.compareHetero(.gte, bit_value, zcu)) {
                 return sema.fail(block, rhs_src, "shift amount '{}' is too large for operand type '{}'", .{
                     rhs_val.fmtValueSema(pt, sema),
                     scalar_ty.fmt(pt),
                 });
             }
         }
-        if (rhs_ty.zigTypeTag(mod) == .Vector) {
+        if (rhs_ty.zigTypeTag(zcu) == .Vector) {
             var i: usize = 0;
-            while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
+            while (i < rhs_ty.vectorLen(zcu)) : (i += 1) {
                 const rhs_elem = try rhs_val.elemValue(pt, i);
-                if (rhs_elem.compareHetero(.lt, try pt.intValue(scalar_rhs_ty, 0), pt)) {
+                if (rhs_elem.compareHetero(.lt, try pt.intValue(scalar_rhs_ty, 0), zcu)) {
                     return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
                         rhs_elem.fmtValueSema(pt, sema),
                         i,
                     });
                 }
             }
-        } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), pt)) {
+        } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), zcu)) {
             return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
                 rhs_val.fmtValueSema(pt, sema),
             });
 @@ -14053,19 +14052,19 @@ fn zirShl(
     }
     const runtime_src = if (maybe_lhs_val) |lhs_val| rs: {
-        if (lhs_val.isUndef(mod)) return pt.undefRef(lhs_ty);
+        if (lhs_val.isUndef(zcu)) return pt.undefRef(lhs_ty);
         const rhs_val = maybe_rhs_val orelse {
-            if (scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
+            if (scalar_ty.zigTypeTag(zcu) == .ComptimeInt) {
                 return sema.fail(block, src, "LHS of shift must be a fixed-width integer type, or RHS must be comptime-known", .{});
             }
             break :rs rhs_src;
         };
-        const val = if (scalar_ty.zigTypeTag(mod) == .ComptimeInt)
+        const val = if (scalar_ty.zigTypeTag(zcu) == .ComptimeInt)
             try lhs_val.shl(rhs_val, lhs_ty, sema.arena, pt)
         else switch (air_tag) {
             .shl_exact => val: {
                 const shifted = try lhs_val.shlWithOverflow(rhs_val, lhs_ty, sema.arena, pt);
-                if (shifted.overflow_bit.compareAllWithZero(.eq, pt)) {
+                if (shifted.overflow_bit.compareAllWithZero(.eq, zcu)) {
                     break :val shifted.wrapped_result;
                 }
                 return sema.fail(block, src, "operation caused overflow", .{});
 @@ -14080,7 +14079,7 @@ fn zirShl(
     const new_rhs = if (air_tag == .shl_sat) rhs: {
         // Limit the RHS type for saturating shl to be an integer as small as the LHS.
         if (rhs_is_comptime_int or
-            scalar_rhs_ty.intInfo(mod).bits > scalar_ty.intInfo(mod).bits)
+            scalar_rhs_ty.intInfo(zcu).bits > scalar_ty.intInfo(zcu).bits)
         {
             const max_int = Air.internedToRef((try lhs_ty.maxInt(pt, lhs_ty)).toIntern());
             const rhs_limited = try sema.analyzeMinMax(block, rhs_src, .min, &.{ rhs, max_int }, &.{ rhs_src, rhs_src });
 @@ -14092,10 +14091,10 @@ fn zirShl(
     try sema.requireRuntimeBlock(block, src, runtime_src);
     if (block.wantSafety()) {
-        const bit_count = scalar_ty.intInfo(mod).bits;
+        const bit_count = scalar_ty.intInfo(zcu).bits;
         if (!std.math.isPowerOfTwo(bit_count)) {
             const bit_count_val = try pt.intValue(scalar_rhs_ty, bit_count);
-            const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
+            const ok = if (rhs_ty.zigTypeTag(zcu) == .Vector) ok: {
                 const bit_count_inst = Air.internedToRef((try sema.splat(rhs_ty, bit_count_val)).toIntern());
                 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
                 break :ok try block.addInst(.{
 @@ -14125,7 +14124,7 @@ fn zirShl(
                 } },
             });
             const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
-            const any_ov_bit = if (lhs_ty.zigTypeTag(mod) == .Vector)
+            const any_ov_bit = if (lhs_ty.zigTypeTag(zcu) == .Vector)
                 try block.addInst(.{
                     .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
                     .data = .{ .reduce = .{
 @@ -14155,7 +14154,7 @@ fn zirShr(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -14166,26 +14165,26 @@ fn zirShr(
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
-    const scalar_ty = lhs_ty.scalarType(mod);
+    const scalar_ty = lhs_ty.scalarType(zcu);
     const maybe_lhs_val = try sema.resolveValueIntable(lhs);
     const maybe_rhs_val = try sema.resolveValueIntable(rhs);
     const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {
-        if (rhs_val.isUndef(mod)) {
+        if (rhs_val.isUndef(zcu)) {
             return pt.undefRef(lhs_ty);
         }
         // If rhs is 0, return lhs without doing any calculations.
         if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
             return lhs;
         }
-        if (scalar_ty.zigTypeTag(mod) != .ComptimeInt) {
+        if (scalar_ty.zigTypeTag(zcu) != .ComptimeInt) {
-            const bit_value = try pt.intValue(Type.comptime_int, scalar_ty.intInfo(mod).bits);
+            const bit_value = try pt.intValue(Type.comptime_int, scalar_ty.intInfo(zcu).bits);
-            if (rhs_ty.zigTypeTag(mod) == .Vector) {
+            if (rhs_ty.zigTypeTag(zcu) == .Vector) {
                 var i: usize = 0;
-                while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
+                while (i < rhs_ty.vectorLen(zcu)) : (i += 1) {
                     const rhs_elem = try rhs_val.elemValue(pt, i);
-                    if (rhs_elem.compareHetero(.gte, bit_value, pt)) {
+                    if (rhs_elem.compareHetero(.gte, bit_value, zcu)) {
                         return sema.fail(block, rhs_src, "shift amount '{}' at index '{d}' is too large for operand type '{}'", .{
                             rhs_elem.fmtValueSema(pt, sema),
                             i,
 @@ -14193,31 +14192,31 @@ fn zirShr(
                         });
                     }
                 }
-            } else if (rhs_val.compareHetero(.gte, bit_value, pt)) {
+            } else if (rhs_val.compareHetero(.gte, bit_value, zcu)) {
                 return sema.fail(block, rhs_src, "shift amount '{}' is too large for operand type '{}'", .{
                     rhs_val.fmtValueSema(pt, sema),
                     scalar_ty.fmt(pt),
                 });
             }
         }
-        if (rhs_ty.zigTypeTag(mod) == .Vector) {
+        if (rhs_ty.zigTypeTag(zcu) == .Vector) {
             var i: usize = 0;
-            while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
+            while (i < rhs_ty.vectorLen(zcu)) : (i += 1) {
                 const rhs_elem = try rhs_val.elemValue(pt, i);
-                if (rhs_elem.compareHetero(.lt, try pt.intValue(rhs_ty.childType(mod), 0), pt)) {
+                if (rhs_elem.compareHetero(.lt, try pt.intValue(rhs_ty.childType(zcu), 0), zcu)) {
                     return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
                         rhs_elem.fmtValueSema(pt, sema),
                         i,
                     });
                 }
             }
-        } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), pt)) {
+        } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), zcu)) {
             return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
                 rhs_val.fmtValueSema(pt, sema),
             });
         }
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
                 return pt.undefRef(lhs_ty);
             }
             if (air_tag == .shr_exact) {
 @@ -14234,18 +14233,18 @@ fn zirShr(
         }
     } else rhs_src;
-    if (maybe_rhs_val == null and scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
+    if (maybe_rhs_val == null and scalar_ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.fail(block, src, "LHS of shift must be a fixed-width integer type, or RHS must be comptime-known", .{});
     }
     try sema.requireRuntimeBlock(block, src, runtime_src);
     const result = try block.addBinOp(air_tag, lhs, rhs);
     if (block.wantSafety()) {
-        const bit_count = scalar_ty.intInfo(mod).bits;
+        const bit_count = scalar_ty.intInfo(zcu).bits;
         if (!std.math.isPowerOfTwo(bit_count)) {
-            const bit_count_val = try pt.intValue(rhs_ty.scalarType(mod), bit_count);
+            const bit_count_val = try pt.intValue(rhs_ty.scalarType(zcu), bit_count);
-            const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
+            const ok = if (rhs_ty.zigTypeTag(zcu) == .Vector) ok: {
                 const bit_count_inst = Air.internedToRef((try sema.splat(rhs_ty, bit_count_val)).toIntern());
                 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
                 break :ok try block.addInst(.{
 @@ -14265,7 +14264,7 @@ fn zirShr(
         if (air_tag == .shr_exact) {
             const back = try block.addBinOp(.shl, result, rhs);
-            const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
+            const ok = if (rhs_ty.zigTypeTag(zcu) == .Vector) ok: {
                 const eql = try block.addCmpVector(lhs, back, .eq);
                 break :ok try block.addInst(.{
                     .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
 @@ -14291,7 +14290,7 @@ fn zirBitwise(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -14305,8 +14304,8 @@ fn zirBitwise(
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
     const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ .override = &[_]?LazySrcLoc{ lhs_src, rhs_src } });
-    const scalar_type = resolved_type.scalarType(mod);
+    const scalar_type = resolved_type.scalarType(zcu);
-    const scalar_tag = scalar_type.zigTypeTag(mod);
+    const scalar_tag = scalar_type.zigTypeTag(zcu);
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 @@ -14314,7 +14313,7 @@ fn zirBitwise(
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
     if (!is_int) {
-        return sema.fail(block, src, "invalid operands to binary bitwise expression: '{s}' and '{s}'", .{ @tagName(lhs_ty.zigTypeTag(mod)), @tagName(rhs_ty.zigTypeTag(mod)) });
+        return sema.fail(block, src, "invalid operands to binary bitwise expression: '{s}' and '{s}'", .{ @tagName(lhs_ty.zigTypeTag(zcu)), @tagName(rhs_ty.zigTypeTag(zcu)) });
     }
     const runtime_src = runtime: {
 @@ -14346,26 +14345,26 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_type = sema.typeOf(operand);
-    const scalar_type = operand_type.scalarType(mod);
+    const scalar_type = operand_type.scalarType(zcu);
-    if (scalar_type.zigTypeTag(mod) != .Int) {
+    if (scalar_type.zigTypeTag(zcu) != .Int) {
         return sema.fail(block, src, "unable to perform binary not operation on type '{}'", .{
             operand_type.fmt(pt),
         });
     }
     if (try sema.resolveValue(operand)) |val| {
-        if (val.isUndef(mod)) {
+        if (val.isUndef(zcu)) {
             return pt.undefRef(operand_type);
-        } else if (operand_type.zigTypeTag(mod) == .Vector) {
+        } else if (operand_type.zigTypeTag(zcu) == .Vector) {
-            const vec_len = try sema.usizeCast(block, operand_src, operand_type.vectorLen(mod));
+            const vec_len = try sema.usizeCast(block, operand_src, operand_type.vectorLen(zcu));
             const elems = try sema.arena.alloc(InternPool.Index, vec_len);
             for (elems, 0..) |*elem, i| {
                 const elem_val = try val.elemValue(pt, i);
 @@ -14393,13 +14392,13 @@ fn analyzeTupleCat(
     rhs: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
     const src = block.nodeOffset(src_node);
-    const lhs_len = lhs_ty.structFieldCount(mod);
+    const lhs_len = lhs_ty.structFieldCount(zcu);
-    const rhs_len = rhs_ty.structFieldCount(mod);
+    const rhs_len = rhs_ty.structFieldCount(zcu);
     const dest_fields = lhs_len + rhs_len;
     if (dest_fields == 0) {
 @@ -14420,8 +14419,8 @@ fn analyzeTupleCat(
         var runtime_src: ?LazySrcLoc = null;
         var i: u32 = 0;
         while (i < lhs_len) : (i += 1) {
-            types[i] = lhs_ty.structFieldType(i, mod).toIntern();
+            types[i] = lhs_ty.fieldType(i, zcu).toIntern();
-            const default_val = lhs_ty.structFieldDefaultValue(i, mod);
+            const default_val = lhs_ty.structFieldDefaultValue(i, zcu);
             values[i] = default_val.toIntern();
             const operand_src = block.src(.{ .array_cat_lhs = .{
                 .array_cat_offset = src_node,
 @@ -14434,8 +14433,8 @@ fn analyzeTupleCat(
         }
         i = 0;
         while (i < rhs_len) : (i += 1) {
-            types[i + lhs_len] = rhs_ty.structFieldType(i, mod).toIntern();
+            types[i + lhs_len] = rhs_ty.fieldType(i, zcu).toIntern();
-            const default_val = rhs_ty.structFieldDefaultValue(i, mod);
+            const default_val = rhs_ty.structFieldDefaultValue(i, zcu);
             values[i + lhs_len] = default_val.toIntern();
             const operand_src = block.src(.{ .array_cat_rhs = .{
                 .array_cat_offset = src_node,
 @@ -14449,7 +14448,7 @@ fn analyzeTupleCat(
         break :rs runtime_src;
     };
-    const tuple_ty = try mod.intern_pool.getAnonStructType(mod.gpa, pt.tid, .{
+    const tuple_ty = try zcu.intern_pool.getAnonStructType(zcu.gpa, pt.tid, .{
         .types = types,
         .values = values,
         .names = &.{},
 @@ -14492,7 +14491,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const lhs = try sema.resolveInst(extra.lhs);
 @@ -14501,8 +14500,8 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const rhs_ty = sema.typeOf(rhs);
     const src = block.nodeOffset(inst_data.src_node);
-    const lhs_is_tuple = lhs_ty.isTuple(mod);
+    const lhs_is_tuple = lhs_ty.isTuple(zcu);
-    const rhs_is_tuple = rhs_ty.isTuple(mod);
+    const rhs_is_tuple = rhs_ty.isTuple(zcu);
     if (lhs_is_tuple and rhs_is_tuple) {
         return sema.analyzeTupleCat(block, inst_data.src_node, lhs, rhs);
     }
 @@ -14584,31 +14583,31 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .child = resolved_elem_ty.toIntern(),
     });
     const ptr_addrspace = p: {
-        if (lhs_ty.zigTypeTag(mod) == .Pointer) break :p lhs_ty.ptrAddressSpace(mod);
+        if (lhs_ty.zigTypeTag(zcu) == .Pointer) break :p lhs_ty.ptrAddressSpace(zcu);
-        if (rhs_ty.zigTypeTag(mod) == .Pointer) break :p rhs_ty.ptrAddressSpace(mod);
+        if (rhs_ty.zigTypeTag(zcu) == .Pointer) break :p rhs_ty.ptrAddressSpace(zcu);
         break :p null;
     };
-    const runtime_src = if (switch (lhs_ty.zigTypeTag(mod)) {
+    const runtime_src = if (switch (lhs_ty.zigTypeTag(zcu)) {
         .Array, .Struct => try sema.resolveValue(lhs),
         .Pointer => try sema.resolveDefinedValue(block, lhs_src, lhs),
         else => unreachable,
     }) |lhs_val| rs: {
-        if (switch (rhs_ty.zigTypeTag(mod)) {
+        if (switch (rhs_ty.zigTypeTag(zcu)) {
             .Array, .Struct => try sema.resolveValue(rhs),
             .Pointer => try sema.resolveDefinedValue(block, rhs_src, rhs),
             else => unreachable,
         }) |rhs_val| {
-            const lhs_sub_val = if (lhs_ty.isSinglePointer(mod))
+            const lhs_sub_val = if (lhs_ty.isSinglePointer(zcu))
                 try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty) orelse break :rs lhs_src
-            else if (lhs_ty.isSlice(mod))
+            else if (lhs_ty.isSlice(zcu))
                 try sema.maybeDerefSliceAsArray(block, lhs_src, lhs_val) orelse break :rs lhs_src
             else
                 lhs_val;
-            const rhs_sub_val = if (rhs_ty.isSinglePointer(mod))
+            const rhs_sub_val = if (rhs_ty.isSinglePointer(zcu))
                 try sema.pointerDeref(block, rhs_src, rhs_val, rhs_ty) orelse break :rs rhs_src
-            else if (rhs_ty.isSlice(mod))
+            else if (rhs_ty.isSlice(zcu))
                 try sema.maybeDerefSliceAsArray(block, rhs_src, rhs_val) orelse break :rs rhs_src
             else
                 rhs_val;
 @@ -14617,7 +14616,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             var elem_i: u32 = 0;
             while (elem_i < lhs_len) : (elem_i += 1) {
                 const lhs_elem_i = elem_i;
-                const elem_default_val = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, mod) else Value.@"unreachable";
+                const elem_default_val = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, zcu) else Value.@"unreachable";
                 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(pt, lhs_elem_i) else elem_default_val;
                 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_lhs = .{
 @@ -14630,7 +14629,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
             while (elem_i < result_len) : (elem_i += 1) {
                 const rhs_elem_i = elem_i - lhs_len;
-                const elem_default_val = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, mod) else Value.@"unreachable";
+                const elem_default_val = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, zcu) else Value.@"unreachable";
                 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(pt, rhs_elem_i) else elem_default_val;
                 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
                 const operand_src = block.src(.{ .array_cat_rhs = .{
 @@ -14723,12 +14722,12 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Inst.Ref, peer_ty: Type) !?Type.ArrayInfo {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
-        .Array => return operand_ty.arrayInfo(mod),
+        .Array => return operand_ty.arrayInfo(zcu),
         .Pointer => {
-            const ptr_info = operand_ty.ptrInfo(mod);
+            const ptr_info = operand_ty.ptrInfo(zcu);
             switch (ptr_info.flags.size) {
                 .Slice => {
                     const val = try sema.resolveConstDefinedValue(block, src, operand, .{
 @@ -14744,20 +14743,20 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
                     };
                 },
                 .One => {
-                    if (Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Array) {
+                    if (Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .Array) {
-                        return Type.fromInterned(ptr_info.child).arrayInfo(mod);
+                        return Type.fromInterned(ptr_info.child).arrayInfo(zcu);
                     }
                 },
                 .C, .Many => {},
             }
         },
         .Struct => {
-            if (operand_ty.isTuple(mod) and peer_ty.isIndexable(mod)) {
+            if (operand_ty.isTuple(zcu) and peer_ty.isIndexable(zcu)) {
-                assert(!peer_ty.isTuple(mod));
+                assert(!peer_ty.isTuple(zcu));
                 return .{
-                    .elem_type = peer_ty.elemType2(mod),
+                    .elem_type = peer_ty.elemType2(zcu),
                     .sentinel = null,
-                    .len = operand_ty.arrayLen(mod),
+                    .len = operand_ty.arrayLen(zcu),
                 };
             }
         },
 @@ -14774,12 +14773,12 @@ fn analyzeTupleMul(
     factor: usize,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     const src = block.nodeOffset(src_node);
     const len_src = block.src(.{ .node_offset_bin_rhs = src_node });
-    const tuple_len = operand_ty.structFieldCount(mod);
+    const tuple_len = operand_ty.structFieldCount(zcu);
     const final_len = std.math.mul(usize, tuple_len, factor) catch
         return sema.fail(block, len_src, "operation results in overflow", .{});
 @@ -14792,8 +14791,8 @@ fn analyzeTupleMul(
     const opt_runtime_src = rs: {
         var runtime_src: ?LazySrcLoc = null;
         for (0..tuple_len) |i| {
-            types[i] = operand_ty.structFieldType(i, mod).toIntern();
+            types[i] = operand_ty.fieldType(i, zcu).toIntern();
-            values[i] = operand_ty.structFieldDefaultValue(i, mod).toIntern();
+            values[i] = operand_ty.structFieldDefaultValue(i, zcu).toIntern();
             const operand_src = block.src(.{ .array_cat_lhs = .{
                 .array_cat_offset = src_node,
                 .elem_index = @intCast(i),
 @@ -14810,7 +14809,7 @@ fn analyzeTupleMul(
         break :rs runtime_src;
     };
-    const tuple_ty = try mod.intern_pool.getAnonStructType(mod.gpa, pt.tid, .{
+    const tuple_ty = try zcu.intern_pool.getAnonStructType(zcu.gpa, pt.tid, .{
         .types = types,
         .values = values,
         .names = &.{},
 @@ -14848,7 +14847,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.ArrayMul, inst_data.payload_index).data;
     const uncoerced_lhs = try sema.resolveInst(extra.lhs);
 @@ -14867,17 +14866,17 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const res_ty_inst = try sema.resolveInst(extra.res_ty);
             const res_ty = try sema.analyzeAsType(block, src, res_ty_inst);
             if (res_ty.isGenericPoison()) break :no_coerce;
-            if (!uncoerced_lhs_ty.isTuple(mod)) break :no_coerce;
+            if (!uncoerced_lhs_ty.isTuple(zcu)) break :no_coerce;
-            const lhs_len = uncoerced_lhs_ty.structFieldCount(mod);
+            const lhs_len = uncoerced_lhs_ty.structFieldCount(zcu);
-            const lhs_dest_ty = switch (res_ty.zigTypeTag(mod)) {
+            const lhs_dest_ty = switch (res_ty.zigTypeTag(zcu)) {
                 else => break :no_coerce,
                 .Array => try pt.arrayType(.{
-                    .child = res_ty.childType(mod).toIntern(),
+                    .child = res_ty.childType(zcu).toIntern(),
                     .len = lhs_len,
-                    .sentinel = if (res_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                    .sentinel = if (res_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                 }),
                 .Vector => try pt.vectorType(.{
-                    .child = res_ty.childType(mod).toIntern(),
+                    .child = res_ty.childType(zcu).toIntern(),
                     .len = lhs_len,
                 }),
             };
 @@ -14893,7 +14892,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         break :coerced_lhs .{ uncoerced_lhs, uncoerced_lhs_ty };
     };
-    if (lhs_ty.isTuple(mod)) {
+    if (lhs_ty.isTuple(zcu)) {
         // In `**` rhs must be comptime-known, but lhs can be runtime-known
         const factor = try sema.resolveInt(block, rhs_src, extra.rhs, Type.usize, .{
             .needed_comptime_reason = "array multiplication factor must be comptime-known",
 @@ -14907,7 +14906,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         const msg = msg: {
             const msg = try sema.errMsg(lhs_src, "expected indexable; found '{}'", .{lhs_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Int, .Float, .ComptimeFloat, .ComptimeInt, .Vector => {
                     try sema.errNote(operator_src, msg, "this operator multiplies arrays; use std.math.pow for exponentiation", .{});
                 },
 @@ -14933,13 +14932,13 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .child = lhs_info.elem_type.toIntern(),
     });
-    const ptr_addrspace = if (lhs_ty.zigTypeTag(mod) == .Pointer) lhs_ty.ptrAddressSpace(mod) else null;
+    const ptr_addrspace = if (lhs_ty.zigTypeTag(zcu) == .Pointer) lhs_ty.ptrAddressSpace(zcu) else null;
     const lhs_len = try sema.usizeCast(block, lhs_src, lhs_info.len);
     if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val| ct: {
-        const lhs_sub_val = if (lhs_ty.isSinglePointer(mod))
+        const lhs_sub_val = if (lhs_ty.isSinglePointer(zcu))
             try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty) orelse break :ct
-        else if (lhs_ty.isSlice(mod))
+        else if (lhs_ty.isSlice(zcu))
             try sema.maybeDerefSliceAsArray(block, lhs_src, lhs_val) orelse break :ct
         else
             lhs_val;
 @@ -15022,7 +15021,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const lhs_src = src;
 @@ -15030,9 +15029,9 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const rhs = try sema.resolveInst(inst_data.operand);
     const rhs_ty = sema.typeOf(rhs);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    if (rhs_scalar_ty.isUnsignedInt(mod) or switch (rhs_scalar_ty.zigTypeTag(mod)) {
+    if (rhs_scalar_ty.isUnsignedInt(zcu) or switch (rhs_scalar_ty.zigTypeTag(zcu)) {
         .Int, .ComptimeInt, .Float, .ComptimeFloat => false,
         else => true,
     }) {
 @@ -15042,7 +15041,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     if (rhs_scalar_ty.isAnyFloat()) {
         // We handle float negation here to ensure negative zero is represented in the bits.
         if (try sema.resolveValue(rhs)) |rhs_val| {
-            if (rhs_val.isUndef(mod)) return pt.undefRef(rhs_ty);
+            if (rhs_val.isUndef(zcu)) return pt.undefRef(rhs_ty);
             return Air.internedToRef((try rhs_val.floatNeg(rhs_ty, sema.arena, pt)).toIntern());
         }
         try sema.requireRuntimeBlock(block, src, null);
 @@ -15055,7 +15054,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const lhs_src = src;
 @@ -15063,9 +15062,9 @@ fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const rhs = try sema.resolveInst(inst_data.operand);
     const rhs_ty = sema.typeOf(rhs);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    switch (rhs_scalar_ty.zigTypeTag(mod)) {
+    switch (rhs_scalar_ty.zigTypeTag(zcu)) {
         .Int, .ComptimeInt, .Float, .ComptimeFloat => {},
         else => return sema.fail(block, src, "negation of type '{}'", .{rhs_ty.fmt(pt)}),
     }
 @@ -15097,7 +15096,7 @@ fn zirArithmetic(
 fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15107,8 +15106,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15120,9 +15119,9 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const lhs_scalar_ty = lhs_ty.scalarType(mod);
+    const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -15131,15 +15130,15 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
     const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
-    if ((lhs_ty.zigTypeTag(mod) == .ComptimeFloat and rhs_ty.zigTypeTag(mod) == .ComptimeInt) or
+    if ((lhs_ty.zigTypeTag(zcu) == .ComptimeFloat and rhs_ty.zigTypeTag(zcu) == .ComptimeInt) or
-        (lhs_ty.zigTypeTag(mod) == .ComptimeInt and rhs_ty.zigTypeTag(mod) == .ComptimeFloat))
+        (lhs_ty.zigTypeTag(zcu) == .ComptimeInt and rhs_ty.zigTypeTag(zcu) == .ComptimeFloat))
     {
         // If it makes a difference whether we coerce to ints or floats before doing the division, error.
         // If lhs % rhs is 0, it doesn't matter.
         const lhs_val = maybe_lhs_val orelse unreachable;
         const rhs_val = maybe_rhs_val orelse unreachable;
         const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, pt) catch unreachable;
-        if (!rem.compareAllWithZero(.eq, pt)) {
+        if (!rem.compareAllWithZero(.eq, zcu)) {
             return sema.fail(
                 block,
                 src,
 @@ -15179,11 +15178,11 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     switch (scalar_tag) {
         .Int, .ComptimeInt, .ComptimeFloat => {
             if (maybe_lhs_val) |lhs_val| {
-                if (!lhs_val.isUndef(mod)) {
+                if (!lhs_val.isUndef(zcu)) {
                     if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                         const scalar_zero = switch (scalar_tag) {
-                            .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                            .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                            .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                            .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                             else => unreachable,
                         };
                         const zero_val = try sema.splat(resolved_type, scalar_zero);
 @@ -15192,7 +15191,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
                 }
             }
             if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(mod)) {
+                if (rhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, rhs_src);
                 }
                 if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15206,8 +15205,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const runtime_src = rs: {
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
+                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
                     if (maybe_rhs_val) |rhs_val| {
                         if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
                             return pt.undefRef(resolved_type);
 @@ -15245,7 +15244,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     }
     const air_tag = if (is_int) blk: {
-        if (lhs_ty.isSignedInt(mod) or rhs_ty.isSignedInt(mod)) {
+        if (lhs_ty.isSignedInt(zcu) or rhs_ty.isSignedInt(zcu)) {
             return sema.fail(
                 block,
                 src,
 @@ -15263,7 +15262,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15273,8 +15272,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15286,8 +15285,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const lhs_scalar_ty = lhs_ty.scalarType(mod);
+    const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -15314,13 +15313,13 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         // If the lhs is undefined, compile error because there is a possible
         // value for which the division would result in a remainder.
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             } else {
                 if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                     const scalar_zero = switch (scalar_tag) {
-                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                         else => unreachable,
                     };
                     const zero_val = try sema.splat(resolved_type, scalar_zero);
 @@ -15329,7 +15328,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
         }
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15341,7 +15340,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             if (maybe_rhs_val) |rhs_val| {
                 if (is_int) {
                     const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, pt);
-                    if (!(modulus_val.compareAllWithZero(.eq, pt))) {
+                    if (!(modulus_val.compareAllWithZero(.eq, zcu))) {
                         return sema.fail(block, src, "exact division produced remainder", .{});
                     }
                     var overflow_idx: ?usize = null;
 @@ -15352,7 +15351,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     return Air.internedToRef(res.toIntern());
                 } else {
                     const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, pt);
-                    if (!(modulus_val.compareAllWithZero(.eq, pt))) {
+                    if (!(modulus_val.compareAllWithZero(.eq, zcu))) {
                         return sema.fail(block, src, "exact division produced remainder", .{});
                     }
                     return Air.internedToRef((try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, pt)).toIntern());
 @@ -15376,7 +15375,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         const ok = if (!is_int) ok: {
             const floored = try block.addUnOp(.floor, result);
-            if (resolved_type.zigTypeTag(mod) == .Vector) {
+            if (resolved_type.zigTypeTag(zcu) == .Vector) {
                 const eql = try block.addCmpVector(result, floored, .eq);
                 break :ok try block.addInst(.{
                     .tag = switch (block.float_mode) {
 @@ -15399,11 +15398,11 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const remainder = try block.addBinOp(.rem, casted_lhs, casted_rhs);
             const scalar_zero = switch (scalar_tag) {
-                .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                 else => unreachable,
             };
-            if (resolved_type.zigTypeTag(mod) == .Vector) {
+            if (resolved_type.zigTypeTag(zcu) == .Vector) {
                 const zero_val = try sema.splat(resolved_type, scalar_zero);
                 const zero = Air.internedToRef(zero_val.toIntern());
                 const eql = try block.addCmpVector(remainder, zero, .eq);
 @@ -15429,7 +15428,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15439,8 +15438,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15452,9 +15451,9 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const lhs_scalar_ty = lhs_ty.scalarType(mod);
+    const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -15484,11 +15483,11 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         // value (zero) for which the division would be illegal behavior.
         // If the lhs is undefined, result is undefined.
         if (maybe_lhs_val) |lhs_val| {
-            if (!lhs_val.isUndef(mod)) {
+            if (!lhs_val.isUndef(zcu)) {
                 if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                     const scalar_zero = switch (scalar_tag) {
-                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                         else => unreachable,
                     };
                     const zero_val = try sema.splat(resolved_type, scalar_zero);
 @@ -15497,7 +15496,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
         }
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15506,8 +15505,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             // TODO: if the RHS is one, return the LHS directly
         }
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
+                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
                     if (maybe_rhs_val) |rhs_val| {
                         if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
                             return pt.undefRef(resolved_type);
 @@ -15540,7 +15539,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15550,8 +15549,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15563,9 +15562,9 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const lhs_scalar_ty = lhs_ty.scalarType(mod);
+    const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -15595,11 +15594,11 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         // value (zero) for which the division would be illegal behavior.
         // If the lhs is undefined, result is undefined.
         if (maybe_lhs_val) |lhs_val| {
-            if (!lhs_val.isUndef(mod)) {
+            if (!lhs_val.isUndef(zcu)) {
                 if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                     const scalar_zero = switch (scalar_tag) {
-                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                         else => unreachable,
                     };
                     const zero_val = try sema.splat(resolved_type, scalar_zero);
 @@ -15608,7 +15607,7 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
         }
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15616,8 +15615,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             }
         }
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
+                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
                     if (maybe_rhs_val) |rhs_val| {
                         if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
                             return pt.undefRef(resolved_type);
 @@ -15666,14 +15665,14 @@ fn addDivIntOverflowSafety(
     is_int: bool,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (!is_int) return;
     // If the LHS is unsigned, it cannot cause overflow.
-    if (!lhs_scalar_ty.isSignedInt(mod)) return;
+    if (!lhs_scalar_ty.isSignedInt(zcu)) return;
     // If the LHS is widened to a larger integer type, no overflow is possible.
-    if (lhs_scalar_ty.intInfo(mod).bits < resolved_type.intInfo(mod).bits) {
+    if (lhs_scalar_ty.intInfo(zcu).bits < resolved_type.intInfo(zcu).bits) {
         return;
     }
 @@ -15693,7 +15692,7 @@ fn addDivIntOverflowSafety(
     }
     var ok: Air.Inst.Ref = .none;
-    if (resolved_type.zigTypeTag(mod) == .Vector) {
+    if (resolved_type.zigTypeTag(zcu) == .Vector) {
         if (maybe_lhs_val == null) {
             const min_int_ref = Air.internedToRef(min_int.toIntern());
             ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq);
 @@ -15751,12 +15750,12 @@ fn addDivByZeroSafety(
     if (maybe_rhs_val != null) return;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const scalar_zero = if (is_int)
-        try pt.intValue(resolved_type.scalarType(mod), 0)
+        try pt.intValue(resolved_type.scalarType(zcu), 0)
     else
-        try pt.floatValue(resolved_type.scalarType(mod), 0.0);
+        try pt.floatValue(resolved_type.scalarType(zcu), 0.0);
-    const ok = if (resolved_type.zigTypeTag(mod) == .Vector) ok: {
+    const ok = if (resolved_type.zigTypeTag(zcu) == .Vector) ok: {
         const zero_val = try sema.splat(resolved_type, scalar_zero);
         const zero = Air.internedToRef(zero_val.toIntern());
         const ok = try block.addCmpVector(casted_rhs, zero, .neq);
 @@ -15784,7 +15783,7 @@ fn airTag(block: *Block, is_int: bool, normal: Air.Inst.Tag, optimized: Air.Inst
 fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15794,8 +15793,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15804,14 +15803,14 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
     });
-    const is_vector = resolved_type.zigTypeTag(mod) == .Vector;
+    const is_vector = resolved_type.zigTypeTag(zcu) == .Vector;
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const lhs_scalar_ty = lhs_ty.scalarType(mod);
+    const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(mod);
+    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -15836,13 +15835,13 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         // then emit a compile error saying you have to pick one.
         if (is_int) {
             if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(mod)) {
+                if (lhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, lhs_src);
                 }
                 if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                     const scalar_zero = switch (scalar_tag) {
-                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(mod), 0.0),
+                        .ComptimeFloat, .Float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(mod), 0),
+                        .ComptimeInt, .Int => try pt.intValue(resolved_type.scalarType(zcu), 0),
                         else => unreachable,
                     };
                     const zero_val = if (is_vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{
 @@ -15851,11 +15850,11 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                     } })) else scalar_zero;
                     return Air.internedToRef(zero_val.toIntern());
                 }
-            } else if (lhs_scalar_ty.isSignedInt(mod)) {
+            } else if (lhs_scalar_ty.isSignedInt(zcu)) {
                 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
             }
             if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(mod)) {
+                if (rhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, rhs_src);
                 }
                 if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15876,7 +15875,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                     return Air.internedToRef(rem_result.toIntern());
                 }
                 break :rs lhs_src;
-            } else if (rhs_scalar_ty.isSignedInt(mod)) {
+            } else if (rhs_scalar_ty.isSignedInt(zcu)) {
                 return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
             } else {
                 break :rs rhs_src;
 @@ -15884,7 +15883,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         }
         // float operands
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -15894,7 +15893,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
             }
             if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(mod) or !(try lhs_val.compareAllWithZeroSema(.gte, pt))) {
+                if (lhs_val.isUndef(zcu) or !(try lhs_val.compareAllWithZeroSema(.gte, pt))) {
                     return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
                 }
                 return Air.internedToRef((try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, pt)).toIntern());
 @@ -15923,10 +15922,10 @@ fn intRem(
     rhs: Value,
 ) CompileError!Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(mod));
+        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
 @@ -15946,8 +15945,8 @@ fn intRemScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) CompileErr
     // resorting to BigInt first.
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, pt, .sema);
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, pt, .sema);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
     const limbs_q = try sema.arena.alloc(
         math.big.Limb,
         lhs_bigint.limbs.len,
 @@ -15970,7 +15969,7 @@ fn intRemScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) CompileErr
 fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -15980,8 +15979,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -15993,7 +15992,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -16016,12 +16015,12 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         // If the lhs is undefined, result is undefined.
         if (is_int) {
             if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(mod)) {
+                if (lhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, lhs_src);
                 }
             }
             if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(mod)) {
+                if (rhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, rhs_src);
                 }
                 if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -16037,7 +16036,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         }
         // float operands
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -16045,7 +16044,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
             }
         }
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
                 return pt.undefRef(resolved_type);
             }
             if (maybe_rhs_val) |rhs_val| {
 @@ -16066,7 +16065,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.src(.{ .node_offset_bin_op = inst_data.src_node });
     const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node });
 @@ -16076,8 +16075,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const rhs = try sema.resolveInst(extra.rhs);
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 @@ -16089,7 +16088,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod);
+    const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -16112,12 +16111,12 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         // If the lhs is undefined, result is undefined.
         if (is_int) {
             if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(mod)) {
+                if (lhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, lhs_src);
                 }
             }
             if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(mod)) {
+                if (rhs_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, rhs_src);
                 }
                 if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -16133,7 +16132,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         }
         // float operands
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(mod)) {
+            if (rhs_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, rhs_src);
             }
             if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
 @@ -16141,7 +16140,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
             }
         }
         if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(mod)) {
+            if (lhs_val.isUndef(zcu)) {
                 return pt.undefRef(resolved_type);
             }
             if (maybe_rhs_val) |rhs_val| {
 @@ -16181,8 +16180,8 @@ fn zirOverflowArithmetic(
     const lhs_ty = sema.typeOf(uncasted_lhs);
     const rhs_ty = sema.typeOf(uncasted_rhs);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
 @@ -16202,7 +16201,7 @@ fn zirOverflowArithmetic(
     const lhs = try sema.coerce(block, dest_ty, uncasted_lhs, lhs_src);
     const rhs = try sema.coerce(block, rhs_dest_ty, uncasted_rhs, rhs_src);
-    if (dest_ty.scalarType(mod).zigTypeTag(mod) != .Int) {
+    if (dest_ty.scalarType(zcu).zigTypeTag(zcu) != .Int) {
         return sema.fail(block, src, "expected vector of integers or integer tag type, found '{}'", .{dest_ty.fmt(pt)});
     }
 @@ -16224,18 +16223,18 @@ fn zirOverflowArithmetic(
                 // to the result, even if it is undefined..
                 // Otherwise, if either of the argument is undefined, undefined is returned.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = rhs };
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (!rhs_val.isUndef(mod) and (try rhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!rhs_val.isUndef(zcu) and (try rhs_val.compareAllWithZeroSema(.eq, pt))) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = lhs };
                     }
                 }
                 if (maybe_lhs_val) |lhs_val| {
                     if (maybe_rhs_val) |rhs_val| {
-                        if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu) or rhs_val.isUndef(zcu)) {
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 @@ -16248,12 +16247,12 @@ fn zirOverflowArithmetic(
                 // If the rhs is zero, then the result is lhs and no overflow occured.
                 // Otherwise, if either result is undefined, both results are undefined.
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                     } else if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = lhs };
                     } else if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu)) {
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 @@ -16266,9 +16265,9 @@ fn zirOverflowArithmetic(
                 // If either of the arguments is zero, the result is zero and no overflow occured.
                 // If either of the arguments is one, the result is the other and no overflow occured.
                 // Otherwise, if either of the arguments is undefined, both results are undefined.
-                const scalar_one = try pt.intValue(dest_ty.scalarType(mod), 1);
+                const scalar_one = try pt.intValue(dest_ty.scalarType(zcu), 1);
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod)) {
+                    if (!lhs_val.isUndef(zcu)) {
                         if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                             break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = lhs };
                         } else if (try sema.compareAll(lhs_val, .eq, try sema.splat(dest_ty, scalar_one), dest_ty)) {
 @@ -16278,7 +16277,7 @@ fn zirOverflowArithmetic(
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (!rhs_val.isUndef(mod)) {
+                    if (!rhs_val.isUndef(zcu)) {
                         if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
                             break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = rhs };
                         } else if (try sema.compareAll(rhs_val, .eq, try sema.splat(dest_ty, scalar_one), dest_ty)) {
 @@ -16289,7 +16288,7 @@ fn zirOverflowArithmetic(
                 if (maybe_lhs_val) |lhs_val| {
                     if (maybe_rhs_val) |rhs_val| {
-                        if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu) or rhs_val.isUndef(zcu)) {
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 @@ -16303,18 +16302,18 @@ fn zirOverflowArithmetic(
                 // If rhs is zero, the result is lhs (even if undefined) and no overflow occurred.
                 // Oterhwise if either of the arguments is undefined, both results are undefined.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = lhs };
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (!rhs_val.isUndef(mod) and (try rhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!rhs_val.isUndef(zcu) and (try rhs_val.compareAllWithZeroSema(.eq, pt))) {
                         break :result .{ .overflow_bit = try sema.splat(overflow_ty, zero_bit), .inst = lhs };
                     }
                 }
                 if (maybe_lhs_val) |lhs_val| {
                     if (maybe_rhs_val) |rhs_val| {
-                        if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu) or rhs_val.isUndef(zcu)) {
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 @@ -16374,8 +16373,8 @@ fn zirOverflowArithmetic(
 fn splat(sema: *Sema, ty: Type, val: Value) !Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) != .Vector) return val;
+    if (ty.zigTypeTag(zcu) != .Vector) return val;
     const repeated = try pt.intern(.{ .aggregate = .{
         .ty = ty.toIntern(),
         .storage = .{ .repeated_elem = val.toIntern() },
 @@ -16385,16 +16384,16 @@ fn splat(sema: *Sema, ty: Type, val: Value) !Value {
 fn overflowArithmeticTupleType(sema: *Sema, ty: Type) !Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const ov_ty = if (ty.zigTypeTag(mod) == .Vector) try pt.vectorType(.{
+    const ov_ty = if (ty.zigTypeTag(zcu) == .Vector) try pt.vectorType(.{
-        .len = ty.vectorLen(mod),
+        .len = ty.vectorLen(zcu),
         .child = .u1_type,
     }) else Type.u1;
     const types = [2]InternPool.Index{ ty.toIntern(), ov_ty.toIntern() };
     const values = [2]InternPool.Index{ .none, .none };
-    const tuple_ty = try ip.getAnonStructType(mod.gpa, pt.tid, .{
+    const tuple_ty = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
         .types = &types,
         .values = &values,
         .names = &.{},
 @@ -16415,41 +16414,41 @@ fn analyzeArithmetic(
     want_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     if (lhs_zig_ty_tag == .Pointer) {
         if (rhs_zig_ty_tag == .Pointer) {
-            if (lhs_ty.ptrSize(mod) != .Slice and rhs_ty.ptrSize(mod) != .Slice) {
+            if (lhs_ty.ptrSize(zcu) != .Slice and rhs_ty.ptrSize(zcu) != .Slice) {
                 if (zir_tag != .sub) {
                     return sema.failWithInvalidPtrArithmetic(block, src, "pointer-pointer", "subtraction");
                 }
-                if (!lhs_ty.elemType2(mod).eql(rhs_ty.elemType2(mod), mod)) {
+                if (!lhs_ty.elemType2(zcu).eql(rhs_ty.elemType2(zcu), zcu)) {
                     return sema.fail(block, src, "incompatible pointer arithmetic operands '{}' and '{}'", .{
                         lhs_ty.fmt(pt), rhs_ty.fmt(pt),
                     });
                 }
-                const elem_size = lhs_ty.elemType2(mod).abiSize(pt);
+                const elem_size = lhs_ty.elemType2(zcu).abiSize(zcu);
                 if (elem_size == 0) {
                     return sema.fail(block, src, "pointer arithmetic requires element type '{}' to have runtime bits", .{
-                        lhs_ty.elemType2(mod).fmt(pt),
+                        lhs_ty.elemType2(zcu).fmt(pt),
                     });
                 }
                 const runtime_src = runtime_src: {
                     if (try sema.resolveValue(lhs)) |lhs_value| {
                         if (try sema.resolveValue(rhs)) |rhs_value| {
-                            const lhs_ptr = switch (mod.intern_pool.indexToKey(lhs_value.toIntern())) {
+                            const lhs_ptr = switch (zcu.intern_pool.indexToKey(lhs_value.toIntern())) {
                                 .undef => return sema.failWithUseOfUndef(block, lhs_src),
                                 .ptr => |ptr| ptr,
                                 else => unreachable,
                             };
-                            const rhs_ptr = switch (mod.intern_pool.indexToKey(rhs_value.toIntern())) {
+                            const rhs_ptr = switch (zcu.intern_pool.indexToKey(rhs_value.toIntern())) {
                                 .undef => return sema.failWithUseOfUndef(block, rhs_src),
                                 .ptr => |ptr| ptr,
                                 else => unreachable,
 @@ -16475,7 +16474,7 @@ fn analyzeArithmetic(
                 return try block.addBinOp(.div_exact, address, try pt.intRef(Type.usize, elem_size));
             }
         } else {
-            switch (lhs_ty.ptrSize(mod)) {
+            switch (lhs_ty.ptrSize(zcu)) {
                 .One, .Slice => {},
                 .Many, .C => {
                     const air_tag: Air.Inst.Tag = switch (zir_tag) {
 @@ -16484,9 +16483,9 @@ fn analyzeArithmetic(
                         else => return sema.failWithInvalidPtrArithmetic(block, src, "pointer-integer", "addition and subtraction"),
                     };
-                    if (!try sema.typeHasRuntimeBits(lhs_ty.elemType2(mod))) {
+                    if (!try lhs_ty.elemType2(zcu).hasRuntimeBitsSema(pt)) {
                         return sema.fail(block, src, "pointer arithmetic requires element type '{}' to have runtime bits", .{
-                            lhs_ty.elemType2(mod).fmt(pt),
+                            lhs_ty.elemType2(zcu).fmt(pt),
                         });
                     }
                     return sema.analyzePtrArithmetic(block, src, lhs, rhs, air_tag, lhs_src, rhs_src);
 @@ -16503,8 +16502,8 @@ fn analyzeArithmetic(
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
-    const scalar_type = resolved_type.scalarType(mod);
+    const scalar_type = resolved_type.scalarType(zcu);
-    const scalar_tag = scalar_type.zigTypeTag(mod);
+    const scalar_tag = scalar_type.zigTypeTag(zcu);
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
 @@ -16523,12 +16522,12 @@ fn analyzeArithmetic(
                 // overflow (max_int), causing illegal behavior.
                 // For floats: either operand being undef makes the result undef.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
                         return casted_rhs;
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         if (is_int) {
                             return sema.failWithUseOfUndef(block, rhs_src);
                         } else {
 @@ -16541,7 +16540,7 @@ fn analyzeArithmetic(
                 }
                 const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .add_optimized else .add;
                 if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(mod)) {
+                    if (lhs_val.isUndef(zcu)) {
                         if (is_int) {
                             return sema.failWithUseOfUndef(block, lhs_src);
                         } else {
 @@ -16567,12 +16566,12 @@ fn analyzeArithmetic(
                 // If either of the operands are zero, the other operand is returned.
                 // If either of the operands are undefined, the result is undefined.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
                         return casted_rhs;
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
 @@ -16588,19 +16587,19 @@ fn analyzeArithmetic(
                 // If either of the operands are zero, then the other operand is returned.
                 // If either of the operands are undefined, the result is undefined.
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
+                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
                         return casted_rhs;
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
                         return casted_lhs;
                     }
                     if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu)) {
                             return pt.undefRef(resolved_type);
                         }
 @@ -16630,7 +16629,7 @@ fn analyzeArithmetic(
                 // overflow, causing illegal behavior.
                 // For floats: either operand being undef makes the result undef.
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         if (is_int) {
                             return sema.failWithUseOfUndef(block, rhs_src);
                         } else {
 @@ -16643,7 +16642,7 @@ fn analyzeArithmetic(
                 }
                 const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .sub_optimized else .sub;
                 if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(mod)) {
+                    if (lhs_val.isUndef(zcu)) {
                         if (is_int) {
                             return sema.failWithUseOfUndef(block, lhs_src);
                         } else {
 @@ -16669,7 +16668,7 @@ fn analyzeArithmetic(
                 // If the RHS is zero, then the LHS is returned, even if it is undefined.
                 // If either of the operands are undefined, the result is undefined.
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
 @@ -16677,7 +16676,7 @@ fn analyzeArithmetic(
                     }
                 }
                 if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(mod)) {
+                    if (lhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (maybe_rhs_val) |rhs_val| {
 @@ -16690,7 +16689,7 @@ fn analyzeArithmetic(
                 // If the RHS is zero, then the LHS is returned, even if it is undefined.
                 // If either of the operands are undefined, the result is undefined.
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
 @@ -16698,7 +16697,7 @@ fn analyzeArithmetic(
                     }
                 }
                 if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(mod)) {
+                    if (lhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (maybe_rhs_val) |rhs_val| {
 @@ -16736,16 +16735,16 @@ fn analyzeArithmetic(
                     else => unreachable,
                 };
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod)) {
+                    if (!lhs_val.isUndef(zcu)) {
-                        if (lhs_val.isNan(mod)) {
+                        if (lhs_val.isNan(zcu)) {
                             return Air.internedToRef(lhs_val.toIntern());
                         }
                         if (try lhs_val.compareAllWithZeroSema(.eq, pt)) lz: {
                             if (maybe_rhs_val) |rhs_val| {
-                                if (rhs_val.isNan(mod)) {
+                                if (rhs_val.isNan(zcu)) {
                                     return Air.internedToRef(rhs_val.toIntern());
                                 }
-                                if (rhs_val.isInf(mod)) {
+                                if (rhs_val.isInf(zcu)) {
                                     return Air.internedToRef((try pt.floatValue(resolved_type, std.math.nan(f128))).toIntern());
                                 }
                             } else if (resolved_type.isAnyFloat()) {
 @@ -16761,19 +16760,19 @@ fn analyzeArithmetic(
                 }
                 const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .mul_optimized else .mul;
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         if (is_int) {
                             return sema.failWithUseOfUndef(block, rhs_src);
                         } else {
                             return pt.undefRef(resolved_type);
                         }
                     }
-                    if (rhs_val.isNan(mod)) {
+                    if (rhs_val.isNan(zcu)) {
                         return Air.internedToRef(rhs_val.toIntern());
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) rz: {
                         if (maybe_lhs_val) |lhs_val| {
-                            if (lhs_val.isInf(mod)) {
+                            if (lhs_val.isInf(zcu)) {
                                 return Air.internedToRef((try pt.floatValue(resolved_type, std.math.nan(f128))).toIntern());
                             }
                         } else if (resolved_type.isAnyFloat()) {
 @@ -16786,7 +16785,7 @@ fn analyzeArithmetic(
                         return casted_lhs;
                     }
                     if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu)) {
                             if (is_int) {
                                 return sema.failWithUseOfUndef(block, lhs_src);
                             } else {
 @@ -16822,7 +16821,7 @@ fn analyzeArithmetic(
                     else => unreachable,
                 };
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod)) {
+                    if (!lhs_val.isUndef(zcu)) {
                         if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                             const zero_val = try sema.splat(resolved_type, scalar_zero);
                             return Air.internedToRef(zero_val.toIntern());
 @@ -16833,7 +16832,7 @@ fn analyzeArithmetic(
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
 @@ -16844,7 +16843,7 @@ fn analyzeArithmetic(
                         return casted_lhs;
                     }
                     if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu)) {
                             return pt.undefRef(resolved_type);
                         }
                         return Air.internedToRef((try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, pt)).toIntern());
 @@ -16867,7 +16866,7 @@ fn analyzeArithmetic(
                     else => unreachable,
                 };
                 if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(mod)) {
+                    if (!lhs_val.isUndef(zcu)) {
                         if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
                             const zero_val = try sema.splat(resolved_type, scalar_zero);
                             return Air.internedToRef(zero_val.toIntern());
 @@ -16878,7 +16877,7 @@ fn analyzeArithmetic(
                     }
                 }
                 if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) {
+                    if (rhs_val.isUndef(zcu)) {
                         return pt.undefRef(resolved_type);
                     }
                     if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
 @@ -16889,7 +16888,7 @@ fn analyzeArithmetic(
                         return casted_lhs;
                     }
                     if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(mod)) {
+                        if (lhs_val.isUndef(zcu)) {
                             return pt.undefRef(resolved_type);
                         }
 @@ -16909,7 +16908,7 @@ fn analyzeArithmetic(
     try sema.requireRuntimeBlock(block, src, runtime_src);
     if (block.wantSafety() and want_safety and scalar_tag == .Int) {
-        if (mod.backendSupportsFeature(.safety_checked_instructions)) {
+        if (zcu.backendSupportsFeature(.safety_checked_instructions)) {
             if (air_tag != air_tag_safe) {
                 _ = try sema.preparePanicId(block, src, .integer_overflow);
             }
 @@ -16934,7 +16933,7 @@ fn analyzeArithmetic(
                     } },
                 });
                 const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
-                const any_ov_bit = if (resolved_type.zigTypeTag(mod) == .Vector)
+                const any_ov_bit = if (resolved_type.zigTypeTag(zcu) == .Vector)
                     try block.addInst(.{
                         .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce,
                         .data = .{ .reduce = .{
 @@ -16969,11 +16968,11 @@ fn analyzePtrArithmetic(
     // coerce to isize instead of usize.
     const offset = try sema.coerce(block, Type.usize, uncasted_offset, offset_src);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const opt_ptr_val = try sema.resolveValue(ptr);
     const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);
     const ptr_ty = sema.typeOf(ptr);
-    const ptr_info = ptr_ty.ptrInfo(mod);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
     assert(ptr_info.flags.size == .Many or ptr_info.flags.size == .C);
     const new_ptr_ty = t: {
 @@ -16985,7 +16984,7 @@ fn analyzePtrArithmetic(
         }
         // If the addend is not a comptime-known value we can still count on
         // it being a multiple of the type size.
-        const elem_size = try sema.typeAbiSize(Type.fromInterned(ptr_info.child));
+        const elem_size = try Type.fromInterned(ptr_info.child).abiSizeSema(pt);
         const addend = if (opt_off_val) |off_val| a: {
             const off_int = try sema.usizeCast(block, offset_src, try off_val.toUnsignedIntSema(pt));
             break :a elem_size * off_int;
 @@ -17017,12 +17016,12 @@ fn analyzePtrArithmetic(
     const runtime_src = rs: {
         if (opt_ptr_val) |ptr_val| {
             if (opt_off_val) |offset_val| {
-                if (ptr_val.isUndef(mod)) return pt.undefRef(new_ptr_ty);
+                if (ptr_val.isUndef(zcu)) return pt.undefRef(new_ptr_ty);
                 const offset_int = try sema.usizeCast(block, offset_src, try offset_val.toUnsignedIntSema(pt));
                 if (offset_int == 0) return ptr;
                 if (air_tag == .ptr_sub) {
-                    const elem_size = try sema.typeAbiSize(Type.fromInterned(ptr_info.child));
+                    const elem_size = try Type.fromInterned(ptr_info.child).abiSizeSema(pt);
                     const new_ptr_val = try sema.ptrSubtract(block, op_src, ptr_val, offset_int * elem_size, new_ptr_ty);
                     return Air.internedToRef(new_ptr_val.toIntern());
                 } else {
 @@ -17067,7 +17066,7 @@ fn zirAsm(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const extra = sema.code.extraData(Zir.Inst.Asm, extended.operand);
     const src = block.nodeOffset(extra.data.src_node);
     const ret_ty_src = block.src(.{ .node_offset_asm_ret_ty = extra.data.src_node });
 @@ -17099,7 +17098,7 @@ fn zirAsm(
         if (is_volatile) {
             return sema.fail(block, src, "volatile keyword is redundant on module-level assembly", .{});
         }
-        try mod.addGlobalAssembly(sema.owner.unwrap().cau, asm_source);
+        try zcu.addGlobalAssembly(sema.owner.unwrap().cau, asm_source);
         return .void_value;
     }
 @@ -17153,7 +17152,7 @@ fn zirAsm(
         const uncasted_arg = try sema.resolveInst(input.data.operand);
         const uncasted_arg_ty = sema.typeOf(uncasted_arg);
-        switch (uncasted_arg_ty.zigTypeTag(mod)) {
+        switch (uncasted_arg_ty.zigTypeTag(zcu)) {
             .ComptimeInt => arg.* = try sema.coerce(block, Type.usize, uncasted_arg, src),
             .ComptimeFloat => arg.* = try sema.coerce(block, Type.f64, uncasted_arg, src),
             else => {
 @@ -17236,7 +17235,7 @@ fn zirCmpEq(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src: LazySrcLoc = block.nodeOffset(inst_data.src_node);
 @@ -17247,18 +17246,18 @@ fn zirCmpEq(
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    const lhs_ty_tag = lhs_ty.zigTypeTag(mod);
+    const lhs_ty_tag = lhs_ty.zigTypeTag(zcu);
-    const rhs_ty_tag = rhs_ty.zigTypeTag(mod);
+    const rhs_ty_tag = rhs_ty.zigTypeTag(zcu);
     if (lhs_ty_tag == .Null and rhs_ty_tag == .Null) {
         // null == null, null != null
         return if (op == .eq) .bool_true else .bool_false;
     }
     // comparing null with optionals
-    if (lhs_ty_tag == .Null and (rhs_ty_tag == .Optional or rhs_ty.isCPtr(mod))) {
+    if (lhs_ty_tag == .Null and (rhs_ty_tag == .Optional or rhs_ty.isCPtr(zcu))) {
         return sema.analyzeIsNull(block, src, rhs, op == .neq);
     }
-    if (rhs_ty_tag == .Null and (lhs_ty_tag == .Optional or lhs_ty.isCPtr(mod))) {
+    if (rhs_ty_tag == .Null and (lhs_ty_tag == .Optional or lhs_ty.isCPtr(zcu))) {
         return sema.analyzeIsNull(block, src, lhs, op == .neq);
     }
 @@ -17278,11 +17277,11 @@ fn zirCmpEq(
         const runtime_src: LazySrcLoc = src: {
             if (try sema.resolveValue(lhs)) |lval| {
                 if (try sema.resolveValue(rhs)) |rval| {
-                    if (lval.isUndef(mod) or rval.isUndef(mod)) {
+                    if (lval.isUndef(zcu) or rval.isUndef(zcu)) {
                         return pt.undefRef(Type.bool);
                     }
-                    const lkey = mod.intern_pool.indexToKey(lval.toIntern());
+                    const lkey = zcu.intern_pool.indexToKey(lval.toIntern());
-                    const rkey = mod.intern_pool.indexToKey(rval.toIntern());
+                    const rkey = zcu.intern_pool.indexToKey(rval.toIntern());
                     return if ((lkey.err.name == rkey.err.name) == (op == .eq))
                         .bool_true
                     else
 @@ -17300,7 +17299,7 @@ fn zirCmpEq(
     if (lhs_ty_tag == .Type and rhs_ty_tag == .Type) {
         const lhs_as_type = try sema.analyzeAsType(block, lhs_src, lhs);
         const rhs_as_type = try sema.analyzeAsType(block, rhs_src, rhs);
-        return if (lhs_as_type.eql(rhs_as_type, mod) == (op == .eq)) .bool_true else .bool_false;
+        return if (lhs_as_type.eql(rhs_as_type, zcu) == (op == .eq)) .bool_true else .bool_false;
     }
     return sema.analyzeCmp(block, src, lhs, rhs, op, lhs_src, rhs_src, true);
 }
 @@ -17316,14 +17315,14 @@ fn analyzeCmpUnionTag(
     op: std.math.CompareOperator,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const union_ty = sema.typeOf(un);
     try union_ty.resolveFields(pt);
-    const union_tag_ty = union_ty.unionTagType(mod) orelse {
+    const union_tag_ty = union_ty.unionTagType(zcu) orelse {
         const msg = msg: {
             const msg = try sema.errMsg(un_src, "comparison of union and enum literal is only valid for tagged union types", .{});
             errdefer msg.destroy(sema.gpa);
-            try sema.errNote(union_ty.srcLoc(mod), msg, "union '{}' is not a tagged union", .{union_ty.fmt(pt)});
+            try sema.errNote(union_ty.srcLoc(zcu), msg, "union '{}' is not a tagged union", .{union_ty.fmt(pt)});
             break :msg msg;
         };
         return sema.failWithOwnedErrorMsg(block, msg);
 @@ -17334,9 +17333,9 @@ fn analyzeCmpUnionTag(
     const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);
     if (try sema.resolveValue(coerced_tag)) |enum_val| {
-        if (enum_val.isUndef(mod)) return pt.undefRef(Type.bool);
+        if (enum_val.isUndef(zcu)) return pt.undefRef(Type.bool);
-        const field_ty = union_ty.unionFieldType(enum_val, mod).?;
+        const field_ty = union_ty.unionFieldType(enum_val, zcu).?;
-        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+        if (field_ty.zigTypeTag(zcu) == .NoReturn) {
             return .bool_false;
         }
     }
 @@ -17376,33 +17375,33 @@ fn analyzeCmp(
     is_equality_cmp: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    if (lhs_ty.zigTypeTag(mod) != .Optional and rhs_ty.zigTypeTag(mod) != .Optional) {
+    if (lhs_ty.zigTypeTag(zcu) != .Optional and rhs_ty.zigTypeTag(zcu) != .Optional) {
         try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     }
-    if (lhs_ty.zigTypeTag(mod) == .Vector and rhs_ty.zigTypeTag(mod) == .Vector) {
+    if (lhs_ty.zigTypeTag(zcu) == .Vector and rhs_ty.zigTypeTag(zcu) == .Vector) {
         return sema.cmpVector(block, src, lhs, rhs, op, lhs_src, rhs_src);
     }
-    if (lhs_ty.isNumeric(mod) and rhs_ty.isNumeric(mod)) {
+    if (lhs_ty.isNumeric(zcu) and rhs_ty.isNumeric(zcu)) {
         // This operation allows any combination of integer and float types, regardless of the
         // signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for
         // numeric types.
         return sema.cmpNumeric(block, src, lhs, rhs, op, lhs_src, rhs_src);
     }
-    if (is_equality_cmp and lhs_ty.zigTypeTag(mod) == .ErrorUnion and rhs_ty.zigTypeTag(mod) == .ErrorSet) {
+    if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .ErrorUnion and rhs_ty.zigTypeTag(zcu) == .ErrorSet) {
         const casted_lhs = try sema.analyzeErrUnionCode(block, lhs_src, lhs);
         return sema.cmpSelf(block, src, casted_lhs, rhs, op, lhs_src, rhs_src);
     }
-    if (is_equality_cmp and lhs_ty.zigTypeTag(mod) == .ErrorSet and rhs_ty.zigTypeTag(mod) == .ErrorUnion) {
+    if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .ErrorSet and rhs_ty.zigTypeTag(zcu) == .ErrorUnion) {
         const casted_rhs = try sema.analyzeErrUnionCode(block, rhs_src, rhs);
         return sema.cmpSelf(block, src, lhs, casted_rhs, op, lhs_src, rhs_src);
     }
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
     const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ .override = &[_]?LazySrcLoc{ lhs_src, rhs_src } });
-    if (!resolved_type.isSelfComparable(mod, is_equality_cmp)) {
+    if (!resolved_type.isSelfComparable(zcu, is_equality_cmp)) {
         return sema.fail(block, src, "operator {s} not allowed for type '{}'", .{
             compareOperatorName(op), resolved_type.fmt(pt),
         });
 @@ -17434,15 +17433,15 @@ fn cmpSelf(
     rhs_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const resolved_type = sema.typeOf(casted_lhs);
     const runtime_src: LazySrcLoc = src: {
         if (try sema.resolveValue(casted_lhs)) |lhs_val| {
-            if (lhs_val.isUndef(mod)) return pt.undefRef(Type.bool);
+            if (lhs_val.isUndef(zcu)) return pt.undefRef(Type.bool);
             if (try sema.resolveValue(casted_rhs)) |rhs_val| {
-                if (rhs_val.isUndef(mod)) return pt.undefRef(Type.bool);
+                if (rhs_val.isUndef(zcu)) return pt.undefRef(Type.bool);
-                if (resolved_type.zigTypeTag(mod) == .Vector) {
+                if (resolved_type.zigTypeTag(zcu) == .Vector) {
                     const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_type);
                     return Air.internedToRef(cmp_val.toIntern());
                 }
 @@ -17452,7 +17451,7 @@ fn cmpSelf(
                 else
                     .bool_false;
             } else {
-                if (resolved_type.zigTypeTag(mod) == .Bool) {
+                if (resolved_type.zigTypeTag(zcu) == .Bool) {
                     // We can lower bool eq/neq more efficiently.
                     return sema.runtimeBoolCmp(block, src, op, casted_rhs, lhs_val.toBool(), rhs_src);
                 }
 @@ -17461,9 +17460,9 @@ fn cmpSelf(
         } else {
             // For bools, we still check the other operand, because we can lower
             // bool eq/neq more efficiently.
-            if (resolved_type.zigTypeTag(mod) == .Bool) {
+            if (resolved_type.zigTypeTag(zcu) == .Bool) {
                 if (try sema.resolveValue(casted_rhs)) |rhs_val| {
-                    if (rhs_val.isUndef(mod)) return pt.undefRef(Type.bool);
+                    if (rhs_val.isUndef(zcu)) return pt.undefRef(Type.bool);
                     return sema.runtimeBoolCmp(block, src, op, casted_lhs, rhs_val.toBool(), lhs_src);
                 }
             }
 @@ -17471,7 +17470,7 @@ fn cmpSelf(
         }
     };
     try sema.requireRuntimeBlock(block, src, runtime_src);
-    if (resolved_type.zigTypeTag(mod) == .Vector) {
+    if (resolved_type.zigTypeTag(zcu) == .Vector) {
         return block.addCmpVector(casted_lhs, casted_rhs, op);
     }
     const tag = Air.Inst.Tag.fromCmpOp(op, block.float_mode == .optimized);
 @@ -17535,17 +17534,17 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         .AnyFrame,
         => {},
     }
-    const val = try ty.lazyAbiSize(pt);
+    const val = try ty.abiSizeLazy(pt);
     return Air.internedToRef(val.toIntern());
 }
 fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Fn,
         .NoReturn,
         .Undefined,
 @@ -17576,7 +17575,7 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         .AnyFrame,
         => {},
     }
-    const bit_size = try operand_ty.bitSizeAdvanced(pt, .sema);
+    const bit_size = try operand_ty.bitSizeSema(pt);
     return pt.intRef(Type.comptime_int, bit_size);
 }
 @@ -17599,9 +17598,9 @@ fn zirThis(
 fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const captures = Type.fromInterned(mod.namespacePtr(block.namespace).owner_type).getCaptures(mod);
+    const captures = Type.fromInterned(zcu.namespacePtr(block.namespace).owner_type).getCaptures(zcu);
     const src_node: i32 = @bitCast(extended.operand);
     const src = block.nodeOffset(src_node);
 @@ -17619,7 +17618,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
         const msg = msg: {
             const name = name: {
                 // TODO: we should probably store this name in the ZIR to avoid this complexity.
-                const file, const src_base_node = Module.LazySrcLoc.resolveBaseNode(block.src_base_inst, mod).?;
+                const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;
                 const tree = file.getTree(sema.gpa) catch |err| {
                     // In this case we emit a warning + a less precise source location.
                     log.warn("unable to load {s}: {s}", .{
 @@ -17647,7 +17646,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     if (!block.is_typeof and !block.is_comptime and sema.func_index != .none) {
         const msg = msg: {
             const name = name: {
-                const file, const src_base_node = Module.LazySrcLoc.resolveBaseNode(block.src_base_inst, mod).?;
+                const file, const src_base_node = Zcu.LazySrcLoc.resolveBaseNode(block.src_base_inst, zcu).?;
                 const tree = file.getTree(sema.gpa) catch |err| {
                     // In this case we emit a warning + a less precise source location.
                     log.warn("unable to load {s}: {s}", .{
 @@ -17816,20 +17815,20 @@ fn zirBuiltinSrc(
 fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty = try sema.resolveType(block, src, inst_data.operand);
     const type_info_ty = try pt.getBuiltinType("Type");
-    const type_info_tag_ty = type_info_ty.unionTagType(mod).?;
+    const type_info_tag_ty = type_info_ty.unionTagType(zcu).?;
-    if (ty.typeDeclInst(mod)) |type_decl_inst| {
+    if (ty.typeDeclInst(zcu)) |type_decl_inst| {
         try sema.declareDependency(.{ .namespace = type_decl_inst });
     }
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Type,
         .Void,
         .Bool,
 @@ -17848,7 +17847,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const fn_info_nav = try sema.namespaceLookup(
                 block,
                 src,
-                type_info_ty.getNamespaceIndex(mod),
+                type_info_ty.getNamespaceIndex(zcu),
                 try ip.getOrPutString(gpa, pt.tid, "Fn", .no_embedded_nulls),
             ) orelse @panic("std.builtin.Type is corrupt");
             try sema.ensureNavResolved(src, fn_info_nav);
 @@ -17857,13 +17856,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const param_info_nav = try sema.namespaceLookup(
                 block,
                 src,
-                fn_info_ty.getNamespaceIndex(mod),
+                fn_info_ty.getNamespaceIndex(zcu),
                 try ip.getOrPutString(gpa, pt.tid, "Param", .no_embedded_nulls),
             ) orelse @panic("std.builtin.Type is corrupt");
             try sema.ensureNavResolved(src, param_info_nav);
             const param_info_ty = Type.fromInterned(ip.getNav(param_info_nav).status.resolved.val);
-            const func_ty_info = mod.typeToFunc(ty).?;
+            const func_ty_info = zcu.typeToFunc(ty).?;
             const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len);
             for (param_vals, 0..) |*param_val, i| {
                 const param_ty = func_ty_info.param_types.get(ip)[i];
 @@ -17908,7 +17907,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         .is_const = true,
                     },
                 })).toIntern();
-                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(mod).toIntern();
+                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern();
                 break :v try pt.intern(.{ .slice = .{
                     .ty = slice_ty,
                     .ptr = try pt.intern(.{ .ptr = .{
 @@ -17958,14 +17957,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const int_info_nav = try sema.namespaceLookup(
                 block,
                 src,
-                type_info_ty.getNamespaceIndex(mod),
+                type_info_ty.getNamespaceIndex(zcu),
                 try ip.getOrPutString(gpa, pt.tid, "Int", .no_embedded_nulls),
             ) orelse @panic("std.builtin.Type is corrupt");
             try sema.ensureNavResolved(src, int_info_nav);
             const int_info_ty = Type.fromInterned(ip.getNav(int_info_nav).status.resolved.val);
             const signedness_ty = try pt.getBuiltinType("Signedness");
-            const info = ty.intInfo(mod);
+            const info = ty.intInfo(zcu);
             const field_values = .{
                 // signedness: Signedness,
                 (try pt.enumValueFieldIndex(signedness_ty, @intFromEnum(info.signedness))).toIntern(),
 @@ -17985,7 +17984,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const float_info_nav = try sema.namespaceLookup(
                 block,
                 src,
-                type_info_ty.getNamespaceIndex(mod),
+                type_info_ty.getNamespaceIndex(zcu),
                 try ip.getOrPutString(gpa, pt.tid, "Float", .no_embedded_nulls),
             ) orelse @panic("std.builtin.Type is corrupt");
             try sema.ensureNavResolved(src, float_info_nav);
 @@ -17993,7 +17992,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const field_vals = .{
                 // bits: u16,
-                (try pt.intValue(Type.u16, ty.bitSize(pt))).toIntern(),
+                (try pt.intValue(Type.u16, ty.bitSize(zcu))).toIntern(),
             };
             return Air.internedToRef((try pt.intern(.{ .un = .{
                 .ty = type_info_ty.toIntern(),
 @@ -18005,7 +18004,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             } })));
         },
         .Pointer => {
-            const info = ty.ptrInfo(mod);
+            const info = ty.ptrInfo(zcu);
             const alignment = if (info.flags.alignment.toByteUnits()) |alignment|
                 try pt.intValue(Type.comptime_int, alignment)
             else
 @@ -18016,7 +18015,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(mod),
+                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Pointer", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18026,7 +18025,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    pointer_ty.getNamespaceIndex(mod),
+                    pointer_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Size", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18068,14 +18067,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Array", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
                 break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
             };
-            const info = ty.arrayInfo(mod);
+            const info = ty.arrayInfo(zcu);
             const field_values = .{
                 // len: comptime_int,
                 (try pt.intValue(Type.comptime_int, info.len)).toIntern(),
 @@ -18098,14 +18097,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Vector", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
                 break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
             };
-            const info = ty.arrayInfo(mod);
+            const info = ty.arrayInfo(zcu);
             const field_values = .{
                 // len: comptime_int,
                 (try pt.intValue(Type.comptime_int, info.len)).toIntern(),
 @@ -18126,7 +18125,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Optional", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18135,7 +18134,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const field_values = .{
                 // child: type,
-                ty.optionalChild(mod).toIntern(),
+                ty.optionalChild(zcu).toIntern(),
             };
             return Air.internedToRef((try pt.intern(.{ .un = .{
                 .ty = type_info_ty.toIntern(),
 @@ -18152,7 +18151,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Error", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18226,7 +18225,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     .ty = array_errors_ty.toIntern(),
                     .storage = .{ .elems = vals },
                 } });
-                const manyptr_errors_ty = slice_errors_ty.slicePtrFieldType(mod).toIntern();
+                const manyptr_errors_ty = slice_errors_ty.slicePtrFieldType(zcu).toIntern();
                 break :v try pt.intern(.{ .slice = .{
                     .ty = slice_errors_ty.toIntern(),
                     .ptr = try pt.intern(.{ .ptr = .{
 @@ -18257,7 +18256,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "ErrorUnion", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18266,9 +18265,9 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             const field_values = .{
                 // error_set: type,
-                ty.errorUnionSet(mod).toIntern(),
+                ty.errorUnionSet(zcu).toIntern(),
                 // payload: type,
-                ty.errorUnionPayload(mod).toIntern(),
+                ty.errorUnionPayload(zcu).toIntern(),
             };
             return Air.internedToRef((try pt.intern(.{ .un = .{
                 .ty = type_info_ty.toIntern(),
 @@ -18286,7 +18285,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "EnumField", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18298,7 +18297,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const enum_type = ip.loadEnumType(ty.toIntern());
                 const value_val = if (enum_type.values.len > 0)
                     try ip.getCoercedInts(
-                        mod.gpa,
+                        zcu.gpa,
                         pt.tid,
                         ip.indexToKey(enum_type.values.get(ip)[tag_index]).int,
                         .comptime_int_type,
 @@ -18361,7 +18360,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         .is_const = true,
                     },
                 })).toIntern();
-                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(mod).toIntern();
+                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern();
                 break :v try pt.intern(.{ .slice = .{
                     .ty = slice_ty,
                     .ptr = try pt.intern(.{ .ptr = .{
 @@ -18382,7 +18381,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Enum", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18413,7 +18412,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Union", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18424,7 +18423,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "UnionField", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18432,7 +18431,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             };
             try ty.resolveLayout(pt); // Getting alignment requires type layout
-            const union_obj = mod.typeToUnion(ty).?;
+            const union_obj = zcu.typeToUnion(ty).?;
             const tag_type = union_obj.loadTagType(ip);
             const layout = union_obj.flagsUnordered(ip).layout;
 @@ -18467,7 +18466,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 };
                 const alignment = switch (layout) {
-                    .auto, .@"extern" => try pt.unionFieldNormalAlignmentAdvanced(union_obj, @intCast(field_index), .sema),
+                    .auto, .@"extern" => try ty.fieldAlignmentSema(field_index, pt),
                     .@"packed" => .none,
                 };
 @@ -18502,7 +18501,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         .is_const = true,
                     },
                 })).toIntern();
-                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(mod).toIntern();
+                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern();
                 break :v try pt.intern(.{ .slice = .{
                     .ty = slice_ty,
                     .ptr = try pt.intern(.{ .ptr = .{
 @@ -18517,18 +18516,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 } });
             };
-            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(mod).toOptional());
+            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(zcu).toOptional());
             const enum_tag_ty_val = try pt.intern(.{ .opt = .{
                 .ty = (try pt.optionalType(.type_type)).toIntern(),
-                .val = if (ty.unionTagType(mod)) |tag_ty| tag_ty.toIntern() else .none,
+                .val = if (ty.unionTagType(zcu)) |tag_ty| tag_ty.toIntern() else .none,
             } });
             const container_layout_ty = t: {
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(mod),
+                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18560,7 +18559,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Struct", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18571,7 +18570,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "StructField", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18633,7 +18632,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                                 // is_comptime: bool,
                                 Value.makeBool(is_comptime).toIntern(),
                                 // alignment: comptime_int,
-                                (try pt.intValue(Type.comptime_int, Type.fromInterned(field_ty).abiAlignment(pt).toByteUnits() orelse 0)).toIntern(),
+                                (try pt.intValue(Type.comptime_int, Type.fromInterned(field_ty).abiAlignment(zcu).toByteUnits() orelse 0)).toIntern(),
                             };
                             struct_field_val.* = try pt.intern(.{ .aggregate = .{
                                 .ty = struct_field_ty.toIntern(),
 @@ -18686,11 +18685,10 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     const default_val_ptr = try sema.optRefValue(opt_default_val);
                     const alignment = switch (struct_type.layout) {
                         .@"packed" => .none,
-                        else => try pt.structFieldAlignmentAdvanced(
+                        else => try field_ty.structFieldAlignmentSema(
                             struct_type.fieldAlign(ip, field_index),
-                            field_ty,
                             struct_type.layout,
-                            .sema,
+                            pt,
                         ),
                     };
 @@ -18729,7 +18727,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         .is_const = true,
                     },
                 })).toIntern();
-                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(mod).toIntern();
+                const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern();
                 break :v try pt.intern(.{ .slice = .{
                     .ty = slice_ty,
                     .ptr = try pt.intern(.{ .ptr = .{
 @@ -18744,12 +18742,12 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 } });
             };
-            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(mod));
+            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(zcu));
             const backing_integer_val = try pt.intern(.{ .opt = .{
                 .ty = (try pt.optionalType(.type_type)).toIntern(),
-                .val = if (mod.typeToPackedStruct(ty)) |packed_struct| val: {
+                .val = if (zcu.typeToPackedStruct(ty)) |packed_struct| val: {
-                    assert(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)).isInt(mod));
+                    assert(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)).isInt(zcu));
                     break :val packed_struct.backingIntTypeUnordered(ip);
                 } else .none,
             } });
 @@ -18758,14 +18756,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    (try pt.getBuiltinType("Type")).getNamespaceIndex(mod),
+                    (try pt.getBuiltinType("Type")).getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "ContainerLayout", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
                 break :t Type.fromInterned(ip.getNav(nav).status.resolved.val);
             };
-            const layout = ty.containerLayout(mod);
+            const layout = ty.containerLayout(zcu);
             const field_values = [_]InternPool.Index{
                 // layout: ContainerLayout,
 @@ -18777,7 +18775,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 // decls: []const Declaration,
                 decls_val,
                 // is_tuple: bool,
-                Value.makeBool(ty.isTuple(mod)).toIntern(),
+                Value.makeBool(ty.isTuple(zcu)).toIntern(),
             };
             return Air.internedToRef((try pt.intern(.{ .un = .{
                 .ty = type_info_ty.toIntern(),
 @@ -18793,7 +18791,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 const nav = try sema.namespaceLookup(
                     block,
                     src,
-                    type_info_ty.getNamespaceIndex(mod),
+                    type_info_ty.getNamespaceIndex(zcu),
                     try ip.getOrPutString(gpa, pt.tid, "Opaque", .no_embedded_nulls),
                 ) orelse @panic("std.builtin.Type is corrupt");
                 try sema.ensureNavResolved(src, nav);
 @@ -18801,7 +18799,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             };
             try ty.resolveFields(pt);
-            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(mod));
+            const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(zcu));
             const field_values = .{
                 // decls: []const Declaration,
 @@ -19000,11 +18998,11 @@ fn zirTypeofLog2IntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
 fn log2IntType(sema: *Sema, block: *Block, operand: Type, src: LazySrcLoc) CompileError!Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (operand.zigTypeTag(mod)) {
+    switch (operand.zigTypeTag(zcu)) {
         .ComptimeInt => return Type.comptime_int,
         .Int => {
-            const bits = operand.bitSize(pt);
+            const bits = operand.bitSize(zcu);
             const count = if (bits == 0)
                 0
             else blk: {
 @@ -19018,10 +19016,10 @@ fn log2IntType(sema: *Sema, block: *Block, operand: Type, src: LazySrcLoc) Compi
             return pt.intType(.unsigned, count);
         },
         .Vector => {
-            const elem_ty = operand.elemType2(mod);
+            const elem_ty = operand.elemType2(zcu);
             const log2_elem_ty = try sema.log2IntType(block, elem_ty, src);
             return pt.vectorType(.{
-                .len = operand.vectorLen(mod),
+                .len = operand.vectorLen(zcu),
                 .child = log2_elem_ty.toIntern(),
             });
         },
 @@ -19084,7 +19082,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node });
 @@ -19092,7 +19090,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const operand = try sema.coerce(block, Type.bool, uncasted_operand, operand_src);
     if (try sema.resolveValue(operand)) |val| {
-        return if (val.isUndef(mod))
+        return if (val.isUndef(zcu))
             pt.undefRef(Type.bool)
         else if (val.toBool()) .bool_false else .bool_true;
     }
 @@ -19110,7 +19108,7 @@ fn zirBoolBr(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const datas = sema.code.instructions.items(.data);
 @@ -19134,7 +19132,7 @@ fn zirBoolBr(
         // is simply the rhs expression. Here we rely on there only being 1
         // break instruction (`break_inline`).
         const rhs_result = try sema.resolveInlineBody(parent_block, body, inst);
-        if (sema.typeOf(rhs_result).isNoReturn(mod)) {
+        if (sema.typeOf(rhs_result).isNoReturn(zcu)) {
             return rhs_result;
         }
         return sema.coerce(parent_block, Type.bool, rhs_result, rhs_src);
 @@ -19168,7 +19166,7 @@ fn zirBoolBr(
     _ = try lhs_block.addBr(block_inst, lhs_result);
     const rhs_result = try sema.resolveInlineBody(rhs_block, body, inst);
-    const rhs_noret = sema.typeOf(rhs_result).isNoReturn(mod);
+    const rhs_noret = sema.typeOf(rhs_result).isNoReturn(zcu);
     const coerced_rhs_result = if (!rhs_noret) rhs: {
         const coerced_result = try sema.coerce(rhs_block, Type.bool, rhs_result, rhs_src);
         _ = try rhs_block.addBr(block_inst, coerced_result);
 @@ -19227,10 +19225,10 @@ fn finishCondBr(
 fn checkNullableType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Optional, .Null, .Undefined => return,
-        .Pointer => if (ty.isPtrLikeOptional(mod)) return,
+        .Pointer => if (ty.isPtrLikeOptional(zcu)) return,
         else => {},
     }
     return sema.failWithExpectedOptionalType(block, src, ty);
 @@ -19260,11 +19258,11 @@ fn zirIsNonNullPtr(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ptr = try sema.resolveInst(inst_data.operand);
-    try sema.checkNullableType(block, src, sema.typeOf(ptr).elemType2(mod));
+    try sema.checkNullableType(block, src, sema.typeOf(ptr).elemType2(zcu));
     if ((try sema.resolveValue(ptr)) == null) {
         return block.addUnOp(.is_non_null_ptr, ptr);
     }
 @@ -19274,8 +19272,8 @@ fn zirIsNonNullPtr(
 fn checkErrorType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .ErrorSet, .ErrorUnion, .Undefined => return,
         else => return sema.fail(block, src, "expected error union type, found '{}'", .{
             ty.fmt(pt),
 @@ -19299,11 +19297,11 @@ fn zirIsNonErrPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ptr = try sema.resolveInst(inst_data.operand);
-    try sema.checkErrorType(block, src, sema.typeOf(ptr).elemType2(mod));
+    try sema.checkErrorType(block, src, sema.typeOf(ptr).elemType2(zcu));
     const loaded = try sema.analyzeLoad(block, src, ptr, src);
     return sema.analyzeIsNonErr(block, src, loaded);
 }
 @@ -19327,7 +19325,7 @@ fn zirCondbr(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const cond_src = parent_block.src(.{ .node_offset_if_cond = inst_data.src_node });
     const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
 @@ -19368,8 +19366,8 @@ fn zirCondbr(
         const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node;
         const err_operand = try sema.resolveInst(err_inst_data.operand);
         const operand_ty = sema.typeOf(err_operand);
-        assert(operand_ty.zigTypeTag(mod) == .ErrorUnion);
+        assert(operand_ty.zigTypeTag(zcu) == .ErrorUnion);
-        const result_ty = operand_ty.errorUnionSet(mod);
+        const result_ty = operand_ty.errorUnionSet(zcu);
         break :blk try sub_block.addTyOp(.unwrap_errunion_err, result_ty, err_operand);
     };
 @@ -19403,8 +19401,8 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!
     const err_union = try sema.resolveInst(extra.data.operand);
     const err_union_ty = sema.typeOf(err_union);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) {
+    if (err_union_ty.zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(parent_block, operand_src, "expected error union type, found '{}'", .{
             err_union_ty.fmt(pt),
         });
 @@ -19452,8 +19450,8 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
     const err_union = try sema.analyzeLoad(parent_block, src, operand, operand_src);
     const err_union_ty = sema.typeOf(err_union);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) {
+    if (err_union_ty.zigTypeTag(zcu) != .ErrorUnion) {
         return sema.fail(parent_block, operand_src, "expected error union type, found '{}'", .{
             err_union_ty.fmt(pt),
         });
 @@ -19477,9 +19475,9 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
     try sema.analyzeBodyInner(&sub_block, body);
     const operand_ty = sema.typeOf(operand);
-    const ptr_info = operand_ty.ptrInfo(mod);
+    const ptr_info = operand_ty.ptrInfo(zcu);
     const res_ty = try pt.ptrTypeSema(.{
-        .child = err_union_ty.errorUnionPayload(mod).toIntern(),
+        .child = err_union_ty.errorUnionPayload(zcu).toIntern(),
         .flags = .{
             .is_const = ptr_info.flags.is_const,
             .is_volatile = ptr_info.flags.is_volatile,
 @@ -19594,10 +19592,10 @@ fn zirRetErrValue(
     inst: Zir.Inst.Index,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
     const src = block.tokenOffset(inst_data.src_tok);
-    const err_name = try mod.intern_pool.getOrPutString(
+    const err_name = try zcu.intern_pool.getOrPutString(
         sema.gpa,
         pt.tid,
         inst_data.get(sema.code),
 @@ -19622,7 +19620,7 @@ fn zirRetImplicit(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;
     const r_brace_src = block.tokenOffset(inst_data.src_tok);
     if (block.inlining == null and sema.func_is_naked) {
 @@ -19638,7 +19636,7 @@ fn zirRetImplicit(
     const operand = try sema.resolveInst(inst_data.operand);
     const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = 0 });
-    const base_tag = sema.fn_ret_ty.baseZigTypeTag(mod);
+    const base_tag = sema.fn_ret_ty.baseZigTypeTag(zcu);
     if (base_tag == .NoReturn) {
         const msg = msg: {
             const msg = try sema.errMsg(ret_ty_src, "function declared '{}' implicitly returns", .{
 @@ -19755,13 +19753,13 @@ fn retWithErrTracing(
 fn wantErrorReturnTracing(sema: *Sema, fn_ret_ty: Type) bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return fn_ret_ty.isError(mod) and mod.comp.config.any_error_tracing;
+    return fn_ret_ty.isError(zcu) and zcu.comp.config.any_error_tracing;
 }
 fn zirSaveErrRetIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].save_err_ret_index;
     if (!block.ownerModule().error_tracing) return;
 @@ -19772,7 +19770,7 @@ fn zirSaveErrRetIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const save_index = inst_data.operand == .none or b: {
         const operand = try sema.resolveInst(inst_data.operand);
         const operand_ty = sema.typeOf(operand);
-        break :b operand_ty.isError(mod);
+        break :b operand_ty.isError(zcu);
     };
     if (save_index)
 @@ -19792,7 +19790,7 @@ fn restoreErrRetIndex(sema: *Sema, start_block: *Block, src: LazySrcLoc, target_
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const saved_index = if (target_block.toIndexAllowNone()) |zir_block| b: {
         var block = start_block;
 @@ -19830,13 +19828,13 @@ fn restoreErrRetIndex(sema: *Sema, start_block: *Block, src: LazySrcLoc, target_
         if (is_non_error) return;
         const saved_index_val = try sema.resolveDefinedValue(start_block, src, saved_index);
-        const saved_index_int = saved_index_val.?.toUnsignedInt(pt);
+        const saved_index_int = saved_index_val.?.toUnsignedInt(zcu);
         assert(saved_index_int <= sema.comptime_err_ret_trace.items.len);
         sema.comptime_err_ret_trace.items.len = @intCast(saved_index_int);
         return;
     }
-    if (!mod.intern_pool.funcAnalysisUnordered(sema.owner.unwrap().func).calls_or_awaits_errorable_fn) return;
+    if (!zcu.intern_pool.funcAnalysisUnordered(sema.owner.unwrap().func).calls_or_awaits_errorable_fn) return;
     if (!start_block.ownerModule().error_tracing) return;
     assert(saved_index != .none); // The .error_return_trace_index field was dropped somewhere
 @@ -19846,10 +19844,10 @@ fn restoreErrRetIndex(sema: *Sema, start_block: *Block, src: LazySrcLoc, target_
 fn addToInferredErrorSet(sema: *Sema, uncasted_operand: Air.Inst.Ref) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    assert(sema.fn_ret_ty.zigTypeTag(mod) == .ErrorUnion);
+    assert(sema.fn_ret_ty.zigTypeTag(zcu) == .ErrorUnion);
-    const err_set_ty = sema.fn_ret_ty.errorUnionSet(mod).toIntern();
+    const err_set_ty = sema.fn_ret_ty.errorUnionSet(zcu).toIntern();
     switch (err_set_ty) {
         .adhoc_inferred_error_set_type => {
             const ies = sema.fn_ret_ty_ies.?;
 @@ -19867,11 +19865,11 @@ fn addToInferredErrorSet(sema: *Sema, uncasted_operand: Air.Inst.Ref) !void {
 fn addToInferredErrorSetPtr(sema: *Sema, ies: *InferredErrorSet, op_ty: Type) !void {
     const arena = sema.arena;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (op_ty.zigTypeTag(mod)) {
+    switch (op_ty.zigTypeTag(zcu)) {
         .ErrorSet => try ies.addErrorSet(op_ty, ip, arena),
-        .ErrorUnion => try ies.addErrorSet(op_ty.errorUnionSet(mod), ip, arena),
+        .ErrorUnion => try ies.addErrorSet(op_ty.errorUnionSet(zcu), ip, arena),
         else => {},
     }
 }
 @@ -19887,8 +19885,8 @@ fn analyzeRet(
     // add the error tag to the inferred error set of the in-scope function, so
     // that the coercion below works correctly.
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (sema.fn_ret_ty_ies != null and sema.fn_ret_ty.zigTypeTag(mod) == .ErrorUnion) {
+    if (sema.fn_ret_ty_ies != null and sema.fn_ret_ty.zigTypeTag(zcu) == .ErrorUnion) {
         try sema.addToInferredErrorSet(uncasted_operand);
     }
     const operand = sema.coerceExtra(block, sema.fn_ret_ty, uncasted_operand, operand_src, .{ .is_ret = true }) catch |err| switch (err) {
 @@ -19903,7 +19901,7 @@ fn analyzeRet(
             });
             inlining.comptime_result = operand;
-            if (sema.fn_ret_ty.isError(mod) and ret_val.getErrorName(mod) != .none) {
+            if (sema.fn_ret_ty.isError(zcu) and ret_val.getErrorName(zcu) != .none) {
                 try sema.comptime_err_ret_trace.append(src);
             }
             return error.ComptimeReturn;
 @@ -19955,7 +19953,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].ptr_type;
     const extra = sema.code.extraData(Zir.Inst.PtrType, inst_data.payload_index);
     const elem_ty_src = block.src(.{ .node_offset_ptr_elem = extra.data.src_node });
 @@ -19968,7 +19966,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const elem_ty = blk: {
         const air_inst = try sema.resolveInst(extra.data.elem_type);
         const ty = sema.analyzeAsType(block, elem_ty_src, air_inst) catch |err| {
-            if (err == error.AnalysisFail and sema.err != null and sema.typeOf(air_inst).isSinglePointer(mod)) {
+            if (err == error.AnalysisFail and sema.err != null and sema.typeOf(air_inst).isSinglePointer(zcu)) {
                 try sema.errNote(elem_ty_src, sema.err.?, "use '.*' to dereference pointer", .{});
             }
             return err;
 @@ -19977,10 +19975,10 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         break :blk ty;
     };
-    if (elem_ty.zigTypeTag(mod) == .NoReturn)
+    if (elem_ty.zigTypeTag(zcu) == .NoReturn)
         return sema.fail(block, elem_ty_src, "pointer to noreturn not allowed", .{});
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     var extra_i = extra.end;
 @@ -20003,14 +20001,14 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         });
         // Check if this happens to be the lazy alignment of our element type, in
         // which case we can make this 0 without resolving it.
-        switch (mod.intern_pool.indexToKey(val.toIntern())) {
+        switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .int => |int| switch (int.storage) {
                 .lazy_align => |lazy_ty| if (lazy_ty == elem_ty.toIntern()) break :blk .none,
                 else => {},
             },
             else => {},
         }
-        const align_bytes = (try val.getUnsignedIntAdvanced(pt, .sema)).?;
+        const align_bytes = (try val.getUnsignedIntSema(pt)).?;
         break :blk try sema.validateAlignAllowZero(block, align_src, align_bytes);
     } else .none;
 @@ -20018,7 +20016,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
         extra_i += 1;
         break :blk try sema.resolveAddressSpace(block, addrspace_src, ref, .pointer);
-    } else if (elem_ty.zigTypeTag(mod) == .Fn and target.cpu.arch == .avr) .flash else .generic;
+    } else if (elem_ty.zigTypeTag(zcu) == .Fn and target.cpu.arch == .avr) .flash else .generic;
     const bit_offset: u16 = if (inst_data.flags.has_bit_range) blk: {
         const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
 @@ -20044,7 +20042,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
                 elem_ty.fmt(pt), bit_offset, bit_offset - host_size * 8, host_size,
             });
         }
-        const elem_bit_size = try elem_ty.bitSizeAdvanced(pt, .sema);
+        const elem_bit_size = try elem_ty.bitSizeSema(pt);
         if (elem_bit_size > host_size * 8 - bit_offset) {
             return sema.fail(block, bitoffset_src, "packed type '{}' at bit offset {} ends {} bits after the end of a {} byte host integer", .{
                 elem_ty.fmt(pt), bit_offset, elem_bit_size - (host_size * 8 - bit_offset), host_size,
 @@ -20052,11 +20050,11 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         }
     }
-    if (elem_ty.zigTypeTag(mod) == .Fn) {
+    if (elem_ty.zigTypeTag(zcu) == .Fn) {
         if (inst_data.size != .One) {
             return sema.fail(block, elem_ty_src, "function pointers must be single pointers", .{});
         }
-    } else if (inst_data.size == .Many and elem_ty.zigTypeTag(mod) == .Opaque) {
+    } else if (inst_data.size == .Many and elem_ty.zigTypeTag(zcu) == .Opaque) {
         return sema.fail(block, elem_ty_src, "unknown-length pointer to opaque not allowed", .{});
     } else if (inst_data.size == .C) {
         if (!try sema.validateExternType(elem_ty, .other)) {
 @@ -20071,7 +20069,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         }
-        if (elem_ty.zigTypeTag(mod) == .Opaque) {
+        if (elem_ty.zigTypeTag(zcu) == .Opaque) {
             return sema.fail(block, elem_ty_src, "C pointers cannot point to opaque types", .{});
         }
     }
 @@ -20113,9 +20111,9 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const ty_src = block.src(.{ .node_offset_init_ty = inst_data.src_node });
     const obj_ty = try sema.resolveType(block, ty_src, inst_data.operand);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (obj_ty.zigTypeTag(mod)) {
+    switch (obj_ty.zigTypeTag(zcu)) {
         .Struct => return sema.structInitEmpty(block, obj_ty, src, src),
         .Array, .Vector => return sema.arrayInitEmpty(block, src, obj_ty),
         .Void => return Air.internedToRef(Value.void.toIntern()),
 @@ -20129,7 +20127,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty_operand = sema.resolveType(block, src, inst_data.operand) catch |err| switch (err) {
 @@ -20138,21 +20136,21 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
         else => |e| return e,
     };
     const init_ty = if (is_byref) ty: {
-        const ptr_ty = ty_operand.optEuBaseType(mod);
+        const ptr_ty = ty_operand.optEuBaseType(zcu);
-        assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
+        assert(ptr_ty.zigTypeTag(zcu) == .Pointer); // validated by a previous instruction
-        if (!ptr_ty.isSlice(mod)) {
+        if (!ptr_ty.isSlice(zcu)) {
-            break :ty ptr_ty.childType(mod);
+            break :ty ptr_ty.childType(zcu);
         }
         // To make `&.{}` a `[:s]T`, the init should be a `[0:s]T`.
         break :ty try pt.arrayType(.{
             .len = 0,
-            .sentinel = if (ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+            .sentinel = if (ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
-            .child = ptr_ty.childType(mod).toIntern(),
+            .child = ptr_ty.childType(zcu).toIntern(),
         });
     } else ty_operand;
-    const obj_ty = init_ty.optEuBaseType(mod);
+    const obj_ty = init_ty.optEuBaseType(zcu);
-    const empty_ref = switch (obj_ty.zigTypeTag(mod)) {
+    const empty_ref = switch (obj_ty.zigTypeTag(zcu)) {
         .Struct => try sema.structInitEmpty(block, obj_ty, src, src),
         .Array, .Vector => try sema.arrayInitEmpty(block, src, obj_ty),
         .Union => return sema.fail(block, src, "union initializer must initialize one field", .{}),
 @@ -20176,13 +20174,13 @@ fn structInitEmpty(
     init_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     // This logic must be synchronized with that in `zirStructInit`.
     try struct_ty.resolveFields(pt);
     // The init values to use for the struct instance.
-    const field_inits = try gpa.alloc(Air.Inst.Ref, struct_ty.structFieldCount(mod));
+    const field_inits = try gpa.alloc(Air.Inst.Ref, struct_ty.structFieldCount(zcu));
     defer gpa.free(field_inits);
     @memset(field_inits, .none);
 @@ -20191,10 +20189,10 @@ fn structInitEmpty(
 fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const arr_len = obj_ty.arrayLen(mod);
+    const arr_len = obj_ty.arrayLen(zcu);
     if (arr_len != 0) {
-        if (obj_ty.zigTypeTag(mod) == .Array) {
+        if (obj_ty.zigTypeTag(zcu) == .Array) {
             return sema.fail(block, src, "expected {d} array elements; found 0", .{arr_len});
         } else {
             return sema.fail(block, src, "expected {d} vector elements; found 0", .{arr_len});
 @@ -20235,14 +20233,14 @@ fn unionInit(
     field_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
-    const field_ty = Type.fromInterned(mod.typeToUnion(union_ty).?.field_types.get(ip)[field_index]);
+    const field_ty = Type.fromInterned(zcu.typeToUnion(union_ty).?.field_types.get(ip)[field_index]);
     const init = try sema.coerce(block, field_ty, uncasted_init, init_src);
     if (try sema.resolveValue(init)) |init_val| {
-        const tag_ty = union_ty.unionTagTypeHypothetical(mod);
+        const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
         return Air.internedToRef((try pt.intern(.{ .un = .{
             .ty = union_ty.toIntern(),
 @@ -20269,8 +20267,8 @@ fn zirStructInit(
     const src = block.nodeOffset(inst_data.src_node);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const first_item = sema.code.extraData(Zir.Inst.StructInit.Item, extra.end).data;
     const first_field_type_data = zir_datas[@intFromEnum(first_item.field_type)].pl_node;
     const first_field_type_extra = sema.code.extraData(Zir.Inst.FieldType, first_field_type_data.payload_index).data;
 @@ -20281,26 +20279,26 @@ fn zirStructInit(
         },
         else => |e| return e,
     };
-    const resolved_ty = result_ty.optEuBaseType(mod);
+    const resolved_ty = result_ty.optEuBaseType(zcu);
     try resolved_ty.resolveLayout(pt);
-    if (resolved_ty.zigTypeTag(mod) == .Struct) {
+    if (resolved_ty.zigTypeTag(zcu) == .Struct) {
         // This logic must be synchronized with that in `zirStructInitEmpty`.
         // Maps field index to field_type index of where it was already initialized.
         // For making sure all fields are accounted for and no fields are duplicated.
-        const found_fields = try gpa.alloc(Zir.Inst.Index, resolved_ty.structFieldCount(mod));
+        const found_fields = try gpa.alloc(Zir.Inst.Index, resolved_ty.structFieldCount(zcu));
         defer gpa.free(found_fields);
         // The init values to use for the struct instance.
-        const field_inits = try gpa.alloc(Air.Inst.Ref, resolved_ty.structFieldCount(mod));
+        const field_inits = try gpa.alloc(Air.Inst.Ref, resolved_ty.structFieldCount(zcu));
         defer gpa.free(field_inits);
         @memset(field_inits, .none);
         var field_i: u32 = 0;
         var extra_index = extra.end;
-        const is_packed = resolved_ty.containerLayout(mod) == .@"packed";
+        const is_packed = resolved_ty.containerLayout(zcu) == .@"packed";
         while (field_i < extra.data.fields_len) : (field_i += 1) {
             const item = sema.code.extraData(Zir.Inst.StructInit.Item, extra_index);
             extra_index = item.end;
 @@ -20314,14 +20312,14 @@ fn zirStructInit(
                 sema.code.nullTerminatedString(field_type_extra.name_start),
                 .no_embedded_nulls,
             );
-            const field_index = if (resolved_ty.isTuple(mod))
+            const field_index = if (resolved_ty.isTuple(zcu))
                 try sema.tupleFieldIndex(block, resolved_ty, field_name, field_src)
             else
                 try sema.structFieldIndex(block, resolved_ty, field_name, field_src);
             assert(field_inits[field_index] == .none);
             found_fields[field_index] = item.data.field_type;
             const uncoerced_init = try sema.resolveInst(item.data.init);
-            const field_ty = resolved_ty.structFieldType(field_index, mod);
+            const field_ty = resolved_ty.fieldType(field_index, zcu);
             field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
             if (!is_packed) {
                 try resolved_ty.resolveStructFieldInits(pt);
 @@ -20332,7 +20330,7 @@ fn zirStructInit(
                         });
                     };
-                    if (!init_val.eql(default_value, resolved_ty.structFieldType(field_index, mod), mod)) {
+                    if (!init_val.eql(default_value, resolved_ty.fieldType(field_index, zcu), zcu)) {
                         return sema.failWithInvalidComptimeFieldStore(block, field_src, resolved_ty, field_index);
                     }
                 }
 @@ -20340,7 +20338,7 @@ fn zirStructInit(
         }
         return sema.finishStructInit(block, src, src, field_inits, resolved_ty, result_ty, is_ref);
-    } else if (resolved_ty.zigTypeTag(mod) == .Union) {
+    } else if (resolved_ty.zigTypeTag(zcu) == .Union) {
         if (extra.data.fields_len != 1) {
             return sema.fail(block, src, "union initialization expects exactly one field", .{});
         }
 @@ -20357,11 +20355,11 @@ fn zirStructInit(
             .no_embedded_nulls,
         );
         const field_index = try sema.unionFieldIndex(block, resolved_ty, field_name, field_src);
-        const tag_ty = resolved_ty.unionTagTypeHypothetical(mod);
+        const tag_ty = resolved_ty.unionTagTypeHypothetical(zcu);
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
-        const field_ty = Type.fromInterned(mod.typeToUnion(resolved_ty).?.field_types.get(ip)[field_index]);
+        const field_ty = Type.fromInterned(zcu.typeToUnion(resolved_ty).?.field_types.get(ip)[field_index]);
-        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+        if (field_ty.zigTypeTag(zcu) == .NoReturn) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "cannot initialize 'noreturn' field of union", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -20388,7 +20386,7 @@ fn zirStructInit(
             return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
         }
-        if (try sema.typeRequiresComptime(resolved_ty)) {
+        if (try resolved_ty.comptimeOnlySema(pt)) {
             return sema.failWithNeededComptime(block, field_src, .{
                 .needed_comptime_reason = "initializer of comptime only union must be comptime-known",
             });
 @@ -20397,7 +20395,7 @@ fn zirStructInit(
         try sema.validateRuntimeValue(block, field_src, init_inst);
         if (is_ref) {
-            const target = mod.getTarget();
+            const target = zcu.getTarget();
             const alloc_ty = try pt.ptrTypeSema(.{
                 .child = result_ty.toIntern(),
                 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
 @@ -20429,10 +20427,10 @@ fn finishStructInit(
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    var root_msg: ?*Module.ErrorMsg = null;
+    var root_msg: ?*Zcu.ErrorMsg = null;
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
     switch (ip.indexToKey(struct_ty.toIntern())) {
 @@ -20545,7 +20543,7 @@ fn finishStructInit(
         return sema.addConstantMaybeRef(final_val.toIntern(), is_ref);
     };
-    if (try sema.typeRequiresComptime(struct_ty)) {
+    if (try struct_ty.comptimeOnlySema(pt)) {
         return sema.failWithNeededComptime(block, block.src(.{ .init_elem = .{
             .init_node_offset = init_src.offset.node_offset.x,
             .elem_index = @intCast(runtime_index),
 @@ -20560,7 +20558,7 @@ fn finishStructInit(
     if (is_ref) {
         try struct_ty.resolveLayout(pt);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const alloc_ty = try pt.ptrTypeSema(.{
             .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
 @@ -20612,9 +20610,9 @@ fn structInitAnon(
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const zir_datas = sema.code.instructions.items(.data);
     const types = try sema.arena.alloc(InternPool.Index, extra_data.fields_len);
 @@ -20642,11 +20640,11 @@ fn structInitAnon(
                 },
             };
-            field_name.* = try mod.intern_pool.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
+            field_name.* = try zcu.intern_pool.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
             const init = try sema.resolveInst(item.data.init);
             field_ty.* = sema.typeOf(init).toIntern();
-            if (Type.fromInterned(field_ty.*).zigTypeTag(mod) == .Opaque) {
+            if (Type.fromInterned(field_ty.*).zigTypeTag(zcu) == .Opaque) {
                 const msg = msg: {
                     const field_src = block.src(.{ .init_elem = .{
                         .init_node_offset = src.offset.node_offset.x,
 @@ -20690,7 +20688,7 @@ fn structInitAnon(
     } }));
     if (is_ref) {
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const alloc_ty = try pt.ptrTypeSema(.{
             .child = tuple_ty,
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
 @@ -20740,7 +20738,7 @@ fn zirArrayInit(
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -20756,14 +20754,14 @@ fn zirArrayInit(
         },
         else => |e| return e,
     };
-    const array_ty = result_ty.optEuBaseType(mod);
+    const array_ty = result_ty.optEuBaseType(zcu);
-    const is_tuple = array_ty.zigTypeTag(mod) == .Struct;
+    const is_tuple = array_ty.zigTypeTag(zcu) == .Struct;
-    const sentinel_val = array_ty.sentinel(mod);
+    const sentinel_val = array_ty.sentinel(zcu);
-    var root_msg: ?*Module.ErrorMsg = null;
+    var root_msg: ?*Zcu.ErrorMsg = null;
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
-    const final_len = try sema.usizeCast(block, src, array_ty.arrayLenIncludingSentinel(mod));
+    const final_len = try sema.usizeCast(block, src, array_ty.arrayLenIncludingSentinel(zcu));
     const resolved_args = try gpa.alloc(Air.Inst.Ref, final_len);
     defer gpa.free(resolved_args);
     for (resolved_args, 0..) |*dest, i| {
 @@ -20773,7 +20771,7 @@ fn zirArrayInit(
         } });
         // Less inits than needed.
         if (i + 2 > args.len) if (is_tuple) {
-            const default_val = array_ty.structFieldDefaultValue(i, mod).toIntern();
+            const default_val = array_ty.structFieldDefaultValue(i, zcu).toIntern();
             if (default_val == .unreachable_value) {
                 const template = "missing tuple field with index {d}";
                 if (root_msg) |msg| {
 @@ -20793,12 +20791,12 @@ fn zirArrayInit(
         const arg = args[i + 1];
         const resolved_arg = try sema.resolveInst(arg);
         const elem_ty = if (is_tuple)
-            array_ty.structFieldType(i, mod)
+            array_ty.fieldType(i, zcu)
         else
-            array_ty.elemType2(mod);
+            array_ty.elemType2(zcu);
         dest.* = try sema.coerce(block, elem_ty, resolved_arg, elem_src);
         if (is_tuple) {
-            if (array_ty.structFieldIsComptime(i, mod))
+            if (array_ty.structFieldIsComptime(i, zcu))
                 try array_ty.resolveStructFieldInits(pt);
             if (try array_ty.structFieldValueComptime(pt, i)) |field_val| {
                 const init_val = try sema.resolveValue(dest.*) orelse {
 @@ -20806,7 +20804,7 @@ fn zirArrayInit(
                         .needed_comptime_reason = "value stored in comptime field must be comptime-known",
                     });
                 };
-                if (!field_val.eql(init_val, elem_ty, mod)) {
+                if (!field_val.eql(init_val, elem_ty, zcu)) {
                     return sema.failWithInvalidComptimeFieldStore(block, elem_src, array_ty, i);
                 }
             }
 @@ -20845,7 +20843,7 @@ fn zirArrayInit(
     } }));
     if (is_ref) {
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const alloc_ty = try pt.ptrTypeSema(.{
             .child = result_ty.toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
 @@ -20856,7 +20854,7 @@ fn zirArrayInit(
         if (is_tuple) {
             for (resolved_args, 0..) |arg, i| {
                 const elem_ptr_ty = try pt.ptrTypeSema(.{
-                    .child = array_ty.structFieldType(i, mod).toIntern(),
+                    .child = array_ty.fieldType(i, zcu).toIntern(),
                     .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
                 });
                 const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
 @@ -20869,7 +20867,7 @@ fn zirArrayInit(
         }
         const elem_ptr_ty = try pt.ptrTypeSema(.{
-            .child = array_ty.elemType2(mod).toIntern(),
+            .child = array_ty.elemType2(zcu).toIntern(),
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
 @@ -20906,9 +20904,9 @@ fn arrayInitAnon(
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const types = try sema.arena.alloc(InternPool.Index, operands.len);
     const values = try sema.arena.alloc(InternPool.Index, operands.len);
 @@ -20919,7 +20917,7 @@ fn arrayInitAnon(
             const operand_src = src; // TODO better source location
             const elem = try sema.resolveInst(operand);
             types[i] = sema.typeOf(elem).toIntern();
-            if (Type.fromInterned(types[i]).zigTypeTag(mod) == .Opaque) {
+            if (Type.fromInterned(types[i]).zigTypeTag(zcu) == .Opaque) {
                 const msg = msg: {
                     const msg = try sema.errMsg(operand_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
                     errdefer msg.destroy(gpa);
 @@ -21003,8 +21001,8 @@ fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data;
     const ty_src = block.nodeOffset(inst_data.src_node);
 @@ -21017,7 +21015,7 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp
         error.GenericPoison => return .generic_poison_type,
         else => |e| return e,
     };
-    const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(mod);
+    const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(zcu);
     const zir_field_name = sema.code.nullTerminatedString(extra.name_start);
     const field_name = try ip.getOrPutString(sema.gpa, pt.tid, zir_field_name, .no_embedded_nulls);
     return sema.fieldType(block, aggregate_ty, field_name, field_name_src, ty_src);
 @@ -21032,12 +21030,12 @@ fn fieldType(
     ty_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     var cur_ty = aggregate_ty;
     while (true) {
         try cur_ty.resolveFields(pt);
-        switch (cur_ty.zigTypeTag(mod)) {
+        switch (cur_ty.zigTypeTag(zcu)) {
             .Struct => switch (ip.indexToKey(cur_ty.toIntern())) {
                 .anon_struct_type => |anon_struct| {
                     const field_index = if (anon_struct.names.len == 0)
 @@ -21056,7 +21054,7 @@ fn fieldType(
                 else => unreachable,
             },
             .Union => {
-                const union_obj = mod.typeToUnion(cur_ty).?;
+                const union_obj = zcu.typeToUnion(cur_ty).?;
                 const field_index = union_obj.loadTagType(ip).nameIndex(ip, field_name) orelse
                     return sema.failWithBadUnionFieldAccess(block, cur_ty, union_obj, field_src, field_name);
                 const field_ty = union_obj.field_types.get(ip)[field_index];
 @@ -21069,7 +21067,7 @@ fn fieldType(
                 continue;
             },
             .ErrorUnion => {
-                cur_ty = cur_ty.errorUnionPayload(mod);
+                cur_ty = cur_ty.errorUnionPayload(zcu);
                 continue;
             },
             else => {},
 @@ -21086,8 +21084,8 @@ fn zirErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
 fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const stack_trace_ty = try pt.getBuiltinType("StackTrace");
     try stack_trace_ty.resolveFields(pt);
     const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
 @@ -21115,42 +21113,42 @@ fn zirFrame(
 }
 fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    const pt = sema.pt;
+    const zcu = sema.pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const ty = try sema.resolveType(block, operand_src, inst_data.operand);
-    if (ty.isNoReturn(pt.zcu)) {
+    if (ty.isNoReturn(zcu)) {
-        return sema.fail(block, operand_src, "no align available for type '{}'", .{ty.fmt(pt)});
+        return sema.fail(block, operand_src, "no align available for type '{}'", .{ty.fmt(sema.pt)});
     }
-    const val = try ty.lazyAbiAlignment(pt);
+    const val = try ty.lazyAbiAlignment(sema.pt);
     return Air.internedToRef(val.toIntern());
 }
 fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    const is_vector = operand_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = operand_ty.zigTypeTag(zcu) == .Vector;
-    const operand_scalar_ty = operand_ty.scalarType(mod);
+    const operand_scalar_ty = operand_ty.scalarType(zcu);
     if (operand_scalar_ty.toIntern() != .bool_type) {
-        return sema.fail(block, src, "expected 'bool', found '{}'", .{operand_scalar_ty.zigTypeTag(mod)});
+        return sema.fail(block, src, "expected 'bool', found '{}'", .{operand_scalar_ty.zigTypeTag(zcu)});
     }
     if (try sema.resolveValue(operand)) |val| {
         if (!is_vector) {
-            if (val.isUndef(mod)) return pt.undefRef(Type.u1);
+            if (val.isUndef(zcu)) return pt.undefRef(Type.u1);
             if (val.toBool()) return Air.internedToRef((try pt.intValue(Type.u1, 1)).toIntern());
             return Air.internedToRef((try pt.intValue(Type.u1, 0)).toIntern());
         }
-        const len = operand_ty.vectorLen(mod);
+        const len = operand_ty.vectorLen(zcu);
         const dest_ty = try pt.vectorType(.{ .child = .u1_type, .len = len });
-        if (val.isUndef(mod)) return pt.undefRef(dest_ty);
+        if (val.isUndef(zcu)) return pt.undefRef(dest_ty);
         const new_elems = try sema.arena.alloc(InternPool.Index, len);
         for (new_elems, 0..) |*new_elem, i| {
             const old_elem = try val.elemValue(pt, i);
-            const new_val = if (old_elem.isUndef(mod))
+            const new_val = if (old_elem.isUndef(zcu))
                 try pt.undefValue(Type.u1)
             else if (old_elem.toBool())
                 try pt.intValue(Type.u1, 1)
 @@ -21166,7 +21164,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     if (!is_vector) {
         return block.addUnOp(.int_from_bool, operand);
     }
-    const len = operand_ty.vectorLen(mod);
+    const len = operand_ty.vectorLen(zcu);
     const dest_ty = try pt.vectorType(.{ .child = .u1_type, .len = len });
     const new_elems = try sema.arena.alloc(Air.Inst.Ref, len);
     for (new_elems, 0..) |*new_elem, i| {
 @@ -21199,16 +21197,16 @@ fn zirAbs(
     inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_ty = sema.typeOf(operand);
-    const scalar_ty = operand_ty.scalarType(mod);
+    const scalar_ty = operand_ty.scalarType(zcu);
-    const result_ty = switch (scalar_ty.zigTypeTag(mod)) {
+    const result_ty = switch (scalar_ty.zigTypeTag(zcu)) {
         .ComptimeFloat, .Float, .ComptimeInt => operand_ty,
-        .Int => if (scalar_ty.isSignedInt(mod)) try operand_ty.toUnsigned(pt) else return operand,
+        .Int => if (scalar_ty.isSignedInt(zcu)) try operand_ty.toUnsigned(pt) else return operand,
         else => return sema.fail(
             block,
             operand_src,
 @@ -21230,12 +21228,12 @@ fn maybeConstantUnaryMath(
     comptime eval: fn (Value, Type, Allocator, Zcu.PerThread) Allocator.Error!Value,
 ) CompileError!?Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (result_ty.zigTypeTag(mod)) {
+    switch (result_ty.zigTypeTag(zcu)) {
         .Vector => if (try sema.resolveValue(operand)) |val| {
-            const scalar_ty = result_ty.scalarType(mod);
+            const scalar_ty = result_ty.scalarType(zcu);
-            const vec_len = result_ty.vectorLen(mod);
+            const vec_len = result_ty.vectorLen(zcu);
-            if (val.isUndef(mod))
+            if (val.isUndef(zcu))
                 return try pt.undefRef(result_ty);
             const elems = try sema.arena.alloc(InternPool.Index, vec_len);
 @@ -21249,7 +21247,7 @@ fn maybeConstantUnaryMath(
             } })));
         },
         else => if (try sema.resolveValue(operand)) |operand_val| {
-            if (operand_val.isUndef(mod))
+            if (operand_val.isUndef(zcu))
                 return try pt.undefRef(result_ty);
             const result_val = try eval(operand_val, result_ty, sema.arena, pt);
             return Air.internedToRef(result_val.toIntern());
 @@ -21269,14 +21267,14 @@ fn zirUnaryMath(
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand_ty = sema.typeOf(operand);
-    const scalar_ty = operand_ty.scalarType(mod);
+    const scalar_ty = operand_ty.scalarType(zcu);
-    switch (scalar_ty.zigTypeTag(mod)) {
+    switch (scalar_ty.zigTypeTag(zcu)) {
         .ComptimeFloat, .Float => {},
         else => return sema.fail(
             block,
 @@ -21359,9 +21357,9 @@ fn zirReify(
     inst: Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small);
     const extra = sema.code.extraData(Zir.Inst.Reify, extended.operand).data;
     const tracked_inst = try block.trackZir(inst);
 @@ -21388,7 +21386,7 @@ fn zirReify(
     if (try sema.anyUndef(block, operand_src, Value.fromInterned(union_val.val))) {
         return sema.failWithUseOfUndef(block, operand_src);
     }
-    const tag_index = type_info_ty.unionTagFieldIndex(Value.fromInterned(union_val.tag), mod).?;
+    const tag_index = type_info_ty.unionTagFieldIndex(Value.fromInterned(union_val.tag), zcu).?;
     switch (@as(std.builtin.TypeId, @enumFromInt(tag_index))) {
         .Type => return .type_type,
         .Void => return .void_type,
 @@ -21411,7 +21409,7 @@ fn zirReify(
                 struct_type.nameIndex(ip, try ip.getOrPutString(gpa, pt.tid, "bits", .no_embedded_nulls)).?,
             );
-            const signedness = mod.toEnum(std.builtin.Signedness, signedness_val);
+            const signedness = zcu.toEnum(std.builtin.Signedness, signedness_val);
             const bits: u16 = @intCast(try bits_val.toUnsignedIntSema(pt));
             const ty = try pt.intType(signedness, bits);
             return Air.internedToRef(ty.toIntern());
 @@ -21495,7 +21493,7 @@ fn zirReify(
                 return sema.fail(block, src, "alignment must fit in 'u32'", .{});
             }
-            const alignment_val_int = (try alignment_val.getUnsignedIntAdvanced(pt, .sema)).?;
+            const alignment_val_int = try alignment_val.toUnsignedIntSema(pt);
             if (alignment_val_int > 0 and !math.isPowerOfTwo(alignment_val_int)) {
                 return sema.fail(block, src, "alignment value '{d}' is not a power of two or zero", .{alignment_val_int});
             }
 @@ -21506,14 +21504,14 @@ fn zirReify(
                 try elem_ty.resolveLayout(pt);
             }
-            const ptr_size = mod.toEnum(std.builtin.Type.Pointer.Size, size_val);
+            const ptr_size = zcu.toEnum(std.builtin.Type.Pointer.Size, size_val);
             const actual_sentinel: InternPool.Index = s: {
-                if (!sentinel_val.isNull(mod)) {
+                if (!sentinel_val.isNull(zcu)) {
                     if (ptr_size == .One or ptr_size == .C) {
                         return sema.fail(block, src, "sentinels are only allowed on slices and unknown-length pointers", .{});
                     }
-                    const sentinel_ptr_val = sentinel_val.optionalValue(mod).?;
+                    const sentinel_ptr_val = sentinel_val.optionalValue(zcu).?;
                     const ptr_ty = try pt.singleMutPtrType(elem_ty);
                     const sent_val = (try sema.pointerDeref(block, src, sentinel_ptr_val, ptr_ty)).?;
                     break :s sent_val.toIntern();
 @@ -21521,13 +21519,13 @@ fn zirReify(
                 break :s .none;
             };
-            if (elem_ty.zigTypeTag(mod) == .NoReturn) {
+            if (elem_ty.zigTypeTag(zcu) == .NoReturn) {
                 return sema.fail(block, src, "pointer to noreturn not allowed", .{});
-            } else if (elem_ty.zigTypeTag(mod) == .Fn) {
+            } else if (elem_ty.zigTypeTag(zcu) == .Fn) {
                 if (ptr_size != .One) {
                     return sema.fail(block, src, "function pointers must be single pointers", .{});
                 }
-            } else if (ptr_size == .Many and elem_ty.zigTypeTag(mod) == .Opaque) {
+            } else if (ptr_size == .Many and elem_ty.zigTypeTag(zcu) == .Opaque) {
                 return sema.fail(block, src, "unknown-length pointer to opaque not allowed", .{});
             } else if (ptr_size == .C) {
                 if (!try sema.validateExternType(elem_ty, .other)) {
 @@ -21542,7 +21540,7 @@ fn zirReify(
                     };
                     return sema.failWithOwnedErrorMsg(block, msg);
                 }
-                if (elem_ty.zigTypeTag(mod) == .Opaque) {
+                if (elem_ty.zigTypeTag(zcu) == .Opaque) {
                     return sema.fail(block, src, "C pointers cannot point to opaque types", .{});
                 }
             }
 @@ -21555,7 +21553,7 @@ fn zirReify(
                     .is_const = is_const_val.toBool(),
                     .is_volatile = is_volatile_val.toBool(),
                     .alignment = abi_align,
-                    .address_space = mod.toEnum(std.builtin.AddressSpace, address_space_val),
+                    .address_space = zcu.toEnum(std.builtin.AddressSpace, address_space_val),
                     .is_allowzero = is_allowzero_val.toBool(),
                 },
             });
 @@ -21578,7 +21576,7 @@ fn zirReify(
             const len = try len_val.toUnsignedIntSema(pt);
             const child_ty = child_val.toType();
-            const sentinel = if (sentinel_val.optionalValue(mod)) |p| blk: {
+            const sentinel = if (sentinel_val.optionalValue(zcu)) |p| blk: {
                 const ptr_ty = try pt.singleMutPtrType(child_ty);
                 break :blk (try sema.pointerDeref(block, src, p, ptr_ty)).?;
             } else null;
 @@ -21616,7 +21614,7 @@ fn zirReify(
             const error_set_ty = error_set_val.toType();
             const payload_ty = payload_val.toType();
-            if (error_set_ty.zigTypeTag(mod) != .ErrorSet) {
+            if (error_set_ty.zigTypeTag(zcu) != .ErrorSet) {
                 return sema.fail(block, src, "Type.ErrorUnion.error_set must be an error set type", .{});
             }
 @@ -21624,14 +21622,14 @@ fn zirReify(
             return Air.internedToRef(ty.toIntern());
         },
         .ErrorSet => {
-            const payload_val = Value.fromInterned(union_val.val).optionalValue(mod) orelse
+            const payload_val = Value.fromInterned(union_val.val).optionalValue(zcu) orelse
                 return Air.internedToRef(Type.anyerror.toIntern());
             const names_val = try sema.derefSliceAsArray(block, src, payload_val, .{
                 .needed_comptime_reason = "error set contents must be comptime-known",
             });
-            const len = try sema.usizeCast(block, src, names_val.typeOf(mod).arrayLen(mod));
+            const len = try sema.usizeCast(block, src, names_val.typeOf(zcu).arrayLen(zcu));
             var names: InferredErrorSet.NameMap = .{};
             try names.ensureUnusedCapacity(sema.arena, len);
             for (0..len) |i| {
 @@ -21680,14 +21678,14 @@ fn zirReify(
                 try ip.getOrPutString(gpa, pt.tid, "is_tuple", .no_embedded_nulls),
             ).?);
-            const layout = mod.toEnum(std.builtin.Type.ContainerLayout, layout_val);
+            const layout = zcu.toEnum(std.builtin.Type.ContainerLayout, layout_val);
             // Decls
             if (try decls_val.sliceLen(pt) > 0) {
                 return sema.fail(block, src, "reified structs must have no decls", .{});
             }
-            if (layout != .@"packed" and !backing_integer_val.isNull(mod)) {
+            if (layout != .@"packed" and !backing_integer_val.isNull(zcu)) {
                 return sema.fail(block, src, "non-packed struct does not support backing integer type", .{});
             }
 @@ -21762,8 +21760,8 @@ fn zirReify(
             const new_namespace_index = try pt.createNamespace(.{
                 .parent = block.namespace.toOptional(),
                 .owner_type = wip_ty.index,
-                .file_scope = block.getFileScopeIndex(mod),
+                .file_scope = block.getFileScopeIndex(zcu),
-                .generation = mod.generation,
+                .generation = zcu.generation,
             });
             try sema.addTypeReferenceEntry(src, wip_ty.index);
 @@ -21791,7 +21789,7 @@ fn zirReify(
             if (try decls_val.sliceLen(pt) > 0) {
                 return sema.fail(block, src, "reified unions must have no decls", .{});
             }
-            const layout = mod.toEnum(std.builtin.Type.ContainerLayout, layout_val);
+            const layout = zcu.toEnum(std.builtin.Type.ContainerLayout, layout_val);
             const fields_arr = try sema.derefSliceAsArray(block, operand_src, fields_val, .{
                 .needed_comptime_reason = "union fields must be comptime-known",
 @@ -21828,19 +21826,19 @@ fn zirReify(
             }
             const is_var_args = is_var_args_val.toBool();
-            const cc = mod.toEnum(std.builtin.CallingConvention, calling_convention_val);
+            const cc = zcu.toEnum(std.builtin.CallingConvention, calling_convention_val);
             if (is_var_args) {
                 try sema.checkCallConvSupportsVarArgs(block, src, cc);
             }
-            const return_type = return_type_val.optionalValue(mod) orelse
+            const return_type = return_type_val.optionalValue(zcu) orelse
                 return sema.fail(block, src, "Type.Fn.return_type must be non-null for @Type", .{});
             const params_val = try sema.derefSliceAsArray(block, operand_src, params_slice_val, .{
                 .needed_comptime_reason = "function parameters must be comptime-known",
             });
-            const args_len = try sema.usizeCast(block, src, params_val.typeOf(mod).arrayLen(mod));
+            const args_len = try sema.usizeCast(block, src, params_val.typeOf(zcu).arrayLen(zcu));
             const param_types = try sema.arena.alloc(InternPool.Index, args_len);
             var noalias_bits: u32 = 0;
 @@ -21864,12 +21862,12 @@ fn zirReify(
                     return sema.fail(block, src, "Type.Fn.Param.is_generic must be false for @Type", .{});
                 }
-                const param_type_val = opt_param_type_val.optionalValue(mod) orelse
+                const param_type_val = opt_param_type_val.optionalValue(zcu) orelse
                     return sema.fail(block, src, "Type.Fn.Param.type must be non-null for @Type", .{});
                 param_type.* = param_type_val.toIntern();
                 if (param_is_noalias_val.toBool()) {
-                    if (!Type.fromInterned(param_type.*).isPtrAtRuntime(mod)) {
+                    if (!Type.fromInterned(param_type.*).isPtrAtRuntime(zcu)) {
                         return sema.fail(block, src, "non-pointer parameter declared noalias", .{});
                     }
                     noalias_bits |= @as(u32, 1) << (std.math.cast(u5, i) orelse
 @@ -21901,13 +21899,13 @@ fn reifyEnum(
     name_strategy: Zir.Inst.NameStrategy,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     // This logic must stay in sync with the structure of `std.builtin.Type.Enum` - search for `fieldValue`.
-    const fields_len: u32 = @intCast(fields_val.typeOf(mod).arrayLen(mod));
+    const fields_len: u32 = @intCast(fields_val.typeOf(zcu).arrayLen(zcu));
     // The validation work here is non-trivial, and it's possible the type already exists.
     // So in this first pass, let's just construct a hash to optimize for this case. If the
 @@ -21957,7 +21955,7 @@ fn reifyEnum(
     var done = false;
     errdefer if (!done) wip_ty.cancel(ip, pt.tid);
-    if (tag_ty.zigTypeTag(mod) != .Int) {
+    if (tag_ty.zigTypeTag(zcu) != .Int) {
         return sema.fail(block, src, "Type.Enum.tag_type must be an integer type", .{});
     }
 @@ -21972,8 +21970,8 @@ fn reifyEnum(
     const new_namespace_index = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
 @@ -22023,14 +22021,14 @@ fn reifyEnum(
         }
     }
-    if (!is_exhaustive and fields_len > 1 and std.math.log2_int(u64, fields_len) == tag_ty.bitSize(pt)) {
+    if (!is_exhaustive and fields_len > 1 and std.math.log2_int(u64, fields_len) == tag_ty.bitSize(zcu)) {
         return sema.fail(block, src, "non-exhaustive enum specified every value", .{});
     }
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     return Air.internedToRef(wip_ty.index);
 }
 @@ -22046,13 +22044,13 @@ fn reifyUnion(
     name_strategy: Zir.Inst.NameStrategy,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     // This logic must stay in sync with the structure of `std.builtin.Type.Union` - search for `fieldValue`.
-    const fields_len: u32 = @intCast(fields_val.typeOf(mod).arrayLen(mod));
+    const fields_len: u32 = @intCast(fields_val.typeOf(zcu).arrayLen(zcu));
     // The validation work here is non-trivial, and it's possible the type already exists.
     // So in this first pass, let's just construct a hash to optimize for this case. If the
 @@ -22084,7 +22082,7 @@ fn reifyUnion(
             field_align_val.toIntern(),
         });
-        if (field_align_val.toUnsignedInt(pt) != 0) {
+        if (field_align_val.toUnsignedInt(zcu) != 0) {
             any_aligns = true;
         }
     }
 @@ -22095,7 +22093,7 @@ fn reifyUnion(
         .flags = .{
             .layout = layout,
             .status = .none,
-            .runtime_tag = if (opt_tag_type_val.optionalValue(mod) != null)
+            .runtime_tag = if (opt_tag_type_val.optionalValue(zcu) != null)
                 .tagged
             else if (layout != .auto)
                 .none
 @@ -22139,7 +22137,7 @@ fn reifyUnion(
     const field_types = try sema.arena.alloc(InternPool.Index, fields_len);
     const field_aligns = if (any_aligns) try sema.arena.alloc(InternPool.Alignment, fields_len) else undefined;
-    const enum_tag_ty, const has_explicit_tag = if (opt_tag_type_val.optionalValue(mod)) |tag_type_val| tag_ty: {
+    const enum_tag_ty, const has_explicit_tag = if (opt_tag_type_val.optionalValue(zcu)) |tag_type_val| tag_ty: {
         switch (ip.indexToKey(tag_type_val.toIntern())) {
             .enum_type => {},
             else => return sema.fail(block, src, "Type.Union.tag_type must be an enum type", .{}),
 @@ -22147,7 +22145,7 @@ fn reifyUnion(
         const enum_tag_ty = tag_type_val.toType();
         // We simply track which fields of the tag type have been seen.
-        const tag_ty_fields_len = enum_tag_ty.enumFieldCount(mod);
+        const tag_ty_fields_len = enum_tag_ty.enumFieldCount(zcu);
         var seen_tags = try std.DynamicBitSetUnmanaged.initEmpty(sema.arena, tag_ty_fields_len);
         for (field_types, 0..) |*field_ty, field_idx| {
 @@ -22159,7 +22157,7 @@ fn reifyUnion(
             // Don't pass a reason; first loop acts as an assertion that this is valid.
             const field_name = try sema.sliceToIpString(block, src, field_name_val, undefined);
-            const enum_index = enum_tag_ty.enumFieldIndex(field_name, mod) orelse {
+            const enum_index = enum_tag_ty.enumFieldIndex(field_name, zcu) orelse {
                 // TODO: better source location
                 return sema.fail(block, src, "no field named '{}' in enum '{}'", .{
                     field_name.fmt(ip), enum_tag_ty.fmt(pt),
 @@ -22187,7 +22185,7 @@ fn reifyUnion(
             errdefer msg.destroy(gpa);
             var it = seen_tags.iterator(.{ .kind = .unset });
             while (it.next()) |enum_index| {
-                const field_name = enum_tag_ty.enumFieldName(enum_index, mod);
+                const field_name = enum_tag_ty.enumFieldName(enum_index, zcu);
                 try sema.addFieldErrNote(enum_tag_ty, enum_index, msg, "field '{}' missing, declared here", .{
                     field_name.fmt(ip),
                 });
 @@ -22234,7 +22232,7 @@ fn reifyUnion(
     for (field_types) |field_ty_ip| {
         const field_ty = Type.fromInterned(field_ty_ip);
-        if (field_ty.zigTypeTag(mod) == .Opaque) {
+        if (field_ty.zigTypeTag(zcu) == .Opaque) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
                 errdefer msg.destroy(gpa);
 @@ -22277,17 +22275,17 @@ fn reifyUnion(
     const new_namespace_index = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
-    try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
+    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
     try sema.addTypeReferenceEntry(src, wip_ty.index);
 @@ -22306,13 +22304,13 @@ fn reifyStruct(
     is_tuple: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     // This logic must stay in sync with the structure of `std.builtin.Type.Struct` - search for `fieldValue`.
-    const fields_len: u32 = @intCast(fields_val.typeOf(mod).arrayLen(mod));
+    const fields_len: u32 = @intCast(fields_val.typeOf(zcu).arrayLen(zcu));
     // The validation work here is non-trivial, and it's possible the type already exists.
     // So in this first pass, let's just construct a hash to optimize for this case. If the
 @@ -22343,7 +22341,7 @@ fn reifyStruct(
             .needed_comptime_reason = "struct field name must be comptime-known",
         });
         const field_is_comptime = field_is_comptime_val.toBool();
-        const field_default_value: InternPool.Index = if (field_default_value_val.optionalValue(mod)) |ptr_val| d: {
+        const field_default_value: InternPool.Index = if (field_default_value_val.optionalValue(zcu)) |ptr_val| d: {
             const ptr_ty = try pt.singleConstPtrType(field_type_val.toType());
             // We need to do this deref here, so we won't check for this error case later on.
             const val = try sema.pointerDeref(block, src, ptr_val, ptr_ty) orelse return sema.failWithNeededComptime(
 @@ -22365,7 +22363,7 @@ fn reifyStruct(
         if (field_is_comptime) any_comptime_fields = true;
         if (field_default_value != .none) any_default_inits = true;
-        switch (try field_alignment_val.orderAgainstZeroAdvanced(pt, .sema)) {
+        switch (try field_alignment_val.orderAgainstZeroSema(pt)) {
             .eq => {},
             .gt => any_aligned_fields = true,
             .lt => unreachable,
 @@ -22475,7 +22473,7 @@ fn reifyStruct(
         const field_default: InternPool.Index = d: {
             if (!any_default_inits) break :d .none;
-            const ptr_val = field_default_value_val.optionalValue(mod) orelse break :d .none;
+            const ptr_val = field_default_value_val.optionalValue(zcu) orelse break :d .none;
             const ptr_ty = try pt.singleConstPtrType(field_ty);
             // Asserted comptime-dereferencable above.
             const val = (try sema.pointerDeref(block, src, ptr_val, ptr_ty)).?;
 @@ -22492,7 +22490,7 @@ fn reifyStruct(
             struct_type.field_inits.get(ip)[field_idx] = field_default;
         }
-        if (field_ty.zigTypeTag(mod) == .Opaque) {
+        if (field_ty.zigTypeTag(zcu) == .Opaque) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
                 errdefer msg.destroy(gpa);
 @@ -22501,7 +22499,7 @@ fn reifyStruct(
                 break :msg msg;
             });
         }
-        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+        if (field_ty.zigTypeTag(zcu) == .NoReturn) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "struct fields cannot be 'noreturn'", .{});
                 errdefer msg.destroy(gpa);
 @@ -22545,10 +22543,10 @@ fn reifyStruct(
                 },
                 else => return err,
             };
-            fields_bit_sum += field_ty.bitSize(pt);
+            fields_bit_sum += field_ty.bitSize(zcu);
         }
-        if (opt_backing_int_val.optionalValue(mod)) |backing_int_val| {
+        if (opt_backing_int_val.optionalValue(zcu)) |backing_int_val| {
             const backing_int_ty = backing_int_val.toType();
             try sema.checkBackingIntType(block, src, backing_int_ty, fields_bit_sum);
             struct_type.setBackingIntType(ip, backing_int_ty.toIntern());
 @@ -22561,17 +22559,17 @@ fn reifyStruct(
     const new_namespace_index = try pt.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .owner_type = wip_ty.index,
-        .file_scope = block.getFileScopeIndex(mod),
+        .file_scope = block.getFileScopeIndex(zcu),
-        .generation = mod.generation,
+        .generation = zcu.generation,
     });
     const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
-    try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
+    try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (mod.comp.config.use_llvm) break :codegen_type;
+        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (block.ownerModule().strip) break :codegen_type;
-        try mod.comp.queueJob(.{ .codegen_type = wip_ty.index });
+        try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
     try sema.addTypeReferenceEntry(src, wip_ty.index);
 @@ -22649,8 +22647,8 @@ fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData)
 fn zirTypeName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0);
 @@ -22674,7 +22672,7 @@ fn zirFrameSize(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
 fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 @@ -22684,10 +22682,10 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const operand_ty = sema.typeOf(operand);
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, src, operand_src);
-    const is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
-    const dest_scalar_ty = dest_ty.scalarType(mod);
+    const dest_scalar_ty = dest_ty.scalarType(zcu);
-    const operand_scalar_ty = operand_ty.scalarType(mod);
+    const operand_scalar_ty = operand_ty.scalarType(zcu);
     _ = try sema.checkIntType(block, src, dest_scalar_ty);
     try sema.checkFloatType(block, operand_src, operand_scalar_ty);
 @@ -22695,14 +22693,14 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     if (try sema.resolveValue(operand)) |operand_val| {
         const result_val = try sema.intFromFloat(block, operand_src, operand_val, operand_ty, dest_ty, .truncate);
         return Air.internedToRef(result_val.toIntern());
-    } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
+    } else if (dest_scalar_ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.failWithNeededComptime(block, operand_src, .{
             .needed_comptime_reason = "value being casted to 'comptime_int' must be comptime-known",
         });
     }
     try sema.requireRuntimeBlock(block, src, operand_src);
-    if (dest_scalar_ty.intInfo(mod).bits == 0) {
+    if (dest_scalar_ty.intInfo(zcu).bits == 0) {
         if (!is_vector) {
             if (block.wantSafety()) {
                 const ok = try block.addBinOp(if (block.float_mode == .optimized) .cmp_eq_optimized else .cmp_eq, operand, Air.internedToRef((try pt.floatValue(operand_ty, 0.0)).toIntern()));
 @@ -22711,7 +22709,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
             return Air.internedToRef((try pt.intValue(dest_ty, 0)).toIntern());
         }
         if (block.wantSafety()) {
-            const len = dest_ty.vectorLen(mod);
+            const len = dest_ty.vectorLen(zcu);
             for (0..len) |i| {
                 const idx_ref = try pt.intRef(Type.usize, i);
                 const elem_ref = try block.addBinOp(.array_elem_val, operand, idx_ref);
 @@ -22736,7 +22734,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
         }
         return result;
     }
-    const len = dest_ty.vectorLen(mod);
+    const len = dest_ty.vectorLen(zcu);
     const new_elems = try sema.arena.alloc(Air.Inst.Ref, len);
     for (new_elems, 0..) |*new_elem, i| {
         const idx_ref = try pt.intRef(Type.usize, i);
 @@ -22757,7 +22755,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
 @@ -22767,10 +22765,10 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     const operand_ty = sema.typeOf(operand);
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, operand_ty, src, operand_src);
-    const is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
-    const dest_scalar_ty = dest_ty.scalarType(mod);
+    const dest_scalar_ty = dest_ty.scalarType(zcu);
-    const operand_scalar_ty = operand_ty.scalarType(mod);
+    const operand_scalar_ty = operand_ty.scalarType(zcu);
     try sema.checkFloatType(block, src, dest_scalar_ty);
     _ = try sema.checkIntType(block, operand_src, operand_scalar_ty);
 @@ -22778,7 +22776,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     if (try sema.resolveValue(operand)) |operand_val| {
         const result_val = try operand_val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, pt, .sema);
         return Air.internedToRef(result_val.toIntern());
-    } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeFloat) {
+    } else if (dest_scalar_ty.zigTypeTag(zcu) == .ComptimeFloat) {
         return sema.failWithNeededComptime(block, operand_src, .{
             .needed_comptime_reason = "value being casted to 'comptime_float' must be comptime-known",
         });
 @@ -22788,7 +22786,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     if (!is_vector) {
         return block.addTyOp(.float_from_int, dest_ty, operand);
     }
-    const len = operand_ty.vectorLen(mod);
+    const len = operand_ty.vectorLen(zcu);
     const new_elems = try sema.arena.alloc(Air.Inst.Ref, len);
     for (new_elems, 0..) |*new_elem, i| {
         const idx_ref = try pt.intRef(Type.usize, i);
 @@ -22800,7 +22798,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -22813,21 +22811,21 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu, "@ptrFromInt");
     try sema.checkVectorizableBinaryOperands(block, operand_src, dest_ty, uncoerced_operand_ty, src, operand_src);
-    const is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
     const operand_ty = if (is_vector) operand_ty: {
-        const len = dest_ty.vectorLen(mod);
+        const len = dest_ty.vectorLen(zcu);
         break :operand_ty try pt.vectorType(.{ .child = .usize_type, .len = len });
     } else Type.usize;
     const operand_coerced = try sema.coerce(block, operand_ty, operand_res, operand_src);
-    const ptr_ty = dest_ty.scalarType(mod);
+    const ptr_ty = dest_ty.scalarType(zcu);
     try sema.checkPtrType(block, src, ptr_ty, true);
-    const elem_ty = ptr_ty.elemType2(mod);
+    const elem_ty = ptr_ty.elemType2(zcu);
-    const ptr_align = try ptr_ty.ptrAlignmentAdvanced(pt, .sema);
+    const ptr_align = try ptr_ty.ptrAlignmentSema(pt);
-    if (ptr_ty.isSlice(mod)) {
+    if (ptr_ty.isSlice(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(src, "integer cannot be converted to slice type '{}'", .{ptr_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -22842,7 +22840,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
             const ptr_val = try sema.ptrFromIntVal(block, operand_src, val, ptr_ty, ptr_align);
             return Air.internedToRef(ptr_val.toIntern());
         }
-        const len = dest_ty.vectorLen(mod);
+        const len = dest_ty.vectorLen(zcu);
         const new_elems = try sema.arena.alloc(InternPool.Index, len);
         for (new_elems, 0..) |*new_elem, i| {
             const elem = try val.elemValue(pt, i);
 @@ -22854,7 +22852,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
             .storage = .{ .elems = new_elems },
         } }));
     }
-    if (try sema.typeRequiresComptime(ptr_ty)) {
+    if (try ptr_ty.comptimeOnlySema(pt)) {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "pointer to comptime-only type '{}' must be comptime-known, but operand is runtime-known", .{ptr_ty.fmt(pt)});
             errdefer msg.destroy(sema.gpa);
 @@ -22865,8 +22863,8 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     }
     try sema.requireRuntimeBlock(block, src, operand_src);
     if (!is_vector) {
-        if (block.wantSafety() and (try sema.typeHasRuntimeBits(elem_ty) or elem_ty.zigTypeTag(mod) == .Fn)) {
+        if (block.wantSafety() and (try elem_ty.hasRuntimeBitsSema(pt) or elem_ty.zigTypeTag(zcu) == .Fn)) {
-            if (!ptr_ty.isAllowzeroPtr(mod)) {
+            if (!ptr_ty.isAllowzeroPtr(zcu)) {
                 const is_non_zero = try block.addBinOp(.cmp_neq, operand_coerced, .zero_usize);
                 try sema.addSafetyCheck(block, src, is_non_zero, .cast_to_null);
             }
 @@ -22881,12 +22879,12 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         return block.addBitCast(dest_ty, operand_coerced);
     }
-    const len = dest_ty.vectorLen(mod);
+    const len = dest_ty.vectorLen(zcu);
-    if (block.wantSafety() and (try sema.typeHasRuntimeBits(elem_ty) or elem_ty.zigTypeTag(mod) == .Fn)) {
+    if (block.wantSafety() and (try elem_ty.hasRuntimeBitsSema(pt) or elem_ty.zigTypeTag(zcu) == .Fn)) {
         for (0..len) |i| {
             const idx_ref = try pt.intRef(Type.usize, i);
             const elem_coerced = try block.addBinOp(.array_elem_val, operand_coerced, idx_ref);
-            if (!ptr_ty.isAllowzeroPtr(mod)) {
+            if (!ptr_ty.isAllowzeroPtr(zcu)) {
                 const is_non_zero = try block.addBinOp(.cmp_neq, elem_coerced, .zero_usize);
                 try sema.addSafetyCheck(block, src, is_non_zero, .cast_to_null);
             }
 @@ -22943,16 +22941,16 @@ fn ptrFromIntVal(
 fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
     const base_dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_opt, "@errorCast");
     const operand = try sema.resolveInst(extra.rhs);
     const base_operand_ty = sema.typeOf(operand);
-    const dest_tag = base_dest_ty.zigTypeTag(mod);
+    const dest_tag = base_dest_ty.zigTypeTag(zcu);
-    const operand_tag = base_operand_ty.zigTypeTag(mod);
+    const operand_tag = base_operand_ty.zigTypeTag(zcu);
     if (dest_tag != .ErrorSet and dest_tag != .ErrorUnion) {
         return sema.fail(block, src, "expected error set or error union type, found '{s}'", .{@tagName(dest_tag)});
 @@ -22964,13 +22962,13 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
         return sema.fail(block, src, "cannot cast an error union type to error set", .{});
     }
     if (dest_tag == .ErrorUnion and operand_tag == .ErrorUnion and
-        base_dest_ty.errorUnionPayload(mod).toIntern() != base_operand_ty.errorUnionPayload(mod).toIntern())
+        base_dest_ty.errorUnionPayload(zcu).toIntern() != base_operand_ty.errorUnionPayload(zcu).toIntern())
     {
         return sema.failWithOwnedErrorMsg(block, msg: {
             const msg = try sema.errMsg(src, "payload types of error unions must match", .{});
             errdefer msg.destroy(sema.gpa);
-            const dest_ty = base_dest_ty.errorUnionPayload(mod);
+            const dest_ty = base_dest_ty.errorUnionPayload(zcu);
-            const operand_ty = base_operand_ty.errorUnionPayload(mod);
+            const operand_ty = base_operand_ty.errorUnionPayload(zcu);
             try sema.errNote(src, msg, "destination payload is '{}'", .{dest_ty.fmt(pt)});
             try sema.errNote(src, msg, "operand payload is '{}'", .{operand_ty.fmt(pt)});
             try addDeclaredHereNote(sema, msg, dest_ty);
 @@ -22978,19 +22976,19 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
             break :msg msg;
         });
     }
-    const dest_ty = if (dest_tag == .ErrorUnion) base_dest_ty.errorUnionSet(mod) else base_dest_ty;
+    const dest_ty = if (dest_tag == .ErrorUnion) base_dest_ty.errorUnionSet(zcu) else base_dest_ty;
-    const operand_ty = if (operand_tag == .ErrorUnion) base_operand_ty.errorUnionSet(mod) else base_operand_ty;
+    const operand_ty = if (operand_tag == .ErrorUnion) base_operand_ty.errorUnionSet(zcu) else base_operand_ty;
     // operand must be defined since it can be an invalid error value
     const maybe_operand_val = try sema.resolveDefinedValue(block, operand_src, operand);
     const disjoint = disjoint: {
         // Try avoiding resolving inferred error sets if we can
-        if (!dest_ty.isAnyError(mod) and dest_ty.errorSetIsEmpty(mod)) break :disjoint true;
+        if (!dest_ty.isAnyError(zcu) and dest_ty.errorSetIsEmpty(zcu)) break :disjoint true;
-        if (!operand_ty.isAnyError(mod) and operand_ty.errorSetIsEmpty(mod)) break :disjoint true;
+        if (!operand_ty.isAnyError(zcu) and operand_ty.errorSetIsEmpty(zcu)) break :disjoint true;
-        if (dest_ty.isAnyError(mod)) break :disjoint false;
+        if (dest_ty.isAnyError(zcu)) break :disjoint false;
-        if (operand_ty.isAnyError(mod)) break :disjoint false;
+        if (operand_ty.isAnyError(zcu)) break :disjoint false;
-        const dest_err_names = dest_ty.errorSetNames(mod);
+        const dest_err_names = dest_ty.errorSetNames(zcu);
         for (0..dest_err_names.len) |dest_err_index| {
             if (Type.errorSetHasFieldIp(ip, operand_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))
                 break :disjoint false;
 @@ -23018,8 +23016,8 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
     }
     if (maybe_operand_val) |val| {
-        if (!dest_ty.isAnyError(mod)) check: {
+        if (!dest_ty.isAnyError(zcu)) check: {
-            const operand_val = mod.intern_pool.indexToKey(val.toIntern());
+            const operand_val = zcu.intern_pool.indexToKey(val.toIntern());
             var error_name: InternPool.NullTerminatedString = undefined;
             if (operand_tag == .ErrorUnion) {
                 if (operand_val.error_union.val != .err_name) break :check;
 @@ -23039,9 +23037,9 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
     try sema.requireRuntimeBlock(block, src, operand_src);
     const err_int_ty = try pt.errorIntType();
-    if (block.wantSafety() and !dest_ty.isAnyError(mod) and
+    if (block.wantSafety() and !dest_ty.isAnyError(zcu) and
         dest_ty.toIntern() != .adhoc_inferred_error_set_type and
-        mod.backendSupportsFeature(.error_set_has_value))
+        zcu.backendSupportsFeature(.error_set_has_value))
     {
         if (dest_tag == .ErrorUnion) {
             const err_code = try sema.analyzeErrUnionCode(block, operand_src, operand);
 @@ -23116,23 +23114,23 @@ fn ptrCastFull(
     operation: []const u8,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     try sema.checkPtrType(block, src, dest_ty, true);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
-    const src_info = operand_ty.ptrInfo(mod);
+    const src_info = operand_ty.ptrInfo(zcu);
-    const dest_info = dest_ty.ptrInfo(mod);
+    const dest_info = dest_ty.ptrInfo(zcu);
     try Type.fromInterned(src_info.child).resolveLayout(pt);
     try Type.fromInterned(dest_info.child).resolveLayout(pt);
     const src_slice_like = src_info.flags.size == .Slice or
-        (src_info.flags.size == .One and Type.fromInterned(src_info.child).zigTypeTag(mod) == .Array);
+        (src_info.flags.size == .One and Type.fromInterned(src_info.child).zigTypeTag(zcu) == .Array);
     const dest_slice_like = dest_info.flags.size == .Slice or
-        (dest_info.flags.size == .One and Type.fromInterned(dest_info.child).zigTypeTag(mod) == .Array);
+        (dest_info.flags.size == .One and Type.fromInterned(dest_info.child).zigTypeTag(zcu) == .Array);
     if (dest_info.flags.size == .Slice and !src_slice_like) {
         return sema.fail(block, src, "illegal pointer cast to slice", .{});
 @@ -23140,12 +23138,12 @@ fn ptrCastFull(
     if (dest_info.flags.size == .Slice) {
         const src_elem_size = switch (src_info.flags.size) {
-            .Slice => Type.fromInterned(src_info.child).abiSize(pt),
+            .Slice => Type.fromInterned(src_info.child).abiSize(zcu),
             // pointer to array
-            .One => Type.fromInterned(src_info.child).childType(mod).abiSize(pt),
+            .One => Type.fromInterned(src_info.child).childType(zcu).abiSize(zcu),
             else => unreachable,
         };
-        const dest_elem_size = Type.fromInterned(dest_info.child).abiSize(pt);
+        const dest_elem_size = Type.fromInterned(dest_info.child).abiSize(zcu);
         if (src_elem_size != dest_elem_size) {
             return sema.fail(block, src, "TODO: implement {s} between slices changing the length", .{operation});
         }
 @@ -23167,7 +23165,7 @@ fn ptrCastFull(
                 errdefer msg.destroy(sema.gpa);
                 if (dest_info.flags.size == .Many and
                     (src_info.flags.size == .Slice or
-                    (src_info.flags.size == .One and Type.fromInterned(src_info.child).zigTypeTag(mod) == .Array)))
+                    (src_info.flags.size == .One and Type.fromInterned(src_info.child).zigTypeTag(zcu) == .Array)))
                 {
                     try sema.errNote(src, msg, "use 'ptr' field to convert slice to many pointer", .{});
                 } else {
 @@ -23180,7 +23178,7 @@ fn ptrCastFull(
         check_child: {
             const src_child = if (dest_info.flags.size == .Slice and src_info.flags.size == .One) blk: {
                 // *[n]T -> []T
-                break :blk Type.fromInterned(src_info.child).childType(mod);
+                break :blk Type.fromInterned(src_info.child).childType(zcu);
             } else Type.fromInterned(src_info.child);
             const dest_child = Type.fromInterned(dest_info.child);
 @@ -23190,7 +23188,7 @@ fn ptrCastFull(
                 dest_child,
                 src_child,
                 !dest_info.flags.is_const,
-                mod.getTarget(),
+                zcu.getTarget(),
                 src,
                 operand_src,
                 null,
 @@ -23211,14 +23209,14 @@ fn ptrCastFull(
             if (dest_info.sentinel == .none) break :check_sent;
             if (src_info.flags.size == .C) break :check_sent;
             if (src_info.sentinel != .none) {
-                const coerced_sent = try mod.intern_pool.getCoerced(sema.gpa, pt.tid, src_info.sentinel, dest_info.child);
+                const coerced_sent = try zcu.intern_pool.getCoerced(sema.gpa, pt.tid, src_info.sentinel, dest_info.child);
                 if (dest_info.sentinel == coerced_sent) break :check_sent;
             }
             if (src_slice_like and src_info.flags.size == .One and dest_info.flags.size == .Slice) {
                 // [*]nT -> []T
                 const arr_ty = Type.fromInterned(src_info.child);
-                if (arr_ty.sentinel(mod)) |src_sentinel| {
+                if (arr_ty.sentinel(zcu)) |src_sentinel| {
-                    const coerced_sent = try mod.intern_pool.getCoerced(sema.gpa, pt.tid, src_sentinel.toIntern(), dest_info.child);
+                    const coerced_sent = try zcu.intern_pool.getCoerced(sema.gpa, pt.tid, src_sentinel.toIntern(), dest_info.child);
                     if (dest_info.sentinel == coerced_sent) break :check_sent;
                 }
             }
 @@ -23264,8 +23262,8 @@ fn ptrCastFull(
         }
         check_allowzero: {
-            const src_allows_zero = operand_ty.ptrAllowsZero(mod);
+            const src_allows_zero = operand_ty.ptrAllowsZero(zcu);
-            const dest_allows_zero = dest_ty.ptrAllowsZero(mod);
+            const dest_allows_zero = dest_ty.ptrAllowsZero(zcu);
             if (!src_allows_zero) break :check_allowzero;
             if (dest_allows_zero) break :check_allowzero;
 @@ -23286,12 +23284,12 @@ fn ptrCastFull(
     const src_align = if (src_info.flags.alignment != .none)
         src_info.flags.alignment
     else
-        Type.fromInterned(src_info.child).abiAlignment(pt);
+        Type.fromInterned(src_info.child).abiAlignment(zcu);
     const dest_align = if (dest_info.flags.alignment != .none)
         dest_info.flags.alignment
     else
-        Type.fromInterned(dest_info.child).abiAlignment(pt);
+        Type.fromInterned(dest_info.child).abiAlignment(zcu);
     if (!flags.align_cast) {
         if (dest_align.compare(.gt, src_align)) {
 @@ -23327,7 +23325,7 @@ fn ptrCastFull(
         }
     } else {
         // Some address space casts are always disallowed
-        if (!target_util.addrSpaceCastIsValid(mod.getTarget(), src_info.flags.address_space, dest_info.flags.address_space)) {
+        if (!target_util.addrSpaceCastIsValid(zcu.getTarget(), src_info.flags.address_space, dest_info.flags.address_space)) {
             return sema.failWithOwnedErrorMsg(block, msg: {
                 const msg = try sema.errMsg(src, "invalid address space cast", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -23363,7 +23361,7 @@ fn ptrCastFull(
     }
     const ptr = if (src_info.flags.size == .Slice and dest_info.flags.size != .Slice) ptr: {
-        if (operand_ty.zigTypeTag(mod) == .Optional) {
+        if (operand_ty.zigTypeTag(zcu) == .Optional) {
             break :ptr try sema.analyzeOptionalSlicePtr(block, operand_src, operand, operand_ty);
         } else {
             break :ptr try sema.analyzeSlicePtr(block, operand_src, operand, operand_ty);
 @@ -23375,7 +23373,7 @@ fn ptrCastFull(
         var info = dest_info;
         info.flags.size = .Many;
         const ty = try pt.ptrTypeSema(info);
-        if (dest_ty.zigTypeTag(mod) == .Optional) {
+        if (dest_ty.zigTypeTag(zcu) == .Optional) {
             break :blk try pt.optionalType(ty.toIntern());
         } else {
             break :blk ty;
 @@ -23385,14 +23383,14 @@ fn ptrCastFull(
     // Cannot do @addrSpaceCast at comptime
     if (!flags.addrspace_cast) {
         if (try sema.resolveValue(ptr)) |ptr_val| {
-            if (!dest_ty.ptrAllowsZero(mod) and ptr_val.isUndef(mod)) {
+            if (!dest_ty.ptrAllowsZero(zcu) and ptr_val.isUndef(zcu)) {
                 return sema.failWithUseOfUndef(block, operand_src);
             }
-            if (!dest_ty.ptrAllowsZero(mod) and ptr_val.isNull(mod)) {
+            if (!dest_ty.ptrAllowsZero(zcu) and ptr_val.isNull(zcu)) {
                 return sema.fail(block, operand_src, "null pointer casted to type '{}'", .{dest_ty.fmt(pt)});
             }
             if (dest_align.compare(.gt, src_align)) {
-                if (try ptr_val.getUnsignedIntAdvanced(pt, .sema)) |addr| {
+                if (try ptr_val.getUnsignedIntSema(pt)) |addr| {
                     if (!dest_align.check(addr)) {
                         return sema.fail(block, operand_src, "pointer address 0x{X} is not aligned to {d} bytes", .{
                             addr,
 @@ -23402,20 +23400,20 @@ fn ptrCastFull(
                 }
             }
             if (dest_info.flags.size == .Slice and src_info.flags.size != .Slice) {
-                if (ptr_val.isUndef(mod)) return pt.undefRef(dest_ty);
+                if (ptr_val.isUndef(zcu)) return pt.undefRef(dest_ty);
-                const arr_len = try pt.intValue(Type.usize, Type.fromInterned(src_info.child).arrayLen(mod));
+                const arr_len = try pt.intValue(Type.usize, Type.fromInterned(src_info.child).arrayLen(zcu));
-                const ptr_val_key = mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
+                const ptr_val_key = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
                 return Air.internedToRef((try pt.intern(.{ .slice = .{
                     .ty = dest_ty.toIntern(),
                     .ptr = try pt.intern(.{ .ptr = .{
-                        .ty = dest_ty.slicePtrFieldType(mod).toIntern(),
+                        .ty = dest_ty.slicePtrFieldType(zcu).toIntern(),
                         .base_addr = ptr_val_key.base_addr,
                         .byte_offset = ptr_val_key.byte_offset,
                     } }),
                     .len = arr_len.toIntern(),
                 } })));
             } else {
-                assert(dest_ptr_ty.eql(dest_ty, mod));
+                assert(dest_ptr_ty.eql(dest_ty, zcu));
                 return Air.internedToRef((try pt.getCoerced(ptr_val, dest_ty)).toIntern());
             }
         }
 @@ -23424,8 +23422,8 @@ fn ptrCastFull(
     try sema.requireRuntimeBlock(block, src, null);
     try sema.validateRuntimeValue(block, operand_src, ptr);
-    if (block.wantSafety() and operand_ty.ptrAllowsZero(mod) and !dest_ty.ptrAllowsZero(mod) and
+    if (block.wantSafety() and operand_ty.ptrAllowsZero(zcu) and !dest_ty.ptrAllowsZero(zcu) and
-        (try sema.typeHasRuntimeBits(Type.fromInterned(dest_info.child)) or Type.fromInterned(dest_info.child).zigTypeTag(mod) == .Fn))
+        (try Type.fromInterned(dest_info.child).hasRuntimeBitsSema(pt) or Type.fromInterned(dest_info.child).zigTypeTag(zcu) == .Fn))
     {
         const ptr_int = try block.addUnOp(.int_from_ptr, ptr);
         const is_non_zero = try block.addBinOp(.cmp_neq, ptr_int, .zero_usize);
 @@ -23439,7 +23437,7 @@ fn ptrCastFull(
     if (block.wantSafety() and
         dest_align.compare(.gt, src_align) and
-        try sema.typeHasRuntimeBits(Type.fromInterned(dest_info.child)))
+        try Type.fromInterned(dest_info.child).hasRuntimeBitsSema(pt))
     {
         const align_bytes_minus_1 = dest_align.toByteUnits().? - 1;
         const align_minus_1 = Air.internedToRef((try pt.intValue(Type.usize, align_bytes_minus_1)).toIntern());
 @@ -23460,7 +23458,7 @@ fn ptrCastFull(
         var intermediate_info = src_info;
         intermediate_info.flags.address_space = dest_info.flags.address_space;
         const intermediate_ptr_ty = try pt.ptrTypeSema(intermediate_info);
-        const intermediate_ty = if (dest_ptr_ty.zigTypeTag(mod) == .Optional) blk: {
+        const intermediate_ty = if (dest_ptr_ty.zigTypeTag(zcu) == .Optional) blk: {
             break :blk try pt.optionalType(intermediate_ptr_ty.toIntern());
         } else intermediate_ptr_ty;
         const intermediate = try block.addInst(.{
 @@ -23470,7 +23468,7 @@ fn ptrCastFull(
                 .operand = ptr,
             } },
         });
-        if (intermediate_ty.eql(dest_ptr_ty, mod)) {
+        if (intermediate_ty.eql(dest_ptr_ty, zcu)) {
             // We only changed the address space, so no need for a bitcast
             break :ptr intermediate;
         }
 @@ -23482,7 +23480,7 @@ fn ptrCastFull(
     if (dest_info.flags.size == .Slice and src_info.flags.size != .Slice) {
         // We have to construct a slice using the operand's child's array length
         // Note that we know from the check at the start of the function that operand_ty is slice-like
-        const arr_len = Air.internedToRef((try pt.intValue(Type.usize, Type.fromInterned(src_info.child).arrayLen(mod))).toIntern());
+        const arr_len = Air.internedToRef((try pt.intValue(Type.usize, Type.fromInterned(src_info.child).arrayLen(zcu))).toIntern());
         return block.addInst(.{
             .tag = .slice,
             .data = .{ .ty_pl = .{
 @@ -23494,7 +23492,7 @@ fn ptrCastFull(
             } },
         });
     } else {
-        assert(dest_ptr_ty.eql(dest_ty, mod));
+        assert(dest_ptr_ty.eql(dest_ty, zcu));
         try sema.checkKnownAllocPtr(block, operand, result_ptr);
         return result_ptr;
     }
 @@ -23502,7 +23500,7 @@ fn ptrCastFull(
 fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const FlagsInt = @typeInfo(Zir.Inst.FullPtrCastFlags).Struct.backing_integer.?;
     const flags: Zir.Inst.FullPtrCastFlags = @bitCast(@as(FlagsInt, @truncate(extended.small)));
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
 @@ -23512,13 +23510,13 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
     const operand_ty = sema.typeOf(operand);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
-    var ptr_info = operand_ty.ptrInfo(mod);
+    var ptr_info = operand_ty.ptrInfo(zcu);
     if (flags.const_cast) ptr_info.flags.is_const = false;
     if (flags.volatile_cast) ptr_info.flags.is_volatile = false;
     const dest_ty = blk: {
         const dest_ty = try pt.ptrTypeSema(ptr_info);
-        if (operand_ty.zigTypeTag(mod) == .Optional) {
+        if (operand_ty.zigTypeTag(zcu) == .Optional) {
             break :blk try pt.optionalType(dest_ty.toIntern());
         }
         break :blk dest_ty;
 @@ -23536,7 +23534,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
 fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
 @@ -23547,24 +23545,24 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const operand_ty = sema.typeOf(operand);
     const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
-    const operand_is_vector = operand_ty.zigTypeTag(mod) == .Vector;
+    const operand_is_vector = operand_ty.zigTypeTag(zcu) == .Vector;
-    const dest_is_vector = dest_ty.zigTypeTag(mod) == .Vector;
+    const dest_is_vector = dest_ty.zigTypeTag(zcu) == .Vector;
     if (operand_is_vector != dest_is_vector) {
         return sema.fail(block, operand_src, "expected type '{}', found '{}'", .{ dest_ty.fmt(pt), operand_ty.fmt(pt) });
     }
-    if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
+    if (dest_scalar_ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.coerce(block, dest_ty, operand, operand_src);
     }
-    const dest_info = dest_scalar_ty.intInfo(mod);
+    const dest_info = dest_scalar_ty.intInfo(zcu);
     if (try sema.typeHasOnePossibleValue(dest_ty)) |val| {
         return Air.internedToRef(val.toIntern());
     }
-    if (operand_scalar_ty.zigTypeTag(mod) != .ComptimeInt) {
+    if (operand_scalar_ty.zigTypeTag(zcu) != .ComptimeInt) {
-        const operand_info = operand_ty.intInfo(mod);
+        const operand_info = operand_ty.intInfo(zcu);
         if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
             return Air.internedToRef(val.toIntern());
         }
 @@ -23595,14 +23593,14 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     }
     if (try sema.resolveValueIntable(operand)) |val| {
-        if (val.isUndef(mod)) return pt.undefRef(dest_ty);
+        if (val.isUndef(zcu)) return pt.undefRef(dest_ty);
         if (!dest_is_vector) {
             return Air.internedToRef((try pt.getCoerced(
                 try val.intTrunc(operand_ty, sema.arena, dest_info.signedness, dest_info.bits, pt),
                 dest_ty,
             )).toIntern());
         }
-        const elems = try sema.arena.alloc(InternPool.Index, operand_ty.vectorLen(mod));
+        const elems = try sema.arena.alloc(InternPool.Index, operand_ty.vectorLen(zcu));
         for (elems, 0..) |*elem, i| {
             const elem_val = try val.elemValue(pt, i);
             const uncoerced_elem = try elem_val.intTrunc(operand_scalar_ty, sema.arena, dest_info.signedness, dest_info.bits, pt);
 @@ -23623,38 +23621,38 @@ fn zirBitCount(
     block: *Block,
     inst: Zir.Inst.Index,
     air_tag: Air.Inst.Tag,
-    comptime comptimeOp: fn (val: Value, ty: Type, pt: Zcu.PerThread) u64,
+    comptime comptimeOp: fn (val: Value, ty: Type, zcu: *Zcu) u64,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     _ = try sema.checkIntOrVector(block, operand, operand_src);
-    const bits = operand_ty.intInfo(mod).bits;
+    const bits = operand_ty.intInfo(zcu).bits;
     if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
         return Air.internedToRef(val.toIntern());
     }
     const result_scalar_ty = try pt.smallestUnsignedInt(bits);
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Vector => {
-            const vec_len = operand_ty.vectorLen(mod);
+            const vec_len = operand_ty.vectorLen(zcu);
             const result_ty = try pt.vectorType(.{
                 .len = vec_len,
                 .child = result_scalar_ty.toIntern(),
             });
             if (try sema.resolveValue(operand)) |val| {
-                if (val.isUndef(mod)) return pt.undefRef(result_ty);
+                if (val.isUndef(zcu)) return pt.undefRef(result_ty);
                 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
-                const scalar_ty = operand_ty.scalarType(mod);
+                const scalar_ty = operand_ty.scalarType(zcu);
                 for (elems, 0..) |*elem, i| {
                     const elem_val = try val.elemValue(pt, i);
-                    const count = comptimeOp(elem_val, scalar_ty, pt);
+                    const count = comptimeOp(elem_val, scalar_ty, zcu);
                     elem.* = (try pt.intValue(result_scalar_ty, count)).toIntern();
                 }
                 return Air.internedToRef((try pt.intern(.{ .aggregate = .{
 @@ -23668,8 +23666,8 @@ fn zirBitCount(
         },
         .Int => {
             if (try sema.resolveValueResolveLazy(operand)) |val| {
-                if (val.isUndef(mod)) return pt.undefRef(result_scalar_ty);
+                if (val.isUndef(zcu)) return pt.undefRef(result_scalar_ty);
-                return pt.intRef(result_scalar_ty, comptimeOp(val, operand_ty, pt));
+                return pt.intRef(result_scalar_ty, comptimeOp(val, operand_ty, zcu));
             } else {
                 try sema.requireRuntimeBlock(block, src, operand_src);
                 return block.addTyOp(air_tag, result_scalar_ty, operand);
 @@ -23681,14 +23679,14 @@ fn zirBitCount(
 fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
-    const bits = scalar_ty.intInfo(mod).bits;
+    const bits = scalar_ty.intInfo(zcu).bits;
     if (bits % 8 != 0) {
         return sema.fail(
             block,
 @@ -23702,10 +23700,10 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         return Air.internedToRef(val.toIntern());
     }
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Int => {
             const runtime_src = if (try sema.resolveValue(operand)) |val| {
-                if (val.isUndef(mod)) return pt.undefRef(operand_ty);
+                if (val.isUndef(zcu)) return pt.undefRef(operand_ty);
                 const result_val = try val.byteSwap(operand_ty, pt, sema.arena);
                 return Air.internedToRef(result_val.toIntern());
             } else operand_src;
 @@ -23715,10 +23713,10 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         },
         .Vector => {
             const runtime_src = if (try sema.resolveValue(operand)) |val| {
-                if (val.isUndef(mod))
+                if (val.isUndef(zcu))
                     return pt.undefRef(operand_ty);
-                const vec_len = operand_ty.vectorLen(mod);
+                const vec_len = operand_ty.vectorLen(zcu);
                 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
                 for (elems, 0..) |*elem, i| {
                     const elem_val = try val.elemValue(pt, i);
 @@ -23750,11 +23748,11 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
     }
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (operand_ty.zigTypeTag(mod)) {
+    switch (operand_ty.zigTypeTag(zcu)) {
         .Int => {
             const runtime_src = if (try sema.resolveValue(operand)) |val| {
-                if (val.isUndef(mod)) return pt.undefRef(operand_ty);
+                if (val.isUndef(zcu)) return pt.undefRef(operand_ty);
                 const result_val = try val.bitReverse(operand_ty, pt, sema.arena);
                 return Air.internedToRef(result_val.toIntern());
             } else operand_src;
 @@ -23764,10 +23762,10 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         },
         .Vector => {
             const runtime_src = if (try sema.resolveValue(operand)) |val| {
-                if (val.isUndef(mod))
+                if (val.isUndef(zcu))
                     return pt.undefRef(operand_ty);
-                const vec_len = operand_ty.vectorLen(mod);
+                const vec_len = operand_ty.vectorLen(zcu);
                 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
                 for (elems, 0..) |*elem, i| {
                     const elem_val = try val.elemValue(pt, i);
 @@ -23810,26 +23808,26 @@ fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u6
     });
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     try ty.resolveLayout(pt);
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Struct => {},
         else => return sema.fail(block, lhs_src, "expected struct type, found '{}'", .{ty.fmt(pt)}),
     }
-    const field_index = if (ty.isTuple(mod)) blk: {
+    const field_index = if (ty.isTuple(zcu)) blk: {
         if (field_name.eqlSlice("len", ip)) {
             return sema.fail(block, src, "no offset available for 'len' field of tuple", .{});
         }
         break :blk try sema.tupleFieldIndex(block, ty, field_name, rhs_src);
     } else try sema.structFieldIndex(block, ty, field_name, rhs_src);
-    if (ty.structFieldIsComptime(field_index, mod)) {
+    if (ty.structFieldIsComptime(field_index, zcu)) {
         return sema.fail(block, src, "no offset available for comptime field", .{});
     }
-    switch (ty.containerLayout(mod)) {
+    switch (ty.containerLayout(zcu)) {
         .@"packed" => {
             var bit_sum: u64 = 0;
             const struct_type = ip.loadStructType(ty.toIntern());
 @@ -23838,17 +23836,17 @@ fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u6
                     return bit_sum;
                 }
                 const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-                bit_sum += field_ty.bitSize(pt);
+                bit_sum += field_ty.bitSize(zcu);
             } else unreachable;
         },
-        else => return ty.structFieldOffset(field_index, pt) * 8,
+        else => return ty.structFieldOffset(field_index, zcu) * 8,
     }
 }
 fn checkNamespaceType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Struct, .Enum, .Union, .Opaque => return,
         else => return sema.fail(block, src, "expected struct, enum, union, or opaque; found '{}'", .{ty.fmt(pt)}),
     }
 @@ -23857,8 +23855,8 @@ fn checkNamespaceType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) Com
 /// Returns `true` if the type was a comptime_int.
 fn checkIntType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (try ty.zigTypeTagOrPoison(mod)) {
+    switch (try ty.zigTypeTagOrPoison(zcu)) {
         .ComptimeInt => return true,
         .Int => return false,
         else => return sema.fail(block, src, "expected integer type, found '{}'", .{ty.fmt(pt)}),
 @@ -23872,9 +23870,9 @@ fn checkInvalidPtrIntArithmetic(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (try ty.zigTypeTagOrPoison(mod)) {
+    switch (try ty.zigTypeTagOrPoison(zcu)) {
-        .Pointer => switch (ty.ptrSize(mod)) {
+        .Pointer => switch (ty.ptrSize(zcu)) {
             .One, .Slice => return,
             .Many, .C => return sema.failWithInvalidPtrArithmetic(block, src, "pointer-integer", "addition and subtraction"),
         },
 @@ -23908,8 +23906,8 @@ fn checkPtrOperand(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Pointer => return,
         .Fn => {
             const msg = msg: {
 @@ -23926,7 +23924,7 @@ fn checkPtrOperand(
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         },
-        .Optional => if (ty.childType(mod).zigTypeTag(mod) == .Pointer) return,
+        .Optional => if (ty.childType(zcu).zigTypeTag(zcu) == .Pointer) return,
         else => {},
     }
     return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty.fmt(pt)});
 @@ -23940,9 +23938,9 @@ fn checkPtrType(
     allow_slice: bool,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
-        .Pointer => if (allow_slice or !ty.isSlice(mod)) return,
+        .Pointer => if (allow_slice or !ty.isSlice(zcu)) return,
         .Fn => {
             const msg = msg: {
                 const msg = try sema.errMsg(
 @@ -23958,7 +23956,7 @@ fn checkPtrType(
             };
             return sema.failWithOwnedErrorMsg(block, msg);
         },
-        .Optional => if (ty.childType(mod).zigTypeTag(mod) == .Pointer) return,
+        .Optional => if (ty.childType(zcu).zigTypeTag(zcu) == .Pointer) return,
         else => {},
     }
     return sema.fail(block, ty_src, "expected pointer type, found '{}'", .{ty.fmt(pt)});
 @@ -23971,10 +23969,10 @@ fn checkVectorElemType(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Int, .Float, .Bool => return,
-        .Optional, .Pointer => if (ty.isPtrAtRuntime(mod)) return,
+        .Optional, .Pointer => if (ty.isPtrAtRuntime(zcu)) return,
         else => {},
     }
     return sema.fail(block, ty_src, "expected integer, float, bool, or pointer for the vector element type; found '{}'", .{ty.fmt(pt)});
 @@ -23987,8 +23985,8 @@ fn checkFloatType(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .ComptimeInt, .ComptimeFloat, .Float => {},
         else => return sema.fail(block, ty_src, "expected float type, found '{}'", .{ty.fmt(pt)}),
     }
 @@ -24001,10 +23999,10 @@ fn checkNumericType(
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .ComptimeFloat, .Float, .ComptimeInt, .Int => {},
-        .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+        .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
             .ComptimeFloat, .Float, .ComptimeInt, .Int => {},
             else => |t| return sema.fail(block, ty_src, "expected number, found '{}'", .{t}),
         },
 @@ -24023,9 +24021,9 @@ fn checkAtomicPtrOperand(
     ptr_const: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    var diag: Module.AtomicPtrAlignmentDiagnostics = .{};
+    var diag: Zcu.AtomicPtrAlignmentDiagnostics = .{};
-    const alignment = mod.atomicPtrAlignment(elem_ty, &diag) catch |err| switch (err) {
+    const alignment = zcu.atomicPtrAlignment(elem_ty, &diag) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         error.FloatTooBig => return sema.fail(
             block,
 @@ -24056,8 +24054,8 @@ fn checkAtomicPtrOperand(
     };
     const ptr_ty = sema.typeOf(ptr);
-    const ptr_data = switch (try ptr_ty.zigTypeTagOrPoison(mod)) {
+    const ptr_data = switch (try ptr_ty.zigTypeTagOrPoison(zcu)) {
-        .Pointer => ptr_ty.ptrInfo(mod),
+        .Pointer => ptr_ty.ptrInfo(zcu),
         else => {
             const wanted_ptr_ty = try pt.ptrTypeSema(wanted_ptr_data);
             _ = try sema.coerce(block, wanted_ptr_ty, ptr, ptr_src);
 @@ -24095,13 +24093,13 @@ fn checkIntOrVector(
     operand_src: LazySrcLoc,
 ) CompileError!Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
-    switch (try operand_ty.zigTypeTagOrPoison(mod)) {
+    switch (try operand_ty.zigTypeTagOrPoison(zcu)) {
         .Int => return operand_ty,
         .Vector => {
-            const elem_ty = operand_ty.childType(mod);
+            const elem_ty = operand_ty.childType(zcu);
-            switch (try elem_ty.zigTypeTagOrPoison(mod)) {
+            switch (try elem_ty.zigTypeTagOrPoison(zcu)) {
                 .Int => return elem_ty,
                 else => return sema.fail(block, operand_src, "expected vector of integers; found vector of '{}'", .{
                     elem_ty.fmt(pt),
 @@ -24121,12 +24119,12 @@ fn checkIntOrVectorAllowComptime(
     operand_src: LazySrcLoc,
 ) CompileError!Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (try operand_ty.zigTypeTagOrPoison(mod)) {
+    switch (try operand_ty.zigTypeTagOrPoison(zcu)) {
         .Int, .ComptimeInt => return operand_ty,
         .Vector => {
-            const elem_ty = operand_ty.childType(mod);
+            const elem_ty = operand_ty.childType(zcu);
-            switch (try elem_ty.zigTypeTagOrPoison(mod)) {
+            switch (try elem_ty.zigTypeTagOrPoison(zcu)) {
                 .Int, .ComptimeInt => return elem_ty,
                 else => return sema.fail(block, operand_src, "expected vector of integers; found vector of '{}'", .{
                     elem_ty.fmt(pt),
 @@ -24162,12 +24160,12 @@ fn checkSimdBinOp(
     rhs_src: LazySrcLoc,
 ) CompileError!SimdBinOp {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(uncasted_lhs);
     const rhs_ty = sema.typeOf(uncasted_rhs);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
-    const vec_len: ?usize = if (lhs_ty.zigTypeTag(mod) == .Vector) lhs_ty.vectorLen(mod) else null;
+    const vec_len: ?usize = if (lhs_ty.zigTypeTag(zcu) == .Vector) lhs_ty.vectorLen(zcu) else null;
     const result_ty = try sema.resolvePeerTypes(block, src, &.{ uncasted_lhs, uncasted_rhs }, .{
         .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
     });
 @@ -24181,7 +24179,7 @@ fn checkSimdBinOp(
         .lhs_val = try sema.resolveValue(lhs),
         .rhs_val = try sema.resolveValue(rhs),
         .result_ty = result_ty,
-        .scalar_ty = result_ty.scalarType(mod),
+        .scalar_ty = result_ty.scalarType(zcu),
     };
 }
 @@ -24195,9 +24193,9 @@ fn checkVectorizableBinaryOperands(
     rhs_src: LazySrcLoc,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(zcu);
-    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(zcu);
     if (lhs_zig_ty_tag != .Vector and rhs_zig_ty_tag != .Vector) return;
     const lhs_is_vector = switch (lhs_zig_ty_tag) {
 @@ -24210,8 +24208,8 @@ fn checkVectorizableBinaryOperands(
     };
     if (lhs_is_vector and rhs_is_vector) {
-        const lhs_len = lhs_ty.arrayLen(mod);
+        const lhs_len = lhs_ty.arrayLen(zcu);
-        const rhs_len = rhs_ty.arrayLen(mod);
+        const rhs_len = rhs_ty.arrayLen(zcu);
         if (lhs_len != rhs_len) {
             const msg = msg: {
                 const msg = try sema.errMsg(src, "vector length mismatch", .{});
 @@ -24246,11 +24244,11 @@ fn resolveExportOptions(
     block: *Block,
     src: LazySrcLoc,
     zir_ref: Zir.Inst.Ref,
-) CompileError!Module.Export.Options {
+) CompileError!Zcu.Export.Options {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const export_options_ty = try pt.getBuiltinType("ExportOptions");
     const air_ref = try sema.resolveInst(zir_ref);
     const options = try sema.coerce(block, export_options_ty, air_ref, src);
 @@ -24269,13 +24267,13 @@ fn resolveExportOptions(
     const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_operand, .{
         .needed_comptime_reason = "linkage of exported value must be comptime-known",
     });
-    const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);
+    const linkage = zcu.toEnum(std.builtin.GlobalLinkage, linkage_val);
     const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "section", .no_embedded_nulls), section_src);
     const section_opt_val = try sema.resolveConstDefinedValue(block, section_src, section_operand, .{
         .needed_comptime_reason = "linksection of exported value must be comptime-known",
     });
-    const section = if (section_opt_val.optionalValue(mod)) |section_val|
+    const section = if (section_opt_val.optionalValue(zcu)) |section_val|
         try sema.toConstString(block, section_src, Air.internedToRef(section_val.toIntern()), .{
             .needed_comptime_reason = "linksection of exported value must be comptime-known",
         })
 @@ -24286,7 +24284,7 @@ fn resolveExportOptions(
     const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_operand, .{
         .needed_comptime_reason = "visibility of exported value must be comptime-known",
     });
-    const visibility = mod.toEnum(std.builtin.SymbolVisibility, visibility_val);
+    const visibility = zcu.toEnum(std.builtin.SymbolVisibility, visibility_val);
     if (name.len < 1) {
         return sema.fail(block, name_src, "exported symbol name cannot be empty", .{});
 @@ -24349,7 +24347,7 @@ fn zirCmpxchg(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const extra = sema.code.extraData(Zir.Inst.Cmpxchg, extended.operand).data;
     const air_tag: Air.Inst.Tag = switch (extended.small) {
         0 => .cmpxchg_weak,
 @@ -24367,7 +24365,7 @@ fn zirCmpxchg(
     // zig fmt: on
     const expected_value = try sema.resolveInst(extra.expected_value);
     const elem_ty = sema.typeOf(expected_value);
-    if (elem_ty.zigTypeTag(mod) == .Float) {
+    if (elem_ty.zigTypeTag(zcu) == .Float) {
         return sema.fail(
             block,
             elem_ty_src,
 @@ -24411,7 +24409,7 @@ fn zirCmpxchg(
     const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
         if (try sema.resolveValue(expected_value)) |expected_val| {
             if (try sema.resolveValue(new_value)) |new_val| {
-                if (expected_val.isUndef(mod) or new_val.isUndef(mod)) {
+                if (expected_val.isUndef(zcu) or new_val.isUndef(zcu)) {
                     // TODO: this should probably cause the memory stored at the pointer
                     // to become undef as well
                     return pt.undefRef(result_ty);
 @@ -24420,7 +24418,7 @@ fn zirCmpxchg(
                 const stored_val = (try sema.pointerDeref(block, ptr_src, ptr_val, ptr_ty)) orelse break :rs ptr_src;
                 const result_val = try pt.intern(.{ .opt = .{
                     .ty = result_ty.toIntern(),
-                    .val = if (stored_val.eql(expected_val, elem_ty, mod)) blk: {
+                    .val = if (stored_val.eql(expected_val, elem_ty, zcu)) blk: {
                         try sema.storePtr(block, src, ptr, new_value);
                         break :blk .none;
                     } else stored_val.toIntern(),
 @@ -24450,16 +24448,16 @@ fn zirCmpxchg(
 fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
     const scalar_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_eu_opt, "@splat");
-    if (!dest_ty.isVector(mod)) return sema.fail(block, src, "expected vector type, found '{}'", .{dest_ty.fmt(pt)});
+    if (!dest_ty.isVector(zcu)) return sema.fail(block, src, "expected vector type, found '{}'", .{dest_ty.fmt(pt)});
-    if (!dest_ty.hasRuntimeBits(pt)) {
+    if (!dest_ty.hasRuntimeBits(zcu)) {
         const empty_aggregate = try pt.intern(.{ .aggregate = .{
             .ty = dest_ty.toIntern(),
             .storage = .{ .elems = &[_]InternPool.Index{} },
 @@ -24468,10 +24466,10 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     }
     const operand = try sema.resolveInst(extra.rhs);
-    const scalar_ty = dest_ty.childType(mod);
+    const scalar_ty = dest_ty.childType(zcu);
     const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
     if (try sema.resolveValue(scalar)) |scalar_val| {
-        if (scalar_val.isUndef(mod)) return pt.undefRef(dest_ty);
+        if (scalar_val.isUndef(zcu)) return pt.undefRef(dest_ty);
         return Air.internedToRef((try sema.splat(dest_ty, scalar_val)).toIntern());
     }
 @@ -24490,23 +24488,23 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const operand = try sema.resolveInst(extra.rhs);
     const operand_ty = sema.typeOf(operand);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (operand_ty.zigTypeTag(mod) != .Vector) {
+    if (operand_ty.zigTypeTag(zcu) != .Vector) {
         return sema.fail(block, operand_src, "expected vector, found '{}'", .{operand_ty.fmt(pt)});
     }
-    const scalar_ty = operand_ty.childType(mod);
+    const scalar_ty = operand_ty.childType(zcu);
     // Type-check depending on operation.
     switch (operation) {
-        .And, .Or, .Xor => switch (scalar_ty.zigTypeTag(mod)) {
+        .And, .Or, .Xor => switch (scalar_ty.zigTypeTag(zcu)) {
             .Int, .Bool => {},
             else => return sema.fail(block, operand_src, "@reduce operation '{s}' requires integer or boolean operand; found '{}'", .{
                 @tagName(operation), operand_ty.fmt(pt),
             }),
         },
-        .Min, .Max, .Add, .Mul => switch (scalar_ty.zigTypeTag(mod)) {
+        .Min, .Max, .Add, .Mul => switch (scalar_ty.zigTypeTag(zcu)) {
             .Int, .Float => {},
             else => return sema.fail(block, operand_src, "@reduce operation '{s}' requires integer or float operand; found '{}'", .{
                 @tagName(operation), operand_ty.fmt(pt),
 @@ -24514,7 +24512,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         },
     }
-    const vec_len = operand_ty.vectorLen(mod);
+    const vec_len = operand_ty.vectorLen(zcu);
     if (vec_len == 0) {
         // TODO re-evaluate if we should introduce a "neutral value" for some operations,
         // e.g. zero for add and one for mul.
 @@ -24522,7 +24520,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     }
     if (try sema.resolveValue(operand)) |operand_val| {
-        if (operand_val.isUndef(mod)) return pt.undefRef(scalar_ty);
+        if (operand_val.isUndef(zcu)) return pt.undefRef(scalar_ty);
         var accum: Value = try operand_val.elemValue(pt, 0);
         var i: u32 = 1;
 @@ -24532,8 +24530,8 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 .And => accum = try accum.bitwiseAnd(elem_val, scalar_ty, sema.arena, pt),
                 .Or => accum = try accum.bitwiseOr(elem_val, scalar_ty, sema.arena, pt),
                 .Xor => accum = try accum.bitwiseXor(elem_val, scalar_ty, sema.arena, pt),
-                .Min => accum = accum.numberMin(elem_val, pt),
+                .Min => accum = accum.numberMin(elem_val, zcu),
-                .Max => accum = accum.numberMax(elem_val, pt),
+                .Max => accum = accum.numberMax(elem_val, zcu),
                 .Add => accum = try sema.numberAddWrapScalar(accum, elem_val, scalar_ty),
                 .Mul => accum = try accum.numberMulWrap(elem_val, scalar_ty, sema.arena, pt),
             }
 @@ -24553,7 +24551,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Shuffle, inst_data.payload_index).data;
     const elem_ty_src = block.builtinCallArgSrc(inst_data.src_node, 0);
 @@ -24566,8 +24564,8 @@ fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     var mask = try sema.resolveInst(extra.mask);
     var mask_ty = sema.typeOf(mask);
-    const mask_len = switch (sema.typeOf(mask).zigTypeTag(mod)) {
+    const mask_len = switch (sema.typeOf(mask).zigTypeTag(zcu)) {
-        .Array, .Vector => sema.typeOf(mask).arrayLen(mod),
+        .Array, .Vector => sema.typeOf(mask).arrayLen(zcu),
         else => return sema.fail(block, mask_src, "expected vector or array, found '{}'", .{sema.typeOf(mask).fmt(pt)}),
     };
     mask_ty = try pt.vectorType(.{
 @@ -24592,6 +24590,7 @@ fn analyzeShuffle(
     mask_len: u32,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     const a_src = block.builtinCallArgSrc(src_node, 1);
     const b_src = block.builtinCallArgSrc(src_node, 2);
     const mask_src = block.builtinCallArgSrc(src_node, 3);
 @@ -24603,16 +24602,16 @@ fn analyzeShuffle(
         .child = elem_ty.toIntern(),
     });
-    const maybe_a_len = switch (sema.typeOf(a).zigTypeTag(pt.zcu)) {
+    const maybe_a_len = switch (sema.typeOf(a).zigTypeTag(zcu)) {
-        .Array, .Vector => sema.typeOf(a).arrayLen(pt.zcu),
+        .Array, .Vector => sema.typeOf(a).arrayLen(zcu),
         .Undefined => null,
         else => return sema.fail(block, a_src, "expected vector or array with element type '{}', found '{}'", .{
             elem_ty.fmt(pt),
             sema.typeOf(a).fmt(pt),
         }),
     };
-    const maybe_b_len = switch (sema.typeOf(b).zigTypeTag(pt.zcu)) {
+    const maybe_b_len = switch (sema.typeOf(b).zigTypeTag(zcu)) {
-        .Array, .Vector => sema.typeOf(b).arrayLen(pt.zcu),
+        .Array, .Vector => sema.typeOf(b).arrayLen(zcu),
         .Undefined => null,
         else => return sema.fail(block, b_src, "expected vector or array with element type '{}', found '{}'", .{
             elem_ty.fmt(pt),
 @@ -24644,9 +24643,9 @@ fn analyzeShuffle(
     for (0..@intCast(mask_len)) |i| {
         const elem = try mask.elemValue(pt, i);
-        if (elem.isUndef(pt.zcu)) continue;
+        if (elem.isUndef(zcu)) continue;
         const elem_resolved = try sema.resolveLazyValue(elem);
-        const int = elem_resolved.toSignedInt(pt);
+        const int = elem_resolved.toSignedInt(zcu);
         var unsigned: u32 = undefined;
         var chosen: u32 = undefined;
         if (int >= 0) {
 @@ -24681,11 +24680,11 @@ fn analyzeShuffle(
             const values = try sema.arena.alloc(InternPool.Index, mask_len);
             for (values, 0..) |*value, i| {
                 const mask_elem_val = try mask.elemValue(pt, i);
-                if (mask_elem_val.isUndef(pt.zcu)) {
+                if (mask_elem_val.isUndef(zcu)) {
                     value.* = try pt.intern(.{ .undef = elem_ty.toIntern() });
                     continue;
                 }
-                const int = mask_elem_val.toSignedInt(pt);
+                const int = mask_elem_val.toSignedInt(zcu);
                 const unsigned: u32 = @intCast(if (int >= 0) int else ~int);
                 values[i] = (try (if (int >= 0) a_val else b_val).elemValue(pt, unsigned)).toIntern();
             }
 @@ -24743,7 +24742,7 @@ fn analyzeShuffle(
 fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const extra = sema.code.extraData(Zir.Inst.Select, extended.operand).data;
     const src = block.nodeOffset(extra.node);
 @@ -24757,8 +24756,8 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
     const pred_uncoerced = try sema.resolveInst(extra.pred);
     const pred_ty = sema.typeOf(pred_uncoerced);
-    const vec_len_u64 = switch (try pred_ty.zigTypeTagOrPoison(mod)) {
+    const vec_len_u64 = switch (try pred_ty.zigTypeTagOrPoison(zcu)) {
-        .Vector, .Array => pred_ty.arrayLen(mod),
+        .Vector, .Array => pred_ty.arrayLen(zcu),
         else => return sema.fail(block, pred_src, "expected vector or array, found '{}'", .{pred_ty.fmt(pt)}),
     };
     const vec_len: u32 = @intCast(try sema.usizeCast(block, pred_src, vec_len_u64));
 @@ -24781,13 +24780,13 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
     const maybe_b = try sema.resolveValue(b);
     const runtime_src = if (maybe_pred) |pred_val| rs: {
-        if (pred_val.isUndef(mod)) return pt.undefRef(vec_ty);
+        if (pred_val.isUndef(zcu)) return pt.undefRef(vec_ty);
         if (maybe_a) |a_val| {
-            if (a_val.isUndef(mod)) return pt.undefRef(vec_ty);
+            if (a_val.isUndef(zcu)) return pt.undefRef(vec_ty);
             if (maybe_b) |b_val| {
-                if (b_val.isUndef(mod)) return pt.undefRef(vec_ty);
+                if (b_val.isUndef(zcu)) return pt.undefRef(vec_ty);
                 const elems = try sema.gpa.alloc(InternPool.Index, vec_len);
                 defer sema.gpa.free(elems);
 @@ -24806,16 +24805,16 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
             }
         } else {
             if (maybe_b) |b_val| {
-                if (b_val.isUndef(mod)) return pt.undefRef(vec_ty);
+                if (b_val.isUndef(zcu)) return pt.undefRef(vec_ty);
             }
             break :rs a_src;
         }
     } else rs: {
         if (maybe_a) |a_val| {
-            if (a_val.isUndef(mod)) return pt.undefRef(vec_ty);
+            if (a_val.isUndef(zcu)) return pt.undefRef(vec_ty);
         }
         if (maybe_b) |b_val| {
-            if (b_val.isUndef(mod)) return pt.undefRef(vec_ty);
+            if (b_val.isUndef(zcu)) return pt.undefRef(vec_ty);
         }
         break :rs pred_src;
     };
 @@ -24882,7 +24881,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
 fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.AtomicRmw, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -24899,7 +24898,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     const ptr = try sema.checkAtomicPtrOperand(block, elem_ty, elem_ty_src, uncasted_ptr, ptr_src, false);
     const op = try sema.resolveAtomicRmwOp(block, op_src, extra.operation);
-    switch (elem_ty.zigTypeTag(mod)) {
+    switch (elem_ty.zigTypeTag(zcu)) {
         .Enum => if (op != .Xchg) {
             return sema.fail(block, op_src, "@atomicRmw with enum only allowed with .Xchg", .{});
         },
 @@ -24939,12 +24938,12 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
                 .Xchg => operand_val,
                 .Add  => try sema.numberAddWrapScalar(stored_val, operand_val, elem_ty),
                 .Sub  => try sema.numberSubWrapScalar(stored_val, operand_val, elem_ty),
-                .And  => try                   stored_val.bitwiseAnd   (operand_val, elem_ty, sema.arena, pt),
+                .And  => try                   stored_val.bitwiseAnd   (operand_val, elem_ty, sema.arena, pt ),
-                .Nand => try                   stored_val.bitwiseNand  (operand_val, elem_ty, sema.arena, pt),
+                .Nand => try                   stored_val.bitwiseNand  (operand_val, elem_ty, sema.arena, pt ),
-                .Or   => try                   stored_val.bitwiseOr    (operand_val, elem_ty, sema.arena, pt),
+                .Or   => try                   stored_val.bitwiseOr    (operand_val, elem_ty, sema.arena, pt ),
-                .Xor  => try                   stored_val.bitwiseXor   (operand_val, elem_ty, sema.arena, pt),
+                .Xor  => try                   stored_val.bitwiseXor   (operand_val, elem_ty, sema.arena, pt ),
-                .Max  =>                       stored_val.numberMax    (operand_val,                      pt),
+                .Max  =>                       stored_val.numberMax    (operand_val,                      zcu),
-                .Min  =>                       stored_val.numberMin    (operand_val,                      pt),
+                .Min  =>                       stored_val.numberMin    (operand_val,                      zcu),
                 // zig fmt: on
             };
             try sema.storePtrVal(block, src, ptr_val, new_val, elem_ty);
 @@ -25021,19 +25020,19 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const maybe_mulend2 = try sema.resolveValue(mulend2);
     const maybe_addend = try sema.resolveValue(addend);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.scalarType(mod).zigTypeTag(mod)) {
+    switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
         .ComptimeFloat, .Float => {},
         else => return sema.fail(block, src, "expected vector of floats or float type, found '{}'", .{ty.fmt(pt)}),
     }
     const runtime_src = if (maybe_mulend1) |mulend1_val| rs: {
         if (maybe_mulend2) |mulend2_val| {
-            if (mulend2_val.isUndef(mod)) return pt.undefRef(ty);
+            if (mulend2_val.isUndef(zcu)) return pt.undefRef(ty);
             if (maybe_addend) |addend_val| {
-                if (addend_val.isUndef(mod)) return pt.undefRef(ty);
+                if (addend_val.isUndef(zcu)) return pt.undefRef(ty);
                 const result_val = try Value.mulAdd(ty, mulend1_val, mulend2_val, addend_val, sema.arena, pt);
                 return Air.internedToRef(result_val.toIntern());
             } else {
 @@ -25041,16 +25040,16 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             }
         } else {
             if (maybe_addend) |addend_val| {
-                if (addend_val.isUndef(mod)) return pt.undefRef(ty);
+                if (addend_val.isUndef(zcu)) return pt.undefRef(ty);
             }
             break :rs mulend2_src;
         }
     } else rs: {
         if (maybe_mulend2) |mulend2_val| {
-            if (mulend2_val.isUndef(mod)) return pt.undefRef(ty);
+            if (mulend2_val.isUndef(zcu)) return pt.undefRef(ty);
         }
         if (maybe_addend) |addend_val| {
-            if (addend_val.isUndef(mod)) return pt.undefRef(ty);
+            if (addend_val.isUndef(zcu)) return pt.undefRef(ty);
         }
         break :rs mulend1_src;
     };
 @@ -25073,7 +25072,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const modifier_src = block.builtinCallArgSrc(inst_data.src_node, 0);
     const func_src = block.builtinCallArgSrc(inst_data.src_node, 1);
 @@ -25089,7 +25088,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{
         .needed_comptime_reason = "call modifier must be comptime-known",
     });
-    var modifier = mod.toEnum(std.builtin.CallModifier, modifier_val);
+    var modifier = zcu.toEnum(std.builtin.CallModifier, modifier_val);
     switch (modifier) {
         // These can be upgraded to comptime or nosuspend calls.
         .auto, .never_tail, .no_async => {
 @@ -25135,11 +25134,11 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const args = try sema.resolveInst(extra.args);
     const args_ty = sema.typeOf(args);
-    if (!args_ty.isTuple(mod) and args_ty.toIntern() != .empty_struct_type) {
+    if (!args_ty.isTuple(zcu) and args_ty.toIntern() != .empty_struct_type) {
         return sema.fail(block, args_src, "expected a tuple, found '{}'", .{args_ty.fmt(pt)});
     }
-    const resolved_args: []Air.Inst.Ref = try sema.arena.alloc(Air.Inst.Ref, args_ty.structFieldCount(mod));
+    const resolved_args: []Air.Inst.Ref = try sema.arena.alloc(Air.Inst.Ref, args_ty.structFieldCount(zcu));
     for (resolved_args, 0..) |*resolved, i| {
         resolved.* = try sema.tupleFieldValByIndex(block, args_src, args, @intCast(i), args_ty);
     }
 @@ -25219,7 +25218,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     var actual_parent_ptr_info: InternPool.Key.PtrType = .{
         .child = parent_ty.toIntern(),
         .flags = .{
-            .alignment = try parent_ptr_ty.ptrAlignmentAdvanced(pt, .sema),
+            .alignment = try parent_ptr_ty.ptrAlignmentSema(pt),
             .is_const = field_ptr_info.flags.is_const,
             .is_volatile = field_ptr_info.flags.is_volatile,
             .is_allowzero = field_ptr_info.flags.is_allowzero,
 @@ -25227,11 +25226,11 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
         },
         .packed_offset = parent_ptr_info.packed_offset,
     };
-    const field_ty = parent_ty.structFieldType(field_index, zcu);
+    const field_ty = parent_ty.fieldType(field_index, zcu);
     var actual_field_ptr_info: InternPool.Key.PtrType = .{
         .child = field_ty.toIntern(),
         .flags = .{
-            .alignment = try field_ptr_ty.ptrAlignmentAdvanced(pt, .sema),
+            .alignment = try field_ptr_ty.ptrAlignmentSema(pt),
             .is_const = field_ptr_info.flags.is_const,
             .is_volatile = field_ptr_info.flags.is_volatile,
             .is_allowzero = field_ptr_info.flags.is_allowzero,
 @@ -25242,13 +25241,18 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
     switch (parent_ty.containerLayout(zcu)) {
         .auto => {
             actual_parent_ptr_info.flags.alignment = actual_field_ptr_info.flags.alignment.minStrict(
-                if (zcu.typeToStruct(parent_ty)) |struct_obj| try pt.structFieldAlignmentAdvanced(
+                if (zcu.typeToStruct(parent_ty)) |struct_obj|
-                    struct_obj.fieldAlign(ip, field_index),
+                    try field_ty.structFieldAlignmentSema(
-                    field_ty,
+                        struct_obj.fieldAlign(ip, field_index),
-                    struct_obj.layout,
+                        struct_obj.layout,
-                    .sema,
+                        pt,
-                ) else if (zcu.typeToUnion(parent_ty)) |union_obj|
+                    )
-                    try pt.unionFieldNormalAlignmentAdvanced(union_obj, field_index, .sema)
+                else if (zcu.typeToUnion(parent_ty)) |union_obj|
+                    try field_ty.unionFieldAlignmentSema(
+                        union_obj.fieldAlign(ip, field_index),
+                        union_obj.flagsUnordered(ip).layout,
+                        pt,
+                    )
                 else
                     actual_field_ptr_info.flags.alignment,
             );
 @@ -25257,7 +25261,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
             actual_field_ptr_info.packed_offset = .{ .bit_offset = 0, .host_size = 0 };
         },
         .@"extern" => {
-            const field_offset = parent_ty.structFieldOffset(field_index, pt);
+            const field_offset = parent_ty.structFieldOffset(field_index, zcu);
             actual_parent_ptr_info.flags.alignment = actual_field_ptr_info.flags.alignment.minStrict(if (field_offset > 0)
                 Alignment.fromLog2Units(@ctz(field_offset))
             else
 @@ -25287,7 +25291,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Ins
             .Struct => switch (parent_ty.containerLayout(zcu)) {
                 .auto => {},
                 .@"extern" => {
-                    const byte_offset = parent_ty.structFieldOffset(field_index, pt);
+                    const byte_offset = parent_ty.structFieldOffset(field_index, zcu);
                     const parent_ptr_val = try sema.ptrSubtract(block, field_ptr_src, field_ptr_val, byte_offset, actual_parent_ptr_ty);
                     break :result Air.internedToRef(parent_ptr_val.toIntern());
                 },
 @@ -25428,7 +25432,7 @@ fn analyzeMinMax(
     assert(operands.len == operand_srcs.len);
     assert(operands.len > 0);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (operands.len == 1) return operands[0];
 @@ -25466,20 +25470,20 @@ fn analyzeMinMax(
         switch (bounds_status) {
             .unknown, .defined => refine_bounds: {
                 const ty = sema.typeOf(operand);
-                if (!ty.scalarType(mod).isInt(mod) and !ty.scalarType(mod).eql(Type.comptime_int, mod)) {
+                if (!ty.scalarType(zcu).isInt(zcu) and !ty.scalarType(zcu).eql(Type.comptime_int, zcu)) {
                     bounds_status = .non_integral;
                     break :refine_bounds;
                 }
                 const scalar_bounds: ?[2]Value = bounds: {
-                    if (!ty.isVector(mod)) break :bounds try uncoerced_val.intValueBounds(pt);
+                    if (!ty.isVector(zcu)) break :bounds try uncoerced_val.intValueBounds(pt);
                     var cur_bounds: [2]Value = try Value.intValueBounds(try uncoerced_val.elemValue(pt, 0), pt) orelse break :bounds null;
-                    const len = try sema.usizeCast(block, src, ty.vectorLen(mod));
+                    const len = try sema.usizeCast(block, src, ty.vectorLen(zcu));
                     for (1..len) |i| {
                         const elem = try uncoerced_val.elemValue(pt, i);
                         const elem_bounds = try elem.intValueBounds(pt) orelse break :bounds null;
                         cur_bounds = .{
-                            Value.numberMin(elem_bounds[0], cur_bounds[0], pt),
+                            Value.numberMin(elem_bounds[0], cur_bounds[0], zcu),
-                            Value.numberMax(elem_bounds[1], cur_bounds[1], pt),
+                            Value.numberMax(elem_bounds[1], cur_bounds[1], zcu),
                         };
                     }
                     break :bounds cur_bounds;
 @@ -25490,8 +25494,8 @@ fn analyzeMinMax(
                         cur_max_scalar = bounds[1];
                         bounds_status = .defined;
                     } else {
-                        cur_min_scalar = opFunc(cur_min_scalar, bounds[0], pt);
+                        cur_min_scalar = opFunc(cur_min_scalar, bounds[0], zcu);
-                        cur_max_scalar = opFunc(cur_max_scalar, bounds[1], pt);
+                        cur_max_scalar = opFunc(cur_max_scalar, bounds[1], zcu);
                     }
                 }
             },
 @@ -25509,7 +25513,7 @@ fn analyzeMinMax(
         const operand_val = try sema.resolveLazyValue(simd_op.rhs_val.?); // we checked the operand was resolvable above
         const vec_len = simd_op.len orelse {
-            const result_val = opFunc(cur_val, operand_val, pt);
+            const result_val = opFunc(cur_val, operand_val, zcu);
             cur_minmax = Air.internedToRef(result_val.toIntern());
             continue;
         };
 @@ -25517,7 +25521,7 @@ fn analyzeMinMax(
         for (elems, 0..) |*elem, i| {
             const lhs_elem_val = try cur_val.elemValue(pt, i);
             const rhs_elem_val = try operand_val.elemValue(pt, i);
-            const uncoerced_elem = opFunc(lhs_elem_val, rhs_elem_val, pt);
+            const uncoerced_elem = opFunc(lhs_elem_val, rhs_elem_val, zcu);
             elem.* = (try pt.getCoerced(uncoerced_elem, simd_op.scalar_ty)).toIntern();
         }
         cur_minmax = Air.internedToRef((try pt.intern(.{ .aggregate = .{
 @@ -25537,19 +25541,19 @@ fn analyzeMinMax(
         const val = (try sema.resolveValue(ct_minmax_ref)).?;
         const orig_ty = sema.typeOf(ct_minmax_ref);
-        if (opt_runtime_idx == null and orig_ty.scalarType(mod).eql(Type.comptime_int, mod)) {
+        if (opt_runtime_idx == null and orig_ty.scalarType(zcu).eql(Type.comptime_int, zcu)) {
             // If all arguments were `comptime_int`, and there are no runtime args, we'll preserve that type
             break :refine;
         }
         // We can't refine float types
-        if (orig_ty.scalarType(mod).isAnyFloat()) break :refine;
+        if (orig_ty.scalarType(zcu).isAnyFloat()) break :refine;
         assert(bounds_status == .defined); // there was a non-comptime-int integral comptime-known arg
         const refined_scalar_ty = try pt.intFittingRange(cur_min_scalar, cur_max_scalar);
-        const refined_ty = if (orig_ty.isVector(mod)) try pt.vectorType(.{
+        const refined_ty = if (orig_ty.isVector(zcu)) try pt.vectorType(.{
-            .len = orig_ty.vectorLen(mod),
+            .len = orig_ty.vectorLen(zcu),
             .child = refined_scalar_ty.toIntern(),
         }) else refined_scalar_ty;
 @@ -25570,7 +25574,7 @@ fn analyzeMinMax(
     // If the comptime-known part is undef we can avoid emitting actual instructions later
     const known_undef = if (cur_minmax) |operand| blk: {
         const val = (try sema.resolveValue(operand)).?;
-        break :blk val.isUndef(mod);
+        break :blk val.isUndef(zcu);
     } else false;
     if (cur_minmax == null) {
 @@ -25580,8 +25584,8 @@ fn analyzeMinMax(
         cur_minmax = operands[0];
         cur_minmax_src = runtime_src;
         runtime_known.unset(0); // don't look at this operand in the loop below
-        const scalar_ty = sema.typeOf(cur_minmax.?).scalarType(mod);
+        const scalar_ty = sema.typeOf(cur_minmax.?).scalarType(zcu);
-        if (scalar_ty.isInt(mod)) {
+        if (scalar_ty.isInt(zcu)) {
             cur_min_scalar = try scalar_ty.minInt(pt, scalar_ty);
             cur_max_scalar = try scalar_ty.maxInt(pt, scalar_ty);
             bounds_status = .defined;
 @@ -25605,7 +25609,7 @@ fn analyzeMinMax(
         // Compute the bounds of this type
         switch (bounds_status) {
             .unknown, .defined => refine_bounds: {
-                const scalar_ty = sema.typeOf(rhs).scalarType(mod);
+                const scalar_ty = sema.typeOf(rhs).scalarType(zcu);
                 if (scalar_ty.isAnyFloat()) {
                     bounds_status = .non_integral;
                     break :refine_bounds;
 @@ -25617,8 +25621,8 @@ fn analyzeMinMax(
                     cur_max_scalar = scalar_max;
                     bounds_status = .defined;
                 } else {
-                    cur_min_scalar = opFunc(cur_min_scalar, scalar_min, pt);
+                    cur_min_scalar = opFunc(cur_min_scalar, scalar_min, zcu);
-                    cur_max_scalar = opFunc(cur_max_scalar, scalar_max, pt);
+                    cur_max_scalar = opFunc(cur_max_scalar, scalar_max, zcu);
                 }
             },
             .non_integral => {},
 @@ -25627,18 +25631,18 @@ fn analyzeMinMax(
     // Finally, refine the type based on the known bounds.
     const unrefined_ty = sema.typeOf(cur_minmax.?);
-    if (unrefined_ty.scalarType(mod).isAnyFloat()) {
+    if (unrefined_ty.scalarType(zcu).isAnyFloat()) {
         // We can't refine floats, so we're done.
         return cur_minmax.?;
     }
     assert(bounds_status == .defined); // there were integral runtime operands
     const refined_scalar_ty = try pt.intFittingRange(cur_min_scalar, cur_max_scalar);
-    const refined_ty = if (unrefined_ty.isVector(mod)) try pt.vectorType(.{
+    const refined_ty = if (unrefined_ty.isVector(zcu)) try pt.vectorType(.{
-        .len = unrefined_ty.vectorLen(mod),
+        .len = unrefined_ty.vectorLen(zcu),
         .child = refined_scalar_ty.toIntern(),
     }) else refined_scalar_ty;
-    if (!refined_ty.eql(unrefined_ty, mod)) {
+    if (!refined_ty.eql(unrefined_ty, zcu)) {
         // We've reduced the type - cast the result down
         return block.addTyOp(.intcast, refined_ty, cur_minmax.?);
     }
 @@ -25648,9 +25652,9 @@ fn analyzeMinMax(
 fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = sema.typeOf(ptr);
-    const info = ptr_ty.ptrInfo(mod);
+    const info = ptr_ty.ptrInfo(zcu);
     if (info.flags.size == .One) {
         // Already an array pointer.
         return ptr;
 @@ -25670,7 +25674,7 @@ fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !A
         },
     });
     const non_slice_ptr = if (info.flags.size == .Slice)
-        try block.addTyOp(.slice_ptr, ptr_ty.slicePtrFieldType(mod), ptr)
+        try block.addTyOp(.slice_ptr, ptr_ty.slicePtrFieldType(zcu), ptr)
     else
         ptr;
     return block.addBitCast(new_ty, non_slice_ptr);
 @@ -25689,10 +25693,10 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const dest_len = try indexablePtrLenOrNone(sema, block, dest_src, dest_ptr);
     const src_len = try indexablePtrLenOrNone(sema, block, src_src, src_ptr);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
-    if (dest_ty.isConstPtr(mod)) {
+    if (dest_ty.isConstPtr(zcu)) {
         return sema.fail(block, dest_src, "cannot memcpy to constant pointer", .{});
     }
 @@ -25755,7 +25759,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const runtime_src = if (try sema.resolveDefinedValue(block, dest_src, dest_ptr)) |dest_ptr_val| rs: {
         if (!sema.isComptimeMutablePtr(dest_ptr_val)) break :rs dest_src;
         if (try sema.resolveDefinedValue(block, src_src, src_ptr)) |_| {
-            const len_u64 = (try len_val.?.getUnsignedIntAdvanced(pt, .sema)).?;
+            const len_u64 = try len_val.?.toUnsignedIntSema(pt);
             const len = try sema.usizeCast(block, dest_src, len_u64);
             for (0..len) |i| {
                 const elem_index = try pt.intRef(Type.usize, i);
 @@ -25798,12 +25802,12 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     // lowering. The AIR instruction requires pointers with element types of
     // equal ABI size.
-    if (dest_ty.zigTypeTag(mod) != .Pointer or src_ty.zigTypeTag(mod) != .Pointer) {
+    if (dest_ty.zigTypeTag(zcu) != .Pointer or src_ty.zigTypeTag(zcu) != .Pointer) {
         return sema.fail(block, src, "TODO: lower @memcpy to a for loop because the source or destination iterable is a tuple", .{});
     }
-    const dest_elem_ty = dest_ty.elemType2(mod);
+    const dest_elem_ty = dest_ty.elemType2(zcu);
-    const src_elem_ty = src_ty.elemType2(mod);
+    const src_elem_ty = src_ty.elemType2(zcu);
     if (.ok != try sema.coerceInMemoryAllowed(block, dest_elem_ty, src_elem_ty, true, target, dest_src, src_src, null)) {
         return sema.fail(block, src, "TODO: lower @memcpy to a for loop because the element types have different ABI sizes", .{});
     }
 @@ -25827,7 +25831,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         // Change the src from slice to a many pointer, to avoid multiple ptr
         // slice extractions in AIR instructions.
         const new_src_ptr_ty = sema.typeOf(new_src_ptr);
-        if (new_src_ptr_ty.isSlice(mod)) {
+        if (new_src_ptr_ty.isSlice(zcu)) {
             new_src_ptr = try sema.analyzeSlicePtr(block, src_src, new_src_ptr, new_src_ptr_ty);
         }
     } else if (dest_len == .none and len_val == null) {
 @@ -25835,7 +25839,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         const dest_ptr_ptr = try sema.analyzeRef(block, dest_src, new_dest_ptr);
         new_dest_ptr = try sema.analyzeSlice(block, dest_src, dest_ptr_ptr, .zero, src_len, .none, LazySrcLoc.unneeded, dest_src, dest_src, dest_src, false);
         const new_src_ptr_ty = sema.typeOf(new_src_ptr);
-        if (new_src_ptr_ty.isSlice(mod)) {
+        if (new_src_ptr_ty.isSlice(zcu)) {
             new_src_ptr = try sema.analyzeSlicePtr(block, src_src, new_src_ptr, new_src_ptr_ty);
         }
     }
 @@ -25854,10 +25858,10 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         // Extract raw pointer from dest slice. The AIR instructions could support them, but
         // it would cause redundant machine code instructions.
         const new_dest_ptr_ty = sema.typeOf(new_dest_ptr);
-        const raw_dest_ptr = if (new_dest_ptr_ty.isSlice(mod))
+        const raw_dest_ptr = if (new_dest_ptr_ty.isSlice(zcu))
             try sema.analyzeSlicePtr(block, dest_src, new_dest_ptr, new_dest_ptr_ty)
-        else if (new_dest_ptr_ty.ptrSize(mod) == .One) ptr: {
+        else if (new_dest_ptr_ty.ptrSize(zcu) == .One) ptr: {
-            var dest_manyptr_ty_key = mod.intern_pool.indexToKey(new_dest_ptr_ty.toIntern()).ptr_type;
+            var dest_manyptr_ty_key = zcu.intern_pool.indexToKey(new_dest_ptr_ty.toIntern()).ptr_type;
             assert(dest_manyptr_ty_key.flags.size == .One);
             dest_manyptr_ty_key.child = dest_elem_ty.toIntern();
             dest_manyptr_ty_key.flags.size = .Many;
 @@ -25865,10 +25869,10 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         } else new_dest_ptr;
         const new_src_ptr_ty = sema.typeOf(new_src_ptr);
-        const raw_src_ptr = if (new_src_ptr_ty.isSlice(mod))
+        const raw_src_ptr = if (new_src_ptr_ty.isSlice(zcu))
             try sema.analyzeSlicePtr(block, src_src, new_src_ptr, new_src_ptr_ty)
-        else if (new_src_ptr_ty.ptrSize(mod) == .One) ptr: {
+        else if (new_src_ptr_ty.ptrSize(zcu) == .One) ptr: {
-            var src_manyptr_ty_key = mod.intern_pool.indexToKey(new_src_ptr_ty.toIntern()).ptr_type;
+            var src_manyptr_ty_key = zcu.intern_pool.indexToKey(new_src_ptr_ty.toIntern()).ptr_type;
             assert(src_manyptr_ty_key.flags.size == .One);
             src_manyptr_ty_key.child = src_elem_ty.toIntern();
             src_manyptr_ty_key.flags.size = .Many;
 @@ -25896,9 +25900,9 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
 fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const src = block.nodeOffset(inst_data.src_node);
 @@ -25909,17 +25913,17 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
     const dest_ptr_ty = sema.typeOf(dest_ptr);
     try checkMemOperand(sema, block, dest_src, dest_ptr_ty);
-    if (dest_ptr_ty.isConstPtr(mod)) {
+    if (dest_ptr_ty.isConstPtr(zcu)) {
         return sema.fail(block, dest_src, "cannot memset constant pointer", .{});
     }
     const dest_elem_ty: Type = dest_elem_ty: {
-        const ptr_info = dest_ptr_ty.ptrInfo(mod);
+        const ptr_info = dest_ptr_ty.ptrInfo(zcu);
         switch (ptr_info.flags.size) {
             .Slice => break :dest_elem_ty Type.fromInterned(ptr_info.child),
             .One => {
-                if (Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Array) {
+                if (Type.fromInterned(ptr_info.child).zigTypeTag(zcu) == .Array) {
-                    break :dest_elem_ty Type.fromInterned(ptr_info.child).childType(mod);
+                    break :dest_elem_ty Type.fromInterned(ptr_info.child).childType(zcu);
                 }
             },
             .Many, .C => {},
 @@ -25940,7 +25944,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
         const ptr_val = try sema.resolveDefinedValue(block, dest_src, dest_ptr) orelse break :rs dest_src;
         const len_air_ref = try sema.fieldVal(block, src, dest_ptr, try ip.getOrPutString(gpa, pt.tid, "len", .no_embedded_nulls), dest_src);
         const len_val = (try sema.resolveDefinedValue(block, dest_src, len_air_ref)) orelse break :rs dest_src;
-        const len_u64 = (try len_val.getUnsignedIntAdvanced(pt, .sema)).?;
+        const len_u64 = try len_val.toUnsignedIntSema(pt);
         const len = try sema.usizeCast(block, dest_src, len_u64);
         if (len == 0) {
             // This AIR instruction guarantees length > 0 if it is comptime-known.
 @@ -25958,12 +25962,12 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
             .storage = .{ .repeated_elem = elem_val.toIntern() },
         } }));
         const array_ptr_ty = ty: {
-            var info = dest_ptr_ty.ptrInfo(mod);
+            var info = dest_ptr_ty.ptrInfo(zcu);
             info.flags.size = .One;
             info.child = array_ty.toIntern();
             break :ty try pt.ptrType(info);
         };
-        const raw_ptr_val = if (dest_ptr_ty.isSlice(mod)) ptr_val.slicePtr(mod) else ptr_val;
+        const raw_ptr_val = if (dest_ptr_ty.isSlice(zcu)) ptr_val.slicePtr(zcu) else ptr_val;
         const array_ptr_val = try pt.getCoerced(raw_ptr_val, array_ptr_ty);
         return sema.storePtrVal(block, src, array_ptr_val, array_val, array_ty);
     };
 @@ -26129,10 +26133,10 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     defer tracy.end();
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const extra = sema.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     const align_src = block.src(.{ .node_offset_fn_type_align = inst_data.src_node });
     const addrspace_src = block.src(.{ .node_offset_fn_type_addrspace = inst_data.src_node });
 @@ -26207,7 +26211,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         if (val.isGenericPoison()) {
             break :blk null;
         }
-        break :blk mod.toEnum(std.builtin.AddressSpace, val);
+        break :blk zcu.toEnum(std.builtin.AddressSpace, val);
     } else if (extra.data.bits.has_addrspace_ref) blk: {
         const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
 @@ -26226,7 +26230,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
             error.GenericPoison => break :blk null,
             else => |e| return e,
         };
-        break :blk mod.toEnum(std.builtin.AddressSpace, addrspace_val);
+        break :blk zcu.toEnum(std.builtin.AddressSpace, addrspace_val);
     } else target_util.defaultAddressSpace(target, .function);
     const section: Section = if (extra.data.bits.has_section_body) blk: {
 @@ -26272,7 +26276,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         if (val.isGenericPoison()) {
             break :blk null;
         }
-        break :blk mod.toEnum(std.builtin.CallingConvention, val);
+        break :blk zcu.toEnum(std.builtin.CallingConvention, val);
     } else if (extra.data.bits.has_cc_ref) blk: {
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
 @@ -26291,18 +26295,18 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
             error.GenericPoison => break :blk null,
             else => |e| return e,
         };
-        break :blk mod.toEnum(std.builtin.CallingConvention, cc_val);
+        break :blk zcu.toEnum(std.builtin.CallingConvention, cc_val);
     } else cc: {
         if (has_body) {
             const decl_inst = if (sema.generic_owner != .none) decl_inst: {
                 // Generic instance -- use the original function declaration to
                 // look for the `export` syntax.
-                const nav = mod.intern_pool.getNav(mod.funcInfo(sema.generic_owner).owner_nav);
+                const nav = zcu.intern_pool.getNav(zcu.funcInfo(sema.generic_owner).owner_nav);
-                const cau = mod.intern_pool.getCau(nav.analysis_owner.unwrap().?);
+                const cau = zcu.intern_pool.getCau(nav.analysis_owner.unwrap().?);
                 break :decl_inst cau.zir_index;
             } else sema.getOwnerCauDeclInst(); // not an instantiation so we're analyzing a function declaration Cau
-            const zir_decl = sema.code.getDeclaration(decl_inst.resolve(&mod.intern_pool) orelse return error.AnalysisFail)[0];
+            const zir_decl = sema.code.getDeclaration(decl_inst.resolve(&zcu.intern_pool) orelse return error.AnalysisFail)[0];
             if (zir_decl.flags.is_export) {
                 break :cc .C;
             }
 @@ -26408,7 +26412,7 @@ fn zirCDefine(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
     const name_src = block.builtinCallArgSrc(extra.node, 0);
     const val_src = block.builtinCallArgSrc(extra.node, 1);
 @@ -26417,7 +26421,7 @@ fn zirCDefine(
         .needed_comptime_reason = "name of macro being undefined must be comptime-known",
     });
     const rhs = try sema.resolveInst(extra.rhs);
-    if (sema.typeOf(rhs).zigTypeTag(mod) != .Void) {
+    if (sema.typeOf(rhs).zigTypeTag(zcu) != .Void) {
         const value = try sema.resolveConstString(block, val_src, extra.rhs, .{
             .needed_comptime_reason = "value of macro being undefined must be comptime-known",
         });
 @@ -26490,9 +26494,9 @@ fn resolvePrefetchOptions(
     zir_ref: Zir.Inst.Ref,
 ) CompileError!std.builtin.PrefetchOptions {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const options_ty = try pt.getBuiltinType("PrefetchOptions");
     const options = try sema.coerce(block, options_ty, try sema.resolveInst(zir_ref), src);
 @@ -26516,9 +26520,9 @@ fn resolvePrefetchOptions(
     });
     return std.builtin.PrefetchOptions{
-        .rw = mod.toEnum(std.builtin.PrefetchOptions.Rw, rw_val),
+        .rw = zcu.toEnum(std.builtin.PrefetchOptions.Rw, rw_val),
         .locality = @intCast(try locality_val.toUnsignedIntSema(pt)),
-        .cache = mod.toEnum(std.builtin.PrefetchOptions.Cache, cache_val),
+        .cache = zcu.toEnum(std.builtin.PrefetchOptions.Cache, cache_val),
     };
 }
 @@ -26562,9 +26566,9 @@ fn resolveExternOptions(
     is_thread_local: bool = false,
 } {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const options_inst = try sema.resolveInst(zir_ref);
     const extern_options_ty = try pt.getBuiltinType("ExternOptions");
     const options = try sema.coerce(block, extern_options_ty, options_inst, src);
 @@ -26588,14 +26592,14 @@ fn resolveExternOptions(
     const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{
         .needed_comptime_reason = "linkage of the extern symbol must be comptime-known",
     });
-    const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);
+    const linkage = zcu.toEnum(std.builtin.GlobalLinkage, linkage_val);
     const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "is_thread_local", .no_embedded_nulls), thread_local_src);
     const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{
         .needed_comptime_reason = "threadlocality of the extern symbol must be comptime-known",
     });
-    const library_name = if (library_name_val.optionalValue(mod)) |library_name_payload| library_name: {
+    const library_name = if (library_name_val.optionalValue(zcu)) |library_name_payload| library_name: {
         const library_name = try sema.toConstString(block, library_src, Air.internedToRef(library_name_payload.toIntern()), .{
             .needed_comptime_reason = "library in which extern symbol is must be comptime-known",
         });
 @@ -26628,14 +26632,14 @@ fn zirBuiltinExtern(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
     const ty_src = block.builtinCallArgSrc(extra.node, 0);
     const options_src = block.builtinCallArgSrc(extra.node, 1);
     var ty = try sema.resolveType(block, ty_src, extra.lhs);
-    if (!ty.isPtrAtRuntime(mod)) {
+    if (!ty.isPtrAtRuntime(zcu)) {
         return sema.fail(block, ty_src, "expected (optional) pointer", .{});
     }
     if (!try sema.validateExternType(ty, .other)) {
 @@ -26652,10 +26656,10 @@ fn zirBuiltinExtern(
     // TODO: error for threadlocal functions, non-const functions, etc
-    if (options.linkage == .weak and !ty.ptrAllowsZero(mod)) {
+    if (options.linkage == .weak and !ty.ptrAllowsZero(zcu)) {
         ty = try pt.optionalType(ty.toIntern());
     }
-    const ptr_info = ty.ptrInfo(mod);
+    const ptr_info = ty.ptrInfo(zcu);
     const extern_val = try pt.getExtern(.{
         .name = options.name,
 @@ -26801,7 +26805,7 @@ fn validateVarType(
     is_extern: bool,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (is_extern) {
         if (!try sema.validateExternType(var_ty, .other)) {
             const msg = msg: {
 @@ -26813,7 +26817,7 @@ fn validateVarType(
             return sema.failWithOwnedErrorMsg(block, msg);
         }
     } else {
-        if (var_ty.zigTypeTag(mod) == .Opaque) {
+        if (var_ty.zigTypeTag(zcu) == .Opaque) {
             return sema.fail(
                 block,
                 src,
 @@ -26823,14 +26827,14 @@ fn validateVarType(
         }
     }
-    if (!try sema.typeRequiresComptime(var_ty)) return;
+    if (!try var_ty.comptimeOnlySema(pt)) return;
     const msg = msg: {
         const msg = try sema.errMsg(src, "variable of type '{}' must be const or comptime", .{var_ty.fmt(pt)});
         errdefer msg.destroy(sema.gpa);
         try sema.explainWhyTypeIsComptime(msg, src, var_ty);
-        if (var_ty.zigTypeTag(mod) == .ComptimeInt or var_ty.zigTypeTag(mod) == .ComptimeFloat) {
+        if (var_ty.zigTypeTag(zcu) == .ComptimeInt or var_ty.zigTypeTag(zcu) == .ComptimeFloat) {
             try sema.errNote(src, msg, "to modify this variable at runtime, it must be given an explicit fixed-size number type", .{});
         }
 @@ -26843,7 +26847,7 @@ const TypeSet = std.AutoHashMapUnmanaged(InternPool.Index, void);
 fn explainWhyTypeIsComptime(
     sema: *Sema,
-    msg: *Module.ErrorMsg,
+    msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
     ty: Type,
 ) CompileError!void {
 @@ -26856,15 +26860,15 @@ fn explainWhyTypeIsComptime(
 fn explainWhyTypeIsComptimeInner(
     sema: *Sema,
-    msg: *Module.ErrorMsg,
+    msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
     ty: Type,
     type_set: *TypeSet,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Bool,
         .Int,
         .Float,
 @@ -26896,12 +26900,12 @@ fn explainWhyTypeIsComptimeInner(
         },
         .Array, .Vector => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(mod), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(zcu), type_set);
         },
         .Pointer => {
-            const elem_ty = ty.elemType2(mod);
+            const elem_ty = ty.elemType2(zcu);
-            if (elem_ty.zigTypeTag(mod) == .Fn) {
+            if (elem_ty.zigTypeTag(zcu) == .Fn) {
-                const fn_info = mod.typeToFunc(elem_ty).?;
+                const fn_info = zcu.typeToFunc(elem_ty).?;
                 if (fn_info.is_generic) {
                     try sema.errNote(src_loc, msg, "function is generic", .{});
                 }
 @@ -26909,25 +26913,25 @@ fn explainWhyTypeIsComptimeInner(
                     .Inline => try sema.errNote(src_loc, msg, "function has inline calling convention", .{}),
                     else => {},
                 }
-                if (Type.fromInterned(fn_info.return_type).comptimeOnly(pt)) {
+                if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) {
                     try sema.errNote(src_loc, msg, "function has a comptime-only return type", .{});
                 }
                 return;
             }
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(mod), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(zcu), type_set);
         },
         .Optional => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.optionalChild(mod), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.optionalChild(zcu), type_set);
         },
         .ErrorUnion => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.errorUnionPayload(mod), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.errorUnionPayload(zcu), type_set);
         },
         .Struct => {
             if ((try type_set.getOrPut(sema.gpa, ty.toIntern())).found_existing) return;
-            if (mod.typeToStruct(ty)) |struct_type| {
+            if (zcu.typeToStruct(ty)) |struct_type| {
                 for (0..struct_type.field_types.len) |i| {
                     const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
                     const field_src: LazySrcLoc = .{
 @@ -26935,7 +26939,7 @@ fn explainWhyTypeIsComptimeInner(
                         .offset = .{ .container_field_type = @intCast(i) },
                     };
-                    if (try sema.typeRequiresComptime(field_ty)) {
+                    if (try field_ty.comptimeOnlySema(pt)) {
                         try sema.errNote(field_src, msg, "struct requires comptime because of this field", .{});
                         try sema.explainWhyTypeIsComptimeInner(msg, field_src, field_ty, type_set);
                     }
 @@ -26947,7 +26951,7 @@ fn explainWhyTypeIsComptimeInner(
         .Union => {
             if ((try type_set.getOrPut(sema.gpa, ty.toIntern())).found_existing) return;
-            if (mod.typeToUnion(ty)) |union_obj| {
+            if (zcu.typeToUnion(ty)) |union_obj| {
                 for (0..union_obj.field_types.len) |i| {
                     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[i]);
                     const field_src: LazySrcLoc = .{
 @@ -26955,7 +26959,7 @@ fn explainWhyTypeIsComptimeInner(
                         .offset = .{ .container_field_type = @intCast(i) },
                     };
-                    if (try sema.typeRequiresComptime(field_ty)) {
+                    if (try field_ty.comptimeOnlySema(pt)) {
                         try sema.errNote(field_src, msg, "union requires comptime because of this field", .{});
                         try sema.explainWhyTypeIsComptimeInner(msg, field_src, field_ty, type_set);
                     }
 @@ -26983,8 +26987,8 @@ fn validateExternType(
     position: ExternPosition,
 ) !bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Type,
         .ComptimeFloat,
         .ComptimeInt,
 @@ -27003,58 +27007,58 @@ fn validateExternType(
         .AnyFrame,
         => return true,
         .Pointer => {
-            if (ty.childType(mod).zigTypeTag(mod) == .Fn) {
+            if (ty.childType(zcu).zigTypeTag(zcu) == .Fn) {
-                return ty.isConstPtr(mod) and try sema.validateExternType(ty.childType(mod), .other);
+                return ty.isConstPtr(zcu) and try sema.validateExternType(ty.childType(zcu), .other);
             }
-            return !(ty.isSlice(mod) or try sema.typeRequiresComptime(ty));
+            return !(ty.isSlice(zcu) or try ty.comptimeOnlySema(pt));
         },
-        .Int => switch (ty.intInfo(mod).bits) {
+        .Int => switch (ty.intInfo(zcu).bits) {
             0, 8, 16, 32, 64, 128 => return true,
             else => return false,
         },
         .Fn => {
             if (position != .other) return false;
-            const target = mod.getTarget();
+            const target = zcu.getTarget();
             // For now we want to authorize PTX kernel to use zig objects, even if we end up exposing the ABI.
             // The goal is to experiment with more integrated CPU/GPU code.
-            if (ty.fnCallingConvention(mod) == .Kernel and (target.cpu.arch == .nvptx or target.cpu.arch == .nvptx64)) {
+            if (ty.fnCallingConvention(zcu) == .Kernel and (target.cpu.arch == .nvptx or target.cpu.arch == .nvptx64)) {
                 return true;
             }
-            return !target_util.fnCallConvAllowsZigTypes(target, ty.fnCallingConvention(mod));
+            return !target_util.fnCallConvAllowsZigTypes(target, ty.fnCallingConvention(zcu));
         },
         .Enum => {
-            return sema.validateExternType(ty.intTagType(mod), position);
+            return sema.validateExternType(ty.intTagType(zcu), position);
         },
-        .Struct, .Union => switch (ty.containerLayout(mod)) {
+        .Struct, .Union => switch (ty.containerLayout(zcu)) {
             .@"extern" => return true,
             .@"packed" => {
-                const bit_size = try ty.bitSizeAdvanced(pt, .sema);
+                const bit_size = try ty.bitSizeSema(pt);
                 switch (bit_size) {
                     0, 8, 16, 32, 64, 128 => return true,
                     else => return false,
                 }
             },
-            .auto => return !(try sema.typeHasRuntimeBits(ty)),
+            .auto => return !(try ty.hasRuntimeBitsSema(pt)),
         },
         .Array => {
             if (position == .ret_ty or position == .param_ty) return false;
-            return sema.validateExternType(ty.elemType2(mod), .element);
+            return sema.validateExternType(ty.elemType2(zcu), .element);
         },
-        .Vector => return sema.validateExternType(ty.elemType2(mod), .element),
+        .Vector => return sema.validateExternType(ty.elemType2(zcu), .element),
-        .Optional => return ty.isPtrLikeOptional(mod),
+        .Optional => return ty.isPtrLikeOptional(zcu),
     }
 }
 fn explainWhyTypeIsNotExtern(
     sema: *Sema,
-    msg: *Module.ErrorMsg,
+    msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
     ty: Type,
     position: ExternPosition,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Opaque,
         .Bool,
         .Float,
 @@ -27073,13 +27077,13 @@ fn explainWhyTypeIsNotExtern(
         => return,
         .Pointer => {
-            if (ty.isSlice(mod)) {
+            if (ty.isSlice(zcu)) {
                 try sema.errNote(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
             } else {
-                const pointee_ty = ty.childType(mod);
+                const pointee_ty = ty.childType(zcu);
-                if (!ty.isConstPtr(mod) and pointee_ty.zigTypeTag(mod) == .Fn) {
+                if (!ty.isConstPtr(zcu) and pointee_ty.zigTypeTag(zcu) == .Fn) {
                     try sema.errNote(src_loc, msg, "pointer to extern function must be 'const'", .{});
-                } else if (try sema.typeRequiresComptime(ty)) {
+                } else if (try ty.comptimeOnlySema(pt)) {
                     try sema.errNote(src_loc, msg, "pointer to comptime-only type '{}'", .{pointee_ty.fmt(pt)});
                     try sema.explainWhyTypeIsComptime(msg, src_loc, ty);
                 }
 @@ -27088,7 +27092,7 @@ fn explainWhyTypeIsNotExtern(
         },
         .Void => try sema.errNote(src_loc, msg, "'void' is a zero bit type; for C 'void' use 'anyopaque'", .{}),
         .NoReturn => try sema.errNote(src_loc, msg, "'noreturn' is only allowed as a return type", .{}),
-        .Int => if (!std.math.isPowerOfTwo(ty.intInfo(mod).bits)) {
+        .Int => if (!std.math.isPowerOfTwo(ty.intInfo(zcu).bits)) {
             try sema.errNote(src_loc, msg, "only integers with 0 or power of two bits are extern compatible", .{});
         } else {
             try sema.errNote(src_loc, msg, "only integers with 0, 8, 16, 32, 64 and 128 bits are extern compatible", .{});
 @@ -27099,7 +27103,7 @@ fn explainWhyTypeIsNotExtern(
                 try sema.errNote(src_loc, msg, "use '*const ' to make a function pointer type", .{});
                 return;
             }
-            switch (ty.fnCallingConvention(mod)) {
+            switch (ty.fnCallingConvention(zcu)) {
                 .Unspecified => try sema.errNote(src_loc, msg, "extern function must specify calling convention", .{}),
                 .Async => try sema.errNote(src_loc, msg, "async function cannot be extern", .{}),
                 .Inline => try sema.errNote(src_loc, msg, "inline function cannot be extern", .{}),
 @@ -27107,7 +27111,7 @@ fn explainWhyTypeIsNotExtern(
             }
         },
         .Enum => {
-            const tag_ty = ty.intTagType(mod);
+            const tag_ty = ty.intTagType(zcu);
             try sema.errNote(src_loc, msg, "enum tag type '{}' is not extern compatible", .{tag_ty.fmt(pt)});
             try sema.explainWhyTypeIsNotExtern(msg, src_loc, tag_ty, position);
         },
 @@ -27119,9 +27123,9 @@ fn explainWhyTypeIsNotExtern(
             } else if (position == .param_ty) {
                 return sema.errNote(src_loc, msg, "arrays are not allowed as a parameter type", .{});
             }
-            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(mod), .element);
+            try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(zcu), .element);
         },
-        .Vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(mod), .element),
+        .Vector => try sema.explainWhyTypeIsNotExtern(msg, src_loc, ty.elemType2(zcu), .element),
         .Optional => try sema.errNote(src_loc, msg, "only pointer like optionals are extern compatible", .{}),
     }
 }
 @@ -27158,20 +27162,20 @@ fn validatePackedType(sema: *Sema, ty: Type) !bool {
             .auto => false,
             .explicit, .nonexhaustive => true,
         },
-        .Pointer => !ty.isSlice(zcu) and !try sema.typeRequiresComptime(ty),
+        .Pointer => !ty.isSlice(zcu) and !try ty.comptimeOnlySema(pt),
         .Struct, .Union => ty.containerLayout(zcu) == .@"packed",
     };
 }
 fn explainWhyTypeIsNotPacked(
     sema: *Sema,
-    msg: *Module.ErrorMsg,
+    msg: *Zcu.ErrorMsg,
     src_loc: LazySrcLoc,
     ty: Type,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Void,
         .Bool,
         .Float,
 @@ -27194,7 +27198,7 @@ fn explainWhyTypeIsNotPacked(
         .Optional,
         .Array,
         => try sema.errNote(src_loc, msg, "type has no guaranteed in-memory representation", .{}),
-        .Pointer => if (ty.isSlice(mod)) {
+        .Pointer => if (ty.isSlice(zcu)) {
             try sema.errNote(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
         } else {
             try sema.errNote(src_loc, msg, "comptime-only pointer has no guaranteed in-memory representation", .{});
 @@ -27211,23 +27215,23 @@ fn explainWhyTypeIsNotPacked(
 fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (mod.panic_func_index == .none) {
+    if (zcu.panic_func_index == .none) {
         const fn_ref = try sema.analyzeNavVal(block, src, try pt.getBuiltinNav("panic"));
         const fn_val = try sema.resolveConstValue(block, src, fn_ref, .{
             .needed_comptime_reason = "panic handler must be comptime-known",
         });
-        assert(fn_val.typeOf(mod).zigTypeTag(mod) == .Fn);
+        assert(fn_val.typeOf(zcu).zigTypeTag(zcu) == .Fn);
-        assert(try sema.fnHasRuntimeBits(fn_val.typeOf(mod)));
+        assert(try fn_val.typeOf(zcu).fnHasRuntimeBitsSema(pt));
-        try mod.ensureFuncBodyAnalysisQueued(fn_val.toIntern());
+        try zcu.ensureFuncBodyAnalysisQueued(fn_val.toIntern());
-        mod.panic_func_index = fn_val.toIntern();
+        zcu.panic_func_index = fn_val.toIntern();
     }
-    if (mod.null_stack_trace == .none) {
+    if (zcu.null_stack_trace == .none) {
         const stack_trace_ty = try pt.getBuiltinType("StackTrace");
         try stack_trace_ty.resolveFields(pt);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const ptr_stack_trace_ty = try pt.ptrTypeSema(.{
             .child = stack_trace_ty.toIntern(),
             .flags = .{
 @@ -27235,7 +27239,7 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void {
             },
         });
         const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
-        mod.null_stack_trace = try pt.intern(.{ .opt = .{
+        zcu.null_stack_trace = try pt.intern(.{ .opt = .{
             .ty = opt_ptr_stack_trace_ty.toIntern(),
             .val = .none,
         } });
 @@ -27245,11 +27249,11 @@ fn prepareSimplePanic(sema: *Sema, block: *Block, src: LazySrcLoc) !void {
 /// Backends depend on panic decls being available when lowering safety-checked
 /// instructions. This function ensures the panic function will be available to
 /// be called during that time.
-fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Module.PanicId) !InternPool.Nav.Index {
+fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) !InternPool.Nav.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    if (mod.panic_messages[@intFromEnum(panic_id)].unwrap()) |x| return x;
+    if (zcu.panic_messages[@intFromEnum(panic_id)].unwrap()) |x| return x;
     try sema.prepareSimplePanic(block, src);
 @@ -27257,15 +27261,15 @@ fn preparePanicId(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Module.
     const msg_nav_index = (sema.namespaceLookup(
         block,
         LazySrcLoc.unneeded,
-        panic_messages_ty.getNamespaceIndex(mod),
+        panic_messages_ty.getNamespaceIndex(zcu),
-        try mod.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls),
+        try zcu.intern_pool.getOrPutString(gpa, pt.tid, @tagName(panic_id), .no_embedded_nulls),
     ) catch |err| switch (err) {
         error.AnalysisFail => @panic("std.builtin.panic_messages is corrupt"),
         error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
         error.OutOfMemory => |e| return e,
     }).?;
     try sema.ensureNavResolved(src, msg_nav_index);
-    mod.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional();
+    zcu.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional();
     return msg_nav_index;
 }
 @@ -27274,7 +27278,7 @@ fn addSafetyCheck(
     parent_block: *Block,
     src: LazySrcLoc,
     ok: Air.Inst.Ref,
-    panic_id: Module.PanicId,
+    panic_id: Zcu.PanicId,
 ) !void {
     const gpa = sema.gpa;
     assert(!parent_block.is_comptime);
 @@ -27353,18 +27357,18 @@ fn addSafetyCheckExtra(
 fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.Ref, operation: CallOperation) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (!mod.backendSupportsFeature(.panic_fn)) {
+    if (!zcu.backendSupportsFeature(.panic_fn)) {
         _ = try block.addNoOp(.trap);
         return;
     }
     try sema.prepareSimplePanic(block, src);
-    const panic_func = mod.funcInfo(mod.panic_func_index);
+    const panic_func = zcu.funcInfo(zcu.panic_func_index);
     const panic_fn = try sema.analyzeNavVal(block, src, panic_func.owner_nav);
-    const null_stack_trace = Air.internedToRef(mod.null_stack_trace);
+    const null_stack_trace = Air.internedToRef(zcu.null_stack_trace);
     const opt_usize_ty = try pt.optionalType(.usize_type);
     const null_ret_addr = Air.internedToRef((try pt.intern(.{ .opt = .{
 @@ -27459,12 +27463,12 @@ fn panicSentinelMismatch(
 ) !void {
     assert(!parent_block.is_comptime);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const expected_sentinel_val = maybe_sentinel orelse return;
     const expected_sentinel = Air.internedToRef(expected_sentinel_val.toIntern());
     const ptr_ty = sema.typeOf(ptr);
-    const actual_sentinel = if (ptr_ty.isSlice(mod))
+    const actual_sentinel = if (ptr_ty.isSlice(zcu))
         try parent_block.addBinOp(.slice_elem_val, ptr, sentinel_index)
     else blk: {
         const elem_ptr_ty = try ptr_ty.elemPtrType(null, pt);
 @@ -27472,7 +27476,7 @@ fn panicSentinelMismatch(
         break :blk try parent_block.addTyOp(.load, sentinel_ty, sentinel_ptr);
     };
-    const ok = if (sentinel_ty.zigTypeTag(mod) == .Vector) ok: {
+    const ok = if (sentinel_ty.zigTypeTag(zcu) == .Vector) ok: {
         const eql =
             try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq);
         break :ok try parent_block.addInst(.{
 @@ -27482,7 +27486,7 @@ fn panicSentinelMismatch(
                 .operation = .And,
             } },
         });
-    } else if (sentinel_ty.isSelfComparable(mod, true))
+    } else if (sentinel_ty.isSelfComparable(zcu, true))
         try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel)
     else {
         const panic_fn = try pt.getBuiltin("checkNonScalarSentinel");
 @@ -27532,7 +27536,7 @@ fn safetyCheckFormatted(
     try sema.addSafetyCheckExtra(parent_block, ok, &fail_block);
 }
-fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Module.PanicId) CompileError!void {
+fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Zcu.PanicId) CompileError!void {
     const msg_nav_index = try sema.preparePanicId(block, src, panic_id);
     const msg_inst = try sema.analyzeNavVal(block, src, msg_nav_index);
     try sema.panicWithMsg(block, src, msg_inst, .@"safety check");
 @@ -27568,30 +27572,30 @@ fn fieldVal(
     // in `fieldPtr`. This function takes a value and returns a value.
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const object_src = src; // TODO better source location
     const object_ty = sema.typeOf(object);
     // Zig allows dereferencing a single pointer during field lookup. Note that
     // we don't actually need to generate the dereference some field lookups, like the
     // length of arrays and other comptime operations.
-    const is_pointer_to = object_ty.isSinglePointer(mod);
+    const is_pointer_to = object_ty.isSinglePointer(zcu);
     const inner_ty = if (is_pointer_to)
-        object_ty.childType(mod)
+        object_ty.childType(zcu)
     else
         object_ty;
-    switch (inner_ty.zigTypeTag(mod)) {
+    switch (inner_ty.zigTypeTag(zcu)) {
         .Array => {
             if (field_name.eqlSlice("len", ip)) {
-                return Air.internedToRef((try pt.intValue(Type.usize, inner_ty.arrayLen(mod))).toIntern());
+                return Air.internedToRef((try pt.intValue(Type.usize, inner_ty.arrayLen(zcu))).toIntern());
             } else if (field_name.eqlSlice("ptr", ip) and is_pointer_to) {
-                const ptr_info = object_ty.ptrInfo(mod);
+                const ptr_info = object_ty.ptrInfo(zcu);
                 const result_ty = try pt.ptrTypeSema(.{
-                    .child = Type.fromInterned(ptr_info.child).childType(mod).toIntern(),
+                    .child = Type.fromInterned(ptr_info.child).childType(zcu).toIntern(),
-                    .sentinel = if (inner_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                    .sentinel = if (inner_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
                         .size = .Many,
                         .alignment = ptr_info.flags.alignment,
 @@ -27614,7 +27618,7 @@ fn fieldVal(
             }
         },
         .Pointer => {
-            const ptr_info = inner_ty.ptrInfo(mod);
+            const ptr_info = inner_ty.ptrInfo(zcu);
             if (ptr_info.flags.size == .Slice) {
                 if (field_name.eqlSlice("ptr", ip)) {
                     const slice = if (is_pointer_to)
 @@ -27647,7 +27651,7 @@ fn fieldVal(
             const val = (try sema.resolveDefinedValue(block, object_src, dereffed_type)).?;
             const child_type = val.toType();
-            switch (try child_type.zigTypeTagOrPoison(mod)) {
+            switch (try child_type.zigTypeTagOrPoison(zcu)) {
                 .ErrorSet => {
                     switch (ip.indexToKey(child_type.toIntern())) {
                         .error_set_type => |error_set_type| blk: {
 @@ -27666,7 +27670,7 @@ fn fieldVal(
                         else => unreachable,
                     }
-                    const error_set_type = if (!child_type.isAnyError(mod))
+                    const error_set_type = if (!child_type.isAnyError(zcu))
                         child_type
                     else
                         try pt.singleErrorSetType(field_name);
 @@ -27676,12 +27680,12 @@ fn fieldVal(
                     } })));
                 },
                 .Union => {
-                    if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                    if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
                     try child_type.resolveFields(pt);
-                    if (child_type.unionTagType(mod)) |enum_ty| {
+                    if (child_type.unionTagType(zcu)) |enum_ty| {
-                        if (enum_ty.enumFieldIndex(field_name, mod)) |field_index_usize| {
+                        if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index_usize| {
                             const field_index: u32 = @intCast(field_index_usize);
                             return Air.internedToRef((try pt.enumValueFieldIndex(enum_ty, field_index)).toIntern());
                         }
 @@ -27689,10 +27693,10 @@ fn fieldVal(
                     return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                 },
                 .Enum => {
-                    if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                    if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    const field_index_usize = child_type.enumFieldIndex(field_name, mod) orelse
+                    const field_index_usize = child_type.enumFieldIndex(field_name, zcu) orelse
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     const field_index: u32 = @intCast(field_index_usize);
                     const enum_val = try pt.enumValueFieldIndex(child_type, field_index);
 @@ -27701,7 +27705,7 @@ fn fieldVal(
                 .Struct, .Opaque => {
                     switch (child_type.toIntern()) {
                         .empty_struct_type, .anyopaque_type => {}, // no namespace
-                        else => if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                        else => if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                             return inst;
                         },
                     }
 @@ -27710,8 +27714,8 @@ fn fieldVal(
                 else => return sema.failWithOwnedErrorMsg(block, msg: {
                     const msg = try sema.errMsg(src, "type '{}' has no members", .{child_type.fmt(pt)});
                     errdefer msg.destroy(sema.gpa);
-                    if (child_type.isSlice(mod)) try sema.errNote(src, msg, "slice values have 'len' and 'ptr' members", .{});
+                    if (child_type.isSlice(zcu)) try sema.errNote(src, msg, "slice values have 'len' and 'ptr' members", .{});
-                    if (child_type.zigTypeTag(mod) == .Array) try sema.errNote(src, msg, "array values have 'len' member", .{});
+                    if (child_type.zigTypeTag(zcu) == .Array) try sema.errNote(src, msg, "array values have 'len' member", .{});
                     break :msg msg;
                 }),
             }
 @@ -27748,35 +27752,35 @@ fn fieldPtr(
     // in `fieldVal`. This function takes a pointer and returns a pointer.
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const object_ptr_src = src; // TODO better source location
     const object_ptr_ty = sema.typeOf(object_ptr);
-    const object_ty = switch (object_ptr_ty.zigTypeTag(mod)) {
+    const object_ty = switch (object_ptr_ty.zigTypeTag(zcu)) {
-        .Pointer => object_ptr_ty.childType(mod),
+        .Pointer => object_ptr_ty.childType(zcu),
         else => return sema.fail(block, object_ptr_src, "expected pointer, found '{}'", .{object_ptr_ty.fmt(pt)}),
     };
     // Zig allows dereferencing a single pointer during field lookup. Note that
     // we don't actually need to generate the dereference some field lookups, like the
     // length of arrays and other comptime operations.
-    const is_pointer_to = object_ty.isSinglePointer(mod);
+    const is_pointer_to = object_ty.isSinglePointer(zcu);
     const inner_ty = if (is_pointer_to)
-        object_ty.childType(mod)
+        object_ty.childType(zcu)
     else
         object_ty;
-    switch (inner_ty.zigTypeTag(mod)) {
+    switch (inner_ty.zigTypeTag(zcu)) {
         .Array => {
             if (field_name.eqlSlice("len", ip)) {
-                const int_val = try pt.intValue(Type.usize, inner_ty.arrayLen(mod));
+                const int_val = try pt.intValue(Type.usize, inner_ty.arrayLen(zcu));
                 return uavRef(sema, int_val.toIntern());
             } else if (field_name.eqlSlice("ptr", ip) and is_pointer_to) {
-                const ptr_info = object_ty.ptrInfo(mod);
+                const ptr_info = object_ty.ptrInfo(zcu);
                 const new_ptr_ty = try pt.ptrTypeSema(.{
-                    .child = Type.fromInterned(ptr_info.child).childType(mod).toIntern(),
+                    .child = Type.fromInterned(ptr_info.child).childType(zcu).toIntern(),
-                    .sentinel = if (object_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                    .sentinel = if (object_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
                         .size = .Many,
                         .alignment = ptr_info.flags.alignment,
 @@ -27788,10 +27792,10 @@ fn fieldPtr(
                     },
                     .packed_offset = ptr_info.packed_offset,
                 });
-                const ptr_ptr_info = object_ptr_ty.ptrInfo(mod);
+                const ptr_ptr_info = object_ptr_ty.ptrInfo(zcu);
                 const result_ty = try pt.ptrTypeSema(.{
                     .child = new_ptr_ty.toIntern(),
-                    .sentinel = if (object_ptr_ty.sentinel(mod)) |s| s.toIntern() else .none,
+                    .sentinel = if (object_ptr_ty.sentinel(zcu)) |s| s.toIntern() else .none,
                     .flags = .{
                         .alignment = ptr_ptr_info.flags.alignment,
                         .is_const = ptr_ptr_info.flags.is_const,
 @@ -27812,7 +27816,7 @@ fn fieldPtr(
                 );
             }
         },
-        .Pointer => if (inner_ty.isSlice(mod)) {
+        .Pointer => if (inner_ty.isSlice(zcu)) {
             const inner_ptr = if (is_pointer_to)
                 try sema.analyzeLoad(block, src, object_ptr, object_ptr_src)
             else
 @@ -27821,14 +27825,14 @@ fn fieldPtr(
             const attr_ptr_ty = if (is_pointer_to) object_ty else object_ptr_ty;
             if (field_name.eqlSlice("ptr", ip)) {
-                const slice_ptr_ty = inner_ty.slicePtrFieldType(mod);
+                const slice_ptr_ty = inner_ty.slicePtrFieldType(zcu);
                 const result_ty = try pt.ptrTypeSema(.{
                     .child = slice_ptr_ty.toIntern(),
                     .flags = .{
-                        .is_const = !attr_ptr_ty.ptrIsMutable(mod),
+                        .is_const = !attr_ptr_ty.ptrIsMutable(zcu),
-                        .is_volatile = attr_ptr_ty.isVolatilePtr(mod),
+                        .is_volatile = attr_ptr_ty.isVolatilePtr(zcu),
-                        .address_space = attr_ptr_ty.ptrAddressSpace(mod),
+                        .address_space = attr_ptr_ty.ptrAddressSpace(zcu),
                     },
                 });
 @@ -27844,9 +27848,9 @@ fn fieldPtr(
                 const result_ty = try pt.ptrTypeSema(.{
                     .child = .usize_type,
                     .flags = .{
-                        .is_const = !attr_ptr_ty.ptrIsMutable(mod),
+                        .is_const = !attr_ptr_ty.ptrIsMutable(zcu),
-                        .is_volatile = attr_ptr_ty.isVolatilePtr(mod),
+                        .is_volatile = attr_ptr_ty.isVolatilePtr(zcu),
-                        .address_space = attr_ptr_ty.ptrAddressSpace(mod),
+                        .address_space = attr_ptr_ty.ptrAddressSpace(zcu),
                     },
                 });
 @@ -27878,7 +27882,7 @@ fn fieldPtr(
             const val = (sema.resolveDefinedValue(block, src, inner) catch unreachable).?;
             const child_type = val.toType();
-            switch (child_type.zigTypeTag(mod)) {
+            switch (child_type.zigTypeTag(zcu)) {
                 .ErrorSet => {
                     switch (ip.indexToKey(child_type.toIntern())) {
                         .error_set_type => |error_set_type| blk: {
 @@ -27899,7 +27903,7 @@ fn fieldPtr(
                         else => unreachable,
                     }
-                    const error_set_type = if (!child_type.isAnyError(mod))
+                    const error_set_type = if (!child_type.isAnyError(zcu))
                         child_type
                     else
                         try pt.singleErrorSetType(field_name);
 @@ -27909,12 +27913,12 @@ fn fieldPtr(
                     } }));
                 },
                 .Union => {
-                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
                     try child_type.resolveFields(pt);
-                    if (child_type.unionTagType(mod)) |enum_ty| {
+                    if (child_type.unionTagType(zcu)) |enum_ty| {
-                        if (enum_ty.enumFieldIndex(field_name, mod)) |field_index| {
+                        if (enum_ty.enumFieldIndex(field_name, zcu)) |field_index| {
                             const field_index_u32: u32 = @intCast(field_index);
                             const idx_val = try pt.enumValueFieldIndex(enum_ty, field_index_u32);
                             return uavRef(sema, idx_val.toIntern());
 @@ -27923,10 +27927,10 @@ fn fieldPtr(
                     return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                 },
                 .Enum => {
-                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
-                    const field_index = child_type.enumFieldIndex(field_name, mod) orelse {
+                    const field_index = child_type.enumFieldIndex(field_name, zcu) orelse {
                         return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
                     };
                     const field_index_u32: u32 = @intCast(field_index);
 @@ -27934,7 +27938,7 @@ fn fieldPtr(
                     return uavRef(sema, idx_val.toIntern());
                 },
                 .Struct, .Opaque => {
-                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(mod), field_name)) |inst| {
+                    if (try sema.namespaceLookupRef(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                         return inst;
                     }
                     return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
 @@ -28021,14 +28025,14 @@ fn fieldCallBind(
                     }
                     if (field_name.toUnsigned(ip)) |field_index| {
                         if (field_index >= concrete_ty.structFieldCount(zcu)) break :find_field;
-                        return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.structFieldType(field_index, zcu), field_index, object_ptr);
+                        return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.fieldType(field_index, zcu), field_index, object_ptr);
                     }
                 } else {
                     const max = concrete_ty.structFieldCount(zcu);
                     for (0..max) |i_usize| {
                         const i: u32 = @intCast(i_usize);
                         if (field_name == concrete_ty.structFieldName(i, zcu).unwrap().?) {
-                            return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.structFieldType(i, zcu), i, object_ptr);
+                            return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.fieldType(i, zcu), i, object_ptr);
                         }
                     }
                 }
 @@ -28149,18 +28153,18 @@ fn finishFieldCallBind(
     object_ptr: Air.Inst.Ref,
 ) CompileError!ResolvedFieldCallee {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_field_ty = try pt.ptrTypeSema(.{
         .child = field_ty.toIntern(),
         .flags = .{
-            .is_const = !ptr_ty.ptrIsMutable(mod),
+            .is_const = !ptr_ty.ptrIsMutable(zcu),
-            .address_space = ptr_ty.ptrAddressSpace(mod),
+            .address_space = ptr_ty.ptrAddressSpace(zcu),
         },
     });
-    const container_ty = ptr_ty.childType(mod);
+    const container_ty = ptr_ty.childType(zcu);
-    if (container_ty.zigTypeTag(mod) == .Struct) {
+    if (container_ty.zigTypeTag(zcu) == .Struct) {
-        if (container_ty.structFieldIsComptime(field_index, mod)) {
+        if (container_ty.structFieldIsComptime(field_index, zcu)) {
             try container_ty.resolveStructFieldInits(pt);
             const default_val = (try container_ty.structFieldValueComptime(pt, field_index)).?;
             return .{ .direct = Air.internedToRef(default_val.toIntern()) };
 @@ -28237,26 +28241,26 @@ fn structFieldPtr(
     initializing: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    assert(struct_ty.zigTypeTag(mod) == .Struct);
+    assert(struct_ty.zigTypeTag(zcu) == .Struct);
     try struct_ty.resolveFields(pt);
     try struct_ty.resolveLayout(pt);
-    if (struct_ty.isTuple(mod)) {
+    if (struct_ty.isTuple(zcu)) {
         if (field_name.eqlSlice("len", ip)) {
-            const len_inst = try pt.intRef(Type.usize, struct_ty.structFieldCount(mod));
+            const len_inst = try pt.intRef(Type.usize, struct_ty.structFieldCount(zcu));
             return sema.analyzeRef(block, src, len_inst);
         }
         const field_index = try sema.tupleFieldIndex(block, struct_ty, field_name, field_name_src);
         return sema.tupleFieldPtr(block, src, struct_ptr, field_name_src, field_index, initializing);
-    } else if (struct_ty.isAnonStruct(mod)) {
+    } else if (struct_ty.isAnonStruct(zcu)) {
         const field_index = try sema.anonStructFieldIndex(block, struct_ty, field_name, field_name_src);
         return sema.tupleFieldPtr(block, src, struct_ptr, field_name_src, field_index, initializing);
     }
-    const struct_type = mod.typeToStruct(struct_ty).?;
+    const struct_type = zcu.typeToStruct(struct_ty).?;
     const field_index = struct_type.nameIndex(ip, field_name) orelse
         return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_name_src, field_name);
 @@ -28275,9 +28279,9 @@ fn structFieldPtrByIndex(
     initializing: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    if (struct_ty.isAnonStruct(mod)) {
+    if (struct_ty.isAnonStruct(zcu)) {
         return sema.tupleFieldPtr(block, src, struct_ptr, field_src, field_index, initializing);
     }
 @@ -28286,10 +28290,10 @@ fn structFieldPtrByIndex(
         return Air.internedToRef(val.toIntern());
     }
-    const struct_type = mod.typeToStruct(struct_ty).?;
+    const struct_type = zcu.typeToStruct(struct_ty).?;
     const field_ty = struct_type.field_types.get(ip)[field_index];
     const struct_ptr_ty = sema.typeOf(struct_ptr);
-    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(mod);
+    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
     var ptr_ty_data: InternPool.Key.PtrType = .{
         .child = field_ty,
 @@ -28303,7 +28307,7 @@ fn structFieldPtrByIndex(
     const parent_align = if (struct_ptr_ty_info.flags.alignment != .none)
         struct_ptr_ty_info.flags.alignment
     else
-        try sema.typeAbiAlignment(Type.fromInterned(struct_ptr_ty_info.child));
+        try Type.fromInterned(struct_ptr_ty_info.child).abiAlignmentSema(pt);
     if (struct_type.layout == .@"packed") {
         switch (struct_ty.packedStructFieldPtrInfo(struct_ptr_ty, field_index, pt)) {
 @@ -28319,18 +28323,17 @@ fn structFieldPtrByIndex(
         // For extern structs, field alignment might be bigger than type's
         // natural alignment. Eg, in `extern struct { x: u32, y: u16 }` the
         // second field is aligned as u32.
-        const field_offset = struct_ty.structFieldOffset(field_index, pt);
+        const field_offset = struct_ty.structFieldOffset(field_index, zcu);
         ptr_ty_data.flags.alignment = if (parent_align == .none)
             .none
         else
             @enumFromInt(@min(@intFromEnum(parent_align), @ctz(field_offset)));
     } else {
         // Our alignment is capped at the field alignment.
-        const field_align = try pt.structFieldAlignmentAdvanced(
+        const field_align = try Type.fromInterned(field_ty).structFieldAlignmentSema(
             struct_type.fieldAlign(ip, field_index),
-            Type.fromInterned(field_ty),
             struct_type.layout,
-            .sema,
+            pt,
         );
         ptr_ty_data.flags.alignment = if (struct_ptr_ty_info.flags.alignment == .none)
             field_align
 @@ -28364,9 +28367,9 @@ fn structFieldVal(
     struct_ty: Type,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    assert(struct_ty.zigTypeTag(mod) == .Struct);
+    assert(struct_ty.zigTypeTag(zcu) == .Struct);
     try struct_ty.resolveFields(pt);
 @@ -28388,7 +28391,7 @@ fn structFieldVal(
                 return Air.internedToRef(field_val.toIntern());
             if (try sema.resolveValue(struct_byval)) |struct_val| {
-                if (struct_val.isUndef(mod)) return pt.undefRef(field_ty);
+                if (struct_val.isUndef(zcu)) return pt.undefRef(field_ty);
                 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
                     return Air.internedToRef(opv.toIntern());
                 }
 @@ -28421,9 +28424,9 @@ fn tupleFieldVal(
     tuple_ty: Type,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (field_name.eqlSlice("len", &mod.intern_pool)) {
+    if (field_name.eqlSlice("len", &zcu.intern_pool)) {
-        return pt.intRef(Type.usize, tuple_ty.structFieldCount(mod));
+        return pt.intRef(Type.usize, tuple_ty.structFieldCount(zcu));
     }
     const field_index = try sema.tupleFieldIndex(block, tuple_ty, field_name, field_name_src);
     return sema.tupleFieldValByIndex(block, src, tuple_byval, field_index, tuple_ty);
 @@ -28461,10 +28464,10 @@ fn tupleFieldValByIndex(
     tuple_ty: Type,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const field_ty = tuple_ty.structFieldType(field_index, mod);
+    const field_ty = tuple_ty.fieldType(field_index, zcu);
-    if (tuple_ty.structFieldIsComptime(field_index, mod))
+    if (tuple_ty.structFieldIsComptime(field_index, zcu))
         try tuple_ty.resolveStructFieldInits(pt);
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_value| {
         return Air.internedToRef(default_value.toIntern());
 @@ -28474,10 +28477,10 @@ fn tupleFieldValByIndex(
         if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
             return Air.internedToRef(opv.toIntern());
         }
-        return switch (mod.intern_pool.indexToKey(tuple_val.toIntern())) {
+        return switch (zcu.intern_pool.indexToKey(tuple_val.toIntern())) {
             .undef => pt.undefRef(field_ty),
             .aggregate => |aggregate| Air.internedToRef(switch (aggregate.storage) {
-                .bytes => |bytes| try pt.intValue(Type.u8, bytes.at(field_index, &mod.intern_pool)),
+                .bytes => |bytes| try pt.intValue(Type.u8, bytes.at(field_index, &zcu.intern_pool)),
                 .elems => |elems| Value.fromInterned(elems[field_index]),
                 .repeated_elem => |elem| Value.fromInterned(elem),
             }.toIntern()),
 @@ -28501,15 +28504,15 @@ fn unionFieldPtr(
     initializing: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    assert(union_ty.zigTypeTag(mod) == .Union);
+    assert(union_ty.zigTypeTag(zcu) == .Union);
     const union_ptr_ty = sema.typeOf(union_ptr);
-    const union_ptr_info = union_ptr_ty.ptrInfo(mod);
+    const union_ptr_info = union_ptr_ty.ptrInfo(zcu);
     try union_ty.resolveFields(pt);
-    const union_obj = mod.typeToUnion(union_ty).?;
+    const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_name_src);
     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
     const ptr_field_ty = try pt.ptrTypeSema(.{
 @@ -28522,16 +28525,16 @@ fn unionFieldPtr(
                 const union_align = if (union_ptr_info.flags.alignment != .none)
                     union_ptr_info.flags.alignment
                 else
-                    try sema.typeAbiAlignment(union_ty);
+                    try union_ty.abiAlignmentSema(pt);
-                const field_align = try pt.unionFieldNormalAlignmentAdvanced(union_obj, field_index, .sema);
+                const field_align = try union_ty.fieldAlignmentSema(field_index, pt);
                 break :blk union_align.min(field_align);
             } else union_ptr_info.flags.alignment,
         },
         .packed_offset = union_ptr_info.packed_offset,
     });
-    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_ty).enumFieldIndex(field_name, mod).?);
+    const enum_field_index: u32 = @intCast(Type.fromInterned(union_obj.enum_tag_ty).enumFieldIndex(field_name, zcu).?);
-    if (initializing and field_ty.zigTypeTag(mod) == .NoReturn) {
+    if (initializing and field_ty.zigTypeTag(zcu) == .NoReturn) {
         const msg = msg: {
             const msg = try sema.errMsg(src, "cannot initialize 'noreturn' field of union", .{});
             errdefer msg.destroy(sema.gpa);
 @@ -28556,7 +28559,7 @@ fn unionFieldPtr(
             } else {
                 const union_val = (try sema.pointerDeref(block, src, union_ptr_val, union_ptr_ty)) orelse
                     break :ct;
-                if (union_val.isUndef(mod)) {
+                if (union_val.isUndef(zcu)) {
                     return sema.failWithUseOfUndef(block, src);
                 }
                 const un = ip.indexToKey(union_val.toIntern()).un;
 @@ -28564,8 +28567,8 @@ fn unionFieldPtr(
                 const tag_matches = un.tag == field_tag.toIntern();
                 if (!tag_matches) {
                     const msg = msg: {
-                        const active_index = Type.fromInterned(union_obj.enum_tag_ty).enumTagFieldIndex(Value.fromInterned(un.tag), mod).?;
+                        const active_index = Type.fromInterned(union_obj.enum_tag_ty).enumTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                        const active_field_name = Type.fromInterned(union_obj.enum_tag_ty).enumFieldName(active_index, mod);
+                        const active_field_name = Type.fromInterned(union_obj.enum_tag_ty).enumFieldName(active_index, zcu);
                         const msg = try sema.errMsg(src, "access of union field '{}' while field '{}' is active", .{
                             field_name.fmt(ip),
                             active_field_name.fmt(ip),
 @@ -28585,7 +28588,7 @@ fn unionFieldPtr(
     try sema.requireRuntimeBlock(block, src, null);
     if (!initializing and union_obj.flagsUnordered(ip).layout == .auto and block.wantSafety() and
-        union_ty.unionTagTypeSafety(mod) != null and union_obj.field_types.len > 1)
+        union_ty.unionTagTypeSafety(zcu) != null and union_obj.field_types.len > 1)
     {
         const wanted_tag_val = try pt.enumValueFieldIndex(Type.fromInterned(union_obj.enum_tag_ty), enum_field_index);
         const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
 @@ -28594,7 +28597,7 @@ fn unionFieldPtr(
         const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_val);
         try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag);
     }
-    if (field_ty.zigTypeTag(mod) == .NoReturn) {
+    if (field_ty.zigTypeTag(zcu) == .NoReturn) {
         _ = try block.addNoOp(.unreach);
         return .unreachable_value;
     }
 @@ -28654,7 +28657,7 @@ fn unionFieldVal(
             .@"packed" => if (tag_matches) {
                 // Fast path - no need to use bitcast logic.
                 return Air.internedToRef(un.val);
-            } else if (try sema.bitCastVal(union_val, field_ty, 0, try union_ty.bitSizeAdvanced(pt, .sema), 0)) |field_val| {
+            } else if (try sema.bitCastVal(union_val, field_ty, 0, try union_ty.bitSizeSema(pt), 0)) |field_val| {
                 return Air.internedToRef(field_val.toIntern());
             },
         }
 @@ -28688,17 +28691,17 @@ fn elemPtr(
     oob_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const indexable_ptr_src = src; // TODO better source location
     const indexable_ptr_ty = sema.typeOf(indexable_ptr);
-    const indexable_ty = switch (indexable_ptr_ty.zigTypeTag(mod)) {
+    const indexable_ty = switch (indexable_ptr_ty.zigTypeTag(zcu)) {
-        .Pointer => indexable_ptr_ty.childType(mod),
+        .Pointer => indexable_ptr_ty.childType(zcu),
         else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{}'", .{indexable_ptr_ty.fmt(pt)}),
     };
     try checkIndexable(sema, block, src, indexable_ty);
-    const elem_ptr = switch (indexable_ty.zigTypeTag(mod)) {
+    const elem_ptr = switch (indexable_ty.zigTypeTag(zcu)) {
         .Array, .Vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
         .Struct => blk: {
             // Tuple field access.
 @@ -28732,11 +28735,11 @@ fn elemPtrOneLayerOnly(
     const indexable_src = src; // TODO better source location
     const indexable_ty = sema.typeOf(indexable);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     try checkIndexable(sema, block, src, indexable_ty);
-    switch (indexable_ty.ptrSize(mod)) {
+    switch (indexable_ty.ptrSize(zcu)) {
         .Slice => return sema.elemPtrSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
         .Many, .C => {
             const maybe_ptr_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
 @@ -28754,11 +28757,11 @@ fn elemPtrOneLayerOnly(
             return block.addPtrElemPtr(indexable, elem_index, result_ty);
         },
         .One => {
-            const child_ty = indexable_ty.childType(mod);
+            const child_ty = indexable_ty.childType(zcu);
-            const elem_ptr = switch (child_ty.zigTypeTag(mod)) {
+            const elem_ptr = switch (child_ty.zigTypeTag(zcu)) {
                 .Array, .Vector => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),
                 .Struct => blk: {
-                    assert(child_ty.isTuple(mod));
+                    assert(child_ty.isTuple(zcu));
                     const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{
                         .needed_comptime_reason = "tuple field access index must be comptime-known",
                     });
 @@ -28785,7 +28788,7 @@ fn elemVal(
     const indexable_src = src; // TODO better source location
     const indexable_ty = sema.typeOf(indexable);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     try checkIndexable(sema, block, src, indexable_ty);
 @@ -28793,8 +28796,8 @@ fn elemVal(
     // index is a scalar or vector instead of unconditionally casting to usize.
     const elem_index = try sema.coerce(block, Type.usize, elem_index_uncasted, elem_index_src);
-    switch (indexable_ty.zigTypeTag(mod)) {
+    switch (indexable_ty.zigTypeTag(zcu)) {
-        .Pointer => switch (indexable_ty.ptrSize(mod)) {
+        .Pointer => switch (indexable_ty.ptrSize(zcu)) {
             .Slice => return sema.elemValSlice(block, src, indexable_src, indexable, elem_index_src, elem_index, oob_safety),
             .Many, .C => {
                 const maybe_indexable_val = try sema.resolveDefinedValue(block, indexable_src, indexable);
 @@ -28804,7 +28807,7 @@ fn elemVal(
                     const indexable_val = maybe_indexable_val orelse break :rs indexable_src;
                     const index_val = maybe_index_val orelse break :rs elem_index_src;
                     const index: usize = @intCast(try index_val.toUnsignedIntSema(pt));
-                    const elem_ty = indexable_ty.elemType2(mod);
+                    const elem_ty = indexable_ty.elemType2(zcu);
                     const many_ptr_ty = try pt.manyConstPtrType(elem_ty);
                     const many_ptr_val = try pt.getCoerced(indexable_val, many_ptr_ty);
                     const elem_ptr_ty = try pt.singleConstPtrType(elem_ty);
 @@ -28820,12 +28823,12 @@ fn elemVal(
             },
             .One => {
                 arr_sent: {
-                    const inner_ty = indexable_ty.childType(mod);
+                    const inner_ty = indexable_ty.childType(zcu);
-                    if (inner_ty.zigTypeTag(mod) != .Array) break :arr_sent;
+                    if (inner_ty.zigTypeTag(zcu) != .Array) break :arr_sent;
-                    const sentinel = inner_ty.sentinel(mod) orelse break :arr_sent;
+                    const sentinel = inner_ty.sentinel(zcu) orelse break :arr_sent;
                     const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse break :arr_sent;
                     const index = try sema.usizeCast(block, src, try index_val.toUnsignedIntSema(pt));
-                    if (index != inner_ty.arrayLen(mod)) break :arr_sent;
+                    if (index != inner_ty.arrayLen(zcu)) break :arr_sent;
                     return Air.internedToRef(sentinel.toIntern());
                 }
                 const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
 @@ -28857,7 +28860,7 @@ fn validateRuntimeElemAccess(
     parent_ty: Type,
     parent_src: LazySrcLoc,
 ) CompileError!void {
-    if (try sema.typeRequiresComptime(elem_ty)) {
+    if (try elem_ty.comptimeOnlySema(sema.pt)) {
         const msg = msg: {
             const msg = try sema.errMsg(
                 elem_index_src,
 @@ -28884,11 +28887,11 @@ fn tupleFieldPtr(
     init: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const tuple_ptr_ty = sema.typeOf(tuple_ptr);
-    const tuple_ty = tuple_ptr_ty.childType(mod);
+    const tuple_ty = tuple_ptr_ty.childType(zcu);
     try tuple_ty.resolveFields(pt);
-    const field_count = tuple_ty.structFieldCount(mod);
+    const field_count = tuple_ty.structFieldCount(zcu);
     if (field_count == 0) {
         return sema.fail(block, tuple_ptr_src, "indexing into empty tuple is not allowed", .{});
 @@ -28900,17 +28903,17 @@ fn tupleFieldPtr(
         });
     }
-    const field_ty = tuple_ty.structFieldType(field_index, mod);
+    const field_ty = tuple_ty.fieldType(field_index, zcu);
     const ptr_field_ty = try pt.ptrTypeSema(.{
         .child = field_ty.toIntern(),
         .flags = .{
-            .is_const = !tuple_ptr_ty.ptrIsMutable(mod),
+            .is_const = !tuple_ptr_ty.ptrIsMutable(zcu),
-            .is_volatile = tuple_ptr_ty.isVolatilePtr(mod),
+            .is_volatile = tuple_ptr_ty.isVolatilePtr(zcu),
-            .address_space = tuple_ptr_ty.ptrAddressSpace(mod),
+            .address_space = tuple_ptr_ty.ptrAddressSpace(zcu),
         },
     });
-    if (tuple_ty.structFieldIsComptime(field_index, mod))
+    if (tuple_ty.structFieldIsComptime(field_index, zcu))
         try tuple_ty.resolveStructFieldInits(pt);
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_val| {
 @@ -28943,10 +28946,10 @@ fn tupleField(
     field_index: u32,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const tuple_ty = sema.typeOf(tuple);
     try tuple_ty.resolveFields(pt);
-    const field_count = tuple_ty.structFieldCount(mod);
+    const field_count = tuple_ty.structFieldCount(zcu);
     if (field_count == 0) {
         return sema.fail(block, tuple_src, "indexing into empty tuple is not allowed", .{});
 @@ -28958,16 +28961,16 @@ fn tupleField(
         });
     }
-    const field_ty = tuple_ty.structFieldType(field_index, mod);
+    const field_ty = tuple_ty.fieldType(field_index, zcu);
-    if (tuple_ty.structFieldIsComptime(field_index, mod))
+    if (tuple_ty.structFieldIsComptime(field_index, zcu))
         try tuple_ty.resolveStructFieldInits(pt);
     if (try tuple_ty.structFieldValueComptime(pt, field_index)) |default_value| {
         return Air.internedToRef(default_value.toIntern()); // comptime field
     }
     if (try sema.resolveValue(tuple)) |tuple_val| {
-        if (tuple_val.isUndef(mod)) return pt.undefRef(field_ty);
+        if (tuple_val.isUndef(zcu)) return pt.undefRef(field_ty);
         return Air.internedToRef((try tuple_val.fieldValue(pt, field_index)).toIntern());
     }
 @@ -28989,12 +28992,12 @@ fn elemValArray(
     oob_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const array_ty = sema.typeOf(array);
-    const array_sent = array_ty.sentinel(mod);
+    const array_sent = array_ty.sentinel(zcu);
-    const array_len = array_ty.arrayLen(mod);
+    const array_len = array_ty.arrayLen(zcu);
     const array_len_s = array_len + @intFromBool(array_sent != null);
-    const elem_ty = array_ty.childType(mod);
+    const elem_ty = array_ty.childType(zcu);
     if (array_len_s == 0) {
         return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});
 @@ -29017,7 +29020,7 @@ fn elemValArray(
         }
     }
     if (maybe_undef_array_val) |array_val| {
-        if (array_val.isUndef(mod)) {
+        if (array_val.isUndef(zcu)) {
             return pt.undefRef(elem_ty);
         }
         if (maybe_index_val) |index_val| {
 @@ -29058,11 +29061,11 @@ fn elemPtrArray(
     oob_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const array_ptr_ty = sema.typeOf(array_ptr);
-    const array_ty = array_ptr_ty.childType(mod);
+    const array_ty = array_ptr_ty.childType(zcu);
-    const array_sent = array_ty.sentinel(mod) != null;
+    const array_sent = array_ty.sentinel(zcu) != null;
-    const array_len = array_ty.arrayLen(mod);
+    const array_len = array_ty.arrayLen(zcu);
     const array_len_s = array_len + @intFromBool(array_sent);
     if (array_len_s == 0) {
 @@ -29083,7 +29086,7 @@ fn elemPtrArray(
     const elem_ptr_ty = try array_ptr_ty.elemPtrType(offset, pt);
     if (maybe_undef_array_ptr_val) |array_ptr_val| {
-        if (array_ptr_val.isUndef(mod)) {
+        if (array_ptr_val.isUndef(zcu)) {
             return pt.undefRef(elem_ptr_ty);
         }
         if (offset) |index| {
 @@ -29093,7 +29096,7 @@ fn elemPtrArray(
     }
     if (!init) {
-        try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(mod), array_ty, array_ptr_src);
+        try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(zcu), array_ty, array_ptr_src);
     }
     const runtime_src = if (maybe_undef_array_ptr_val != null) elem_index_src else array_ptr_src;
 @@ -29120,10 +29123,10 @@ fn elemValSlice(
     oob_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const slice_ty = sema.typeOf(slice);
-    const slice_sent = slice_ty.sentinel(mod) != null;
+    const slice_sent = slice_ty.sentinel(zcu) != null;
-    const elem_ty = slice_ty.elemType2(mod);
+    const elem_ty = slice_ty.elemType2(zcu);
     var runtime_src = slice_src;
     // slice must be defined since it can dereferenced as null
 @@ -29178,9 +29181,9 @@ fn elemPtrSlice(
     oob_safety: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const slice_ty = sema.typeOf(slice);
-    const slice_sent = slice_ty.sentinel(mod) != null;
+    const slice_sent = slice_ty.sentinel(zcu) != null;
     const maybe_undef_slice_val = try sema.resolveValue(slice);
     // The index must not be undefined since it can be out of bounds.
 @@ -29192,7 +29195,7 @@ fn elemPtrSlice(
     const elem_ptr_ty = try slice_ty.elemPtrType(offset, pt);
     if (maybe_undef_slice_val) |slice_val| {
-        if (slice_val.isUndef(mod)) {
+        if (slice_val.isUndef(zcu)) {
             return pt.undefRef(elem_ptr_ty);
         }
         const slice_len = try slice_val.sliceLen(pt);
 @@ -29217,7 +29220,7 @@ fn elemPtrSlice(
     if (oob_safety and block.wantSafety()) {
         const len_inst = len: {
             if (maybe_undef_slice_val) |slice_val|
-                if (!slice_val.isUndef(mod))
+                if (!slice_val.isUndef(zcu))
                     break :len try pt.intRef(Type.usize, try slice_val.sliceLen(pt));
             break :len try block.addTyOp(.slice_len, Type.usize, slice);
         };
 @@ -29600,7 +29603,7 @@ fn coerceExtra(
                     // empty tuple to zero-length slice
                     // note that this allows coercing to a mutable slice.
                     if (inst_child_ty.structFieldCount(zcu) == 0) {
-                        const align_val = try dest_ty.ptrAlignmentAdvanced(pt, .sema);
+                        const align_val = try dest_ty.ptrAlignmentSema(pt);
                         return Air.internedToRef(try pt.intern(.{ .slice = .{
                             .ty = dest_ty.toIntern(),
                             .ptr = try pt.intern(.{ .ptr = .{
 @@ -30098,7 +30101,7 @@ const InMemoryCoercionResult = union(enum) {
         return res;
     }
-    fn report(res: *const InMemoryCoercionResult, sema: *Sema, src: LazySrcLoc, msg: *Module.ErrorMsg) !void {
+    fn report(res: *const InMemoryCoercionResult, sema: *Sema, src: LazySrcLoc, msg: *Zcu.ErrorMsg) !void {
         const pt = sema.pt;
         var cur = res;
         while (true) switch (cur.*) {
 @@ -30364,18 +30367,18 @@ pub fn coerceInMemoryAllowed(
     src_val: ?Value,
 ) CompileError!InMemoryCoercionResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (dest_ty.eql(src_ty, mod))
+    if (dest_ty.eql(src_ty, zcu))
         return .ok;
-    const dest_tag = dest_ty.zigTypeTag(mod);
+    const dest_tag = dest_ty.zigTypeTag(zcu);
-    const src_tag = src_ty.zigTypeTag(mod);
+    const src_tag = src_ty.zigTypeTag(zcu);
     // Differently-named integers with the same number of bits.
     if (dest_tag == .Int and src_tag == .Int) {
-        const dest_info = dest_ty.intInfo(mod);
+        const dest_info = dest_ty.intInfo(zcu);
-        const src_info = src_ty.intInfo(mod);
+        const src_info = src_ty.intInfo(zcu);
         if (dest_info.signedness == src_info.signedness and
             dest_info.bits == src_info.bits)
 @@ -30425,7 +30428,7 @@ pub fn coerceInMemoryAllowed(
     }
     // Slices
-    if (dest_ty.isSlice(mod) and src_ty.isSlice(mod)) {
+    if (dest_ty.isSlice(zcu) and src_ty.isSlice(zcu)) {
         return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_ty, src_ty, dest_is_mut, target, dest_src, src_src);
     }
 @@ -30436,8 +30439,8 @@ pub fn coerceInMemoryAllowed(
     // Error Unions
     if (dest_tag == .ErrorUnion and src_tag == .ErrorUnion) {
-        const dest_payload = dest_ty.errorUnionPayload(mod);
+        const dest_payload = dest_ty.errorUnionPayload(zcu);
-        const src_payload = src_ty.errorUnionPayload(mod);
+        const src_payload = src_ty.errorUnionPayload(zcu);
         const child = try sema.coerceInMemoryAllowed(block, dest_payload, src_payload, dest_is_mut, target, dest_src, src_src, null);
         if (child != .ok) {
             return InMemoryCoercionResult{ .error_union_payload = .{
 @@ -30446,7 +30449,7 @@ pub fn coerceInMemoryAllowed(
                 .wanted = dest_payload,
             } };
         }
-        return try sema.coerceInMemoryAllowed(block, dest_ty.errorUnionSet(mod), src_ty.errorUnionSet(mod), dest_is_mut, target, dest_src, src_src, null);
+        return try sema.coerceInMemoryAllowed(block, dest_ty.errorUnionSet(zcu), src_ty.errorUnionSet(zcu), dest_is_mut, target, dest_src, src_src, null);
     }
     // Error Sets
 @@ -30456,8 +30459,8 @@ pub fn coerceInMemoryAllowed(
     // Arrays
     if (dest_tag == .Array and src_tag == .Array) {
-        const dest_info = dest_ty.arrayInfo(mod);
+        const dest_info = dest_ty.arrayInfo(zcu);
-        const src_info = src_ty.arrayInfo(mod);
+        const src_info = src_ty.arrayInfo(zcu);
         if (dest_info.len != src_info.len) {
             return InMemoryCoercionResult{ .array_len = .{
                 .actual = src_info.len,
 @@ -30483,7 +30486,7 @@ pub fn coerceInMemoryAllowed(
             dest_info.sentinel.?.eql(
             try pt.getCoerced(src_info.sentinel.?, dest_info.elem_type),
             dest_info.elem_type,
-            mod,
+            zcu,
         ));
         if (!ok_sent) {
             return InMemoryCoercionResult{ .array_sentinel = .{
 @@ -30497,8 +30500,8 @@ pub fn coerceInMemoryAllowed(
     // Vectors
     if (dest_tag == .Vector and src_tag == .Vector) {
-        const dest_len = dest_ty.vectorLen(mod);
+        const dest_len = dest_ty.vectorLen(zcu);
-        const src_len = src_ty.vectorLen(mod);
+        const src_len = src_ty.vectorLen(zcu);
         if (dest_len != src_len) {
             return InMemoryCoercionResult{ .vector_len = .{
                 .actual = src_len,
 @@ -30506,8 +30509,8 @@ pub fn coerceInMemoryAllowed(
             } };
         }
-        const dest_elem_ty = dest_ty.scalarType(mod);
+        const dest_elem_ty = dest_ty.scalarType(zcu);
-        const src_elem_ty = src_ty.scalarType(mod);
+        const src_elem_ty = src_ty.scalarType(zcu);
         const child = try sema.coerceInMemoryAllowed(block, dest_elem_ty, src_elem_ty, dest_is_mut, target, dest_src, src_src, null);
         if (child != .ok) {
             return InMemoryCoercionResult{ .vector_elem = .{
 @@ -30524,8 +30527,8 @@ pub fn coerceInMemoryAllowed(
     if ((dest_tag == .Vector and src_tag == .Array) or
         (dest_tag == .Array and src_tag == .Vector))
     {
-        const dest_len = dest_ty.arrayLen(mod);
+        const dest_len = dest_ty.arrayLen(zcu);
-        const src_len = src_ty.arrayLen(mod);
+        const src_len = src_ty.arrayLen(zcu);
         if (dest_len != src_len) {
             return InMemoryCoercionResult{ .array_len = .{
                 .actual = src_len,
 @@ -30533,8 +30536,8 @@ pub fn coerceInMemoryAllowed(
             } };
         }
-        const dest_elem_ty = dest_ty.childType(mod);
+        const dest_elem_ty = dest_ty.childType(zcu);
-        const src_elem_ty = src_ty.childType(mod);
+        const src_elem_ty = src_ty.childType(zcu);
         const child = try sema.coerceInMemoryAllowed(block, dest_elem_ty, src_elem_ty, dest_is_mut, target, dest_src, src_src, null);
         if (child != .ok) {
             return InMemoryCoercionResult{ .array_elem = .{
 @@ -30545,7 +30548,7 @@ pub fn coerceInMemoryAllowed(
         }
         if (dest_tag == .Array) {
-            const dest_info = dest_ty.arrayInfo(mod);
+            const dest_info = dest_ty.arrayInfo(zcu);
             if (dest_info.sentinel != null) {
                 return InMemoryCoercionResult{ .array_sentinel = .{
                     .actual = Value.@"unreachable",
 @@ -30558,8 +30561,8 @@ pub fn coerceInMemoryAllowed(
         // The memory layout of @Vector(N, iM) is the same as the integer type i(N*M),
         // that is to say, the padding bits are not in the same place as the array [N]iM.
         // If there's no padding, the bitcast is possible.
-        const elem_bit_size = dest_elem_ty.bitSize(pt);
+        const elem_bit_size = dest_elem_ty.bitSize(zcu);
-        const elem_abi_byte_size = dest_elem_ty.abiSize(pt);
+        const elem_abi_byte_size = dest_elem_ty.abiSize(zcu);
         if (elem_abi_byte_size * 8 == elem_bit_size)
             return .ok;
     }
 @@ -30572,8 +30575,8 @@ pub fn coerceInMemoryAllowed(
                 .wanted = dest_ty,
             } };
         }
-        const dest_child_type = dest_ty.optionalChild(mod);
+        const dest_child_type = dest_ty.optionalChild(zcu);
-        const src_child_type = src_ty.optionalChild(mod);
+        const src_child_type = src_ty.optionalChild(zcu);
         const child = try sema.coerceInMemoryAllowed(block, dest_child_type, src_child_type, dest_is_mut, target, dest_src, src_src, null);
         if (child != .ok) {
 @@ -30588,15 +30591,15 @@ pub fn coerceInMemoryAllowed(
     }
     // Tuples (with in-memory-coercible fields)
-    if (dest_ty.isTuple(mod) and src_ty.isTuple(mod)) tuple: {
+    if (dest_ty.isTuple(zcu) and src_ty.isTuple(zcu)) tuple: {
-        if (dest_ty.containerLayout(mod) != src_ty.containerLayout(mod)) break :tuple;
+        if (dest_ty.containerLayout(zcu) != src_ty.containerLayout(zcu)) break :tuple;
-        if (dest_ty.structFieldCount(mod) != src_ty.structFieldCount(mod)) break :tuple;
+        if (dest_ty.structFieldCount(zcu) != src_ty.structFieldCount(zcu)) break :tuple;
-        const field_count = dest_ty.structFieldCount(mod);
+        const field_count = dest_ty.structFieldCount(zcu);
         for (0..field_count) |field_idx| {
-            if (dest_ty.structFieldIsComptime(field_idx, mod) != src_ty.structFieldIsComptime(field_idx, mod)) break :tuple;
+            if (dest_ty.structFieldIsComptime(field_idx, zcu) != src_ty.structFieldIsComptime(field_idx, zcu)) break :tuple;
-            if (dest_ty.structFieldAlign(field_idx, pt) != src_ty.structFieldAlign(field_idx, pt)) break :tuple;
+            if (dest_ty.fieldAlignment(field_idx, zcu) != src_ty.fieldAlignment(field_idx, zcu)) break :tuple;
-            const dest_field_ty = dest_ty.structFieldType(field_idx, mod);
+            const dest_field_ty = dest_ty.fieldType(field_idx, zcu);
-            const src_field_ty = src_ty.structFieldType(field_idx, mod);
+            const src_field_ty = src_ty.fieldType(field_idx, zcu);
             const field = try sema.coerceInMemoryAllowed(block, dest_field_ty, src_field_ty, dest_is_mut, target, dest_src, src_src, null);
             if (field != .ok) break :tuple;
         }
 @@ -30618,13 +30621,13 @@ fn coerceInMemoryAllowedErrorSets(
     src_src: LazySrcLoc,
 ) !InMemoryCoercionResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     // Coercion to `anyerror`. Note that this check can return false negatives
     // in case the error sets did not get resolved.
-    if (dest_ty.isAnyError(mod)) {
+    if (dest_ty.isAnyError(zcu)) {
         return .ok;
     }
 @@ -30669,7 +30672,7 @@ fn coerceInMemoryAllowedErrorSets(
                 const resolved_src_ty = try sema.resolveInferredErrorSet(block, src_src, src_ty.toIntern());
                 // src anyerror status might have changed after the resolution.
                 if (resolved_src_ty == .anyerror_type) {
-                    // dest_ty.isAnyError(mod) == true is already checked for at this point.
+                    // dest_ty.isAnyError(zcu) == true is already checked for at this point.
                     return .from_anyerror;
                 }
 @@ -30717,11 +30720,11 @@ fn coerceInMemoryAllowedFns(
     src_src: LazySrcLoc,
 ) !InMemoryCoercionResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const dest_info = mod.typeToFunc(dest_ty).?;
+    const dest_info = zcu.typeToFunc(dest_ty).?;
-    const src_info = mod.typeToFunc(src_ty).?;
+    const src_info = zcu.typeToFunc(src_ty).?;
     {
         if (dest_info.is_var_args != src_info.is_var_args) {
 @@ -30922,12 +30925,12 @@ fn coerceInMemoryAllowedPtrs(
         const src_align = if (src_info.flags.alignment != .none)
             src_info.flags.alignment
         else
-            try sema.typeAbiAlignment(Type.fromInterned(src_info.child));
+            try Type.fromInterned(src_info.child).abiAlignmentSema(pt);
         const dest_align = if (dest_info.flags.alignment != .none)
             dest_info.flags.alignment
         else
-            try sema.typeAbiAlignment(Type.fromInterned(dest_info.child));
+            try Type.fromInterned(dest_info.child).abiAlignmentSema(pt);
         if (dest_align.compare(.gt, src_align)) {
             return InMemoryCoercionResult{ .ptr_alignment = .{
 @@ -31044,12 +31047,12 @@ fn storePtr2(
     air_tag: Air.Inst.Tag,
 ) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = sema.typeOf(ptr);
-    if (ptr_ty.isConstPtr(mod))
+    if (ptr_ty.isConstPtr(zcu))
         return sema.fail(block, ptr_src, "cannot assign to constant", .{});
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
     // To generate better code for tuples, we detect a tuple operand here, and
     // analyze field loads and stores directly. This avoids an extra allocation + memcpy
 @@ -31060,8 +31063,8 @@ fn storePtr2(
     // this code does not handle tuple-to-struct coercion which requires dealing with missing
     // fields.
     const operand_ty = sema.typeOf(uncasted_operand);
-    if (operand_ty.isTuple(mod) and elem_ty.zigTypeTag(mod) == .Array) {
+    if (operand_ty.isTuple(zcu) and elem_ty.zigTypeTag(zcu) == .Array) {
-        const field_count = operand_ty.structFieldCount(mod);
+        const field_count = operand_ty.structFieldCount(zcu);
         var i: u32 = 0;
         while (i < field_count) : (i += 1) {
             const elem_src = operand_src; // TODO better source location
 @@ -31085,7 +31088,7 @@ fn storePtr2(
     // as well as working around an LLVM bug:
     // https://github.com/ziglang/zig/issues/11154
     if (sema.obtainBitCastedVectorPtr(ptr)) |vector_ptr| {
-        const vector_ty = sema.typeOf(vector_ptr).childType(mod);
+        const vector_ty = sema.typeOf(vector_ptr).childType(zcu);
         const vector = sema.coerceExtra(block, vector_ty, uncasted_operand, operand_src, .{ .is_ret = is_ret }) catch |err| switch (err) {
             error.NotCoercible => unreachable,
             else => |e| return e,
 @@ -31119,7 +31122,7 @@ fn storePtr2(
     try sema.requireRuntimeBlock(block, src, runtime_src);
-    if (ptr_ty.ptrInfo(mod).flags.vector_index == .runtime) {
+    if (ptr_ty.ptrInfo(zcu).flags.vector_index == .runtime) {
         const ptr_inst = ptr.toIndex().?;
         const air_tags = sema.air_instructions.items(.tag);
         if (air_tags[@intFromEnum(ptr_inst)] == .ptr_elem_ptr) {
 @@ -31253,9 +31256,9 @@ fn markMaybeComptimeAllocRuntime(sema: *Sema, block: *Block, alloc_inst: Air.Ins
 /// lengths match.
 fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const array_ty = sema.typeOf(ptr).childType(mod);
+    const array_ty = sema.typeOf(ptr).childType(zcu);
-    if (array_ty.zigTypeTag(mod) != .Array) return null;
+    if (array_ty.zigTypeTag(zcu) != .Array) return null;
     var ptr_ref = ptr;
     var ptr_inst = ptr_ref.toIndex() orelse return null;
     const air_datas = sema.air_instructions.items(.data);
 @@ -31263,15 +31266,15 @@ fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
     const vector_ty = while (air_tags[@intFromEnum(ptr_inst)] == .bitcast) {
         ptr_ref = air_datas[@intFromEnum(ptr_inst)].ty_op.operand;
         if (!sema.isKnownZigType(ptr_ref, .Pointer)) return null;
-        const child_ty = sema.typeOf(ptr_ref).childType(mod);
+        const child_ty = sema.typeOf(ptr_ref).childType(zcu);
-        if (child_ty.zigTypeTag(mod) == .Vector) break child_ty;
+        if (child_ty.zigTypeTag(zcu) == .Vector) break child_ty;
         ptr_inst = ptr_ref.toIndex() orelse return null;
     } else return null;
     // We have a pointer-to-array and a pointer-to-vector. If the elements and
     // lengths match, return the result.
-    if (array_ty.childType(mod).eql(vector_ty.childType(mod), mod) and
+    if (array_ty.childType(zcu).eql(vector_ty.childType(zcu), zcu) and
-        array_ty.arrayLen(mod) == vector_ty.vectorLen(mod))
+        array_ty.arrayLen(zcu) == vector_ty.vectorLen(zcu))
     {
         return ptr_ref;
     } else {
 @@ -31347,8 +31350,8 @@ fn bitCast(
     const old_ty = sema.typeOf(inst);
     try old_ty.resolveLayout(pt);
-    const dest_bits = dest_ty.bitSize(pt);
+    const dest_bits = dest_ty.bitSize(zcu);
-    const old_bits = old_ty.bitSize(pt);
+    const old_bits = old_ty.bitSize(zcu);
     if (old_bits != dest_bits) {
         return sema.fail(block, inst_src, "@bitCast size mismatch: destination type '{}' has {d} bits but source type '{}' has {d} bits", .{
 @@ -31384,16 +31387,16 @@ fn coerceArrayPtrToSlice(
     inst_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (try sema.resolveValue(inst)) |val| {
         const ptr_array_ty = sema.typeOf(inst);
-        const array_ty = ptr_array_ty.childType(mod);
+        const array_ty = ptr_array_ty.childType(zcu);
-        const slice_ptr_ty = dest_ty.slicePtrFieldType(mod);
+        const slice_ptr_ty = dest_ty.slicePtrFieldType(zcu);
         const slice_ptr = try pt.getCoerced(val, slice_ptr_ty);
         const slice_val = try pt.intern(.{ .slice = .{
             .ty = dest_ty.toIntern(),
             .ptr = slice_ptr.toIntern(),
-            .len = (try pt.intValue(Type.usize, array_ty.arrayLen(mod))).toIntern(),
+            .len = (try pt.intValue(Type.usize, array_ty.arrayLen(zcu))).toIntern(),
         } });
         return Air.internedToRef(slice_val);
     }
 @@ -31403,12 +31406,12 @@ fn coerceArrayPtrToSlice(
 fn checkPtrAttributes(sema: *Sema, dest_ty: Type, inst_ty: Type, in_memory_result: *InMemoryCoercionResult) bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const dest_info = dest_ty.ptrInfo(mod);
+    const dest_info = dest_ty.ptrInfo(zcu);
-    const inst_info = inst_ty.ptrInfo(mod);
+    const inst_info = inst_ty.ptrInfo(zcu);
-    const len0 = (Type.fromInterned(inst_info.child).zigTypeTag(mod) == .Array and (Type.fromInterned(inst_info.child).arrayLenIncludingSentinel(mod) == 0 or
+    const len0 = (Type.fromInterned(inst_info.child).zigTypeTag(zcu) == .Array and (Type.fromInterned(inst_info.child).arrayLenIncludingSentinel(zcu) == 0 or
-        (Type.fromInterned(inst_info.child).arrayLen(mod) == 0 and dest_info.sentinel == .none and dest_info.flags.size != .C and dest_info.flags.size != .Many))) or
+        (Type.fromInterned(inst_info.child).arrayLen(zcu) == 0 and dest_info.sentinel == .none and dest_info.flags.size != .C and dest_info.flags.size != .Many))) or
-        (Type.fromInterned(inst_info.child).isTuple(mod) and Type.fromInterned(inst_info.child).structFieldCount(mod) == 0);
+        (Type.fromInterned(inst_info.child).isTuple(zcu) and Type.fromInterned(inst_info.child).structFieldCount(zcu) == 0);
     const ok_cv_qualifiers =
         ((!inst_info.flags.is_const or dest_info.flags.is_const) or len0) and
 @@ -31436,12 +31439,12 @@ fn checkPtrAttributes(sema: *Sema, dest_ty: Type, inst_ty: Type, in_memory_resul
     const inst_align = if (inst_info.flags.alignment != .none)
         inst_info.flags.alignment
     else
-        Type.fromInterned(inst_info.child).abiAlignment(pt);
+        Type.fromInterned(inst_info.child).abiAlignment(zcu);
     const dest_align = if (dest_info.flags.alignment != .none)
         dest_info.flags.alignment
     else
-        Type.fromInterned(dest_info.child).abiAlignment(pt);
+        Type.fromInterned(dest_info.child).abiAlignment(zcu);
     if (dest_align.compare(.gt, inst_align)) {
         in_memory_result.* = .{ .ptr_alignment = .{
 @@ -31461,10 +31464,10 @@ fn coerceCompatiblePtrs(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_ty = sema.typeOf(inst);
     if (try sema.resolveValue(inst)) |val| {
-        if (!val.isUndef(mod) and val.isNull(mod) and !dest_ty.isAllowzeroPtr(mod)) {
+        if (!val.isUndef(zcu) and val.isNull(zcu) and !dest_ty.isAllowzeroPtr(zcu)) {
             return sema.fail(block, inst_src, "null pointer casted to type '{}'", .{dest_ty.fmt(pt)});
         }
         // The comptime Value representation is compatible with both types.
 @@ -31473,17 +31476,17 @@ fn coerceCompatiblePtrs(
         );
     }
     try sema.requireRuntimeBlock(block, inst_src, null);
-    const inst_allows_zero = inst_ty.zigTypeTag(mod) != .Pointer or inst_ty.ptrAllowsZero(mod);
+    const inst_allows_zero = inst_ty.zigTypeTag(zcu) != .Pointer or inst_ty.ptrAllowsZero(zcu);
-    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(mod) and
+    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero(zcu) and
-        (try sema.typeHasRuntimeBits(dest_ty.elemType2(mod)) or dest_ty.elemType2(mod).zigTypeTag(mod) == .Fn))
+        (try dest_ty.elemType2(zcu).hasRuntimeBitsSema(pt) or dest_ty.elemType2(zcu).zigTypeTag(zcu) == .Fn))
     {
-        const actual_ptr = if (inst_ty.isSlice(mod))
+        const actual_ptr = if (inst_ty.isSlice(zcu))
             try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)
         else
             inst;
         const ptr_int = try block.addUnOp(.int_from_ptr, actual_ptr);
         const is_non_zero = try block.addBinOp(.cmp_neq, ptr_int, .zero_usize);
-        const ok = if (inst_ty.isSlice(mod)) ok: {
+        const ok = if (inst_ty.isSlice(zcu)) ok: {
             const len = try sema.analyzeSliceLen(block, inst_src, inst);
             const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize);
             break :ok try block.addBinOp(.bool_or, len_zero, is_non_zero);
 @@ -31504,11 +31507,11 @@ fn coerceEnumToUnion(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_ty = sema.typeOf(inst);
-    const tag_ty = union_ty.unionTagType(mod) orelse {
+    const tag_ty = union_ty.unionTagType(zcu) orelse {
         const msg = msg: {
             const msg = try sema.errMsg(inst_src, "expected type '{}', found '{}'", .{
                 union_ty.fmt(pt), inst_ty.fmt(pt),
 @@ -31529,10 +31532,10 @@ fn coerceEnumToUnion(
             });
         };
-        const union_obj = mod.typeToUnion(union_ty).?;
+        const union_obj = zcu.typeToUnion(union_ty).?;
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
         try field_ty.resolveFields(pt);
-        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+        if (field_ty.zigTypeTag(zcu) == .NoReturn) {
             const msg = msg: {
                 const msg = try sema.errMsg(inst_src, "cannot initialize 'noreturn' field of union", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -31569,7 +31572,7 @@ fn coerceEnumToUnion(
     try sema.requireRuntimeBlock(block, inst_src, null);
-    if (tag_ty.isNonexhaustiveEnum(mod)) {
+    if (tag_ty.isNonexhaustiveEnum(zcu)) {
         const msg = msg: {
             const msg = try sema.errMsg(inst_src, "runtime coercion to union '{}' from non-exhaustive enum", .{
                 union_ty.fmt(pt),
 @@ -31581,13 +31584,13 @@ fn coerceEnumToUnion(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
-    const union_obj = mod.typeToUnion(union_ty).?;
+    const union_obj = zcu.typeToUnion(union_ty).?;
     {
-        var msg: ?*Module.ErrorMsg = null;
+        var msg: ?*Zcu.ErrorMsg = null;
         errdefer if (msg) |some| some.destroy(sema.gpa);
         for (union_obj.field_types.get(ip), 0..) |field_ty, field_index| {
-            if (Type.fromInterned(field_ty).zigTypeTag(mod) == .NoReturn) {
+            if (Type.fromInterned(field_ty).zigTypeTag(zcu) == .NoReturn) {
                 const err_msg = msg orelse try sema.errMsg(
                     inst_src,
                     "runtime coercion from enum '{}' to union '{}' which has a 'noreturn' field",
 @@ -31606,7 +31609,7 @@ fn coerceEnumToUnion(
     }
     // If the union has all fields 0 bits, the union value is just the enum value.
-    if (union_ty.unionHasAllZeroBitFieldTypes(pt)) {
+    if (union_ty.unionHasAllZeroBitFieldTypes(zcu)) {
         return block.addBitCast(union_ty, enum_tag);
     }
 @@ -31621,7 +31624,7 @@ fn coerceEnumToUnion(
         for (0..union_obj.field_types.len) |field_index| {
             const field_name = union_obj.loadTagType(ip).names.get(ip)[field_index];
             const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-            if (!(try sema.typeHasRuntimeBits(field_ty))) continue;
+            if (!(try field_ty.hasRuntimeBitsSema(pt))) continue;
             try sema.addFieldErrNote(union_ty, field_index, msg, "field '{}' has type '{}'", .{
                 field_name.fmt(ip),
                 field_ty.fmt(pt),
 @@ -31642,8 +31645,8 @@ fn coerceAnonStructToUnion(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_ty = sema.typeOf(inst);
     const field_info: union(enum) {
         name: InternPool.NullTerminatedString,
 @@ -31701,8 +31704,8 @@ fn coerceAnonStructToUnionPtrs(
     anon_struct_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const union_ty = ptr_union_ty.childType(mod);
+    const union_ty = ptr_union_ty.childType(zcu);
     const anon_struct = try sema.analyzeLoad(block, anon_struct_src, ptr_anon_struct, anon_struct_src);
     const union_inst = try sema.coerceAnonStructToUnion(block, union_ty, union_ty_src, anon_struct, anon_struct_src);
     return sema.analyzeRef(block, union_ty_src, union_inst);
 @@ -31717,8 +31720,8 @@ fn coerceAnonStructToStructPtrs(
     anon_struct_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const struct_ty = ptr_struct_ty.childType(mod);
+    const struct_ty = ptr_struct_ty.childType(zcu);
     const anon_struct = try sema.analyzeLoad(block, anon_struct_src, ptr_anon_struct, anon_struct_src);
     const struct_inst = try sema.coerceTupleToStruct(block, struct_ty, anon_struct, anon_struct_src);
     return sema.analyzeRef(block, struct_ty_src, struct_inst);
 @@ -31734,9 +31737,9 @@ fn coerceArrayLike(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_ty = sema.typeOf(inst);
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     // try coercion of the whole array
     const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src, null);
 @@ -31750,8 +31753,8 @@ fn coerceArrayLike(
     }
     // otherwise, try element by element
-    const inst_len = inst_ty.arrayLen(mod);
+    const inst_len = inst_ty.arrayLen(zcu);
-    const dest_len = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLen(mod));
+    const dest_len = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLen(zcu));
     if (dest_len != inst_len) {
         const msg = msg: {
             const msg = try sema.errMsg(inst_src, "expected type '{}', found '{}'", .{
 @@ -31765,14 +31768,14 @@ fn coerceArrayLike(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
-    const dest_elem_ty = dest_ty.childType(mod);
+    const dest_elem_ty = dest_ty.childType(zcu);
-    if (dest_ty.isVector(mod) and inst_ty.isVector(mod) and (try sema.resolveValue(inst)) == null) {
+    if (dest_ty.isVector(zcu) and inst_ty.isVector(zcu) and (try sema.resolveValue(inst)) == null) {
-        const inst_elem_ty = inst_ty.childType(mod);
+        const inst_elem_ty = inst_ty.childType(zcu);
-        switch (dest_elem_ty.zigTypeTag(mod)) {
+        switch (dest_elem_ty.zigTypeTag(zcu)) {
-            .Int => if (inst_elem_ty.isInt(mod)) {
+            .Int => if (inst_elem_ty.isInt(zcu)) {
                 // integer widening
-                const dst_info = dest_elem_ty.intInfo(mod);
+                const dst_info = dest_elem_ty.intInfo(zcu);
-                const src_info = inst_elem_ty.intInfo(mod);
+                const src_info = inst_elem_ty.intInfo(zcu);
                 if ((src_info.signedness == dst_info.signedness and dst_info.bits >= src_info.bits) or
                     // small enough unsigned ints can get casted to large enough signed ints
                     (dst_info.signedness == .signed and dst_info.bits > src_info.bits))
 @@ -31835,10 +31838,10 @@ fn coerceTupleToArray(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_ty = sema.typeOf(inst);
-    const inst_len = inst_ty.arrayLen(mod);
+    const inst_len = inst_ty.arrayLen(zcu);
-    const dest_len = dest_ty.arrayLen(mod);
+    const dest_len = dest_ty.arrayLen(zcu);
     if (dest_len != inst_len) {
         const msg = msg: {
 @@ -31856,13 +31859,13 @@ fn coerceTupleToArray(
     const dest_elems = try sema.usizeCast(block, dest_ty_src, dest_len);
     const element_vals = try sema.arena.alloc(InternPool.Index, dest_elems);
     const element_refs = try sema.arena.alloc(Air.Inst.Ref, dest_elems);
-    const dest_elem_ty = dest_ty.childType(mod);
+    const dest_elem_ty = dest_ty.childType(zcu);
     var runtime_src: ?LazySrcLoc = null;
     for (element_vals, element_refs, 0..) |*val, *ref, i_usize| {
         const i: u32 = @intCast(i_usize);
         if (i_usize == inst_len) {
-            const sentinel_val = dest_ty.sentinel(mod).?;
+            const sentinel_val = dest_ty.sentinel(zcu).?;
             val.* = sentinel_val.toIntern();
             ref.* = Air.internedToRef(sentinel_val.toIntern());
             break;
 @@ -31901,12 +31904,12 @@ fn coerceTupleToSlicePtrs(
     tuple_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const tuple_ty = sema.typeOf(ptr_tuple).childType(mod);
+    const tuple_ty = sema.typeOf(ptr_tuple).childType(zcu);
     const tuple = try sema.analyzeLoad(block, tuple_src, ptr_tuple, tuple_src);
-    const slice_info = slice_ty.ptrInfo(mod);
+    const slice_info = slice_ty.ptrInfo(zcu);
     const array_ty = try pt.arrayType(.{
-        .len = tuple_ty.structFieldCount(mod),
+        .len = tuple_ty.structFieldCount(zcu),
         .sentinel = slice_info.sentinel,
         .child = slice_info.child,
     });
 @@ -31928,9 +31931,9 @@ fn coerceTupleToArrayPtrs(
     tuple_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const tuple = try sema.analyzeLoad(block, tuple_src, ptr_tuple, tuple_src);
-    const ptr_info = ptr_array_ty.ptrInfo(mod);
+    const ptr_info = ptr_array_ty.ptrInfo(zcu);
     const array_ty = Type.fromInterned(ptr_info.child);
     const array_inst = try sema.coerceTupleToArray(block, array_ty, array_ty_src, tuple, tuple_src);
     if (ptr_info.flags.alignment != .none) {
 @@ -31950,16 +31953,16 @@ fn coerceTupleToStruct(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     try struct_ty.resolveFields(pt);
     try struct_ty.resolveStructFieldInits(pt);
-    if (struct_ty.isTupleOrAnonStruct(mod)) {
+    if (struct_ty.isTupleOrAnonStruct(zcu)) {
         return sema.coerceTupleToTuple(block, struct_ty, inst, inst_src);
     }
-    const struct_type = mod.typeToStruct(struct_ty).?;
+    const struct_type = zcu.typeToStruct(struct_ty).?;
     const field_vals = try sema.arena.alloc(InternPool.Index, struct_type.field_types.len);
     const field_refs = try sema.arena.alloc(Air.Inst.Ref, field_vals.len);
     @memset(field_refs, .none);
 @@ -31973,7 +31976,7 @@ fn coerceTupleToStruct(
     };
     for (0..field_count) |tuple_field_index| {
         const field_src = inst_src; // TODO better source location
-        const field_name = inst_ty.structFieldName(tuple_field_index, mod).unwrap() orelse
+        const field_name = inst_ty.structFieldName(tuple_field_index, zcu).unwrap() orelse
             try ip.getOrPutStringFmt(sema.gpa, pt.tid, "{d}", .{tuple_field_index}, .no_embedded_nulls);
         const struct_field_index = try sema.structFieldIndex(block, struct_ty, field_name, field_src);
 @@ -32003,7 +32006,7 @@ fn coerceTupleToStruct(
     }
     // Populate default field values and report errors for missing fields.
-    var root_msg: ?*Module.ErrorMsg = null;
+    var root_msg: ?*Zcu.ErrorMsg = null;
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
     for (field_refs, 0..) |*field_ref, i| {
 @@ -32058,8 +32061,8 @@ fn coerceTupleToTuple(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const dest_field_count = switch (ip.indexToKey(tuple_ty.toIntern())) {
         .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
         .struct_type => ip.loadStructType(tuple_ty.toIntern()).field_types.len,
 @@ -32081,7 +32084,7 @@ fn coerceTupleToTuple(
     for (0..dest_field_count) |field_index_usize| {
         const field_i: u32 = @intCast(field_index_usize);
         const field_src = inst_src; // TODO better source location
-        const field_name = inst_ty.structFieldName(field_index_usize, mod).unwrap() orelse
+        const field_name = inst_ty.structFieldName(field_index_usize, zcu).unwrap() orelse
             try ip.getOrPutStringFmt(sema.gpa, pt.tid, "{d}", .{field_index_usize}, .no_embedded_nulls);
         if (field_name.eqlSlice("len", ip))
 @@ -32124,7 +32127,7 @@ fn coerceTupleToTuple(
     }
     // Populate default field values and report errors for missing fields.
-    var root_msg: ?*Module.ErrorMsg = null;
+    var root_msg: ?*Zcu.ErrorMsg = null;
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
     for (field_refs, 0..) |*field_ref, i_usize| {
 @@ -32139,7 +32142,7 @@ fn coerceTupleToTuple(
         const field_src = inst_src; // TODO better source location
         if (default_val == .none) {
-            const field_name = tuple_ty.structFieldName(i, mod).unwrap() orelse {
+            const field_name = tuple_ty.structFieldName(i, zcu).unwrap() orelse {
                 const template = "missing tuple field: {d}";
                 if (root_msg) |msg| {
                     try sema.errNote(field_src, msg, template, .{i});
 @@ -32308,7 +32311,7 @@ fn maybeQueueFuncBodyAnalysis(sema: *Sema, src: LazySrcLoc, nav_index: InternPoo
     const ip = &zcu.intern_pool;
     const nav_val = zcu.navValue(nav_index);
     if (!ip.isFuncBody(nav_val.toIntern())) return;
-    if (!try sema.fnHasRuntimeBits(nav_val.typeOf(zcu))) return;
+    if (!try nav_val.typeOf(zcu).fnHasRuntimeBitsSema(sema.pt)) return;
     try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = nav_val.toIntern() }));
     try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());
 }
 @@ -32320,11 +32323,11 @@ fn analyzeRef(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = sema.typeOf(operand);
     if (try sema.resolveValue(operand)) |val| {
-        switch (mod.intern_pool.indexToKey(val.toIntern())) {
+        switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .@"extern" => |e| return sema.analyzeNavRef(src, e.owner_nav),
             .func => |f| return sema.analyzeNavRef(src, f.owner_nav),
             else => return uavRef(sema, val.toIntern()),
 @@ -32332,7 +32335,7 @@ fn analyzeRef(
     }
     try sema.requireRuntimeBlock(block, src, null);
-    const address_space = target_util.defaultAddressSpace(mod.getTarget(), .local);
+    const address_space = target_util.defaultAddressSpace(zcu.getTarget(), .local);
     const ptr_type = try pt.ptrTypeSema(.{
         .child = operand_ty.toIntern(),
         .flags = .{
 @@ -32359,13 +32362,13 @@ fn analyzeLoad(
     ptr_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = sema.typeOf(ptr);
-    const elem_ty = switch (ptr_ty.zigTypeTag(mod)) {
+    const elem_ty = switch (ptr_ty.zigTypeTag(zcu)) {
-        .Pointer => ptr_ty.childType(mod),
+        .Pointer => ptr_ty.childType(zcu),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ty.fmt(pt)}),
     };
-    if (elem_ty.zigTypeTag(mod) == .Opaque) {
+    if (elem_ty.zigTypeTag(zcu) == .Opaque) {
         return sema.fail(block, ptr_src, "cannot load opaque type '{}'", .{elem_ty.fmt(pt)});
     }
 @@ -32379,7 +32382,7 @@ fn analyzeLoad(
         }
     }
-    if (ptr_ty.ptrInfo(mod).flags.vector_index == .runtime) {
+    if (ptr_ty.ptrInfo(zcu).flags.vector_index == .runtime) {
         const ptr_inst = ptr.toIndex().?;
         const air_tags = sema.air_instructions.items(.tag);
         if (air_tags[@intFromEnum(ptr_inst)] == .ptr_elem_ptr) {
 @@ -32403,11 +32406,11 @@ fn analyzeSlicePtr(
     slice_ty: Type,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const result_ty = slice_ty.slicePtrFieldType(mod);
+    const result_ty = slice_ty.slicePtrFieldType(zcu);
     if (try sema.resolveValue(slice)) |val| {
-        if (val.isUndef(mod)) return pt.undefRef(result_ty);
+        if (val.isUndef(zcu)) return pt.undefRef(result_ty);
-        return Air.internedToRef(val.slicePtr(mod).toIntern());
+        return Air.internedToRef(val.slicePtr(zcu).toIntern());
     }
     try sema.requireRuntimeBlock(block, slice_src, null);
     return block.addTyOp(.slice_ptr, result_ty, slice);
 @@ -32421,13 +32424,13 @@ fn analyzeOptionalSlicePtr(
     opt_slice_ty: Type,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const result_ty = opt_slice_ty.optionalChild(mod).slicePtrFieldType(mod);
+    const result_ty = opt_slice_ty.optionalChild(zcu).slicePtrFieldType(zcu);
     if (try sema.resolveValue(opt_slice)) |opt_val| {
-        if (opt_val.isUndef(mod)) return pt.undefRef(result_ty);
+        if (opt_val.isUndef(zcu)) return pt.undefRef(result_ty);
-        const slice_ptr: InternPool.Index = if (opt_val.optionalValue(mod)) |val|
+        const slice_ptr: InternPool.Index = if (opt_val.optionalValue(zcu)) |val|
-            val.slicePtr(mod).toIntern()
+            val.slicePtr(zcu).toIntern()
         else
             .null_value;
 @@ -32447,9 +32450,9 @@ fn analyzeSliceLen(
     slice_inst: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (try sema.resolveValue(slice_inst)) |slice_val| {
-        if (slice_val.isUndef(mod)) {
+        if (slice_val.isUndef(zcu)) {
             return pt.undefRef(Type.usize);
         }
         return pt.intRef(Type.usize, try slice_val.sliceLen(pt));
 @@ -32466,23 +32469,23 @@ fn analyzeIsNull(
     invert_logic: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result_ty = Type.bool;
     if (try sema.resolveValue(operand)) |opt_val| {
-        if (opt_val.isUndef(mod)) {
+        if (opt_val.isUndef(zcu)) {
             return pt.undefRef(result_ty);
         }
-        const is_null = opt_val.isNull(mod);
+        const is_null = opt_val.isNull(zcu);
         const bool_value = if (invert_logic) !is_null else is_null;
         return if (bool_value) .bool_true else .bool_false;
     }
     const inverted_non_null_res: Air.Inst.Ref = if (invert_logic) .bool_true else .bool_false;
     const operand_ty = sema.typeOf(operand);
-    if (operand_ty.zigTypeTag(mod) == .Optional and operand_ty.optionalChild(mod).zigTypeTag(mod) == .NoReturn) {
+    if (operand_ty.zigTypeTag(zcu) == .Optional and operand_ty.optionalChild(zcu).zigTypeTag(zcu) == .NoReturn) {
         return inverted_non_null_res;
     }
-    if (operand_ty.zigTypeTag(mod) != .Optional and !operand_ty.isPtrLikeOptional(mod)) {
+    if (operand_ty.zigTypeTag(zcu) != .Optional and !operand_ty.isPtrLikeOptional(zcu)) {
         return inverted_non_null_res;
     }
     try sema.requireRuntimeBlock(block, src, null);
 @@ -32497,12 +32500,12 @@ fn analyzePtrIsNonErrComptimeOnly(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = sema.typeOf(operand);
-    assert(ptr_ty.zigTypeTag(mod) == .Pointer);
+    assert(ptr_ty.zigTypeTag(zcu) == .Pointer);
-    const child_ty = ptr_ty.childType(mod);
+    const child_ty = ptr_ty.childType(zcu);
-    const child_tag = child_ty.zigTypeTag(mod);
+    const child_tag = child_ty.zigTypeTag(zcu);
     if (child_tag != .ErrorSet and child_tag != .ErrorUnion) return .bool_true;
     if (child_tag == .ErrorSet) return .bool_false;
     assert(child_tag == .ErrorUnion);
 @@ -32520,16 +32523,16 @@ fn analyzeIsNonErrComptimeOnly(
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const operand_ty = sema.typeOf(operand);
-    const ot = operand_ty.zigTypeTag(mod);
+    const ot = operand_ty.zigTypeTag(zcu);
     if (ot != .ErrorSet and ot != .ErrorUnion) return .bool_true;
     if (ot == .ErrorSet) return .bool_false;
     assert(ot == .ErrorUnion);
-    const payload_ty = operand_ty.errorUnionPayload(mod);
+    const payload_ty = operand_ty.errorUnionPayload(zcu);
-    if (payload_ty.zigTypeTag(mod) == .NoReturn) {
+    if (payload_ty.zigTypeTag(zcu) == .NoReturn) {
         return .bool_false;
     }
 @@ -32588,7 +32591,7 @@ fn analyzeIsNonErrComptimeOnly(
                 // If the error set is empty, we must return a comptime true or false.
                 // However we want to avoid unnecessarily resolving an inferred error set
                 // in case it is already non-empty.
-                try mod.maybeUnresolveIes(func_index);
+                try zcu.maybeUnresolveIes(func_index);
                 switch (ip.funcIesResolvedUnordered(func_index)) {
                     .anyerror_type => break :blk,
                     .none => {},
 @@ -32624,10 +32627,10 @@ fn analyzeIsNonErrComptimeOnly(
     }
     if (maybe_operand_val) |err_union| {
-        if (err_union.isUndef(mod)) {
+        if (err_union.isUndef(zcu)) {
             return pt.undefRef(Type.bool);
         }
-        if (err_union.getErrorName(mod) == .none) {
+        if (err_union.getErrorName(zcu) == .none) {
             return .bool_true;
         } else {
             return .bool_false;
 @@ -32681,12 +32684,12 @@ fn analyzeSlice(
     by_length: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // Slice expressions can operate on a variable whose type is an array. This requires
     // the slice operand to be a pointer. In the case of a non-array, it will be a double pointer.
     const ptr_ptr_ty = sema.typeOf(ptr_ptr);
-    const ptr_ptr_child_ty = switch (ptr_ptr_ty.zigTypeTag(mod)) {
+    const ptr_ptr_child_ty = switch (ptr_ptr_ty.zigTypeTag(zcu)) {
-        .Pointer => ptr_ptr_ty.childType(mod),
+        .Pointer => ptr_ptr_ty.childType(zcu),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ptr_ty.fmt(pt)}),
     };
 @@ -32695,20 +32698,20 @@ fn analyzeSlice(
     var ptr_or_slice = ptr_ptr;
     var elem_ty: Type = undefined;
     var ptr_sentinel: ?Value = null;
-    switch (ptr_ptr_child_ty.zigTypeTag(mod)) {
+    switch (ptr_ptr_child_ty.zigTypeTag(zcu)) {
         .Array => {
-            ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
+            ptr_sentinel = ptr_ptr_child_ty.sentinel(zcu);
-            elem_ty = ptr_ptr_child_ty.childType(mod);
+            elem_ty = ptr_ptr_child_ty.childType(zcu);
         },
-        .Pointer => switch (ptr_ptr_child_ty.ptrSize(mod)) {
+        .Pointer => switch (ptr_ptr_child_ty.ptrSize(zcu)) {
             .One => {
-                const double_child_ty = ptr_ptr_child_ty.childType(mod);
+                const double_child_ty = ptr_ptr_child_ty.childType(zcu);
                 ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src);
-                if (double_child_ty.zigTypeTag(mod) == .Array) {
+                if (double_child_ty.zigTypeTag(zcu) == .Array) {
-                    ptr_sentinel = double_child_ty.sentinel(mod);
+                    ptr_sentinel = double_child_ty.sentinel(zcu);
                     slice_ty = ptr_ptr_child_ty;
                     array_ty = double_child_ty;
-                    elem_ty = double_child_ty.childType(mod);
+                    elem_ty = double_child_ty.childType(zcu);
                 } else {
                     const bounds_error_message = "slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1]";
                     if (uncasted_end_opt == .none) {
 @@ -32777,7 +32780,7 @@ fn analyzeSlice(
                         .len = 1,
                         .child = double_child_ty.toIntern(),
                     });
-                    const ptr_info = ptr_ptr_child_ty.ptrInfo(mod);
+                    const ptr_info = ptr_ptr_child_ty.ptrInfo(zcu);
                     slice_ty = try pt.ptrType(.{
                         .child = array_ty.toIntern(),
                         .flags = .{
 @@ -32792,35 +32795,35 @@ fn analyzeSlice(
                 }
             },
             .Many, .C => {
-                ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
+                ptr_sentinel = ptr_ptr_child_ty.sentinel(zcu);
                 ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src);
                 slice_ty = ptr_ptr_child_ty;
                 array_ty = ptr_ptr_child_ty;
-                elem_ty = ptr_ptr_child_ty.childType(mod);
+                elem_ty = ptr_ptr_child_ty.childType(zcu);
-                if (ptr_ptr_child_ty.ptrSize(mod) == .C) {
+                if (ptr_ptr_child_ty.ptrSize(zcu) == .C) {
                     if (try sema.resolveDefinedValue(block, ptr_src, ptr_or_slice)) |ptr_val| {
-                        if (ptr_val.isNull(mod)) {
+                        if (ptr_val.isNull(zcu)) {
                             return sema.fail(block, src, "slice of null pointer", .{});
                         }
                     }
                 }
             },
             .Slice => {
-                ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
+                ptr_sentinel = ptr_ptr_child_ty.sentinel(zcu);
                 ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src);
                 slice_ty = ptr_ptr_child_ty;
                 array_ty = ptr_ptr_child_ty;
-                elem_ty = ptr_ptr_child_ty.childType(mod);
+                elem_ty = ptr_ptr_child_ty.childType(zcu);
             },
         },
         else => return sema.fail(block, src, "slice of non-array type '{}'", .{ptr_ptr_child_ty.fmt(pt)}),
     }
-    const ptr = if (slice_ty.isSlice(mod))
+    const ptr = if (slice_ty.isSlice(zcu))
         try sema.analyzeSlicePtr(block, ptr_src, ptr_or_slice, slice_ty)
-    else if (array_ty.zigTypeTag(mod) == .Array) ptr: {
+    else if (array_ty.zigTypeTag(zcu) == .Array) ptr: {
-        var manyptr_ty_key = mod.intern_pool.indexToKey(slice_ty.toIntern()).ptr_type;
+        var manyptr_ty_key = zcu.intern_pool.indexToKey(slice_ty.toIntern()).ptr_type;
         assert(manyptr_ty_key.child == array_ty.toIntern());
         assert(manyptr_ty_key.flags.size == .One);
         manyptr_ty_key.child = elem_ty.toIntern();
 @@ -32838,8 +32841,8 @@ fn analyzeSlice(
     // we might learn of the length because it is a comptime-known slice value.
     var end_is_len = uncasted_end_opt == .none;
     const end = e: {
-        if (array_ty.zigTypeTag(mod) == .Array) {
+        if (array_ty.zigTypeTag(zcu) == .Array) {
-            const len_val = try pt.intValue(Type.usize, array_ty.arrayLen(mod));
+            const len_val = try pt.intValue(Type.usize, array_ty.arrayLen(zcu));
             if (!end_is_len) {
                 const end = if (by_length) end: {
 @@ -32850,10 +32853,10 @@ fn analyzeSlice(
                 if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| {
                     const len_s_val = try pt.intValue(
                         Type.usize,
-                        array_ty.arrayLenIncludingSentinel(mod),
+                        array_ty.arrayLenIncludingSentinel(zcu),
                     );
                     if (!(try sema.compareAll(end_val, .lte, len_s_val, Type.usize))) {
-                        const sentinel_label: []const u8 = if (array_ty.sentinel(mod) != null)
+                        const sentinel_label: []const u8 = if (array_ty.sentinel(zcu) != null)
                             " +1 (sentinel)"
                         else
                             "";
 @@ -32873,7 +32876,7 @@ fn analyzeSlice(
                     // end_is_len is only true if we are NOT using the sentinel
                     // length. For sentinel-length, we don't want the type to
                     // contain the sentinel.
-                    if (end_val.eql(len_val, Type.usize, mod)) {
+                    if (end_val.eql(len_val, Type.usize, zcu)) {
                         end_is_len = true;
                     }
                 }
 @@ -32881,7 +32884,7 @@ fn analyzeSlice(
             }
             break :e Air.internedToRef(len_val.toIntern());
-        } else if (slice_ty.isSlice(mod)) {
+        } else if (slice_ty.isSlice(zcu)) {
             if (!end_is_len) {
                 const end = if (by_length) end: {
                     const len = try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);
 @@ -32890,10 +32893,10 @@ fn analyzeSlice(
                 } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);
                 if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| {
                     if (try sema.resolveValue(ptr_or_slice)) |slice_val| {
-                        if (slice_val.isUndef(mod)) {
+                        if (slice_val.isUndef(zcu)) {
                             return sema.fail(block, src, "slice of undefined", .{});
                         }
-                        const has_sentinel = slice_ty.sentinel(mod) != null;
+                        const has_sentinel = slice_ty.sentinel(zcu) != null;
                         const slice_len = try slice_val.sliceLen(pt);
                         const len_plus_sent = slice_len + @intFromBool(has_sentinel);
                         const slice_len_val_with_sentinel = try pt.intValue(Type.usize, len_plus_sent);
 @@ -32919,7 +32922,7 @@ fn analyzeSlice(
                         // is only true if it equals the length WITHOUT the
                         // sentinel, so we don't add a sentinel type.
                         const slice_len_val = try pt.intValue(Type.usize, slice_len);
-                        if (end_val.eql(slice_len_val, Type.usize, mod)) {
+                        if (end_val.eql(slice_len_val, Type.usize, zcu)) {
                             end_is_len = true;
                         }
                     }
 @@ -32976,8 +32979,8 @@ fn analyzeSlice(
             checked_start_lte_end = true;
             if (try sema.resolveValue(new_ptr)) |ptr_val| sentinel_check: {
                 const expected_sentinel = sentinel orelse break :sentinel_check;
-                const start_int = start_val.getUnsignedInt(pt).?;
+                const start_int = start_val.toUnsignedInt(zcu);
-                const end_int = end_val.getUnsignedInt(pt).?;
+                const end_int = end_val.toUnsignedInt(zcu);
                 const sentinel_index = try sema.usizeCast(block, end_src, end_int - start_int);
                 const many_ptr_ty = try pt.manyConstPtrType(elem_ty);
 @@ -33001,7 +33004,7 @@ fn analyzeSlice(
                     ),
                 };
-                if (!actual_sentinel.eql(expected_sentinel, elem_ty, mod)) {
+                if (!actual_sentinel.eql(expected_sentinel, elem_ty, zcu)) {
                     const msg = msg: {
                         const msg = try sema.errMsg(src, "value in memory does not match slice sentinel", .{});
                         errdefer msg.destroy(sema.gpa);
 @@ -33041,8 +33044,8 @@ fn analyzeSlice(
         try sema.analyzeArithmetic(block, .sub, end, start, src, end_src, start_src, false);
     const opt_new_len_val = try sema.resolveDefinedValue(block, src, new_len);
-    const new_ptr_ty_info = new_ptr_ty.ptrInfo(mod);
+    const new_ptr_ty_info = new_ptr_ty.ptrInfo(zcu);
-    const new_allowzero = new_ptr_ty_info.flags.is_allowzero and sema.typeOf(ptr).ptrSize(mod) != .C;
+    const new_allowzero = new_ptr_ty_info.flags.is_allowzero and sema.typeOf(ptr).ptrSize(zcu) != .C;
     if (opt_new_len_val) |new_len_val| {
         const new_len_int = try new_len_val.toUnsignedIntSema(pt);
 @@ -33067,17 +33070,17 @@ fn analyzeSlice(
             const result = try block.addBitCast(return_ty, new_ptr);
             if (block.wantSafety()) {
                 // requirement: slicing C ptr is non-null
-                if (ptr_ptr_child_ty.isCPtr(mod)) {
+                if (ptr_ptr_child_ty.isCPtr(zcu)) {
                     const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true);
                     try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null);
                 }
                 bounds_check: {
-                    const actual_len = if (array_ty.zigTypeTag(mod) == .Array)
+                    const actual_len = if (array_ty.zigTypeTag(zcu) == .Array)
-                        try pt.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(mod))
+                        try pt.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(zcu))
-                    else if (slice_ty.isSlice(mod)) l: {
+                    else if (slice_ty.isSlice(zcu)) l: {
                         const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
-                        break :l if (slice_ty.sentinel(mod) == null)
+                        break :l if (slice_ty.sentinel(zcu) == null)
                             slice_len_inst
                         else
                             try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src, true);
 @@ -33097,7 +33100,7 @@ fn analyzeSlice(
             return result;
         };
-        if (!new_ptr_val.isUndef(mod)) {
+        if (!new_ptr_val.isUndef(zcu)) {
             return Air.internedToRef((try pt.getCoerced(new_ptr_val, return_ty)).toIntern());
         }
 @@ -33125,15 +33128,15 @@ fn analyzeSlice(
     try sema.requireRuntimeBlock(block, src, runtime_src.?);
     if (block.wantSafety()) {
         // requirement: slicing C ptr is non-null
-        if (ptr_ptr_child_ty.isCPtr(mod)) {
+        if (ptr_ptr_child_ty.isCPtr(zcu)) {
             const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true);
             try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null);
         }
         // requirement: end <= len
-        const opt_len_inst = if (array_ty.zigTypeTag(mod) == .Array)
+        const opt_len_inst = if (array_ty.zigTypeTag(zcu) == .Array)
-            try pt.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(mod))
+            try pt.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(zcu))
-        else if (slice_ty.isSlice(mod)) blk: {
+        else if (slice_ty.isSlice(zcu)) blk: {
             if (try sema.resolveDefinedValue(block, src, ptr_or_slice)) |slice_val| {
                 // we don't need to add one for sentinels because the
                 // underlying value data includes the sentinel
 @@ -33141,7 +33144,7 @@ fn analyzeSlice(
             }
             const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
-            if (slice_ty.sentinel(mod) == null) break :blk slice_len_inst;
+            if (slice_ty.sentinel(zcu) == null) break :blk slice_len_inst;
             // we have to add one because slice lengths don't include the sentinel
             break :blk try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src, true);
 @@ -33186,16 +33189,16 @@ fn cmpNumeric(
     rhs_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(uncasted_lhs);
     const rhs_ty = sema.typeOf(uncasted_rhs);
-    assert(lhs_ty.isNumeric(mod));
+    assert(lhs_ty.isNumeric(zcu));
-    assert(rhs_ty.isNumeric(mod));
+    assert(rhs_ty.isNumeric(zcu));
-    const lhs_ty_tag = lhs_ty.zigTypeTag(mod);
+    const lhs_ty_tag = lhs_ty.zigTypeTag(zcu);
-    const rhs_ty_tag = rhs_ty.zigTypeTag(mod);
+    const rhs_ty_tag = rhs_ty.zigTypeTag(zcu);
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     // One exception to heterogeneous comparison: comptime_float needs to
     // coerce to fixed-width float.
 @@ -33214,28 +33217,28 @@ fn cmpNumeric(
         if (try sema.resolveValue(lhs)) |lhs_val| {
             if (try sema.resolveValue(rhs)) |rhs_val| {
                 // Compare ints: const vs. undefined (or vice versa)
-                if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod) and rhs_val.isUndef(mod)) {
+                if (!lhs_val.isUndef(zcu) and (lhs_ty.isInt(zcu) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(zcu) and rhs_val.isUndef(zcu)) {
                     if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| {
                         return if (res) .bool_true else .bool_false;
                     }
-                } else if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod) and lhs_val.isUndef(mod)) {
+                } else if (!rhs_val.isUndef(zcu) and (rhs_ty.isInt(zcu) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(zcu) and lhs_val.isUndef(zcu)) {
                     if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| {
                         return if (res) .bool_true else .bool_false;
                     }
                 }
-                if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
+                if (lhs_val.isUndef(zcu) or rhs_val.isUndef(zcu)) {
                     return pt.undefRef(Type.bool);
                 }
-                if (lhs_val.isNan(mod) or rhs_val.isNan(mod)) {
+                if (lhs_val.isNan(zcu) or rhs_val.isNan(zcu)) {
                     return if (op == std.math.CompareOperator.neq) .bool_true else .bool_false;
                 }
-                return if (try Value.compareHeteroAdvanced(lhs_val, op, rhs_val, pt, .sema))
+                return if (try Value.compareHeteroSema(lhs_val, op, rhs_val, pt))
                     .bool_true
                 else
                     .bool_false;
             } else {
-                if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod)) {
+                if (!lhs_val.isUndef(zcu) and (lhs_ty.isInt(zcu) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(zcu)) {
                     // Compare ints: const vs. var
                     if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| {
                         return if (res) .bool_true else .bool_false;
 @@ -33245,7 +33248,7 @@ fn cmpNumeric(
             }
         } else {
             if (try sema.resolveValueResolveLazy(rhs)) |rhs_val| {
-                if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod)) {
+                if (!rhs_val.isUndef(zcu) and (rhs_ty.isInt(zcu) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(zcu)) {
                     // Compare ints: var vs. const
                     if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| {
                         return if (res) .bool_true else .bool_false;
 @@ -33301,31 +33304,31 @@ fn cmpNumeric(
     const lhs_is_signed = if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val|
         !(try lhs_val.compareAllWithZeroSema(.gte, pt))
     else
-        (lhs_ty.isRuntimeFloat() or lhs_ty.isSignedInt(mod));
+        (lhs_ty.isRuntimeFloat() or lhs_ty.isSignedInt(zcu));
     const rhs_is_signed = if (try sema.resolveDefinedValue(block, rhs_src, rhs)) |rhs_val|
         !(try rhs_val.compareAllWithZeroSema(.gte, pt))
     else
-        (rhs_ty.isRuntimeFloat() or rhs_ty.isSignedInt(mod));
+        (rhs_ty.isRuntimeFloat() or rhs_ty.isSignedInt(zcu));
     const dest_int_is_signed = lhs_is_signed or rhs_is_signed;
     var dest_float_type: ?Type = null;
     var lhs_bits: usize = undefined;
     if (try sema.resolveValueResolveLazy(lhs)) |lhs_val| {
-        if (lhs_val.isUndef(mod))
+        if (lhs_val.isUndef(zcu))
             return pt.undefRef(Type.bool);
-        if (lhs_val.isNan(mod)) switch (op) {
+        if (lhs_val.isNan(zcu)) switch (op) {
             .neq => return .bool_true,
             else => return .bool_false,
         };
-        if (lhs_val.isInf(mod)) switch (op) {
+        if (lhs_val.isInf(zcu)) switch (op) {
             .neq => return .bool_true,
             .eq => return .bool_false,
-            .gt, .gte => return if (lhs_val.isNegativeInf(mod)) .bool_false else .bool_true,
+            .gt, .gte => return if (lhs_val.isNegativeInf(zcu)) .bool_false else .bool_true,
-            .lt, .lte => return if (lhs_val.isNegativeInf(mod)) .bool_true else .bool_false,
+            .lt, .lte => return if (lhs_val.isNegativeInf(zcu)) .bool_true else .bool_false,
         };
         if (!rhs_is_signed) {
-            switch (lhs_val.orderAgainstZero(pt)) {
+            switch (lhs_val.orderAgainstZero(zcu)) {
                 .gt => {},
                 .eq => switch (op) { // LHS = 0, RHS is unsigned
                     .lte => return .bool_true,
 @@ -33339,7 +33342,7 @@ fn cmpNumeric(
             }
         }
         if (lhs_is_float) {
-            if (lhs_val.floatHasFraction(mod)) {
+            if (lhs_val.floatHasFraction(zcu)) {
                 switch (op) {
                     .eq => return .bool_false,
                     .neq => return .bool_true,
 @@ -33347,9 +33350,9 @@ fn cmpNumeric(
                 }
             }
-            var bigint = try float128IntPartToBigInt(sema.gpa, lhs_val.toFloat(f128, pt));
+            var bigint = try float128IntPartToBigInt(sema.gpa, lhs_val.toFloat(f128, zcu));
             defer bigint.deinit();
-            if (lhs_val.floatHasFraction(mod)) {
+            if (lhs_val.floatHasFraction(zcu)) {
                 if (lhs_is_signed) {
                     try bigint.addScalar(&bigint, -1);
                 } else {
 @@ -33358,32 +33361,32 @@ fn cmpNumeric(
             }
             lhs_bits = bigint.toConst().bitCountTwosComp();
         } else {
-            lhs_bits = lhs_val.intBitCountTwosComp(pt);
+            lhs_bits = lhs_val.intBitCountTwosComp(zcu);
         }
         lhs_bits += @intFromBool(!lhs_is_signed and dest_int_is_signed);
     } else if (lhs_is_float) {
         dest_float_type = lhs_ty;
     } else {
-        const int_info = lhs_ty.intInfo(mod);
+        const int_info = lhs_ty.intInfo(zcu);
         lhs_bits = int_info.bits + @intFromBool(int_info.signedness == .unsigned and dest_int_is_signed);
     }
     var rhs_bits: usize = undefined;
     if (try sema.resolveValueResolveLazy(rhs)) |rhs_val| {
-        if (rhs_val.isUndef(mod))
+        if (rhs_val.isUndef(zcu))
             return pt.undefRef(Type.bool);
-        if (rhs_val.isNan(mod)) switch (op) {
+        if (rhs_val.isNan(zcu)) switch (op) {
             .neq => return .bool_true,
             else => return .bool_false,
         };
-        if (rhs_val.isInf(mod)) switch (op) {
+        if (rhs_val.isInf(zcu)) switch (op) {
             .neq => return .bool_true,
             .eq => return .bool_false,
-            .gt, .gte => return if (rhs_val.isNegativeInf(mod)) .bool_true else .bool_false,
+            .gt, .gte => return if (rhs_val.isNegativeInf(zcu)) .bool_true else .bool_false,
-            .lt, .lte => return if (rhs_val.isNegativeInf(mod)) .bool_false else .bool_true,
+            .lt, .lte => return if (rhs_val.isNegativeInf(zcu)) .bool_false else .bool_true,
         };
         if (!lhs_is_signed) {
-            switch (rhs_val.orderAgainstZero(pt)) {
+            switch (rhs_val.orderAgainstZero(zcu)) {
                 .gt => {},
                 .eq => switch (op) { // RHS = 0, LHS is unsigned
                     .gte => return .bool_true,
 @@ -33397,7 +33400,7 @@ fn cmpNumeric(
             }
         }
         if (rhs_is_float) {
-            if (rhs_val.floatHasFraction(mod)) {
+            if (rhs_val.floatHasFraction(zcu)) {
                 switch (op) {
                     .eq => return .bool_false,
                     .neq => return .bool_true,
 @@ -33405,9 +33408,9 @@ fn cmpNumeric(
                 }
             }
-            var bigint = try float128IntPartToBigInt(sema.gpa, rhs_val.toFloat(f128, pt));
+            var bigint = try float128IntPartToBigInt(sema.gpa, rhs_val.toFloat(f128, zcu));
             defer bigint.deinit();
-            if (rhs_val.floatHasFraction(mod)) {
+            if (rhs_val.floatHasFraction(zcu)) {
                 if (rhs_is_signed) {
                     try bigint.addScalar(&bigint, -1);
                 } else {
 @@ -33416,13 +33419,13 @@ fn cmpNumeric(
             }
             rhs_bits = bigint.toConst().bitCountTwosComp();
         } else {
-            rhs_bits = rhs_val.intBitCountTwosComp(pt);
+            rhs_bits = rhs_val.intBitCountTwosComp(zcu);
         }
         rhs_bits += @intFromBool(!rhs_is_signed and dest_int_is_signed);
     } else if (rhs_is_float) {
         dest_float_type = rhs_ty;
     } else {
-        const int_info = rhs_ty.intInfo(mod);
+        const int_info = rhs_ty.intInfo(zcu);
         rhs_bits = int_info.bits + @intFromBool(int_info.signedness == .unsigned and dest_int_is_signed);
     }
 @@ -33450,9 +33453,9 @@ fn compareIntsOnlyPossibleResult(
     rhs_ty: Type,
 ) Allocator.Error!?bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const rhs_info = rhs_ty.intInfo(mod);
+    const rhs_info = rhs_ty.intInfo(zcu);
-    const vs_zero = lhs_val.orderAgainstZeroAdvanced(pt, .sema) catch unreachable;
+    const vs_zero = lhs_val.orderAgainstZeroSema(pt) catch unreachable;
     const is_zero = vs_zero == .eq;
     const is_negative = vs_zero == .lt;
     const is_positive = vs_zero == .gt;
 @@ -33484,7 +33487,7 @@ fn compareIntsOnlyPossibleResult(
     };
     const sign_adj = @intFromBool(!is_negative and rhs_info.signedness == .signed);
-    const req_bits = lhs_val.intBitCountTwosComp(pt) + sign_adj;
+    const req_bits = lhs_val.intBitCountTwosComp(zcu) + sign_adj;
     // No sized type can have more than 65535 bits.
     // The RHS type operand is either a runtime value or sized (but undefined) constant.
 @@ -33515,7 +33518,7 @@ fn compareIntsOnlyPossibleResult(
             if (is_negative) .signed else .unsigned,
             @intCast(req_bits),
         );
-        const pop_count = lhs_val.popCount(ty, pt);
+        const pop_count = lhs_val.popCount(ty, zcu);
         if (is_negative) {
             break :edge .{ pop_count == 1, false };
 @@ -33546,11 +33549,11 @@ fn cmpVector(
     rhs_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = sema.typeOf(lhs);
     const rhs_ty = sema.typeOf(rhs);
-    assert(lhs_ty.zigTypeTag(mod) == .Vector);
+    assert(lhs_ty.zigTypeTag(zcu) == .Vector);
-    assert(rhs_ty.zigTypeTag(mod) == .Vector);
+    assert(rhs_ty.zigTypeTag(zcu) == .Vector);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     const resolved_ty = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{ .override = &.{ lhs_src, rhs_src } });
 @@ -33558,14 +33561,14 @@ fn cmpVector(
     const casted_rhs = try sema.coerce(block, resolved_ty, rhs, rhs_src);
     const result_ty = try pt.vectorType(.{
-        .len = lhs_ty.vectorLen(mod),
+        .len = lhs_ty.vectorLen(zcu),
         .child = .bool_type,
     });
     const runtime_src: LazySrcLoc = src: {
         if (try sema.resolveValue(casted_lhs)) |lhs_val| {
             if (try sema.resolveValue(casted_rhs)) |rhs_val| {
-                if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
+                if (lhs_val.isUndef(zcu) or rhs_val.isUndef(zcu)) {
                     return pt.undefRef(result_ty);
                 }
                 const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_ty);
 @@ -33608,8 +33611,8 @@ fn wrapErrorUnionPayload(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const dest_payload_ty = dest_ty.errorUnionPayload(mod);
+    const dest_payload_ty = dest_ty.errorUnionPayload(zcu);
     const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });
     if (try sema.resolveValue(coerced)) |val| {
         return Air.internedToRef((try pt.intern(.{ .error_union = .{
 @@ -33629,12 +33632,12 @@ fn wrapErrorUnionSet(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const inst_ty = sema.typeOf(inst);
-    const dest_err_set_ty = dest_ty.errorUnionSet(mod);
+    const dest_err_set_ty = dest_ty.errorUnionSet(zcu);
     if (try sema.resolveValue(inst)) |val| {
-        const expected_name = mod.intern_pool.indexToKey(val.toIntern()).err.name;
+        const expected_name = zcu.intern_pool.indexToKey(val.toIntern()).err.name;
         switch (dest_err_set_ty.toIntern()) {
             .anyerror_type => {},
             .adhoc_inferred_error_set_type => ok: {
 @@ -33658,7 +33661,7 @@ fn wrapErrorUnionSet(
                 .inferred_error_set_type => |func_index| ok: {
                     // We carefully do this in an order that avoids unnecessarily
                     // resolving the destination error set type.
-                    try mod.maybeUnresolveIes(func_index);
+                    try zcu.maybeUnresolveIes(func_index);
                     switch (ip.funcIesResolvedUnordered(func_index)) {
                         .anyerror_type => break :ok,
                         .none => if (.ok == try sema.coerceInMemoryAllowedErrorSets(block, dest_err_set_ty, inst_ty, inst_src, inst_src)) {
 @@ -33693,13 +33696,13 @@ fn unionToTag(
     un_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {
         return Air.internedToRef(opv.toIntern());
     }
     if (try sema.resolveValue(un)) |un_val| {
-        const tag_val = un_val.unionTag(mod).?;
+        const tag_val = un_val.unionTag(zcu).?;
-        if (tag_val.isUndef(mod))
+        if (tag_val.isUndef(zcu))
             return try pt.undefRef(enum_ty);
         return Air.internedToRef(tag_val.toIntern());
     }
 @@ -33861,8 +33864,8 @@ const PeerResolveStrategy = enum {
         return strat;
     }
-    fn select(ty: Type, mod: *Module) PeerResolveStrategy {
+    fn select(ty: Type, zcu: *Zcu) PeerResolveStrategy {
-        return switch (ty.zigTypeTag(mod)) {
+        return switch (ty.zigTypeTag(zcu)) {
             .Type, .Void, .Bool, .Opaque, .Frame, .AnyFrame => .exact,
             .NoReturn, .Undefined => .unknown,
             .Null => .nullable,
 @@ -33870,14 +33873,14 @@ const PeerResolveStrategy = enum {
             .Int => .fixed_int,
             .ComptimeFloat => .comptime_float,
             .Float => .fixed_float,
-            .Pointer => if (ty.ptrInfo(mod).flags.size == .C) .c_ptr else .ptr,
+            .Pointer => if (ty.ptrInfo(zcu).flags.size == .C) .c_ptr else .ptr,
             .Array => .array,
             .Vector => .vector,
             .Optional => .optional,
             .ErrorSet => .error_set,
             .ErrorUnion => .error_union,
             .EnumLiteral, .Enum, .Union => .enum_or_union,
-            .Struct => if (ty.isTupleOrAnonStruct(mod)) .coercible_struct else .exact,
+            .Struct => if (ty.isTupleOrAnonStruct(zcu)) .coercible_struct else .exact,
             .Fn => .func,
         };
     }
 @@ -33933,10 +33936,10 @@ const PeerResolveResult = union(enum) {
         src: LazySrcLoc,
         instructions: []const Air.Inst.Ref,
         candidate_srcs: PeerTypeCandidateSrc,
-    ) !*Module.ErrorMsg {
+    ) !*Zcu.ErrorMsg {
         const pt = sema.pt;
-        var opt_msg: ?*Module.ErrorMsg = null;
+        var opt_msg: ?*Zcu.ErrorMsg = null;
         errdefer if (opt_msg) |msg| msg.destroy(sema.gpa);
         // If we mention fields we'll want to include field types, so put peer types in a buffer
 @@ -34053,14 +34056,14 @@ fn resolvePeerTypesInner(
     peer_vals: []?Value,
 ) !PeerResolveResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     var strat_reason: usize = 0;
     var s: PeerResolveStrategy = .unknown;
     for (peer_tys, 0..) |opt_ty, i| {
         const ty = opt_ty orelse continue;
-        s = s.merge(PeerResolveStrategy.select(ty, mod), &strat_reason, i);
+        s = s.merge(PeerResolveStrategy.select(ty, zcu), &strat_reason, i);
     }
     if (s == .unknown) {
 @@ -34070,14 +34073,14 @@ fn resolvePeerTypesInner(
         // There was something other than noreturn and undefined, so we can ignore those peers
         for (peer_tys) |*ty_ptr| {
             const ty = ty_ptr.* orelse continue;
-            switch (ty.zigTypeTag(mod)) {
+            switch (ty.zigTypeTag(zcu)) {
                 .NoReturn, .Undefined => ty_ptr.* = null,
                 else => {},
             }
         }
     }
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     switch (s) {
         .unknown => unreachable,
 @@ -34086,7 +34089,7 @@ fn resolvePeerTypesInner(
             var final_set: ?Type = null;
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                if (ty.zigTypeTag(mod) != .ErrorSet) return .{ .conflict = .{
+                if (ty.zigTypeTag(zcu) != .ErrorSet) return .{ .conflict = .{
                     .peer_idx_a = strat_reason,
                     .peer_idx_b = i,
                 } };
 @@ -34103,15 +34106,15 @@ fn resolvePeerTypesInner(
             var final_set: ?Type = null;
             for (peer_tys, peer_vals) |*ty_ptr, *val_ptr| {
                 const ty = ty_ptr.* orelse continue;
-                const set_ty = switch (ty.zigTypeTag(mod)) {
+                const set_ty = switch (ty.zigTypeTag(zcu)) {
                     .ErrorSet => blk: {
                         ty_ptr.* = null; // no payload to decide on
                         val_ptr.* = null;
                         break :blk ty;
                     },
                     .ErrorUnion => blk: {
-                        const set_ty = ty.errorUnionSet(mod);
+                        const set_ty = ty.errorUnionSet(zcu);
-                        ty_ptr.* = ty.errorUnionPayload(mod);
+                        ty_ptr.* = ty.errorUnionPayload(zcu);
                         if (val_ptr.*) |eu_val| switch (ip.indexToKey(eu_val.toIntern())) {
                             .error_union => |eu| switch (eu.val) {
                                 .payload => |payload_ip| val_ptr.* = Value.fromInterned(payload_ip),
 @@ -34146,7 +34149,7 @@ fn resolvePeerTypesInner(
         .nullable => {
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                if (!ty.eql(Type.null, mod)) return .{ .conflict = .{
+                if (!ty.eql(Type.null, zcu)) return .{ .conflict = .{
                     .peer_idx_a = strat_reason,
                     .peer_idx_b = i,
                 } };
 @@ -34157,14 +34160,14 @@ fn resolvePeerTypesInner(
         .optional => {
             for (peer_tys, peer_vals) |*ty_ptr, *val_ptr| {
                 const ty = ty_ptr.* orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .Null => {
                         ty_ptr.* = null;
                         val_ptr.* = null;
                     },
                     .Optional => {
-                        ty_ptr.* = ty.optionalChild(mod);
+                        ty_ptr.* = ty.optionalChild(zcu);
-                        if (val_ptr.*) |opt_val| val_ptr.* = if (!opt_val.isUndef(mod)) opt_val.optionalValue(mod) else null;
+                        if (val_ptr.*) |opt_val| val_ptr.* = if (!opt_val.isUndef(zcu)) opt_val.optionalValue(zcu) else null;
                     },
                     else => {},
                 }
 @@ -34195,7 +34198,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, 0..) |*ty_ptr, i| {
                 const ty = ty_ptr.* orelse continue;
-                if (!ty.isArrayOrVector(mod)) {
+                if (!ty.isArrayOrVector(zcu)) {
                     // We allow tuples of the correct length. We won't validate their elem type, since the elements can be coerced.
                     const arr_like = sema.typeIsArrayLike(ty) orelse return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
 @@ -34220,29 +34223,29 @@ fn resolvePeerTypesInner(
                 const first_arr_idx = opt_first_arr_idx orelse {
                     if (opt_first_idx == null) {
                         opt_first_idx = i;
-                        len = ty.arrayLen(mod);
+                        len = ty.arrayLen(zcu);
-                        sentinel = ty.sentinel(mod);
+                        sentinel = ty.sentinel(zcu);
                     }
                     opt_first_arr_idx = i;
-                    elem_ty = ty.childType(mod);
+                    elem_ty = ty.childType(zcu);
                     continue;
                 };
-                if (ty.arrayLen(mod) != len) return .{ .conflict = .{
+                if (ty.arrayLen(zcu) != len) return .{ .conflict = .{
                     .peer_idx_a = first_arr_idx,
                     .peer_idx_b = i,
                 } };
-                const peer_elem_ty = ty.childType(mod);
+                const peer_elem_ty = ty.childType(zcu);
-                if (!peer_elem_ty.eql(elem_ty, mod)) coerce: {
+                if (!peer_elem_ty.eql(elem_ty, zcu)) coerce: {
                     const peer_elem_coerces_to_elem =
-                        try sema.coerceInMemoryAllowed(block, elem_ty, peer_elem_ty, false, mod.getTarget(), src, src, null);
+                        try sema.coerceInMemoryAllowed(block, elem_ty, peer_elem_ty, false, zcu.getTarget(), src, src, null);
                     if (peer_elem_coerces_to_elem == .ok) {
                         break :coerce;
                     }
                     const elem_coerces_to_peer_elem =
-                        try sema.coerceInMemoryAllowed(block, peer_elem_ty, elem_ty, false, mod.getTarget(), src, src, null);
+                        try sema.coerceInMemoryAllowed(block, peer_elem_ty, elem_ty, false, zcu.getTarget(), src, src, null);
                     if (elem_coerces_to_peer_elem == .ok) {
                         elem_ty = peer_elem_ty;
                         break :coerce;
 @@ -34255,8 +34258,8 @@ fn resolvePeerTypesInner(
                 }
                 if (sentinel) |cur_sent| {
-                    if (ty.sentinel(mod)) |peer_sent| {
+                    if (ty.sentinel(zcu)) |peer_sent| {
-                        if (!peer_sent.eql(cur_sent, elem_ty, mod)) sentinel = null;
+                        if (!peer_sent.eql(cur_sent, elem_ty, zcu)) sentinel = null;
                     } else {
                         sentinel = null;
                     }
 @@ -34279,7 +34282,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, peer_vals, 0..) |*ty_ptr, *val_ptr, i| {
                 const ty = ty_ptr.* orelse continue;
-                if (!ty.isArrayOrVector(mod)) {
+                if (!ty.isArrayOrVector(zcu)) {
                     // Allow tuples of the correct length
                     const arr_like = sema.typeIsArrayLike(ty) orelse return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
 @@ -34305,16 +34308,16 @@ fn resolvePeerTypesInner(
                 }
                 if (len) |expect_len| {
-                    if (ty.arrayLen(mod) != expect_len) return .{ .conflict = .{
+                    if (ty.arrayLen(zcu) != expect_len) return .{ .conflict = .{
                         .peer_idx_a = first_idx,
                         .peer_idx_b = i,
                     } };
                 } else {
-                    len = ty.arrayLen(mod);
+                    len = ty.arrayLen(zcu);
                     first_idx = i;
                 }
-                ty_ptr.* = ty.childType(mod);
+                ty_ptr.* = ty.childType(zcu);
                 val_ptr.* = null; // multiple child vals, so we can't easily use them in PTR
             }
 @@ -34339,7 +34342,7 @@ fn resolvePeerTypesInner(
             var first_idx: usize = undefined;
             for (peer_tys, peer_vals, 0..) |opt_ty, opt_val, i| {
                 const ty = opt_ty orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .ComptimeInt => continue, // comptime-known integers can always coerce to C pointers
                     .Int => {
                         if (opt_val != null) {
 @@ -34348,7 +34351,7 @@ fn resolvePeerTypesInner(
                         } else {
                             // Runtime-known, so check if the type is no bigger than a usize
                             const ptr_bits = target.ptrBitWidth();
-                            const bits = ty.intInfo(mod).bits;
+                            const bits = ty.intInfo(zcu).bits;
                             if (bits <= ptr_bits) continue;
                         }
                     },
 @@ -34356,13 +34359,13 @@ fn resolvePeerTypesInner(
                     else => {},
                 }
-                if (!ty.isPtrAtRuntime(mod)) return .{ .conflict = .{
+                if (!ty.isPtrAtRuntime(zcu)) return .{ .conflict = .{
                     .peer_idx_a = strat_reason,
                     .peer_idx_b = i,
                 } };
                 // Goes through optionals
-                const peer_info = ty.ptrInfo(mod);
+                const peer_info = ty.ptrInfo(zcu);
                 var ptr_info = opt_ptr_info orelse {
                     opt_ptr_info = peer_info;
 @@ -34391,17 +34394,17 @@ fn resolvePeerTypesInner(
                     ptr_info.sentinel = .none;
                 }
-                // Note that the align can be always non-zero; Module.ptrType will canonicalize it
+                // Note that the align can be always non-zero; Zcu.ptrType will canonicalize it
                 ptr_info.flags.alignment = InternPool.Alignment.min(
                     if (ptr_info.flags.alignment != .none)
                         ptr_info.flags.alignment
                     else
-                        Type.fromInterned(ptr_info.child).abiAlignment(pt),
+                        Type.fromInterned(ptr_info.child).abiAlignment(zcu),
                     if (peer_info.flags.alignment != .none)
                         peer_info.flags.alignment
                     else
-                        Type.fromInterned(peer_info.child).abiAlignment(pt),
+                        Type.fromInterned(peer_info.child).abiAlignment(zcu),
                 );
                 if (ptr_info.flags.address_space != peer_info.flags.address_space) {
                     return .{ .conflict = .{
 @@ -34438,8 +34441,8 @@ fn resolvePeerTypesInner(
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                const peer_info: InternPool.Key.PtrType = switch (ty.zigTypeTag(mod)) {
+                const peer_info: InternPool.Key.PtrType = switch (ty.zigTypeTag(zcu)) {
-                    .Pointer => ty.ptrInfo(mod),
+                    .Pointer => ty.ptrInfo(zcu),
                     .Fn => .{
                         .child = ty.toIntern(),
                         .flags = .{
 @@ -34480,12 +34483,12 @@ fn resolvePeerTypesInner(
                     if (ptr_info.flags.alignment != .none)
                         ptr_info.flags.alignment
                     else
-                        try sema.typeAbiAlignment(Type.fromInterned(ptr_info.child)),
+                        try Type.fromInterned(ptr_info.child).abiAlignmentSema(pt),
                     if (peer_info.flags.alignment != .none)
                         peer_info.flags.alignment
                     else
-                        try sema.typeAbiAlignment(Type.fromInterned(peer_info.child)),
+                        try Type.fromInterned(peer_info.child).abiAlignmentSema(pt),
                 );
                 if (ptr_info.flags.address_space != peer_info.flags.address_space) {
 @@ -34747,7 +34750,7 @@ fn resolvePeerTypesInner(
                     first_idx = i;
                     continue;
                 };
-                if (ty.zigTypeTag(mod) != .Fn) return .{ .conflict = .{
+                if (ty.zigTypeTag(zcu) != .Fn) return .{ .conflict = .{
                     .peer_idx_a = strat_reason,
                     .peer_idx_b = i,
                 } };
 @@ -34775,7 +34778,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .EnumLiteral, .Enum, .Union => {},
                     else => return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
 @@ -34794,32 +34797,32 @@ fn resolvePeerTypesInner(
                     .peer_idx_b = i,
                 } };
-                switch (cur_ty.zigTypeTag(mod)) {
+                switch (cur_ty.zigTypeTag(zcu)) {
                     .EnumLiteral => {
                         opt_cur_ty = ty;
                         cur_ty_idx = i;
                     },
-                    .Enum => switch (ty.zigTypeTag(mod)) {
+                    .Enum => switch (ty.zigTypeTag(zcu)) {
                         .EnumLiteral => {},
                         .Enum => {
-                            if (!ty.eql(cur_ty, mod)) return generic_err;
+                            if (!ty.eql(cur_ty, zcu)) return generic_err;
                         },
                         .Union => {
-                            const tag_ty = ty.unionTagTypeHypothetical(mod);
+                            const tag_ty = ty.unionTagTypeHypothetical(zcu);
-                            if (!tag_ty.eql(cur_ty, mod)) return generic_err;
+                            if (!tag_ty.eql(cur_ty, zcu)) return generic_err;
                             opt_cur_ty = ty;
                             cur_ty_idx = i;
                         },
                         else => unreachable,
                     },
-                    .Union => switch (ty.zigTypeTag(mod)) {
+                    .Union => switch (ty.zigTypeTag(zcu)) {
                         .EnumLiteral => {},
                         .Enum => {
-                            const cur_tag_ty = cur_ty.unionTagTypeHypothetical(mod);
+                            const cur_tag_ty = cur_ty.unionTagTypeHypothetical(zcu);
-                            if (!ty.eql(cur_tag_ty, mod)) return generic_err;
+                            if (!ty.eql(cur_tag_ty, zcu)) return generic_err;
                         },
                         .Union => {
-                            if (!ty.eql(cur_ty, mod)) return generic_err;
+                            if (!ty.eql(cur_ty, zcu)) return generic_err;
                         },
                         else => unreachable,
                     },
 @@ -34832,7 +34835,7 @@ fn resolvePeerTypesInner(
         .comptime_int => {
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .ComptimeInt => {},
                     else => return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
 @@ -34846,7 +34849,7 @@ fn resolvePeerTypesInner(
         .comptime_float => {
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .ComptimeInt, .ComptimeFloat => {},
                     else => return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
 @@ -34868,11 +34871,11 @@ fn resolvePeerTypesInner(
                 const ty = opt_ty orelse continue;
                 const opt_val = ptr_opt_val.*;
-                const peer_tag = ty.zigTypeTag(mod);
+                const peer_tag = ty.zigTypeTag(zcu);
                 switch (peer_tag) {
                     .ComptimeInt => {
                         // If the value is undefined, we can't refine to a fixed-width int
-                        if (opt_val == null or opt_val.?.isUndef(mod)) return .{ .conflict = .{
+                        if (opt_val == null or opt_val.?.isUndef(zcu)) return .{ .conflict = .{
                             .peer_idx_a = strat_reason,
                             .peer_idx_b = i,
                         } };
 @@ -34889,7 +34892,7 @@ fn resolvePeerTypesInner(
                 if (opt_val != null) any_comptime_known = true;
-                const info = ty.intInfo(mod);
+                const info = ty.intInfo(zcu);
                 const idx_ptr = switch (info.signedness) {
                     .unsigned => &idx_unsigned,
 @@ -34901,7 +34904,7 @@ fn resolvePeerTypesInner(
                     continue;
                 };
-                const cur_info = peer_tys[largest_idx].?.intInfo(mod);
+                const cur_info = peer_tys[largest_idx].?.intInfo(zcu);
                 if (info.bits > cur_info.bits) {
                     idx_ptr.* = i;
                 }
 @@ -34915,8 +34918,8 @@ fn resolvePeerTypesInner(
                 return .{ .success = peer_tys[idx_signed.?].? };
             }
-            const unsigned_info = peer_tys[idx_unsigned.?].?.intInfo(mod);
+            const unsigned_info = peer_tys[idx_unsigned.?].?.intInfo(zcu);
-            const signed_info = peer_tys[idx_signed.?].?.intInfo(mod);
+            const signed_info = peer_tys[idx_signed.?].?.intInfo(zcu);
             if (signed_info.bits > unsigned_info.bits) {
                 return .{ .success = peer_tys[idx_signed.?].? };
             }
 @@ -34948,7 +34951,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, peer_vals, 0..) |opt_ty, opt_val, i| {
                 const ty = opt_ty orelse continue;
-                switch (ty.zigTypeTag(mod)) {
+                switch (ty.zigTypeTag(zcu)) {
                     .ComptimeFloat, .ComptimeInt => {},
                     .Int => {
                         if (opt_val == null) return .{ .conflict = .{
 @@ -34958,7 +34961,7 @@ fn resolvePeerTypesInner(
                     },
                     .Float => {
                         if (opt_cur_ty) |cur_ty| {
-                            if (cur_ty.eql(ty, mod)) continue;
+                            if (cur_ty.eql(ty, zcu)) continue;
                             // Recreate the type so we eliminate any c_longdouble
                             const bits = @max(cur_ty.floatBits(target), ty.floatBits(target));
                             opt_cur_ty = switch (bits) {
 @@ -34997,7 +35000,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
-                if (!ty.isTupleOrAnonStruct(mod)) {
+                if (!ty.isTupleOrAnonStruct(zcu)) {
                     return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
                         .peer_idx_b = i,
 @@ -35006,8 +35009,8 @@ fn resolvePeerTypesInner(
                 const first_idx = opt_first_idx orelse {
                     opt_first_idx = i;
-                    is_tuple = ty.isTuple(mod);
+                    is_tuple = ty.isTuple(zcu);
-                    field_count = ty.structFieldCount(mod);
+                    field_count = ty.structFieldCount(zcu);
                     if (!is_tuple) {
                         const names = ip.indexToKey(ty.toIntern()).anon_struct_type.names.get(ip);
                         field_names = try sema.arena.dupe(InternPool.NullTerminatedString, names);
 @@ -35015,7 +35018,7 @@ fn resolvePeerTypesInner(
                     continue;
                 };
-                if (ty.isTuple(mod) != is_tuple or ty.structFieldCount(mod) != field_count) {
+                if (ty.isTuple(zcu) != is_tuple or ty.structFieldCount(zcu) != field_count) {
                     return .{ .conflict = .{
                         .peer_idx_a = first_idx,
                         .peer_idx_b = i,
 @@ -35025,7 +35028,7 @@ fn resolvePeerTypesInner(
                 if (!is_tuple) {
                     for (field_names, 0..) |expected, field_index_usize| {
                         const field_index: u32 = @intCast(field_index_usize);
-                        const actual = ty.structFieldName(field_index, mod).unwrap().?;
+                        const actual = ty.structFieldName(field_index, zcu).unwrap().?;
                         if (actual == expected) continue;
                         return .{ .conflict = .{
                             .peer_idx_a = first_idx,
 @@ -35052,7 +35055,7 @@ fn resolvePeerTypesInner(
                         peer_field_val.* = null;
                         continue;
                     };
-                    peer_field_ty.* = ty.structFieldType(field_index, mod);
+                    peer_field_ty.* = ty.fieldType(field_index, zcu);
                     peer_field_val.* = if (opt_val) |val| try val.fieldValue(pt, field_index) else null;
                 }
 @@ -35074,7 +35077,7 @@ fn resolvePeerTypesInner(
                             // Already-resolved types won't be referenced by the error so it's fine
                             // to leave them undefined.
                             const ty = opt_ty orelse continue;
-                            peer_field_ty.* = ty.structFieldType(field_index, mod);
+                            peer_field_ty.* = ty.fieldType(field_index, zcu);
                         }
                         return .{ .field_error = .{
 @@ -35111,7 +35114,7 @@ fn resolvePeerTypesInner(
                         comptime_val = coerced_val;
                         continue;
                     };
-                    if (!coerced_val.eql(existing, Type.fromInterned(field_ty.*), mod)) {
+                    if (!coerced_val.eql(existing, Type.fromInterned(field_ty.*), zcu)) {
                         comptime_val = null;
                         break;
                     }
 @@ -35120,7 +35123,7 @@ fn resolvePeerTypesInner(
                 field_val.* = if (comptime_val) |v| v.toIntern() else .none;
             }
-            const final_ty = try ip.getAnonStructType(mod.gpa, pt.tid, .{
+            const final_ty = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
                 .types = field_types,
                 .names = if (is_tuple) &.{} else field_names,
                 .values = field_vals,
 @@ -35135,7 +35138,7 @@ fn resolvePeerTypesInner(
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
                 if (expect_ty) |expect| {
-                    if (!ty.eql(expect, mod)) return .{ .conflict = .{
+                    if (!ty.eql(expect, zcu)) return .{ .conflict = .{
                         .peer_idx_a = first_idx,
                         .peer_idx_b = i,
                     } };
 @@ -35186,22 +35189,22 @@ const ArrayLike = struct {
 };
 fn typeIsArrayLike(sema: *Sema, ty: Type) ?ArrayLike {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .Array => .{
-            .len = ty.arrayLen(mod),
+            .len = ty.arrayLen(zcu),
-            .elem_ty = ty.childType(mod),
+            .elem_ty = ty.childType(zcu),
         },
         .Struct => {
-            const field_count = ty.structFieldCount(mod);
+            const field_count = ty.structFieldCount(zcu);
             if (field_count == 0) return .{
                 .len = 0,
                 .elem_ty = Type.noreturn,
             };
-            if (!ty.isTuple(mod)) return null;
+            if (!ty.isTuple(zcu)) return null;
-            const elem_ty = ty.structFieldType(0, mod);
+            const elem_ty = ty.fieldType(0, zcu);
             for (1..field_count) |i| {
-                if (!ty.structFieldType(i, mod).eql(elem_ty, mod)) {
+                if (!ty.fieldType(i, zcu).eql(elem_ty, zcu)) {
                     return null;
                 }
             }
 @@ -35216,8 +35219,8 @@ fn typeIsArrayLike(sema: *Sema, ty: Type) ?ArrayLike {
 pub fn resolveIes(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     if (sema.fn_ret_ty_ies) |ies| {
         try sema.resolveInferredErrorSetPtr(block, src, ies);
 @@ -35228,14 +35231,14 @@ pub fn resolveIes(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError!void
 pub fn resolveFnTypes(sema: *Sema, fn_ty: Type) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_ty_info = mod.typeToFunc(fn_ty).?;
+    const fn_ty_info = zcu.typeToFunc(fn_ty).?;
     try Type.fromInterned(fn_ty_info.return_type).resolveFully(pt);
-    if (mod.comp.config.any_error_tracing and
+    if (zcu.comp.config.any_error_tracing and
-        Type.fromInterned(fn_ty_info.return_type).isError(mod))
+        Type.fromInterned(fn_ty_info.return_type).isError(zcu))
     {
         // Ensure the type exists so that backends can assume that.
         _ = try pt.getBuiltinType("StackTrace");
 @@ -35258,9 +35261,9 @@ pub fn resolveStructAlignment(
     struct_type: InternPool.LoadedStructType,
 ) SemaError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
 @@ -35274,7 +35277,7 @@ pub fn resolveStructAlignment(
     // might require explicit alignment.
     if (struct_type.assumePointerAlignedIfFieldTypesWip(ip, ptr_align)) return;
-    try sema.resolveTypeFieldsStruct(ty, struct_type);
+    try sema.resolveStructFieldTypes(ty, struct_type);
     // We'll guess "pointer-aligned", if the struct has an
     // underaligned pointer field then some allocations
 @@ -35286,13 +35289,12 @@ pub fn resolveStructAlignment(
     for (0..struct_type.field_types.len) |i| {
         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-        if (struct_type.fieldIsComptime(ip, i) or try sema.typeRequiresComptime(field_ty))
+        if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt))
             continue;
-        const field_align = try pt.structFieldAlignmentAdvanced(
+        const field_align = try field_ty.structFieldAlignmentSema(
             struct_type.fieldAlign(ip, i),
-            field_ty,
             struct_type.layout,
-            .sema,
+            pt,
         );
         alignment = alignment.maxStrict(field_align);
     }
 @@ -35311,10 +35313,10 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
     if (struct_type.haveLayout(ip))
         return;
-    try sema.resolveTypeFieldsStruct(ty.toIntern(), struct_type);
+    try sema.resolveStructFieldTypes(ty.toIntern(), struct_type);
     if (struct_type.layout == .@"packed") {
-        semaBackingIntType(pt, struct_type) catch |err| switch (err) {
+        sema.backingIntType(struct_type) catch |err| switch (err) {
             error.OutOfMemory, error.AnalysisFail => |e| return e,
             error.ComptimeBreak, error.ComptimeReturn, error.GenericPoison => unreachable,
         };
 @@ -35338,14 +35340,14 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
     for (aligns, sizes, 0..) |*field_align, *field_size, i| {
         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-        if (struct_type.fieldIsComptime(ip, i) or try sema.typeRequiresComptime(field_ty)) {
+        if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt)) {
             struct_type.offsets.get(ip)[i] = 0;
             field_size.* = 0;
             field_align.* = .none;
             continue;
         }
-        field_size.* = sema.typeAbiSize(field_ty) catch |err| switch (err) {
+        field_size.* = field_ty.abiSizeSema(pt) catch |err| switch (err) {
             error.AnalysisFail => {
                 const msg = sema.err orelse return err;
                 try sema.addFieldErrNote(ty, i, msg, "while checking this field", .{});
 @@ -35353,16 +35355,15 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
             },
             else => return err,
         };
-        field_align.* = try pt.structFieldAlignmentAdvanced(
+        field_align.* = try field_ty.structFieldAlignmentSema(
             struct_type.fieldAlign(ip, i),
-            field_ty,
             struct_type.layout,
-            .sema,
+            pt,
         );
         big_align = big_align.maxStrict(field_align.*);
     }
-    if (struct_type.flagsUnordered(ip).assumed_runtime_bits and !(try sema.typeHasRuntimeBits(ty))) {
+    if (struct_type.flagsUnordered(ip).assumed_runtime_bits and !(try ty.hasRuntimeBitsSema(pt))) {
         const msg = try sema.errMsg(
             ty.srcLoc(zcu),
             "struct layout depends on it having runtime bits",
 @@ -35387,7 +35388,7 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
         for (runtime_order, 0..) |*ro, i| {
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-            if (struct_type.fieldIsComptime(ip, i) or try sema.typeRequiresComptime(field_ty)) {
+            if (struct_type.fieldIsComptime(ip, i) or try field_ty.comptimeOnlySema(pt)) {
                 ro.* = .omitted;
             } else {
                 ro.* = @enumFromInt(i);
 @@ -35440,41 +35441,26 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
         offset = offsets[i] + sizes[i];
     }
     struct_type.setLayoutResolved(ip, @intCast(big_align.forward(offset)), big_align);
-    _ = try sema.typeRequiresComptime(ty);
+    _ = try ty.comptimeOnlySema(pt);
 }
-fn semaBackingIntType(pt: Zcu.PerThread, struct_type: InternPool.LoadedStructType) CompileError!void {
+fn backingIntType(
+    sema: *Sema,
+    struct_type: InternPool.LoadedStructType,
+) CompileError!void {
+    const pt = sema.pt;
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
     const cau_index = struct_type.cau.unwrap().?;
-    const zir = zcu.namespacePtr(struct_type.namespace.unwrap().?).fileScope(zcu).zir;
     var analysis_arena = std.heap.ArenaAllocator.init(gpa);
     defer analysis_arena.deinit();
-    var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = analysis_arena.allocator(),
-        .code = zir,
-        .owner = AnalUnit.wrap(.{ .cau = cau_index }),
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
     var block: Block = .{
         .parent = null,
-        .sema = &sema,
+        .sema = sema,
         .namespace = ip.getCau(cau_index).namespace,
         .instructions = .{},
         .inlining = null,
 @@ -35488,11 +35474,12 @@ fn semaBackingIntType(pt: Zcu.PerThread, struct_type: InternPool.LoadedStructTyp
         var accumulator: u64 = 0;
         for (0..struct_type.field_types.len) |i| {
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-            accumulator += try field_ty.bitSizeAdvanced(pt, .sema);
+            accumulator += try field_ty.bitSizeSema(pt);
         }
         break :blk accumulator;
     };
+    const zir = zcu.namespacePtr(struct_type.namespace.unwrap().?).fileScope(zcu).zir;
     const zir_index = struct_type.zir_index.unwrap().?.resolve(ip) orelse return error.AnalysisFail;
     const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
     assert(extended.opcode == .struct_decl);
 @@ -35543,17 +35530,17 @@ fn semaBackingIntType(pt: Zcu.PerThread, struct_type: InternPool.LoadedStructTyp
 fn checkBackingIntType(sema: *Sema, block: *Block, src: LazySrcLoc, backing_int_ty: Type, fields_bit_sum: u64) CompileError!void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (!backing_int_ty.isInt(mod)) {
+    if (!backing_int_ty.isInt(zcu)) {
         return sema.fail(block, src, "expected backing integer type, found '{}'", .{backing_int_ty.fmt(pt)});
     }
-    if (backing_int_ty.bitSize(pt) != fields_bit_sum) {
+    if (backing_int_ty.bitSize(zcu) != fields_bit_sum) {
         return sema.fail(
             block,
             src,
             "backing integer type '{}' has bit size {} but the struct fields have a total bit size of {}",
-            .{ backing_int_ty.fmt(pt), backing_int_ty.bitSize(pt), fields_bit_sum },
+            .{ backing_int_ty.fmt(pt), backing_int_ty.bitSize(zcu), fields_bit_sum },
         );
     }
 }
 @@ -35573,13 +35560,13 @@ fn checkIndexable(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
 fn checkMemOperand(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Pointer) {
+    if (ty.zigTypeTag(zcu) == .Pointer) {
-        switch (ty.ptrSize(mod)) {
+        switch (ty.ptrSize(zcu)) {
             .Slice, .Many, .C => return,
             .One => {
-                const elem_ty = ty.childType(mod);
+                const elem_ty = ty.childType(zcu);
-                if (elem_ty.zigTypeTag(mod) == .Array) return;
+                if (elem_ty.zigTypeTag(zcu) == .Array) return;
                 // TODO https://github.com/ziglang/zig/issues/15479
                 // if (elem_ty.isTuple()) return;
             },
 @@ -35601,7 +35588,8 @@ pub fn resolveUnionAlignment(
     ty: Type,
     union_type: InternPool.LoadedUnionType,
 ) SemaError!void {
-    const zcu = sema.pt.zcu;
+    const pt = sema.pt;
+    const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
 @@ -35616,18 +35604,18 @@ pub fn resolveUnionAlignment(
     // might require explicit alignment.
     if (union_type.assumePointerAlignedIfFieldTypesWip(ip, ptr_align)) return;
-    try sema.resolveTypeFieldsUnion(ty, union_type);
+    try sema.resolveUnionFieldTypes(ty, union_type);
     var max_align: Alignment = .@"1";
     for (0..union_type.field_types.len) |field_index| {
         const field_ty = Type.fromInterned(union_type.field_types.get(ip)[field_index]);
-        if (!(try sema.typeHasRuntimeBits(field_ty))) continue;
+        if (!(try field_ty.hasRuntimeBitsSema(pt))) continue;
         const explicit_align = union_type.fieldAlign(ip, field_index);
         const field_align = if (explicit_align != .none)
             explicit_align
         else
-            try sema.typeAbiAlignment(field_ty);
+            try field_ty.abiAlignmentSema(sema.pt);
         max_align = max_align.max(field_align);
     }
 @@ -35635,12 +35623,12 @@ pub fn resolveUnionAlignment(
     union_type.setAlignment(ip, max_align);
 }
-/// This logic must be kept in sync with `Module.getUnionLayout`.
+/// This logic must be kept in sync with `Zcu.getUnionLayout`.
 pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
     const pt = sema.pt;
     const ip = &pt.zcu.intern_pool;
-    try sema.resolveTypeFieldsUnion(ty, ip.loadUnionType(ty.ip_index));
+    try sema.resolveUnionFieldTypes(ty, ip.loadUnionType(ty.ip_index));
     // Load again, since the tag type might have changed due to resolution.
     const union_type = ip.loadUnionType(ty.ip_index);
 @@ -35670,9 +35658,9 @@ pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
     for (0..union_type.field_types.len) |field_index| {
         const field_ty = Type.fromInterned(union_type.field_types.get(ip)[field_index]);
-        if (try sema.typeRequiresComptime(field_ty) or field_ty.zigTypeTag(pt.zcu) == .NoReturn) continue; // TODO: should this affect alignment?
+        if (try field_ty.comptimeOnlySema(pt) or field_ty.zigTypeTag(pt.zcu) == .NoReturn) continue; // TODO: should this affect alignment?
-        max_size = @max(max_size, sema.typeAbiSize(field_ty) catch |err| switch (err) {
+        max_size = @max(max_size, field_ty.abiSizeSema(pt) catch |err| switch (err) {
             error.AnalysisFail => {
                 const msg = sema.err orelse return err;
                 try sema.addFieldErrNote(ty, field_index, msg, "while checking this field", .{});
 @@ -35685,17 +35673,17 @@ pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
         const field_align = if (explicit_align != .none)
             explicit_align
         else
-            try sema.typeAbiAlignment(field_ty);
+            try field_ty.abiAlignmentSema(pt);
         max_align = max_align.max(field_align);
     }
     const has_runtime_tag = union_type.flagsUnordered(ip).runtime_tag.hasTag() and
-        try sema.typeHasRuntimeBits(Type.fromInterned(union_type.enum_tag_ty));
+        try Type.fromInterned(union_type.enum_tag_ty).hasRuntimeBitsSema(pt);
     const size, const alignment, const padding = if (has_runtime_tag) layout: {
         const enum_tag_type = Type.fromInterned(union_type.enum_tag_ty);
-        const tag_align = try sema.typeAbiAlignment(enum_tag_type);
+        const tag_align = try enum_tag_type.abiAlignmentSema(pt);
-        const tag_size = try sema.typeAbiSize(enum_tag_type);
+        const tag_size = try enum_tag_type.abiSizeSema(pt);
         // Put the tag before or after the payload depending on which one's
         // alignment is greater.
 @@ -35727,7 +35715,7 @@ pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
     union_type.setHaveLayout(ip, @intCast(size), padding, alignment);
-    if (union_type.flagsUnordered(ip).assumed_runtime_bits and !(try sema.typeHasRuntimeBits(ty))) {
+    if (union_type.flagsUnordered(ip).assumed_runtime_bits and !(try ty.hasRuntimeBitsSema(pt))) {
         const msg = try sema.errMsg(
             ty.srcLoc(pt.zcu),
             "union layout depends on it having runtime bits",
 @@ -35746,6 +35734,7 @@ pub fn resolveUnionLayout(sema: *Sema, ty: Type) SemaError!void {
         );
         return sema.failWithOwnedErrorMsg(null, msg);
     }
+    _ = try ty.comptimeOnlySema(pt);
 }
 /// Returns `error.AnalysisFail` if any of the types (recursively) failed to
 @@ -35754,9 +35743,9 @@ pub fn resolveStructFully(sema: *Sema, ty: Type) SemaError!void {
     try sema.resolveStructLayout(ty);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const struct_type = mod.typeToStruct(ty).?;
+    const struct_type = zcu.typeToStruct(ty).?;
     assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
 @@ -35777,9 +35766,9 @@ pub fn resolveUnionFully(sema: *Sema, ty: Type) SemaError!void {
     try sema.resolveUnionLayout(ty);
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const union_obj = mod.typeToUnion(ty).?;
+    const union_obj = zcu.typeToUnion(ty).?;
     assert(sema.owner.unwrap().cau == union_obj.cau);
 @@ -35804,10 +35793,10 @@ pub fn resolveUnionFully(sema: *Sema, ty: Type) SemaError!void {
     }
     // And let's not forget comptime-only status.
-    _ = try sema.typeRequiresComptime(ty);
+    _ = try ty.comptimeOnlySema(pt);
 }
-pub fn resolveTypeFieldsStruct(
+pub fn resolveStructFieldTypes(
     sema: *Sema,
     ty: InternPool.Index,
     struct_type: InternPool.LoadedStructType,
 @@ -35830,7 +35819,7 @@ pub fn resolveTypeFieldsStruct(
     }
     defer struct_type.clearFieldTypesWip(ip);
-    semaStructFields(pt, sema.arena, struct_type) catch |err| switch (err) {
+    sema.structFields(struct_type) catch |err| switch (err) {
         error.AnalysisFail, error.OutOfMemory => |e| return e,
         error.ComptimeBreak, error.ComptimeReturn, error.GenericPoison => unreachable,
     };
 @@ -35859,14 +35848,14 @@ pub fn resolveStructFieldInits(sema: *Sema, ty: Type) SemaError!void {
     }
     defer struct_type.clearInitsWip(ip);
-    semaStructFieldInits(pt, sema.arena, struct_type) catch |err| switch (err) {
+    sema.structFieldInits(struct_type) catch |err| switch (err) {
         error.AnalysisFail, error.OutOfMemory => |e| return e,
         error.ComptimeBreak, error.ComptimeReturn, error.GenericPoison => unreachable,
     };
     struct_type.setHaveFieldInits(ip);
 }
-pub fn resolveTypeFieldsUnion(sema: *Sema, ty: Type, union_type: InternPool.LoadedUnionType) SemaError!void {
+pub fn resolveUnionFieldTypes(sema: *Sema, ty: Type, union_type: InternPool.LoadedUnionType) SemaError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 @@ -35893,7 +35882,7 @@ pub fn resolveTypeFieldsUnion(sema: *Sema, ty: Type, union_type: InternPool.Load
     union_type.setStatus(ip, .field_types_wip);
     errdefer union_type.setStatus(ip, .none);
-    semaUnionFields(pt, sema.arena, ty.toIntern(), union_type) catch |err| switch (err) {
+    sema.unionFields(ty.toIntern(), union_type) catch |err| switch (err) {
         error.AnalysisFail, error.OutOfMemory => |e| return e,
         error.ComptimeBreak, error.ComptimeReturn, error.GenericPoison => unreachable,
     };
 @@ -35950,7 +35939,7 @@ fn resolveInferredErrorSet(
         try pt.ensureFuncBodyAnalyzed(func_index);
     }
-    // This will now have been resolved by the logic at the end of `Module.analyzeFnBody`
+    // This will now have been resolved by the logic at the end of `Zcu.analyzeFnBody`
     // which calls `resolveInferredErrorSetPtr`.
     const final_resolved_ty = func.resolvedErrorSetUnordered(ip);
     assert(final_resolved_ty != .none);
 @@ -35997,9 +35986,9 @@ fn resolveAdHocInferredErrorSet(
     value: InternPool.Index,
 ) CompileError!InternPool.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const new_ty = try resolveAdHocInferredErrorSetTy(sema, block, src, ip.typeOf(value));
     if (new_ty == .none) return value;
     return ip.getCoerced(gpa, pt.tid, value, new_ty);
 @@ -36013,8 +36002,8 @@ fn resolveAdHocInferredErrorSetTy(
 ) CompileError!InternPool.Index {
     const ies = sema.fn_ret_ty_ies orelse return .none;
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const error_union_info = switch (ip.indexToKey(ty)) {
         .error_union_type => |x| x,
         else => return .none,
 @@ -36037,8 +36026,8 @@ fn resolveInferredErrorSetTy(
     ty: InternPool.Index,
 ) CompileError!InternPool.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     if (ty == .anyerror_type) return ty;
     switch (ip.indexToKey(ty)) {
         .error_set_type => return ty,
 @@ -36096,11 +36085,11 @@ fn structZirInfo(zir: Zir, zir_index: Zir.Inst.Index) struct {
     return .{ fields_len, small, extra_index };
 }
-fn semaStructFields(
+fn structFields(
-    pt: Zcu.PerThread,
+    sema: *Sema,
-    arena: Allocator,
     struct_type: InternPool.LoadedStructType,
 ) CompileError!void {
+    const pt = sema.pt;
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
 @@ -36113,7 +36102,7 @@ fn semaStructFields(
     if (fields_len == 0) switch (struct_type.layout) {
         .@"packed" => {
-            try semaBackingIntType(pt, struct_type);
+            try sema.backingIntType(struct_type);
             return;
         },
         .auto, .@"extern" => {
 @@ -36122,26 +36111,9 @@ fn semaStructFields(
         },
     };
-    var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = arena,
-        .code = zir,
-        .owner = AnalUnit.wrap(.{ .cau = cau_index }),
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
     var block_scope: Block = .{
         .parent = null,
-        .sema = &sema,
+        .sema = sema,
         .namespace = namespace_index,
         .instructions = .{},
         .inlining = null,
 @@ -36315,14 +36287,13 @@ fn semaStructFields(
     try sema.flushExports();
 }
-// This logic must be kept in sync with `semaStructFields`
+// This logic must be kept in sync with `structFields`
-fn semaStructFieldInits(
+fn structFieldInits(
-    pt: Zcu.PerThread,
+    sema: *Sema,
-    arena: Allocator,
     struct_type: InternPool.LoadedStructType,
 ) CompileError!void {
+    const pt = sema.pt;
     const zcu = pt.zcu;
-    const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
     assert(!struct_type.haveFieldInits(ip));
 @@ -36333,26 +36304,9 @@ fn semaStructFieldInits(
     const zir_index = struct_type.zir_index.unwrap().?.resolve(ip) orelse return error.AnalysisFail;
     const fields_len, const small, var extra_index = structZirInfo(zir, zir_index);
-    var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = arena,
-        .code = zir,
-        .owner = AnalUnit.wrap(.{ .cau = cau_index }),
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
     var block_scope: Block = .{
         .parent = null,
-        .sema = &sema,
+        .sema = sema,
         .namespace = namespace_index,
         .instructions = .{},
         .inlining = null,
 @@ -36455,14 +36409,18 @@ fn semaStructFieldInits(
     try sema.flushExports();
 }
-fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Index, union_type: InternPool.LoadedUnionType) CompileError!void {
+fn unionFields(
+    sema: *Sema,
+    union_ty: InternPool.Index,
+    union_type: InternPool.LoadedUnionType,
+) CompileError!void {
     const tracy = trace(@src());
     defer tracy.end();
+    const pt = sema.pt;
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
-    const cau_index = union_type.cau;
     const zir = zcu.namespacePtr(union_type.namespace).fileScope(zcu).zir;
     const zir_index = union_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
     const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
 @@ -36507,26 +36465,9 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
     const body = zir.bodySlice(extra_index, body_len);
     extra_index += body.len;
-    var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
-    defer comptime_err_ret_trace.deinit();
-    var sema: Sema = .{
-        .pt = pt,
-        .gpa = gpa,
-        .arena = arena,
-        .code = zir,
-        .owner = AnalUnit.wrap(.{ .cau = cau_index }),
-        .func_index = .none,
-        .func_is_naked = false,
-        .fn_ret_ty = Type.void,
-        .fn_ret_ty_ies = null,
-        .comptime_err_ret_trace = &comptime_err_ret_trace,
-    };
-    defer sema.deinit();
     var block_scope: Block = .{
         .parent = null,
-        .sema = &sema,
+        .sema = sema,
         .namespace = union_type.namespace,
         .instructions = .{},
         .inlining = null,
 @@ -36669,7 +36610,10 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
         if (enum_field_vals.capacity() > 0) {
             const enum_tag_val = if (tag_ref != .none) blk: {
-                const val = try sema.semaUnionFieldVal(&block_scope, value_src, int_tag_ty, tag_ref);
+                const coerced = try sema.coerce(&block_scope, int_tag_ty, tag_ref, value_src);
+                const val = try sema.resolveConstDefinedValue(&block_scope, value_src, coerced, .{
+                    .needed_comptime_reason = "enum tag value must be comptime-known",
+                });
                 last_tag_val = val;
                 break :blk val;
 @@ -36689,7 +36633,11 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
                     .offset = .{ .container_field_value = @intCast(gop.index) },
                 };
                 const msg = msg: {
-                    const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValueSema(pt, &sema)});
+                    const msg = try sema.errMsg(
+                        value_src,
+                        "enum tag value {} already taken",
+                        .{enum_tag_val.fmtValueSema(pt, sema)},
+                    );
                     errdefer msg.destroy(gpa);
                     try sema.errNote(other_value_src, msg, "other occurrence here", .{});
                     break :msg msg;
 @@ -36829,13 +36777,6 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
     try sema.flushExports();
 }
-fn semaUnionFieldVal(sema: *Sema, block: *Block, src: LazySrcLoc, int_tag_ty: Type, tag_ref: Air.Inst.Ref) CompileError!Value {
-    const coerced = try sema.coerce(block, int_tag_ty, tag_ref, src);
-    return sema.resolveConstDefinedValue(block, src, coerced, .{
-        .needed_comptime_reason = "enum tag value must be comptime-known",
-    });
-}
 fn generateUnionTagTypeNumbered(
     sema: *Sema,
     block: *Block,
 @@ -36845,9 +36786,9 @@ fn generateUnionTagTypeNumbered(
     union_name: InternPool.NullTerminatedString,
 ) !InternPool.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const name = try ip.getOrPutStringFmt(
         gpa,
 @@ -36881,8 +36822,8 @@ fn generateUnionTagTypeSimple(
     union_name: InternPool.NullTerminatedString,
 ) !InternPool.Index {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const gpa = sema.gpa;
     const name = try ip.getOrPutStringFmt(
 @@ -37192,7 +37133,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
                             return null;
                         },
                         .auto, .explicit => {
-                            if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(pt)) return null;
+                            if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(zcu)) return null;
                             return Value.fromInterned(switch (enum_type.names.len) {
                                 0 => try pt.intern(.{ .empty_enum_value = ty.toIntern() }),
 @@ -37279,7 +37220,7 @@ fn analyzeComptimeAlloc(
     alignment: Alignment,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // Needed to make an anon decl with type `var_type` (the `finish()` call below).
     _ = try sema.typeHasOnePossibleValue(var_type);
 @@ -37288,7 +37229,7 @@ fn analyzeComptimeAlloc(
         .child = var_type.toIntern(),
         .flags = .{
             .alignment = alignment,
-            .address_space = target_util.defaultAddressSpace(mod.getTarget(), .global_constant),
+            .address_space = target_util.defaultAddressSpace(zcu.getTarget(), .global_constant),
         },
     });
 @@ -37338,13 +37279,13 @@ pub fn analyzeAsAddressSpace(
     ctx: AddressSpaceContext,
 ) !std.builtin.AddressSpace {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const addrspace_ty = try pt.getBuiltinType("AddressSpace");
     const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
     const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{
         .needed_comptime_reason = "address space must be comptime-known",
     });
-    const address_space = mod.toEnum(std.builtin.AddressSpace, addrspace_val);
+    const address_space = zcu.toEnum(std.builtin.AddressSpace, addrspace_val);
     const target = pt.zcu.getTarget();
     const arch = target.cpu.arch;
 @@ -37446,13 +37387,13 @@ fn usizeCast(sema: *Sema, block: *Block, src: LazySrcLoc, int: u64) CompileError
 /// This logic must be kept in sync with `Type.isPtrLikeOptional`.
 fn typePtrOrOptionalPtrTy(sema: *Sema, ty: Type) !?Type {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return switch (mod.intern_pool.indexToKey(ty.toIntern())) {
+    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
         .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
             .One, .Many, .C => ty,
             .Slice => null,
         },
-        .opt_type => |opt_child| switch (mod.intern_pool.indexToKey(opt_child)) {
+        .opt_type => |opt_child| switch (zcu.intern_pool.indexToKey(opt_child)) {
             .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
                 .Slice, .C => null,
                 .Many, .One => {
 @@ -37473,33 +37414,6 @@ fn typePtrOrOptionalPtrTy(sema: *Sema, ty: Type) !?Type {
     };
 }
-/// `generic_poison` will return false.
-/// May return false negatives when structs and unions are having their field types resolved.
-pub fn typeRequiresComptime(sema: *Sema, ty: Type) SemaError!bool {
-    return ty.comptimeOnlyAdvanced(sema.pt, .sema);
-}
-pub fn typeHasRuntimeBits(sema: *Sema, ty: Type) SemaError!bool {
-    return ty.hasRuntimeBitsAdvanced(sema.pt, false, .sema) catch |err| switch (err) {
-        error.NeedLazy => unreachable,
-        else => |e| return e,
-    };
-}
-pub fn typeAbiSize(sema: *Sema, ty: Type) SemaError!u64 {
-    const pt = sema.pt;
-    try ty.resolveLayout(pt);
-    return ty.abiSize(pt);
-}
-pub fn typeAbiAlignment(sema: *Sema, ty: Type) SemaError!Alignment {
-    return (try ty.abiAlignmentAdvanced(sema.pt, .sema)).scalar;
-}
-pub fn fnHasRuntimeBits(sema: *Sema, ty: Type) CompileError!bool {
-    return ty.fnHasRuntimeBitsAdvanced(sema.pt, .sema);
-}
 fn unionFieldIndex(
     sema: *Sema,
     block: *Block,
 @@ -37508,10 +37422,10 @@ fn unionFieldIndex(
     field_src: LazySrcLoc,
 ) !u32 {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     try union_ty.resolveFields(pt);
-    const union_obj = mod.typeToUnion(union_ty).?;
+    const union_obj = zcu.typeToUnion(union_ty).?;
     const field_index = union_obj.loadTagType(ip).nameIndex(ip, field_name) orelse
         return sema.failWithBadUnionFieldAccess(block, union_ty, union_obj, field_src, field_name);
     return @intCast(field_index);
 @@ -37525,13 +37439,13 @@ fn structFieldIndex(
     field_src: LazySrcLoc,
 ) !u32 {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     try struct_ty.resolveFields(pt);
-    if (struct_ty.isAnonStruct(mod)) {
+    if (struct_ty.isAnonStruct(zcu)) {
         return sema.anonStructFieldIndex(block, struct_ty, field_name, field_src);
     } else {
-        const struct_type = mod.typeToStruct(struct_ty).?;
+        const struct_type = zcu.typeToStruct(struct_ty).?;
         return struct_type.nameIndex(ip, field_name) orelse
             return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_src, field_name);
     }
 @@ -37545,8 +37459,8 @@ fn anonStructFieldIndex(
     field_src: LazySrcLoc,
 ) !u32 {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     switch (ip.indexToKey(struct_ty.toIntern())) {
         .anon_struct_type => |anon_struct_type| for (anon_struct_type.names.get(ip), 0..) |name, i| {
             if (name == field_name) return @intCast(i);
 @@ -37583,10 +37497,10 @@ fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize)
 fn intAddInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize) !Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(mod));
+        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
 @@ -37611,15 +37525,15 @@ fn intAddScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) !Value {
     const pt = sema.pt;
     if (scalar_ty.toIntern() != .comptime_int_type) {
         const res = try sema.intAddWithOverflowScalar(lhs, rhs, scalar_ty);
-        if (res.overflow_bit.compareAllWithZero(.neq, pt)) return error.Overflow;
+        if (res.overflow_bit.compareAllWithZero(.neq, pt.zcu)) return error.Overflow;
         return res.wrapped_result;
     }
     // TODO is this a performance issue? maybe we should try the operation without
     // resorting to BigInt first.
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, pt, .sema);
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, pt, .sema);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
 @@ -37637,10 +37551,10 @@ fn numberAddWrapScalar(
     ty: Type,
 ) !Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (lhs.isUndef(mod) or rhs.isUndef(mod)) return pt.undefValue(ty);
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return pt.undefValue(ty);
-    if (ty.zigTypeTag(mod) == .ComptimeInt) {
+    if (ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.intAdd(lhs, rhs, ty, undefined);
     }
 @@ -37701,17 +37615,18 @@ fn intSubInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *usi
 fn intSubScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) !Value {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     if (scalar_ty.toIntern() != .comptime_int_type) {
         const res = try sema.intSubWithOverflowScalar(lhs, rhs, scalar_ty);
-        if (res.overflow_bit.compareAllWithZero(.neq, pt)) return error.Overflow;
+        if (res.overflow_bit.compareAllWithZero(.neq, zcu)) return error.Overflow;
         return res.wrapped_result;
     }
     // TODO is this a performance issue? maybe we should try the operation without
     // resorting to BigInt first.
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, pt, .sema);
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, pt, .sema);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
 @@ -37729,10 +37644,10 @@ fn numberSubWrapScalar(
     ty: Type,
 ) !Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (lhs.isUndef(mod) or rhs.isUndef(mod)) return pt.undefValue(ty);
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return pt.undefValue(ty);
-    if (ty.zigTypeTag(mod) == .ComptimeInt) {
+    if (ty.zigTypeTag(zcu) == .ComptimeInt) {
         return sema.intSub(lhs, rhs, ty, undefined);
     }
 @@ -37751,12 +37666,12 @@ fn intSubWithOverflow(
     ty: Type,
 ) !Value.OverflowArithmeticResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
-        const vec_len = ty.vectorLen(mod);
+        const vec_len = ty.vectorLen(zcu);
         const overflowed_data = try sema.arena.alloc(InternPool.Index, vec_len);
         const result_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
 @@ -37785,10 +37700,10 @@ fn intSubWithOverflowScalar(
     ty: Type,
 ) !Value.OverflowArithmeticResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const info = ty.intInfo(mod);
+    const info = ty.intInfo(zcu);
-    if (lhs.isUndef(mod) or rhs.isUndef(mod)) {
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
         return .{
             .overflow_bit = try pt.undefValue(Type.u1),
             .wrapped_result = try pt.undefValue(ty),
 @@ -37797,8 +37712,8 @@ fn intSubWithOverflowScalar(
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, pt, .sema);
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, pt, .sema);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         std.math.big.int.calcTwosCompLimbCount(info.bits),
 @@ -37824,12 +37739,12 @@ fn intFromFloat(
     mode: IntFromFloatMode,
 ) CompileError!Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (float_ty.zigTypeTag(mod) == .Vector) {
+    if (float_ty.zigTypeTag(zcu) == .Vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, float_ty.vectorLen(mod));
+        const result_data = try sema.arena.alloc(InternPool.Index, float_ty.vectorLen(zcu));
         for (result_data, 0..) |*scalar, i| {
             const elem_val = try val.elemValue(pt, i);
-            scalar.* = (try sema.intFromFloatScalar(block, src, elem_val, int_ty.scalarType(mod), mode)).toIntern();
+            scalar.* = (try sema.intFromFloatScalar(block, src, elem_val, int_ty.scalarType(zcu), mode)).toIntern();
         }
         return Value.fromInterned(try pt.intern(.{ .aggregate = .{
             .ty = int_ty.toIntern(),
 @@ -37873,18 +37788,18 @@ fn intFromFloatScalar(
     mode: IntFromFloatMode,
 ) CompileError!Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (val.isUndef(mod)) return sema.failWithUseOfUndef(block, src);
+    if (val.isUndef(zcu)) return sema.failWithUseOfUndef(block, src);
-    if (mode == .exact and val.floatHasFraction(mod)) return sema.fail(
+    if (mode == .exact and val.floatHasFraction(zcu)) return sema.fail(
         block,
         src,
         "fractional component prevents float value '{}' from coercion to type '{}'",
         .{ val.fmtValueSema(pt, sema), int_ty.fmt(pt) },
     );
-    const float = val.toFloat(f128, pt);
+    const float = val.toFloat(f128, zcu);
     if (std.math.isNan(float)) {
         return sema.fail(block, src, "float value NaN cannot be stored in integer type '{}'", .{
             int_ty.fmt(pt),
 @@ -37920,15 +37835,15 @@ fn intFitsInType(
     vector_index: ?*usize,
 ) CompileError!bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (ty.toIntern() == .comptime_int_type) return true;
-    const info = ty.intInfo(mod);
+    const info = ty.intInfo(zcu);
     switch (val.toIntern()) {
         .zero_usize, .zero_u8 => return true,
-        else => switch (mod.intern_pool.indexToKey(val.toIntern())) {
+        else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
             .undef => return true,
             .variable, .@"extern", .func, .ptr => {
-                const target = mod.getTarget();
+                const target = zcu.getTarget();
                 const ptr_bits = target.ptrBitWidth();
                 return switch (info.signedness) {
                     .signed => info.bits > ptr_bits,
 @@ -37945,7 +37860,7 @@ fn intFitsInType(
                     const max_needed_bits = @as(u16, 16) + @intFromBool(info.signedness == .signed);
                     // If it is u16 or bigger we know the alignment fits without resolving it.
                     if (info.bits >= max_needed_bits) return true;
-                    const x = try sema.typeAbiAlignment(Type.fromInterned(lazy_ty));
+                    const x = try Type.fromInterned(lazy_ty).abiAlignmentSema(pt);
                     if (x == .none) return true;
                     const actual_needed_bits = @as(usize, x.toLog2Units()) + 1 + @intFromBool(info.signedness == .signed);
                     return info.bits >= actual_needed_bits;
 @@ -37954,16 +37869,16 @@ fn intFitsInType(
                     const max_needed_bits = @as(u16, 64) + @intFromBool(info.signedness == .signed);
                     // If it is u64 or bigger we know the size fits without resolving it.
                     if (info.bits >= max_needed_bits) return true;
-                    const x = try sema.typeAbiSize(Type.fromInterned(lazy_ty));
+                    const x = try Type.fromInterned(lazy_ty).abiSizeSema(pt);
                     if (x == 0) return true;
                     const actual_needed_bits = std.math.log2(x) + 1 + @intFromBool(info.signedness == .signed);
                     return info.bits >= actual_needed_bits;
                 },
             },
             .aggregate => |aggregate| {
-                assert(ty.zigTypeTag(mod) == .Vector);
+                assert(ty.zigTypeTag(zcu) == .Vector);
                 return switch (aggregate.storage) {
-                    .bytes => |bytes| for (bytes.toSlice(ty.vectorLen(mod), &mod.intern_pool), 0..) |byte, i| {
+                    .bytes => |bytes| for (bytes.toSlice(ty.vectorLen(zcu), &zcu.intern_pool), 0..) |byte, i| {
                         if (byte == 0) continue;
                         const actual_needed_bits = std.math.log2(byte) + 1 + @intFromBool(info.signedness == .signed);
                         if (info.bits >= actual_needed_bits) continue;
 @@ -37975,7 +37890,7 @@ fn intFitsInType(
                         .elems => |elems| elems,
                         .repeated_elem => |elem| @as(*const [1]InternPool.Index, &elem),
                     }, 0..) |elem, i| {
-                        if (try sema.intFitsInType(Value.fromInterned(elem), ty.scalarType(mod), null)) continue;
+                        if (try sema.intFitsInType(Value.fromInterned(elem), ty.scalarType(zcu), null)) continue;
                         if (vector_index) |vi| vi.* = i;
                         break false;
                     } else true,
 @@ -37997,15 +37912,15 @@ fn intInRange(sema: *Sema, tag_ty: Type, int_val: Value, end: usize) !bool {
 /// Asserts the type is an enum.
 fn enumHasInt(sema: *Sema, ty: Type, int: Value) CompileError!bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const enum_type = mod.intern_pool.loadEnumType(ty.toIntern());
+    const enum_type = zcu.intern_pool.loadEnumType(ty.toIntern());
     assert(enum_type.tag_mode != .nonexhaustive);
     // The `tagValueIndex` function call below relies on the type being the integer tag type.
     // `getCoerced` assumes the value will fit the new type.
     if (!(try sema.intFitsInType(int, Type.fromInterned(enum_type.tag_ty), null))) return false;
     const int_coerced = try pt.getCoerced(int, Type.fromInterned(enum_type.tag_ty));
-    return enum_type.tagValueIndex(&mod.intern_pool, int_coerced.toIntern()) != null;
+    return enum_type.tagValueIndex(&zcu.intern_pool, int_coerced.toIntern()) != null;
 }
 fn intAddWithOverflow(
 @@ -38015,12 +37930,12 @@ fn intAddWithOverflow(
     ty: Type,
 ) !Value.OverflowArithmeticResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
-        const vec_len = ty.vectorLen(mod);
+        const vec_len = ty.vectorLen(zcu);
         const overflowed_data = try sema.arena.alloc(InternPool.Index, vec_len);
         const result_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
 @@ -38049,10 +37964,10 @@ fn intAddWithOverflowScalar(
     ty: Type,
 ) !Value.OverflowArithmeticResult {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const info = ty.intInfo(mod);
+    const info = ty.intInfo(zcu);
-    if (lhs.isUndef(mod) or rhs.isUndef(mod)) {
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
         return .{
             .overflow_bit = try pt.undefValue(Type.u1),
             .wrapped_result = try pt.undefValue(ty),
 @@ -38061,8 +37976,8 @@ fn intAddWithOverflowScalar(
     var lhs_space: Value.BigIntSpace = undefined;
     var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, pt, .sema);
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, pt, .sema);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
     const limbs = try sema.arena.alloc(
         std.math.big.Limb,
         std.math.big.int.calcTwosCompLimbCount(info.bits),
 @@ -38088,13 +38003,13 @@ fn compareAll(
     ty: Type,
 ) CompileError!bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         var i: usize = 0;
-        while (i < ty.vectorLen(mod)) : (i += 1) {
+        while (i < ty.vectorLen(zcu)) : (i += 1) {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            if (!(try sema.compareScalar(lhs_elem, op, rhs_elem, ty.scalarType(mod)))) {
+            if (!(try sema.compareScalar(lhs_elem, op, rhs_elem, ty.scalarType(zcu)))) {
                 return false;
             }
         }
 @@ -38117,7 +38032,7 @@ fn compareScalar(
     switch (op) {
         .eq => return sema.valuesEqual(coerced_lhs, coerced_rhs, ty),
         .neq => return !(try sema.valuesEqual(coerced_lhs, coerced_rhs, ty)),
-        else => return Value.compareHeteroAdvanced(coerced_lhs, op, coerced_rhs, pt, .sema),
+        else => return Value.compareHeteroSema(coerced_lhs, op, coerced_rhs, pt),
     }
 }
 @@ -38139,17 +38054,17 @@ fn compareVector(
     ty: Type,
 ) !Value {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    assert(ty.zigTypeTag(mod) == .Vector);
+    assert(ty.zigTypeTag(zcu) == .Vector);
-    const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(mod));
+    const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(zcu));
     for (result_data, 0..) |*scalar, i| {
         const lhs_elem = try lhs.elemValue(pt, i);
         const rhs_elem = try rhs.elemValue(pt, i);
-        const res_bool = try sema.compareScalar(lhs_elem, op, rhs_elem, ty.scalarType(mod));
+        const res_bool = try sema.compareScalar(lhs_elem, op, rhs_elem, ty.scalarType(zcu));
         scalar.* = Value.makeBool(res_bool).toIntern();
     }
     return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-        .ty = (try pt.vectorType(.{ .len = ty.vectorLen(mod), .child = .bool_type })).toIntern(),
+        .ty = (try pt.vectorType(.{ .len = ty.vectorLen(zcu), .child = .bool_type })).toIntern(),
         .storage = .{ .elems = result_data },
     } }));
 }
 @@ -38250,8 +38165,8 @@ fn validateRuntimeValue(sema: *Sema, block: *Block, val_src: LazySrcLoc, val: Ai
 /// Returns true if any value contained in `val` is undefined.
 fn anyUndef(sema: *Sema, block: *Block, src: LazySrcLoc, val: Value) !bool {
     const pt = sema.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return switch (mod.intern_pool.indexToKey(val.toIntern())) {
+    return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
         .undef => true,
         .simple_value => |v| v == .undefined,
         .slice => {
 @@ -38261,7 +38176,7 @@ fn anyUndef(sema: *Sema, block: *Block, src: LazySrcLoc, val: Value) !bool {
             return sema.anyUndef(block, src, arr);
         },
         .aggregate => |aggregate| for (0..aggregate.storage.values().len) |i| {
-            const elem = mod.intern_pool.indexToKey(val.toIntern()).aggregate.storage.values()[i];
+            const elem = zcu.intern_pool.indexToKey(val.toIntern()).aggregate.storage.values()[i];
             if (try sema.anyUndef(block, src, Value.fromInterned(elem))) break true;
         } else false,
         else => false,
 @@ -38510,7 +38425,7 @@ pub fn resolveDeclaredEnum(
     wip_ty.setTagTy(ip, int_tag_ty.toIntern());
     if (small.nonexhaustive and int_tag_ty.toIntern() != .comptime_int_type) {
-        if (fields_len > 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(pt)) {
+        if (fields_len > 1 and std.math.log2_int(u64, fields_len) == int_tag_ty.bitSize(zcu)) {
             return sema.fail(&block, src, "non-exhaustive enum specifies every value", .{});
         }
     }

src/Sema/bitcast.zig+51-47

 @@ -85,23 +85,23 @@ fn bitCastInner(
     assert(val_ty.hasWellDefinedLayout(zcu));
     const abi_pad_bits, const host_pad_bits = if (host_bits > 0)
-        .{ val_ty.abiSize(pt) * 8 - host_bits, host_bits - val_ty.bitSize(pt) }
+        .{ val_ty.abiSize(zcu) * 8 - host_bits, host_bits - val_ty.bitSize(zcu) }
     else
-        .{ val_ty.abiSize(pt) * 8 - val_ty.bitSize(pt), 0 };
+        .{ val_ty.abiSize(zcu) * 8 - val_ty.bitSize(zcu), 0 };
     const skip_bits = switch (endian) {
         .little => bit_offset + byte_offset * 8,
         .big => if (host_bits > 0)
-            val_ty.abiSize(pt) * 8 - byte_offset * 8 - host_bits + bit_offset
+            val_ty.abiSize(zcu) * 8 - byte_offset * 8 - host_bits + bit_offset
         else
-            val_ty.abiSize(pt) * 8 - byte_offset * 8 - dest_ty.bitSize(pt),
+            val_ty.abiSize(zcu) * 8 - byte_offset * 8 - dest_ty.bitSize(zcu),
     };
     var unpack: UnpackValueBits = .{
         .pt = sema.pt,
         .arena = sema.arena,
         .skip_bits = skip_bits,
-        .remaining_bits = dest_ty.bitSize(pt),
+        .remaining_bits = dest_ty.bitSize(zcu),
         .unpacked = std.ArrayList(InternPool.Index).init(sema.arena),
     };
     switch (endian) {
 @@ -141,22 +141,22 @@ fn bitCastSpliceInner(
     try val_ty.resolveLayout(pt);
     try splice_val_ty.resolveLayout(pt);
-    const splice_bits = splice_val_ty.bitSize(pt);
+    const splice_bits = splice_val_ty.bitSize(zcu);
     const splice_offset = switch (endian) {
         .little => bit_offset + byte_offset * 8,
         .big => if (host_bits > 0)
-            val_ty.abiSize(pt) * 8 - byte_offset * 8 - host_bits + bit_offset
+            val_ty.abiSize(zcu) * 8 - byte_offset * 8 - host_bits + bit_offset
         else
-            val_ty.abiSize(pt) * 8 - byte_offset * 8 - splice_bits,
+            val_ty.abiSize(zcu) * 8 - byte_offset * 8 - splice_bits,
     };
-    assert(splice_offset + splice_bits <= val_ty.abiSize(pt) * 8);
+    assert(splice_offset + splice_bits <= val_ty.abiSize(zcu) * 8);
     const abi_pad_bits, const host_pad_bits = if (host_bits > 0)
-        .{ val_ty.abiSize(pt) * 8 - host_bits, host_bits - val_ty.bitSize(pt) }
+        .{ val_ty.abiSize(zcu) * 8 - host_bits, host_bits - val_ty.bitSize(zcu) }
     else
-        .{ val_ty.abiSize(pt) * 8 - val_ty.bitSize(pt), 0 };
+        .{ val_ty.abiSize(zcu) * 8 - val_ty.bitSize(zcu), 0 };
     var unpack: UnpackValueBits = .{
         .pt = pt,
 @@ -181,7 +181,7 @@ fn bitCastSpliceInner(
     try unpack.add(splice_val);
     unpack.skip_bits = splice_offset + splice_bits;
-    unpack.remaining_bits = val_ty.abiSize(pt) * 8 - splice_offset - splice_bits;
+    unpack.remaining_bits = val_ty.abiSize(zcu) * 8 - splice_offset - splice_bits;
     switch (endian) {
         .little => {
             try unpack.add(val);
 @@ -229,7 +229,7 @@ const UnpackValueBits = struct {
         }
         const ty = val.typeOf(zcu);
-        const bit_size = ty.bitSize(pt);
+        const bit_size = ty.bitSize(zcu);
         if (unpack.skip_bits >= bit_size) {
             unpack.skip_bits -= bit_size;
 @@ -291,7 +291,7 @@ const UnpackValueBits = struct {
                     // The final element does not have trailing padding.
                     // Elements are reversed in packed memory on BE targets.
                     const elem_ty = ty.childType(zcu);
-                    const pad_bits = elem_ty.abiSize(pt) * 8 - elem_ty.bitSize(pt);
+                    const pad_bits = elem_ty.abiSize(zcu) * 8 - elem_ty.bitSize(zcu);
                     const len = ty.arrayLen(zcu);
                     const maybe_sent = ty.sentinel(zcu);
 @@ -323,12 +323,12 @@ const UnpackValueBits = struct {
                             var cur_bit_off: u64 = 0;
                             var it = zcu.typeToStruct(ty).?.iterateRuntimeOrder(ip);
                             while (it.next()) |field_idx| {
-                                const want_bit_off = ty.structFieldOffset(field_idx, pt) * 8;
+                                const want_bit_off = ty.structFieldOffset(field_idx, zcu) * 8;
                                 const pad_bits = want_bit_off - cur_bit_off;
                                 const field_val = try val.fieldValue(pt, field_idx);
                                 try unpack.padding(pad_bits);
                                 try unpack.add(field_val);
-                                cur_bit_off = want_bit_off + field_val.typeOf(zcu).bitSize(pt);
+                                cur_bit_off = want_bit_off + field_val.typeOf(zcu).bitSize(zcu);
                             }
                             // Add trailing padding bits.
                             try unpack.padding(bit_size - cur_bit_off);
 @@ -339,11 +339,11 @@ const UnpackValueBits = struct {
                             while (it.next()) |field_idx| {
                                 const field_val = try val.fieldValue(pt, field_idx);
                                 const field_ty = field_val.typeOf(zcu);
-                                const want_bit_off = ty.structFieldOffset(field_idx, pt) * 8 + field_ty.bitSize(pt);
+                                const want_bit_off = ty.structFieldOffset(field_idx, zcu) * 8 + field_ty.bitSize(zcu);
                                 const pad_bits = cur_bit_off - want_bit_off;
                                 try unpack.padding(pad_bits);
                                 try unpack.add(field_val);
-                                cur_bit_off = want_bit_off - field_ty.bitSize(pt);
+                                cur_bit_off = want_bit_off - field_ty.bitSize(zcu);
                             }
                             assert(cur_bit_off == 0);
                         },
 @@ -366,7 +366,7 @@ const UnpackValueBits = struct {
                 // This correctly handles the case where `tag == .none`, since the payload is then
                 // either an integer or a byte array, both of which we can unpack.
                 const payload_val = Value.fromInterned(un.val);
-                const pad_bits = bit_size - payload_val.typeOf(zcu).bitSize(pt);
+                const pad_bits = bit_size - payload_val.typeOf(zcu).bitSize(zcu);
                 if (endian == .little or ty.containerLayout(zcu) == .@"packed") {
                     try unpack.add(payload_val);
                     try unpack.padding(pad_bits);
 @@ -398,13 +398,14 @@ const UnpackValueBits = struct {
     fn primitive(unpack: *UnpackValueBits, val: Value) BitCastError!void {
         const pt = unpack.pt;
+        const zcu = pt.zcu;
         if (unpack.remaining_bits == 0) {
             return;
         }
         const ty = val.typeOf(pt.zcu);
-        const bit_size = ty.bitSize(pt);
+        const bit_size = ty.bitSize(zcu);
         // Note that this skips all zero-bit types.
         if (unpack.skip_bits >= bit_size) {
 @@ -429,9 +430,10 @@ const UnpackValueBits = struct {
     fn splitPrimitive(unpack: *UnpackValueBits, val: Value, bit_offset: u64, bit_count: u64) BitCastError!void {
         const pt = unpack.pt;
+        const zcu = pt.zcu;
         const ty = val.typeOf(pt.zcu);
-        const val_bits = ty.bitSize(pt);
+        const val_bits = ty.bitSize(zcu);
         assert(bit_offset + bit_count <= val_bits);
         switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {
 @@ -499,12 +501,12 @@ const PackValueBits = struct {
                 const len = ty.arrayLen(zcu);
                 const elem_ty = ty.childType(zcu);
                 const maybe_sent = ty.sentinel(zcu);
-                const pad_bits = elem_ty.abiSize(pt) * 8 - elem_ty.bitSize(pt);
+                const pad_bits = elem_ty.abiSize(zcu) * 8 - elem_ty.bitSize(zcu);
                 const elems = try arena.alloc(InternPool.Index, @intCast(len));
                 if (endian == .big and maybe_sent != null) {
                     // TODO: validate sentinel was preserved!
-                    try pack.padding(elem_ty.bitSize(pt));
+                    try pack.padding(elem_ty.bitSize(zcu));
                     if (len != 0) try pack.padding(pad_bits);
                 }
 @@ -520,7 +522,7 @@ const PackValueBits = struct {
                 if (endian == .little and maybe_sent != null) {
                     // TODO: validate sentinel was preserved!
                     if (len != 0) try pack.padding(pad_bits);
-                    try pack.padding(elem_ty.bitSize(pt));
+                    try pack.padding(elem_ty.bitSize(zcu));
                 }
                 return Value.fromInterned(try pt.intern(.{ .aggregate = .{
 @@ -538,23 +540,23 @@ const PackValueBits = struct {
                             var cur_bit_off: u64 = 0;
                             var it = zcu.typeToStruct(ty).?.iterateRuntimeOrder(ip);
                             while (it.next()) |field_idx| {
-                                const want_bit_off = ty.structFieldOffset(field_idx, pt) * 8;
+                                const want_bit_off = ty.structFieldOffset(field_idx, zcu) * 8;
                                 try pack.padding(want_bit_off - cur_bit_off);
-                                const field_ty = ty.structFieldType(field_idx, zcu);
+                                const field_ty = ty.fieldType(field_idx, zcu);
                                 elems[field_idx] = (try pack.get(field_ty)).toIntern();
-                                cur_bit_off = want_bit_off + field_ty.bitSize(pt);
+                                cur_bit_off = want_bit_off + field_ty.bitSize(zcu);
                             }
-                            try pack.padding(ty.bitSize(pt) - cur_bit_off);
+                            try pack.padding(ty.bitSize(zcu) - cur_bit_off);
                         },
                         .big => {
-                            var cur_bit_off: u64 = ty.bitSize(pt);
+                            var cur_bit_off: u64 = ty.bitSize(zcu);
                             var it = zcu.typeToStruct(ty).?.iterateRuntimeOrderReverse(ip);
                             while (it.next()) |field_idx| {
-                                const field_ty = ty.structFieldType(field_idx, zcu);
+                                const field_ty = ty.fieldType(field_idx, zcu);
-                                const want_bit_off = ty.structFieldOffset(field_idx, pt) * 8 + field_ty.bitSize(pt);
+                                const want_bit_off = ty.structFieldOffset(field_idx, zcu) * 8 + field_ty.bitSize(zcu);
                                 try pack.padding(cur_bit_off - want_bit_off);
                                 elems[field_idx] = (try pack.get(field_ty)).toIntern();
-                                cur_bit_off = want_bit_off - field_ty.bitSize(pt);
+                                cur_bit_off = want_bit_off - field_ty.bitSize(zcu);
                             }
                             assert(cur_bit_off == 0);
                         },
 @@ -576,7 +578,7 @@ const PackValueBits = struct {
                     // This is identical between LE and BE targets.
                     const elems = try arena.alloc(InternPool.Index, ty.structFieldCount(zcu));
                     for (elems, 0..) |*elem, i| {
-                        const field_ty = ty.structFieldType(i, zcu);
+                        const field_ty = ty.fieldType(i, zcu);
                         elem.* = (try pack.get(field_ty)).toIntern();
                     }
                     return Value.fromInterned(try pt.intern(.{ .aggregate = .{
 @@ -622,16 +624,16 @@ const PackValueBits = struct {
                 for (field_order, 0..) |*f, i| f.* = @intCast(i);
                 // Sort `field_order` to put the fields with the largest bit sizes first.
                 const SizeSortCtx = struct {
-                    pt: Zcu.PerThread,
+                    zcu: *Zcu,
                     field_types: []const InternPool.Index,
                     fn lessThan(ctx: @This(), a_idx: u32, b_idx: u32) bool {
                         const a_ty = Type.fromInterned(ctx.field_types[a_idx]);
                         const b_ty = Type.fromInterned(ctx.field_types[b_idx]);
-                        return a_ty.bitSize(ctx.pt) > b_ty.bitSize(ctx.pt);
+                        return a_ty.bitSize(ctx.zcu) > b_ty.bitSize(ctx.zcu);
                     }
                 };
                 std.mem.sortUnstable(u32, field_order, SizeSortCtx{
-                    .pt = pt,
+                    .zcu = zcu,
                     .field_types = zcu.typeToUnion(ty).?.field_types.get(ip),
                 }, SizeSortCtx.lessThan);
 @@ -639,7 +641,7 @@ const PackValueBits = struct {
                 for (field_order) |field_idx| {
                     const field_ty = Type.fromInterned(zcu.typeToUnion(ty).?.field_types.get(ip)[field_idx]);
-                    const pad_bits = ty.bitSize(pt) - field_ty.bitSize(pt);
+                    const pad_bits = ty.bitSize(zcu) - field_ty.bitSize(zcu);
                     if (!padding_after) try pack.padding(pad_bits);
                     const field_val = pack.get(field_ty) catch |err| switch (err) {
                         error.ReinterpretDeclRef => {
 @@ -682,10 +684,11 @@ const PackValueBits = struct {
     fn primitive(pack: *PackValueBits, want_ty: Type) BitCastError!Value {
         const pt = pack.pt;
-        const vals, const bit_offset = pack.prepareBits(want_ty.bitSize(pt));
+        const zcu = pt.zcu;
+        const vals, const bit_offset = pack.prepareBits(want_ty.bitSize(zcu));
         for (vals) |val| {
-            if (!Value.fromInterned(val).isUndef(pt.zcu)) break;
+            if (!Value.fromInterned(val).isUndef(zcu)) break;
         } else {
             // All bits of the value are `undefined`.
             return pt.undefValue(want_ty);
 @@ -706,8 +709,8 @@ const PackValueBits = struct {
         ptr_cast: {
             if (vals.len != 1) break :ptr_cast;
             const val = Value.fromInterned(vals[0]);
-            if (!val.typeOf(pt.zcu).isPtrAtRuntime(pt.zcu)) break :ptr_cast;
+            if (!val.typeOf(zcu).isPtrAtRuntime(zcu)) break :ptr_cast;
-            if (!want_ty.isPtrAtRuntime(pt.zcu)) break :ptr_cast;
+            if (!want_ty.isPtrAtRuntime(zcu)) break :ptr_cast;
             return pt.getCoerced(val, want_ty);
         }
 @@ -717,7 +720,7 @@ const PackValueBits = struct {
         for (vals) |ip_val| {
             const val = Value.fromInterned(ip_val);
             const ty = val.typeOf(pt.zcu);
-            buf_bits += ty.bitSize(pt);
+            buf_bits += ty.bitSize(zcu);
         }
         const buf = try pack.arena.alloc(u8, @intCast((buf_bits + 7) / 8));
 @@ -726,11 +729,11 @@ const PackValueBits = struct {
         var cur_bit_off: usize = 0;
         for (vals) |ip_val| {
             const val = Value.fromInterned(ip_val);
-            const ty = val.typeOf(pt.zcu);
+            const ty = val.typeOf(zcu);
-            if (!val.isUndef(pt.zcu)) {
+            if (!val.isUndef(zcu)) {
                 try val.writeToPackedMemory(ty, pt, buf, cur_bit_off);
             }
-            cur_bit_off += @intCast(ty.bitSize(pt));
+            cur_bit_off += @intCast(ty.bitSize(zcu));
         }
         return Value.readFromPackedMemory(want_ty, pt, buf, @intCast(bit_offset), pack.arena);
 @@ -740,11 +743,12 @@ const PackValueBits = struct {
         if (need_bits == 0) return .{ &.{}, 0 };
         const pt = pack.pt;
+        const zcu = pt.zcu;
         var bits: u64 = 0;
         var len: usize = 0;
         while (bits < pack.bit_offset + need_bits) {
-            bits += Value.fromInterned(pack.unpacked[len]).typeOf(pt.zcu).bitSize(pt);
+            bits += Value.fromInterned(pack.unpacked[len]).typeOf(pt.zcu).bitSize(zcu);
             len += 1;
         }
 @@ -757,7 +761,7 @@ const PackValueBits = struct {
             pack.bit_offset = 0;
         } else {
             pack.unpacked = pack.unpacked[len - 1 ..];
-            pack.bit_offset = Value.fromInterned(pack.unpacked[0]).typeOf(pt.zcu).bitSize(pt) - extra_bits;
+            pack.bit_offset = Value.fromInterned(pack.unpacked[0]).typeOf(pt.zcu).bitSize(zcu) - extra_bits;
         }
         return .{ result_vals, result_offset };

src/Sema/comptime_ptr_access.zig+29-28

 @@ -13,14 +13,15 @@ pub const ComptimeLoadResult = union(enum) {
 pub fn loadComptimePtr(sema: *Sema, block: *Block, src: LazySrcLoc, ptr: Value) !ComptimeLoadResult {
     const pt = sema.pt;
+    const zcu = pt.zcu;
     const ptr_info = ptr.typeOf(pt.zcu).ptrInfo(pt.zcu);
     // TODO: host size for vectors is terrible
     const host_bits = switch (ptr_info.flags.vector_index) {
         .none => ptr_info.packed_offset.host_size * 8,
-        else => ptr_info.packed_offset.host_size * Type.fromInterned(ptr_info.child).bitSize(pt),
+        else => ptr_info.packed_offset.host_size * Type.fromInterned(ptr_info.child).bitSize(zcu),
     };
     const bit_offset = if (host_bits != 0) bit_offset: {
-        const child_bits = Type.fromInterned(ptr_info.child).bitSize(pt);
+        const child_bits = Type.fromInterned(ptr_info.child).bitSize(zcu);
         const bit_offset = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) {
             .none => 0,
             .runtime => return .runtime_load,
 @@ -67,18 +68,18 @@ pub fn storeComptimePtr(
     // TODO: host size for vectors is terrible
     const host_bits = switch (ptr_info.flags.vector_index) {
         .none => ptr_info.packed_offset.host_size * 8,
-        else => ptr_info.packed_offset.host_size * Type.fromInterned(ptr_info.child).bitSize(pt),
+        else => ptr_info.packed_offset.host_size * Type.fromInterned(ptr_info.child).bitSize(zcu),
     };
     const bit_offset = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) {
         .none => 0,
         .runtime => return .runtime_store,
         else => |idx| switch (zcu.getTarget().cpu.arch.endian()) {
-            .little => Type.fromInterned(ptr_info.child).bitSize(pt) * @intFromEnum(idx),
+            .little => Type.fromInterned(ptr_info.child).bitSize(zcu) * @intFromEnum(idx),
-            .big => host_bits - Type.fromInterned(ptr_info.child).bitSize(pt) * (@intFromEnum(idx) + 1), // element order reversed on big endian
+            .big => host_bits - Type.fromInterned(ptr_info.child).bitSize(zcu) * (@intFromEnum(idx) + 1), // element order reversed on big endian
         },
     };
     const pseudo_store_ty = if (host_bits > 0) t: {
-        const need_bits = Type.fromInterned(ptr_info.child).bitSize(pt);
+        const need_bits = Type.fromInterned(ptr_info.child).bitSize(zcu);
         if (need_bits + bit_offset > host_bits) {
             return .exceeds_host_size;
         }
 @@ -166,9 +167,9 @@ pub fn storeComptimePtr(
         .direct => |direct| .{ direct.val, 0 },
         .index => |index| .{
             index.val,
-            index.elem_index * index.val.typeOf(zcu).childType(zcu).abiSize(pt),
+            index.elem_index * index.val.typeOf(zcu).childType(zcu).abiSize(zcu),
         },
-        .flat_index => |flat| .{ flat.val, flat.flat_elem_index * flat.val.typeOf(zcu).arrayBase(zcu)[0].abiSize(pt) },
+        .flat_index => |flat| .{ flat.val, flat.flat_elem_index * flat.val.typeOf(zcu).arrayBase(zcu)[0].abiSize(zcu) },
         .reinterpret => |reinterpret| .{ reinterpret.val, reinterpret.byte_offset },
         else => unreachable,
     };
 @@ -347,8 +348,8 @@ fn loadComptimePtrInner(
         const load_one_ty, const load_count = load_ty.arrayBase(zcu);
         const extra_base_index: u64 = if (ptr.byte_offset == 0) 0 else idx: {
-            if (try sema.typeRequiresComptime(load_one_ty)) break :restructure_array;
+            if (try load_one_ty.comptimeOnlySema(pt)) break :restructure_array;
-            const elem_len = try sema.typeAbiSize(load_one_ty);
+            const elem_len = try load_one_ty.abiSizeSema(pt);
             if (ptr.byte_offset % elem_len != 0) break :restructure_array;
             break :idx @divExact(ptr.byte_offset, elem_len);
         };
 @@ -394,12 +395,12 @@ fn loadComptimePtrInner(
     var cur_offset = ptr.byte_offset;
     if (load_ty.zigTypeTag(zcu) == .Array and array_offset > 0) {
-        cur_offset += try sema.typeAbiSize(load_ty.childType(zcu)) * array_offset;
+        cur_offset += try load_ty.childType(zcu).abiSizeSema(pt) * array_offset;
     }
-    const need_bytes = if (host_bits > 0) (host_bits + 7) / 8 else try sema.typeAbiSize(load_ty);
+    const need_bytes = if (host_bits > 0) (host_bits + 7) / 8 else try load_ty.abiSizeSema(pt);
-    if (cur_offset + need_bytes > try sema.typeAbiSize(cur_val.typeOf(zcu))) {
+    if (cur_offset + need_bytes > try cur_val.typeOf(zcu).abiSizeSema(pt)) {
         return .{ .out_of_bounds = cur_val.typeOf(zcu) };
     }
 @@ -434,7 +435,7 @@ fn loadComptimePtrInner(
             .Optional => break, // this can only be a pointer-like optional so is terminal
             .Array => {
                 const elem_ty = cur_ty.childType(zcu);
-                const elem_size = try sema.typeAbiSize(elem_ty);
+                const elem_size = try elem_ty.abiSizeSema(pt);
                 const elem_idx = cur_offset / elem_size;
                 const next_elem_off = elem_size * (elem_idx + 1);
                 if (cur_offset + need_bytes <= next_elem_off) {
 @@ -449,8 +450,8 @@ fn loadComptimePtrInner(
                 .auto => unreachable, // ill-defined layout
                 .@"packed" => break, // let the bitcast logic handle this
                 .@"extern" => for (0..cur_ty.structFieldCount(zcu)) |field_idx| {
-                    const start_off = cur_ty.structFieldOffset(field_idx, pt);
+                    const start_off = cur_ty.structFieldOffset(field_idx, zcu);
-                    const end_off = start_off + try sema.typeAbiSize(cur_ty.structFieldType(field_idx, zcu));
+                    const end_off = start_off + try cur_ty.fieldType(field_idx, zcu).abiSizeSema(pt);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
                         cur_val = try cur_val.getElem(sema.pt, field_idx);
                         cur_offset -= start_off;
 @@ -477,7 +478,7 @@ fn loadComptimePtrInner(
                     };
                     // The payload always has offset 0. If it's big enough
                     // to represent the whole load type, we can use it.
-                    if (try sema.typeAbiSize(payload.typeOf(zcu)) >= need_bytes) {
+                    if (try payload.typeOf(zcu).abiSizeSema(pt) >= need_bytes) {
                         cur_val = payload;
                     } else {
                         break;
 @@ -746,8 +747,8 @@ fn prepareComptimePtrStore(
         const store_one_ty, const store_count = store_ty.arrayBase(zcu);
         const extra_base_index: u64 = if (ptr.byte_offset == 0) 0 else idx: {
-            if (try sema.typeRequiresComptime(store_one_ty)) break :restructure_array;
+            if (try store_one_ty.comptimeOnlySema(pt)) break :restructure_array;
-            const elem_len = try sema.typeAbiSize(store_one_ty);
+            const elem_len = try store_one_ty.abiSizeSema(pt);
             if (ptr.byte_offset % elem_len != 0) break :restructure_array;
             break :idx @divExact(ptr.byte_offset, elem_len);
         };
 @@ -800,11 +801,11 @@ fn prepareComptimePtrStore(
     var cur_val: *MutableValue, var cur_offset: u64 = switch (base_strat) {
         .direct => |direct| .{ direct.val, 0 },
         // It's okay to do `abiSize` - the comptime-only case will be caught below.
-        .index => |index| .{ index.val, index.elem_index * try sema.typeAbiSize(index.val.typeOf(zcu).childType(zcu)) },
+        .index => |index| .{ index.val, index.elem_index * try index.val.typeOf(zcu).childType(zcu).abiSizeSema(pt) },
         .flat_index => |flat_index| .{
             flat_index.val,
             // It's okay to do `abiSize` - the comptime-only case will be caught below.
-            flat_index.flat_elem_index * try sema.typeAbiSize(flat_index.val.typeOf(zcu).arrayBase(zcu)[0]),
+            flat_index.flat_elem_index * try flat_index.val.typeOf(zcu).arrayBase(zcu)[0].abiSizeSema(pt),
         },
         .reinterpret => |r| .{ r.val, r.byte_offset },
         else => unreachable,
 @@ -816,12 +817,12 @@ fn prepareComptimePtrStore(
     }
     if (store_ty.zigTypeTag(zcu) == .Array and array_offset > 0) {
-        cur_offset += try sema.typeAbiSize(store_ty.childType(zcu)) * array_offset;
+        cur_offset += try store_ty.childType(zcu).abiSizeSema(pt) * array_offset;
     }
-    const need_bytes = try sema.typeAbiSize(store_ty);
+    const need_bytes = try store_ty.abiSizeSema(pt);
-    if (cur_offset + need_bytes > try sema.typeAbiSize(cur_val.typeOf(zcu))) {
+    if (cur_offset + need_bytes > try cur_val.typeOf(zcu).abiSizeSema(pt)) {
         return .{ .out_of_bounds = cur_val.typeOf(zcu) };
     }
 @@ -856,7 +857,7 @@ fn prepareComptimePtrStore(
             .Optional => break, // this can only be a pointer-like optional so is terminal
             .Array => {
                 const elem_ty = cur_ty.childType(zcu);
-                const elem_size = try sema.typeAbiSize(elem_ty);
+                const elem_size = try elem_ty.abiSizeSema(pt);
                 const elem_idx = cur_offset / elem_size;
                 const next_elem_off = elem_size * (elem_idx + 1);
                 if (cur_offset + need_bytes <= next_elem_off) {
 @@ -871,8 +872,8 @@ fn prepareComptimePtrStore(
                 .auto => unreachable, // ill-defined layout
                 .@"packed" => break, // let the bitcast logic handle this
                 .@"extern" => for (0..cur_ty.structFieldCount(zcu)) |field_idx| {
-                    const start_off = cur_ty.structFieldOffset(field_idx, pt);
+                    const start_off = cur_ty.structFieldOffset(field_idx, zcu);
-                    const end_off = start_off + try sema.typeAbiSize(cur_ty.structFieldType(field_idx, zcu));
+                    const end_off = start_off + try cur_ty.fieldType(field_idx, zcu).abiSizeSema(pt);
                     if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
                         cur_val = try cur_val.elem(pt, sema.arena, field_idx);
                         cur_offset -= start_off;
 @@ -895,7 +896,7 @@ fn prepareComptimePtrStore(
                     };
                     // The payload always has offset 0. If it's big enough
                     // to represent the whole load type, we can use it.
-                    if (try sema.typeAbiSize(payload.typeOf(zcu)) >= need_bytes) {
+                    if (try payload.typeOf(zcu).abiSizeSema(pt) >= need_bytes) {
                         cur_val = payload;
                     } else {
                         break;

src/Type.zig+836-525

...	@@ -10,8 +10,6 @@ const Value = @import("Value.zig");	...	@@ -10,8 +10,6 @@ const Value = @import("Value.zig");
10	const assert = std.debug.assert;	10	const assert = std.debug.assert;
11	const Target = std.Target;	11	const Target = std.Target;
12	const Zcu = @import("Zcu.zig");	12	const Zcu = @import("Zcu.zig");
13	/// Deprecated.
14	const Module = Zcu;
15	const log = std.log.scoped(.Type);	13	const log = std.log.scoped(.Type);
16	const target_util = @import("target.zig");	14	const target_util = @import("target.zig");
17	const Sema = @import("Sema.zig");	15	const Sema = @import("Sema.zig");
...	@@ -23,15 +21,15 @@ const SemaError = Zcu.SemaError;	...	@@ -23,15 +21,15 @@ const SemaError = Zcu.SemaError;
23		21
24	ip_index: InternPool.Index,	22	ip_index: InternPool.Index,
25		23
26	pub fn zigTypeTag(ty: Type, mod: *const Module) std.builtin.TypeId {	24	pub fn zigTypeTag(ty: Type, zcu: *const Zcu) std.builtin.TypeId {
27	return ty.zigTypeTagOrPoison(mod) catch unreachable;	25	return ty.zigTypeTagOrPoison(zcu) catch unreachable;
28	}	26	}
29		27
30	pub fn zigTypeTagOrPoison(ty: Type, mod: *const Module) error{GenericPoison}!std.builtin.TypeId {	28	pub fn zigTypeTagOrPoison(ty: Type, zcu: *const Zcu) error{GenericPoison}!std.builtin.TypeId {
31	return mod.intern_pool.zigTypeTagOrPoison(ty.toIntern());	29	return zcu.intern_pool.zigTypeTagOrPoison(ty.toIntern());
32	}	30	}
33		31
34	pub fn baseZigTypeTag(self: Type, mod: *Module) std.builtin.TypeId {	32	pub fn baseZigTypeTag(self: Type, mod: *Zcu) std.builtin.TypeId {
35	return switch (self.zigTypeTag(mod)) {	33	return switch (self.zigTypeTag(mod)) {
36	.ErrorUnion => self.errorUnionPayload(mod).baseZigTypeTag(mod),	34	.ErrorUnion => self.errorUnionPayload(mod).baseZigTypeTag(mod),
37	.Optional => {	35	.Optional => {
...	@@ -41,15 +39,15 @@ pub fn baseZigTypeTag(self: Type, mod: *Module) std.builtin.TypeId {	...	@@ -41,15 +39,15 @@ pub fn baseZigTypeTag(self: Type, mod: *Module) std.builtin.TypeId {
41	};	39	};
42	}	40	}
43		41
44	pub fn isSelfComparable(ty: Type, mod: *const Module, is_equality_cmp: bool) bool {	42	pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
45	return switch (ty.zigTypeTag(mod)) {	43	return switch (ty.zigTypeTag(zcu)) {
46	.Int,	44	.Int,
47	.Float,	45	.Float,
48	.ComptimeFloat,	46	.ComptimeFloat,
49	.ComptimeInt,	47	.ComptimeInt,
50	=> true,	48	=> true,
51		49
52	.Vector => ty.elemType2(mod).isSelfComparable(mod, is_equality_cmp),	50	.Vector => ty.elemType2(zcu).isSelfComparable(zcu, is_equality_cmp),
53		51
54	.Bool,	52	.Bool,
55	.Type,	53	.Type,
...	@@ -72,25 +70,25 @@ pub fn isSelfComparable(ty: Type, mod: *const Module, is_equality_cmp: bool) boo	...	@@ -72,25 +70,25 @@ pub fn isSelfComparable(ty: Type, mod: *const Module, is_equality_cmp: bool) boo
72	.Frame,	70	.Frame,
73	=> false,	71	=> false,
74		72
75	.Pointer => !ty.isSlice(mod) and (is_equality_cmp or ty.isCPtr(mod)),	73	.Pointer => !ty.isSlice(zcu) and (is_equality_cmp or ty.isCPtr(zcu)),
76	.Optional => {	74	.Optional => {
77	if (!is_equality_cmp) return false;	75	if (!is_equality_cmp) return false;
78	return ty.optionalChild(mod).isSelfComparable(mod, is_equality_cmp);	76	return ty.optionalChild(zcu).isSelfComparable(zcu, is_equality_cmp);
79	},	77	},
80	};	78	};
81	}	79	}
82		80
83	/// If it is a function pointer, returns the function type. Otherwise returns null.	81	/// If it is a function pointer, returns the function type. Otherwise returns null.
84	pub fn castPtrToFn(ty: Type, mod: *const Module) ?Type {	82	pub fn castPtrToFn(ty: Type, zcu: *const Zcu) ?Type {
85	if (ty.zigTypeTag(mod) != .Pointer) return null;	83	if (ty.zigTypeTag(zcu) != .Pointer) return null;
86	const elem_ty = ty.childType(mod);	84	const elem_ty = ty.childType(zcu);
87	if (elem_ty.zigTypeTag(mod) != .Fn) return null;	85	if (elem_ty.zigTypeTag(zcu) != .Fn) return null;
88	return elem_ty;	86	return elem_ty;
89	}	87	}
90		88
91	/// Asserts the type is a pointer.	89	/// Asserts the type is a pointer.
92	pub fn ptrIsMutable(ty: Type, mod: *const Module) bool {	90	pub fn ptrIsMutable(ty: Type, zcu: *const Zcu) bool {
93	return !mod.intern_pool.indexToKey(ty.toIntern()).ptr_type.flags.is_const;	91	return !zcu.intern_pool.indexToKey(ty.toIntern()).ptr_type.flags.is_const;
94	}	92	}
95		93
96	pub const ArrayInfo = struct {	94	pub const ArrayInfo = struct {
...	@@ -99,18 +97,18 @@ pub const ArrayInfo = struct {	...	@@ -99,18 +97,18 @@ pub const ArrayInfo = struct {
99	len: u64,	97	len: u64,
100	};	98	};
101		99
102	pub fn arrayInfo(self: Type, mod: *const Module) ArrayInfo {	100	pub fn arrayInfo(self: Type, zcu: *const Zcu) ArrayInfo {
103	return .{	101	return .{
104	.len = self.arrayLen(mod),	102	.len = self.arrayLen(zcu),
105	.sentinel = self.sentinel(mod),	103	.sentinel = self.sentinel(zcu),
106	.elem_type = self.childType(mod),	104	.elem_type = self.childType(zcu),
107	};	105	};
108	}	106	}
109		107
110	pub fn ptrInfo(ty: Type, mod: *const Module) InternPool.Key.PtrType {	108	pub fn ptrInfo(ty: Type, zcu: *const Zcu) InternPool.Key.PtrType {
111	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	109	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
112	.ptr_type => \|p\| p,	110	.ptr_type => \|p\| p,
113	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {	111	.opt_type => \|child\| switch (zcu.intern_pool.indexToKey(child)) {
114	.ptr_type => \|p\| p,	112	.ptr_type => \|p\| p,
115	else => unreachable,	113	else => unreachable,
116	},	114	},
...	@@ -118,8 +116,8 @@ pub fn ptrInfo(ty: Type, mod: *const Module) InternPool.Key.PtrType {	...	@@ -118,8 +116,8 @@ pub fn ptrInfo(ty: Type, mod: *const Module) InternPool.Key.PtrType {
118	};	116	};
119	}	117	}
120		118
121	pub fn eql(a: Type, b: Type, mod: *const Module) bool {	119	pub fn eql(a: Type, b: Type, zcu: *const Zcu) bool {
122	_ = mod; // TODO: remove this parameter	120	_ = zcu; // TODO: remove this parameter
123	// The InternPool data structure hashes based on Key to make interned objects	121	// The InternPool data structure hashes based on Key to make interned objects
124	// unique. An Index can be treated simply as u32 value for the	122	// unique. An Index can be treated simply as u32 value for the
125	// purpose of Type/Value hashing and equality.	123	// purpose of Type/Value hashing and equality.
...	@@ -179,8 +177,8 @@ pub fn dump(	...	@@ -179,8 +177,8 @@ pub fn dump(
179	/// Prints a name suitable for `@typeName`.	177	/// Prints a name suitable for `@typeName`.
180	/// TODO: take an `opt_sema` to pass to `fmtValue` when printing sentinels.	178	/// TODO: take an `opt_sema` to pass to `fmtValue` when printing sentinels.
181	pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error!void {	179	pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error!void {
182	const mod = pt.zcu;	180	const zcu = pt.zcu;
183	const ip = &mod.intern_pool;	181	const ip = &zcu.intern_pool;
184	switch (ip.indexToKey(ty.toIntern())) {	182	switch (ip.indexToKey(ty.toIntern())) {
185	.int_type => \|int_type\| {	183	.int_type => \|int_type\| {
186	const sign_char: u8 = switch (int_type.signedness) {	184	const sign_char: u8 = switch (int_type.signedness) {
...	@@ -190,7 +188,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -190,7 +188,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
190	return writer.print("{c}{d}", .{ sign_char, int_type.bits });	188	return writer.print("{c}{d}", .{ sign_char, int_type.bits });
191	},	189	},
192	.ptr_type => {	190	.ptr_type => {
193	const info = ty.ptrInfo(mod);	191	const info = ty.ptrInfo(zcu);
194		192
195	if (info.sentinel != .none) switch (info.flags.size) {	193	if (info.sentinel != .none) switch (info.flags.size) {
196	.One, .C => unreachable,	194	.One, .C => unreachable,
...	@@ -210,7 +208,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -210,7 +208,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
210	const alignment = if (info.flags.alignment != .none)	208	const alignment = if (info.flags.alignment != .none)
211	info.flags.alignment	209	info.flags.alignment
212	else	210	else
213	Type.fromInterned(info.child).abiAlignment(pt);	211	Type.fromInterned(info.child).abiAlignment(pt.zcu);
214	try writer.print("align({d}", .{alignment.toByteUnits() orelse 0});	212	try writer.print("align({d}", .{alignment.toByteUnits() orelse 0});
215		213
216	if (info.packed_offset.bit_offset != 0 or info.packed_offset.host_size != 0) {	214	if (info.packed_offset.bit_offset != 0 or info.packed_offset.host_size != 0) {
...	@@ -268,7 +266,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -268,7 +266,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
268	return;	266	return;
269	},	267	},
270	.inferred_error_set_type => \|func_index\| {	268	.inferred_error_set_type => \|func_index\| {
271	const func_nav = ip.getNav(mod.funcInfo(func_index).owner_nav);	269	const func_nav = ip.getNav(zcu.funcInfo(func_index).owner_nav);
272	try writer.print("@typeInfo(@typeInfo(@TypeOf({})).Fn.return_type.?).ErrorUnion.error_set", .{	270	try writer.print("@typeInfo(@typeInfo(@TypeOf({})).Fn.return_type.?).ErrorUnion.error_set", .{
273	func_nav.fqn.fmt(ip),	271	func_nav.fqn.fmt(ip),
274	});	272	});
...	@@ -338,7 +336,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -338,7 +336,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
338	try writer.writeAll("comptime ");	336	try writer.writeAll("comptime ");
339	}	337	}
340	if (anon_struct.names.len != 0) {	338	if (anon_struct.names.len != 0) {
341	try writer.print("{}: ", .{anon_struct.names.get(ip)[i].fmt(&mod.intern_pool)});	339	try writer.print("{}: ", .{anon_struct.names.get(ip)[i].fmt(&zcu.intern_pool)});
342	}	340	}
343		341
344	try print(Type.fromInterned(field_ty), writer, pt);	342	try print(Type.fromInterned(field_ty), writer, pt);
...	@@ -367,7 +365,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -367,7 +365,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
367	try writer.writeAll("noinline ");	365	try writer.writeAll("noinline ");
368	}	366	}
369	try writer.writeAll("fn (");	367	try writer.writeAll("fn (");
370	const param_types = fn_info.param_types.get(&mod.intern_pool);	368	const param_types = fn_info.param_types.get(&zcu.intern_pool);
371	for (param_types, 0..) \|param_ty, i\| {	369	for (param_types, 0..) \|param_ty, i\| {
372	if (i != 0) try writer.writeAll(", ");	370	if (i != 0) try writer.writeAll(", ");
373	if (std.math.cast(u5, i)) \|index\| {	371	if (std.math.cast(u5, i)) \|index\| {
...	@@ -448,6 +446,21 @@ pub fn toValue(self: Type) Value {	...	@@ -448,6 +446,21 @@ pub fn toValue(self: Type) Value {
448		446
449	const RuntimeBitsError = SemaError \|\| error{NeedLazy};	447	const RuntimeBitsError = SemaError \|\| error{NeedLazy};
450		448
		449	pub fn hasRuntimeBits(ty: Type, zcu: *Zcu) bool {
		450	return hasRuntimeBitsInner(ty, false, .eager, zcu, {}) catch unreachable;
		451	}
		452
		453	pub fn hasRuntimeBitsSema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
		454	return hasRuntimeBitsInner(ty, false, .sema, pt.zcu, pt.tid) catch \|err\| switch (err) {
		455	error.NeedLazy => unreachable, // this would require a resolve strat of lazy
		456	else => \|e\| return e,
		457	};
		458	}
		459
		460	pub fn hasRuntimeBitsIgnoreComptime(ty: Type, zcu: *Zcu) bool {
		461	return hasRuntimeBitsInner(ty, true, .eager, zcu, {}) catch unreachable;
		462	}
		463
451	/// true if and only if the type takes up space in memory at runtime.	464	/// true if and only if the type takes up space in memory at runtime.
452	/// There are two reasons a type will return false:	465	/// There are two reasons a type will return false:
453	/// * the type is a comptime-only type. For example, the type `type` itself.	466	/// * the type is a comptime-only type. For example, the type `type` itself.
...	@@ -459,14 +472,14 @@ const RuntimeBitsError = SemaError \|\| error{NeedLazy};	...	@@ -459,14 +472,14 @@ const RuntimeBitsError = SemaError \|\| error{NeedLazy};
459	/// making it one-possible-value only if the integer tag type has 0 bits.	472	/// making it one-possible-value only if the integer tag type has 0 bits.
460	/// When `ignore_comptime_only` is true, then types that are comptime-only	473	/// When `ignore_comptime_only` is true, then types that are comptime-only
461	/// may return false positives.	474	/// may return false positives.
462	pub fn hasRuntimeBitsAdvanced(	475	pub fn hasRuntimeBitsInner(
463	ty: Type,	476	ty: Type,
464	pt: Zcu.PerThread,
465	ignore_comptime_only: bool,	477	ignore_comptime_only: bool,
466	comptime strat: ResolveStratLazy,	478	comptime strat: ResolveStratLazy,
		479	zcu: *Zcu,
		480	tid: strat.Tid(),
467	) RuntimeBitsError!bool {	481	) RuntimeBitsError!bool {
468	const mod = pt.zcu;	482	const ip = &zcu.intern_pool;
469	const ip = &mod.intern_pool;
470	return switch (ty.toIntern()) {	483	return switch (ty.toIntern()) {
471	// False because it is a comptime-only type.	484	// False because it is a comptime-only type.
472	.empty_struct_type => false,	485	.empty_struct_type => false,
...	@@ -477,26 +490,29 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -477,26 +490,29 @@ pub fn hasRuntimeBitsAdvanced(
477	// to comptime-only types do not, with the exception of function pointers.	490	// to comptime-only types do not, with the exception of function pointers.
478	if (ignore_comptime_only) return true;	491	if (ignore_comptime_only) return true;
479	return switch (strat) {	492	return switch (strat) {
480	.sema => !try ty.comptimeOnlyAdvanced(pt, .sema),	493	.sema => {
481	.eager => !ty.comptimeOnly(pt),	494	const pt = strat.pt(zcu, tid);
		495	return !try ty.comptimeOnlySema(pt);
		496	},
		497	.eager => !ty.comptimeOnly(zcu),
482	.lazy => error.NeedLazy,	498	.lazy => error.NeedLazy,
483	};	499	};
484	},	500	},
485	.anyframe_type => true,	501	.anyframe_type => true,
486	.array_type => \|array_type\| return array_type.lenIncludingSentinel() > 0 and	502	.array_type => \|array_type\| return array_type.lenIncludingSentinel() > 0 and
487	try Type.fromInterned(array_type.child).hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat),	503	try Type.fromInterned(array_type.child).hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid),
488	.vector_type => \|vector_type\| return vector_type.len > 0 and	504	.vector_type => \|vector_type\| return vector_type.len > 0 and
489	try Type.fromInterned(vector_type.child).hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat),	505	try Type.fromInterned(vector_type.child).hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid),
490	.opt_type => \|child\| {	506	.opt_type => \|child\| {
491	const child_ty = Type.fromInterned(child);	507	const child_ty = Type.fromInterned(child);
492	if (child_ty.isNoReturn(mod)) {	508	if (child_ty.isNoReturn(zcu)) {
493	// Then the optional is comptime-known to be null.	509	// Then the optional is comptime-known to be null.
494	return false;	510	return false;
495	}	511	}
496	if (ignore_comptime_only) return true;	512	if (ignore_comptime_only) return true;
497	return switch (strat) {	513	return switch (strat) {
498	.sema => !try child_ty.comptimeOnlyAdvanced(pt, .sema),	514	.sema => !try child_ty.comptimeOnlyInner(.sema, zcu, tid),
499	.eager => !child_ty.comptimeOnly(pt),	515	.eager => !child_ty.comptimeOnly(zcu),
500	.lazy => error.NeedLazy,	516	.lazy => error.NeedLazy,
501	};	517	};
502	},	518	},
...	@@ -556,14 +572,14 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -556,14 +572,14 @@ pub fn hasRuntimeBitsAdvanced(
556	return true;	572	return true;
557	}	573	}
558	switch (strat) {	574	switch (strat) {
559	.sema => try ty.resolveFields(pt),	575	.sema => try ty.resolveFields(strat.pt(zcu, tid)),
560	.eager => assert(struct_type.haveFieldTypes(ip)),	576	.eager => assert(struct_type.haveFieldTypes(ip)),
561	.lazy => if (!struct_type.haveFieldTypes(ip)) return error.NeedLazy,	577	.lazy => if (!struct_type.haveFieldTypes(ip)) return error.NeedLazy,
562	}	578	}
563	for (0..struct_type.field_types.len) \|i\| {	579	for (0..struct_type.field_types.len) \|i\| {
564	if (struct_type.comptime_bits.getBit(ip, i)) continue;	580	if (struct_type.comptime_bits.getBit(ip, i)) continue;
565	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);	581	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
566	if (try field_ty.hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat))	582	if (try field_ty.hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid))
567	return true;	583	return true;
568	} else {	584	} else {
569	return false;	585	return false;
...	@@ -572,7 +588,12 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -572,7 +588,12 @@ pub fn hasRuntimeBitsAdvanced(
572	.anon_struct_type => \|tuple\| {	588	.anon_struct_type => \|tuple\| {
573	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {	589	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {
574	if (val != .none) continue; // comptime field	590	if (val != .none) continue; // comptime field
575	if (try Type.fromInterned(field_ty).hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat)) return true;	591	if (try Type.fromInterned(field_ty).hasRuntimeBitsInner(
		592	ignore_comptime_only,
		593	strat,
		594	zcu,
		595	tid,
		596	)) return true;
576	}	597	}
577	return false;	598	return false;
578	},	599	},
...	@@ -591,21 +612,25 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -591,21 +612,25 @@ pub fn hasRuntimeBitsAdvanced(
591	// tag_ty will be `none` if this union's tag type is not resolved yet,	612	// tag_ty will be `none` if this union's tag type is not resolved yet,
592	// in which case we want control flow to continue down below.	613	// in which case we want control flow to continue down below.
593	if (tag_ty != .none and	614	if (tag_ty != .none and
594	try Type.fromInterned(tag_ty).hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat))	615	try Type.fromInterned(tag_ty).hasRuntimeBitsInner(
595	{	616	ignore_comptime_only,
		617	strat,
		618	zcu,
		619	tid,
		620	)) {
596	return true;	621	return true;
597	}	622	}
598	},	623	},
599	}	624	}
600	switch (strat) {	625	switch (strat) {
601	.sema => try ty.resolveFields(pt),	626	.sema => try ty.resolveFields(strat.pt(zcu, tid)),
602	.eager => assert(union_flags.status.haveFieldTypes()),	627	.eager => assert(union_flags.status.haveFieldTypes()),
603	.lazy => if (!union_flags.status.haveFieldTypes())	628	.lazy => if (!union_flags.status.haveFieldTypes())
604	return error.NeedLazy,	629	return error.NeedLazy,
605	}	630	}
606	for (0..union_type.field_types.len) \|field_index\| {	631	for (0..union_type.field_types.len) \|field_index\| {
607	const field_ty = Type.fromInterned(union_type.field_types.get(ip)[field_index]);	632	const field_ty = Type.fromInterned(union_type.field_types.get(ip)[field_index]);
608	if (try field_ty.hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat))	633	if (try field_ty.hasRuntimeBitsInner(ignore_comptime_only, strat, zcu, tid))
609	return true;	634	return true;
610	} else {	635	} else {
611	return false;	636	return false;
...	@@ -613,7 +638,12 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -613,7 +638,12 @@ pub fn hasRuntimeBitsAdvanced(
613	},	638	},
614		639
615	.opaque_type => true,	640	.opaque_type => true,
616	.enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).hasRuntimeBitsAdvanced(pt, ignore_comptime_only, strat),	641	.enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).hasRuntimeBitsInner(
		642	ignore_comptime_only,
		643	strat,
		644	zcu,
		645	tid,
		646	),
617		647
618	// values, not types	648	// values, not types
619	.undef,	649	.undef,
...	@@ -643,8 +673,8 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -643,8 +673,8 @@ pub fn hasRuntimeBitsAdvanced(
643	/// true if and only if the type has a well-defined memory layout	673	/// true if and only if the type has a well-defined memory layout
644	/// readFrom/writeToMemory are supported only for types with a well-	674	/// readFrom/writeToMemory are supported only for types with a well-
645	/// defined memory layout	675	/// defined memory layout
646	pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	676	pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
647	const ip = &mod.intern_pool;	677	const ip = &zcu.intern_pool;
648	return switch (ip.indexToKey(ty.toIntern())) {	678	return switch (ip.indexToKey(ty.toIntern())) {
649	.int_type,	679	.int_type,
650	.vector_type,	680	.vector_type,
...	@@ -660,8 +690,8 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -660,8 +690,8 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
660	.func_type,	690	.func_type,
661	=> false,	691	=> false,
662		692
663	.array_type => \|array_type\| Type.fromInterned(array_type.child).hasWellDefinedLayout(mod),	693	.array_type => \|array_type\| Type.fromInterned(array_type.child).hasWellDefinedLayout(zcu),
664	.opt_type => ty.isPtrLikeOptional(mod),	694	.opt_type => ty.isPtrLikeOptional(zcu),
665	.ptr_type => \|ptr_type\| ptr_type.flags.size != .Slice,	695	.ptr_type => \|ptr_type\| ptr_type.flags.size != .Slice,
666		696
667	.simple_type => \|t\| switch (t) {	697	.simple_type => \|t\| switch (t) {
...	@@ -740,94 +770,99 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -740,94 +770,99 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
740	};	770	};
741	}	771	}
742		772
743	pub fn hasRuntimeBits(ty: Type, pt: Zcu.PerThread) bool {	773	pub fn fnHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
744	return hasRuntimeBitsAdvanced(ty, pt, false, .eager) catch unreachable;	774	return ty.fnHasRuntimeBitsInner(.normal, zcu, {}) catch unreachable;
745	}
746
747	pub fn hasRuntimeBitsIgnoreComptime(ty: Type, pt: Zcu.PerThread) bool {
748	return hasRuntimeBitsAdvanced(ty, pt, true, .eager) catch unreachable;
749	}	775	}
750		776
751	pub fn fnHasRuntimeBits(ty: Type, pt: Zcu.PerThread) bool {	777	pub fn fnHasRuntimeBitsSema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
752	return ty.fnHasRuntimeBitsAdvanced(pt, .normal) catch unreachable;	778	return try ty.fnHasRuntimeBitsInner(.sema, pt.zcu, pt.tid);
753	}	779	}
754		780
755	/// Determines whether a function type has runtime bits, i.e. whether a	781	/// Determines whether a function type has runtime bits, i.e. whether a
756	/// function with this type can exist at runtime.	782	/// function with this type can exist at runtime.
757	/// Asserts that `ty` is a function type.	783	/// Asserts that `ty` is a function type.
758	pub fn fnHasRuntimeBitsAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) SemaError!bool {	784	pub fn fnHasRuntimeBitsInner(
759	const fn_info = pt.zcu.typeToFunc(ty).?;	785	ty: Type,
		786	comptime strat: ResolveStrat,
		787	zcu: *Zcu,
		788	tid: strat.Tid(),
		789	) SemaError!bool {
		790	const fn_info = zcu.typeToFunc(ty).?;
760	if (fn_info.is_generic) return false;	791	if (fn_info.is_generic) return false;
761	if (fn_info.is_var_args) return true;	792	if (fn_info.is_var_args) return true;
762	if (fn_info.cc == .Inline) return false;	793	if (fn_info.cc == .Inline) return false;
763	return !try Type.fromInterned(fn_info.return_type).comptimeOnlyAdvanced(pt, strat);	794	return !try Type.fromInterned(fn_info.return_type).comptimeOnlyInner(strat, zcu, tid);
764	}	795	}
765		796
766	pub fn isFnOrHasRuntimeBits(ty: Type, pt: Zcu.PerThread) bool {	797	pub fn isFnOrHasRuntimeBits(ty: Type, zcu: *Zcu) bool {
767	switch (ty.zigTypeTag(pt.zcu)) {	798	switch (ty.zigTypeTag(zcu)) {
768	.Fn => return ty.fnHasRuntimeBits(pt),	799	.Fn => return ty.fnHasRuntimeBits(zcu),
769	else => return ty.hasRuntimeBits(pt),	800	else => return ty.hasRuntimeBits(zcu),
770	}	801	}
771	}	802	}
772		803
773	/// Same as `isFnOrHasRuntimeBits` but comptime-only types may return a false positive.	804	/// Same as `isFnOrHasRuntimeBits` but comptime-only types may return a false positive.
774	pub fn isFnOrHasRuntimeBitsIgnoreComptime(ty: Type, pt: Zcu.PerThread) bool {	805	pub fn isFnOrHasRuntimeBitsIgnoreComptime(ty: Type, zcu: *Zcu) bool {
775	return switch (ty.zigTypeTag(pt.zcu)) {	806	return switch (ty.zigTypeTag(zcu)) {
776	.Fn => true,	807	.Fn => true,
777	else => return ty.hasRuntimeBitsIgnoreComptime(pt),	808	else => return ty.hasRuntimeBitsIgnoreComptime(zcu),
778	};	809	};
779	}	810	}
780		811
781	pub fn isNoReturn(ty: Type, mod: *Module) bool {	812	pub fn isNoReturn(ty: Type, zcu: *const Zcu) bool {
782	return mod.intern_pool.isNoReturn(ty.toIntern());	813	return zcu.intern_pool.isNoReturn(ty.toIntern());
783	}	814	}
784		815
785	/// Returns `none` if the pointer is naturally aligned and the element type is 0-bit.	816	/// Returns `none` if the pointer is naturally aligned and the element type is 0-bit.
786	pub fn ptrAlignment(ty: Type, pt: Zcu.PerThread) Alignment {	817	pub fn ptrAlignment(ty: Type, zcu: *Zcu) Alignment {
787	return ptrAlignmentAdvanced(ty, pt, .normal) catch unreachable;	818	return ptrAlignmentInner(ty, .normal, zcu, {}) catch unreachable;
		819	}
		820
		821	pub fn ptrAlignmentSema(ty: Type, pt: Zcu.PerThread) SemaError!Alignment {
		822	return try ty.ptrAlignmentInner(.sema, pt.zcu, pt.tid);
788	}	823	}
789		824
790	pub fn ptrAlignmentAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Alignment {	825	pub fn ptrAlignmentInner(
791	return switch (pt.zcu.intern_pool.indexToKey(ty.toIntern())) {	826	ty: Type,
		827	comptime strat: ResolveStrat,
		828	zcu: *Zcu,
		829	tid: strat.Tid(),
		830	) !Alignment {
		831	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
792	.ptr_type => \|ptr_type\| {	832	.ptr_type => \|ptr_type\| {
793	if (ptr_type.flags.alignment != .none)	833	if (ptr_type.flags.alignment != .none)
794	return ptr_type.flags.alignment;	834	return ptr_type.flags.alignment;
795		835
796	if (strat == .sema) {	836	if (strat == .sema) {
797	const res = try Type.fromInterned(ptr_type.child).abiAlignmentAdvanced(pt, .sema);	837	const res = try Type.fromInterned(ptr_type.child).abiAlignmentInner(.sema, zcu, tid);
798	return res.scalar;	838	return res.scalar;
799	}	839	}
800		840
801	return (Type.fromInterned(ptr_type.child).abiAlignmentAdvanced(pt, .eager) catch unreachable).scalar;	841	return Type.fromInterned(ptr_type.child).abiAlignment(zcu);
802	},	842	},
803	.opt_type => \|child\| Type.fromInterned(child).ptrAlignmentAdvanced(pt, strat),	843	.opt_type => \|child\| Type.fromInterned(child).ptrAlignmentInner(strat, zcu, tid),
804	else => unreachable,	844	else => unreachable,
805	};	845	};
806	}	846	}
807		847
808	pub fn ptrAddressSpace(ty: Type, mod: *const Module) std.builtin.AddressSpace {	848	pub fn ptrAddressSpace(ty: Type, zcu: *const Zcu) std.builtin.AddressSpace {
809	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	849	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
810	.ptr_type => \|ptr_type\| ptr_type.flags.address_space,	850	.ptr_type => \|ptr_type\| ptr_type.flags.address_space,
811	.opt_type => \|child\| mod.intern_pool.indexToKey(child).ptr_type.flags.address_space,	851	.opt_type => \|child\| zcu.intern_pool.indexToKey(child).ptr_type.flags.address_space,
812	else => unreachable,	852	else => unreachable,
813	};	853	};
814	}	854	}
815		855
816	/// Never returns `none`. Asserts that all necessary type resolution is already done.
817	pub fn abiAlignment(ty: Type, pt: Zcu.PerThread) Alignment {
818	return (ty.abiAlignmentAdvanced(pt, .eager) catch unreachable).scalar;
819	}
820
821	/// May capture a reference to `ty`.	856	/// May capture a reference to `ty`.
822	/// Returned value has type `comptime_int`.	857	/// Returned value has type `comptime_int`.
823	pub fn lazyAbiAlignment(ty: Type, pt: Zcu.PerThread) !Value {	858	pub fn lazyAbiAlignment(ty: Type, pt: Zcu.PerThread) !Value {
824	switch (try ty.abiAlignmentAdvanced(pt, .lazy)) {	859	switch (try ty.abiAlignmentInner(.lazy, pt.zcu, pt.tid)) {
825	.val => \|val\| return val,	860	.val => \|val\| return val,
826	.scalar => \|x\| return pt.intValue(Type.comptime_int, x.toByteUnits() orelse 0),	861	.scalar => \|x\| return pt.intValue(Type.comptime_int, x.toByteUnits() orelse 0),
827	}	862	}
828	}	863	}
829		864
830	pub const AbiAlignmentAdvanced = union(enum) {	865	pub const AbiAlignmentInner = union(enum) {
831	scalar: Alignment,	866	scalar: Alignment,
832	val: Value,	867	val: Value,
833	};	868	};
...	@@ -842,6 +877,23 @@ pub const ResolveStratLazy = enum {	...	@@ -842,6 +877,23 @@ pub const ResolveStratLazy = enum {
842	/// Return a scalar result, performing type resolution as necessary.	877	/// Return a scalar result, performing type resolution as necessary.
843	/// This should typically be used from semantic analysis.	878	/// This should typically be used from semantic analysis.
844	sema,	879	sema,
		880
		881	pub fn Tid(comptime strat: ResolveStratLazy) type {
		882	return switch (strat) {
		883	.lazy, .sema => Zcu.PerThread.Id,
		884	.eager => void,
		885	};
		886	}
		887
		888	pub fn pt(comptime strat: ResolveStratLazy, zcu: *Zcu, tid: strat.Tid()) switch (strat) {
		889	.lazy, .sema => Zcu.PerThread,
		890	.eager => void,
		891	} {
		892	return switch (strat) {
		893	.lazy, .sema => .{ .tid = tid, .zcu = zcu },
		894	else => {},
		895	};
		896	}
845	};	897	};
846		898
847	/// The chosen strategy can be easily optimized away in release builds.	899	/// The chosen strategy can be easily optimized away in release builds.
...	@@ -854,6 +906,23 @@ pub const ResolveStrat = enum {	...	@@ -854,6 +906,23 @@ pub const ResolveStrat = enum {
854	/// This should typically be used from semantic analysis.	906	/// This should typically be used from semantic analysis.
855	sema,	907	sema,
856		908
		909	pub fn Tid(comptime strat: ResolveStrat) type {
		910	return switch (strat) {
		911	.sema => Zcu.PerThread.Id,
		912	.normal => void,
		913	};
		914	}
		915
		916	pub fn pt(comptime strat: ResolveStrat, zcu: *Zcu, tid: strat.Tid()) switch (strat) {
		917	.sema => Zcu.PerThread,
		918	.normal => void,
		919	} {
		920	return switch (strat) {
		921	.sema => .{ .tid = tid, .zcu = zcu },
		922	.normal => {},
		923	};
		924	}
		925
857	pub inline fn toLazy(strat: ResolveStrat) ResolveStratLazy {	926	pub inline fn toLazy(strat: ResolveStrat) ResolveStratLazy {
858	return switch (strat) {	927	return switch (strat) {
859	.normal => .eager,	928	.normal => .eager,
...	@@ -862,21 +931,31 @@ pub const ResolveStrat = enum {	...	@@ -862,21 +931,31 @@ pub const ResolveStrat = enum {
862	}	931	}
863	};	932	};
864		933
		934	/// Never returns `none`. Asserts that all necessary type resolution is already done.
		935	pub fn abiAlignment(ty: Type, zcu: *Zcu) Alignment {
		936	return (ty.abiAlignmentInner(.eager, zcu, {}) catch unreachable).scalar;
		937	}
		938
		939	pub fn abiAlignmentSema(ty: Type, pt: Zcu.PerThread) SemaError!Alignment {
		940	return (try ty.abiAlignmentInner(.sema, pt.zcu, pt.tid)).scalar;
		941	}
		942
865	/// If you pass `eager` you will get back `scalar` and assert the type is resolved.	943	/// If you pass `eager` you will get back `scalar` and assert the type is resolved.
866	/// In this case there will be no error, guaranteed.	944	/// In this case there will be no error, guaranteed.
867	/// If you pass `lazy` you may get back `scalar` or `val`.	945	/// If you pass `lazy` you may get back `scalar` or `val`.
868	/// If `val` is returned, a reference to `ty` has been captured.	946	/// If `val` is returned, a reference to `ty` has been captured.
869	/// If you pass `sema` you will get back `scalar` and resolve the type if	947	/// If you pass `sema` you will get back `scalar` and resolve the type if
870	/// necessary, possibly returning a CompileError.	948	/// necessary, possibly returning a CompileError.
871	pub fn abiAlignmentAdvanced(	949	pub fn abiAlignmentInner(
872	ty: Type,	950	ty: Type,
873	pt: Zcu.PerThread,
874	comptime strat: ResolveStratLazy,	951	comptime strat: ResolveStratLazy,
875	) SemaError!AbiAlignmentAdvanced {	952	zcu: *Zcu,
876	const mod = pt.zcu;	953	tid: strat.Tid(),
877	const target = mod.getTarget();	954	) SemaError!AbiAlignmentInner {
878	const use_llvm = mod.comp.config.use_llvm;	955	const pt = strat.pt(zcu, tid);
879	const ip = &mod.intern_pool;	956	const target = zcu.getTarget();
		957	const use_llvm = zcu.comp.config.use_llvm;
		958	const ip = &zcu.intern_pool;
880		959
881	switch (ty.toIntern()) {	960	switch (ty.toIntern()) {
882	.empty_struct_type => return .{ .scalar = .@"1" },	961	.empty_struct_type => return .{ .scalar = .@"1" },
...	@@ -889,22 +968,22 @@ pub fn abiAlignmentAdvanced(	...	@@ -889,22 +968,22 @@ pub fn abiAlignmentAdvanced(
889	return .{ .scalar = ptrAbiAlignment(target) };	968	return .{ .scalar = ptrAbiAlignment(target) };
890	},	969	},
891	.array_type => \|array_type\| {	970	.array_type => \|array_type\| {
892	return Type.fromInterned(array_type.child).abiAlignmentAdvanced(pt, strat);	971	return Type.fromInterned(array_type.child).abiAlignmentInner(strat, zcu, tid);
893	},	972	},
894	.vector_type => \|vector_type\| {	973	.vector_type => \|vector_type\| {
895	if (vector_type.len == 0) return .{ .scalar = .@"1" };	974	if (vector_type.len == 0) return .{ .scalar = .@"1" };
896	switch (mod.comp.getZigBackend()) {	975	switch (zcu.comp.getZigBackend()) {
897	else => {	976	else => {
898	// This is fine because the child type of a vector always has a bit-size known	977	// This is fine because the child type of a vector always has a bit-size known
899	// without needing any type resolution.	978	// without needing any type resolution.
900	const elem_bits: u32 = @intCast(Type.fromInterned(vector_type.child).bitSize(pt));	979	const elem_bits: u32 = @intCast(Type.fromInterned(vector_type.child).bitSize(zcu));
901	if (elem_bits == 0) return .{ .scalar = .@"1" };	980	if (elem_bits == 0) return .{ .scalar = .@"1" };
902	const bytes = ((elem_bits * vector_type.len) + 7) / 8;	981	const bytes = ((elem_bits * vector_type.len) + 7) / 8;
903	const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);	982	const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
904	return .{ .scalar = Alignment.fromByteUnits(alignment) };	983	return .{ .scalar = Alignment.fromByteUnits(alignment) };
905	},	984	},
906	.stage2_c => {	985	.stage2_c => {
907	return Type.fromInterned(vector_type.child).abiAlignmentAdvanced(pt, strat);	986	return Type.fromInterned(vector_type.child).abiAlignmentInner(strat, zcu, tid);
908	},	987	},
909	.stage2_x86_64 => {	988	.stage2_x86_64 => {
910	if (vector_type.child == .bool_type) {	989	if (vector_type.child == .bool_type) {
...	@@ -915,7 +994,7 @@ pub fn abiAlignmentAdvanced(	...	@@ -915,7 +994,7 @@ pub fn abiAlignmentAdvanced(
915	const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);	994	const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
916	return .{ .scalar = Alignment.fromByteUnits(alignment) };	995	return .{ .scalar = Alignment.fromByteUnits(alignment) };
917	}	996	}
918	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeAdvanced(pt, strat)).scalar);	997	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
919	if (elem_bytes == 0) return .{ .scalar = .@"1" };	998	if (elem_bytes == 0) return .{ .scalar = .@"1" };
920	const bytes = elem_bytes * vector_type.len;	999	const bytes = elem_bytes * vector_type.len;
921	if (bytes > 32 and std.Target.x86.featureSetHas(target.cpu.features, .avx512f)) return .{ .scalar = .@"64" };	1000	if (bytes > 32 and std.Target.x86.featureSetHas(target.cpu.features, .avx512f)) return .{ .scalar = .@"64" };
...	@@ -925,11 +1004,16 @@ pub fn abiAlignmentAdvanced(	...	@@ -925,11 +1004,16 @@ pub fn abiAlignmentAdvanced(
925	}	1004	}
926	},	1005	},
927		1006
928	.opt_type => return ty.abiAlignmentAdvancedOptional(pt, strat),	1007	.opt_type => return ty.abiAlignmentInnerOptional(strat, zcu, tid),
929	.error_union_type => \|info\| return ty.abiAlignmentAdvancedErrorUnion(pt, strat, Type.fromInterned(info.payload_type)),	1008	.error_union_type => \|info\| return ty.abiAlignmentInnerErrorUnion(
		1009	strat,
		1010	zcu,
		1011	tid,
		1012	Type.fromInterned(info.payload_type),
		1013	),
930		1014
931	.error_set_type, .inferred_error_set_type => {	1015	.error_set_type, .inferred_error_set_type => {
932	const bits = mod.errorSetBits();	1016	const bits = zcu.errorSetBits();
933	if (bits == 0) return .{ .scalar = .@"1" };	1017	if (bits == 0) return .{ .scalar = .@"1" };
934	return .{ .scalar = intAbiAlignment(bits, target, use_llvm) };	1018	return .{ .scalar = intAbiAlignment(bits, target, use_llvm) };
935	},	1019	},
...	@@ -965,7 +1049,7 @@ pub fn abiAlignmentAdvanced(	...	@@ -965,7 +1049,7 @@ pub fn abiAlignmentAdvanced(
965	},	1049	},
966	.f80 => switch (target.cTypeBitSize(.longdouble)) {	1050	.f80 => switch (target.cTypeBitSize(.longdouble)) {
967	80 => return .{ .scalar = cTypeAlign(target, .longdouble) },	1051	80 => return .{ .scalar = cTypeAlign(target, .longdouble) },
968	else => return .{ .scalar = Type.u80.abiAlignment(pt) },	1052	else => return .{ .scalar = Type.u80.abiAlignment(zcu) },
969	},	1053	},
970	.f128 => switch (target.cTypeBitSize(.longdouble)) {	1054	.f128 => switch (target.cTypeBitSize(.longdouble)) {
971	128 => return .{ .scalar = cTypeAlign(target, .longdouble) },	1055	128 => return .{ .scalar = cTypeAlign(target, .longdouble) },
...	@@ -973,7 +1057,7 @@ pub fn abiAlignmentAdvanced(	...	@@ -973,7 +1057,7 @@ pub fn abiAlignmentAdvanced(
973	},	1057	},
974		1058
975	.anyerror, .adhoc_inferred_error_set => {	1059	.anyerror, .adhoc_inferred_error_set => {
976	const bits = mod.errorSetBits();	1060	const bits = zcu.errorSetBits();
977	if (bits == 0) return .{ .scalar = .@"1" };	1061	if (bits == 0) return .{ .scalar = .@"1" };
978	return .{ .scalar = intAbiAlignment(bits, target, use_llvm) };	1062	return .{ .scalar = intAbiAlignment(bits, target, use_llvm) };
979	},	1063	},
...	@@ -1003,7 +1087,7 @@ pub fn abiAlignmentAdvanced(	...	@@ -1003,7 +1087,7 @@ pub fn abiAlignmentAdvanced(
1003	},	1087	},
1004	.eager => {},	1088	.eager => {},
1005	}	1089	}
1006	return .{ .scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiAlignment(pt) };	1090	return .{ .scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiAlignment(zcu) };
1007	}	1091	}
1008		1092
1009	if (struct_type.flagsUnordered(ip).alignment == .none) switch (strat) {	1093	if (struct_type.flagsUnordered(ip).alignment == .none) switch (strat) {
...	@@ -1021,11 +1105,11 @@ pub fn abiAlignmentAdvanced(	...	@@ -1021,11 +1105,11 @@ pub fn abiAlignmentAdvanced(
1021	var big_align: Alignment = .@"1";	1105	var big_align: Alignment = .@"1";
1022	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {	1106	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {
1023	if (val != .none) continue; // comptime field	1107	if (val != .none) continue; // comptime field
1024	switch (try Type.fromInterned(field_ty).abiAlignmentAdvanced(pt, strat)) {	1108	switch (try Type.fromInterned(field_ty).abiAlignmentInner(strat, zcu, tid)) {
1025	.scalar => \|field_align\| big_align = big_align.max(field_align),	1109	.scalar => \|field_align\| big_align = big_align.max(field_align),
1026	.val => switch (strat) {	1110	.val => switch (strat) {
1027	.eager => unreachable, // field type alignment not resolved	1111	.eager => unreachable, // field type alignment not resolved
1028	.sema => unreachable, // passed to abiAlignmentAdvanced above	1112	.sema => unreachable, // passed to abiAlignmentInner above
1029	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1113	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1030	.ty = .comptime_int_type,	1114	.ty = .comptime_int_type,
1031	.storage = .{ .lazy_align = ty.toIntern() },	1115	.storage = .{ .lazy_align = ty.toIntern() },
...	@@ -1051,7 +1135,7 @@ pub fn abiAlignmentAdvanced(	...	@@ -1051,7 +1135,7 @@ pub fn abiAlignmentAdvanced(
1051	},	1135	},
1052	.opaque_type => return .{ .scalar = .@"1" },	1136	.opaque_type => return .{ .scalar = .@"1" },
1053	.enum_type => return .{	1137	.enum_type => return .{
1054	.scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiAlignment(pt),	1138	.scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiAlignment(zcu),
1055	},	1139	},
1056		1140
1057	// values, not types	1141	// values, not types
...	@@ -1079,32 +1163,37 @@ pub fn abiAlignmentAdvanced(	...	@@ -1079,32 +1163,37 @@ pub fn abiAlignmentAdvanced(
1079	}	1163	}
1080	}	1164	}
1081		1165
1082	fn abiAlignmentAdvancedErrorUnion(	1166	fn abiAlignmentInnerErrorUnion(
1083	ty: Type,	1167	ty: Type,
1084	pt: Zcu.PerThread,
1085	comptime strat: ResolveStratLazy,	1168	comptime strat: ResolveStratLazy,
		1169	zcu: *Zcu,
		1170	tid: strat.Tid(),
1086	payload_ty: Type,	1171	payload_ty: Type,
1087	) SemaError!AbiAlignmentAdvanced {	1172	) SemaError!AbiAlignmentInner {
1088	// This code needs to be kept in sync with the equivalent switch prong	1173	// This code needs to be kept in sync with the equivalent switch prong
1089	// in abiSizeAdvanced.	1174	// in abiSizeInner.
1090	const code_align = Type.anyerror.abiAlignment(pt);	1175	const code_align = Type.anyerror.abiAlignment(zcu);
1091	switch (strat) {	1176	switch (strat) {
1092	.eager, .sema => {	1177	.eager, .sema => {
1093	if (!(payload_ty.hasRuntimeBitsAdvanced(pt, false, strat) catch \|err\| switch (err) {	1178	if (!(payload_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch \|err\| switch (err) {
1094	error.NeedLazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1179	error.NeedLazy => if (strat == .lazy) {
1095	.ty = .comptime_int_type,	1180	const pt = strat.pt(zcu, tid);
1096	.storage = .{ .lazy_align = ty.toIntern() },	1181	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1097	} })) },	1182	.ty = .comptime_int_type,
		1183	.storage = .{ .lazy_align = ty.toIntern() },
		1184	} })) };
		1185	} else unreachable,
1098	else => \|e\| return e,	1186	else => \|e\| return e,
1099	})) {	1187	})) {
1100	return .{ .scalar = code_align };	1188	return .{ .scalar = code_align };
1101	}	1189	}
1102	return .{ .scalar = code_align.max(	1190	return .{ .scalar = code_align.max(
1103	(try payload_ty.abiAlignmentAdvanced(pt, strat)).scalar,	1191	(try payload_ty.abiAlignmentInner(strat, zcu, tid)).scalar,
1104	) };	1192	) };
1105	},	1193	},
1106	.lazy => {	1194	.lazy => {
1107	switch (try payload_ty.abiAlignmentAdvanced(pt, strat)) {	1195	const pt = strat.pt(zcu, tid);
		1196	switch (try payload_ty.abiAlignmentInner(strat, zcu, tid)) {
1108	.scalar => \|payload_align\| return .{ .scalar = code_align.max(payload_align) },	1197	.scalar => \|payload_align\| return .{ .scalar = code_align.max(payload_align) },
1109	.val => {},	1198	.val => {},
1110	}	1199	}
...	@@ -1116,36 +1205,39 @@ fn abiAlignmentAdvancedErrorUnion(	...	@@ -1116,36 +1205,39 @@ fn abiAlignmentAdvancedErrorUnion(
1116	}	1205	}
1117	}	1206	}
1118		1207
1119	fn abiAlignmentAdvancedOptional(	1208	fn abiAlignmentInnerOptional(
1120	ty: Type,	1209	ty: Type,
1121	pt: Zcu.PerThread,
1122	comptime strat: ResolveStratLazy,	1210	comptime strat: ResolveStratLazy,
1123	) SemaError!AbiAlignmentAdvanced {	1211	zcu: *Zcu,
1124	const mod = pt.zcu;	1212	tid: strat.Tid(),
1125	const target = mod.getTarget();	1213	) SemaError!AbiAlignmentInner {
1126	const child_type = ty.optionalChild(mod);	1214	const pt = strat.pt(zcu, tid);
1127		1215	const target = zcu.getTarget();
1128	switch (child_type.zigTypeTag(mod)) {	1216	const child_type = ty.optionalChild(zcu);
		1217
		1218	switch (child_type.zigTypeTag(zcu)) {
1129	.Pointer => return .{ .scalar = ptrAbiAlignment(target) },	1219	.Pointer => return .{ .scalar = ptrAbiAlignment(target) },
1130	.ErrorSet => return Type.anyerror.abiAlignmentAdvanced(pt, strat),	1220	.ErrorSet => return Type.anyerror.abiAlignmentInner(strat, zcu, tid),
1131	.NoReturn => return .{ .scalar = .@"1" },	1221	.NoReturn => return .{ .scalar = .@"1" },
1132	else => {},	1222	else => {},
1133	}	1223	}
1134		1224
1135	switch (strat) {	1225	switch (strat) {
1136	.eager, .sema => {	1226	.eager, .sema => {
1137	if (!(child_type.hasRuntimeBitsAdvanced(pt, false, strat) catch \|err\| switch (err) {	1227	if (!(child_type.hasRuntimeBitsInner(false, strat, zcu, tid) catch \|err\| switch (err) {
1138	error.NeedLazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1228	error.NeedLazy => if (strat == .lazy) {
1139	.ty = .comptime_int_type,	1229	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1140	.storage = .{ .lazy_align = ty.toIntern() },	1230	.ty = .comptime_int_type,
1141	} })) },	1231	.storage = .{ .lazy_align = ty.toIntern() },
		1232	} })) };
		1233	} else unreachable,
1142	else => \|e\| return e,	1234	else => \|e\| return e,
1143	})) {	1235	})) {
1144	return .{ .scalar = .@"1" };	1236	return .{ .scalar = .@"1" };
1145	}	1237	}
1146	return child_type.abiAlignmentAdvanced(pt, strat);	1238	return child_type.abiAlignmentInner(strat, zcu, tid);
1147	},	1239	},
1148	.lazy => switch (try child_type.abiAlignmentAdvanced(pt, strat)) {	1240	.lazy => switch (try child_type.abiAlignmentInner(strat, zcu, tid)) {
1149	.scalar => \|x\| return .{ .scalar = x.max(.@"1") },	1241	.scalar => \|x\| return .{ .scalar = x.max(.@"1") },
1150	.val => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1242	.val => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1151	.ty = .comptime_int_type,	1243	.ty = .comptime_int_type,
...	@@ -1155,40 +1247,44 @@ fn abiAlignmentAdvancedOptional(	...	@@ -1155,40 +1247,44 @@ fn abiAlignmentAdvancedOptional(
1155	}	1247	}
1156	}	1248	}
1157		1249
		1250	const AbiSizeInner = union(enum) {
		1251	scalar: u64,
		1252	val: Value,
		1253	};
		1254
		1255	/// Asserts the type has the ABI size already resolved.
		1256	/// Types that return false for hasRuntimeBits() return 0.
		1257	pub fn abiSize(ty: Type, zcu: *Zcu) u64 {
		1258	return (abiSizeInner(ty, .eager, zcu, {}) catch unreachable).scalar;
		1259	}
		1260
1158	/// May capture a reference to `ty`.	1261	/// May capture a reference to `ty`.
1159	pub fn lazyAbiSize(ty: Type, pt: Zcu.PerThread) !Value {	1262	pub fn abiSizeLazy(ty: Type, pt: Zcu.PerThread) !Value {
1160	switch (try ty.abiSizeAdvanced(pt, .lazy)) {	1263	switch (try ty.abiSizeInner(.lazy, pt.zcu, pt.tid)) {
1161	.val => \|val\| return val,	1264	.val => \|val\| return val,
1162	.scalar => \|x\| return pt.intValue(Type.comptime_int, x),	1265	.scalar => \|x\| return pt.intValue(Type.comptime_int, x),
1163	}	1266	}
1164	}	1267	}
1165		1268
1166	/// Asserts the type has the ABI size already resolved.	1269	pub fn abiSizeSema(ty: Type, pt: Zcu.PerThread) SemaError!u64 {
1167	/// Types that return false for hasRuntimeBits() return 0.	1270	return (try abiSizeInner(ty, .sema, pt.zcu, pt.tid)).scalar;
1168	pub fn abiSize(ty: Type, pt: Zcu.PerThread) u64 {
1169	return (abiSizeAdvanced(ty, pt, .eager) catch unreachable).scalar;
1170	}	1271	}
1171		1272
1172	const AbiSizeAdvanced = union(enum) {
1173	scalar: u64,
1174	val: Value,
1175	};
1176
1177	/// If you pass `eager` you will get back `scalar` and assert the type is resolved.	1273	/// If you pass `eager` you will get back `scalar` and assert the type is resolved.
1178	/// In this case there will be no error, guaranteed.	1274	/// In this case there will be no error, guaranteed.
1179	/// If you pass `lazy` you may get back `scalar` or `val`.	1275	/// If you pass `lazy` you may get back `scalar` or `val`.
1180	/// If `val` is returned, a reference to `ty` has been captured.	1276	/// If `val` is returned, a reference to `ty` has been captured.
1181	/// If you pass `sema` you will get back `scalar` and resolve the type if	1277	/// If you pass `sema` you will get back `scalar` and resolve the type if
1182	/// necessary, possibly returning a CompileError.	1278	/// necessary, possibly returning a CompileError.
1183	pub fn abiSizeAdvanced(	1279	pub fn abiSizeInner(
1184	ty: Type,	1280	ty: Type,
1185	pt: Zcu.PerThread,
1186	comptime strat: ResolveStratLazy,	1281	comptime strat: ResolveStratLazy,
1187	) SemaError!AbiSizeAdvanced {	1282	zcu: *Zcu,
1188	const mod = pt.zcu;	1283	tid: strat.Tid(),
1189	const target = mod.getTarget();	1284	) SemaError!AbiSizeInner {
1190	const use_llvm = mod.comp.config.use_llvm;	1285	const target = zcu.getTarget();
1191	const ip = &mod.intern_pool;	1286	const use_llvm = zcu.comp.config.use_llvm;
		1287	const ip = &zcu.intern_pool;
1192		1288
1193	switch (ty.toIntern()) {	1289	switch (ty.toIntern()) {
1194	.empty_struct_type => return .{ .scalar = 0 },	1290	.empty_struct_type => return .{ .scalar = 0 },
...	@@ -1207,14 +1303,17 @@ pub fn abiSizeAdvanced(	...	@@ -1207,14 +1303,17 @@ pub fn abiSizeAdvanced(
1207	.array_type => \|array_type\| {	1303	.array_type => \|array_type\| {
1208	const len = array_type.lenIncludingSentinel();	1304	const len = array_type.lenIncludingSentinel();
1209	if (len == 0) return .{ .scalar = 0 };	1305	if (len == 0) return .{ .scalar = 0 };
1210	switch (try Type.fromInterned(array_type.child).abiSizeAdvanced(pt, strat)) {	1306	switch (try Type.fromInterned(array_type.child).abiSizeInner(strat, zcu, tid)) {
1211	.scalar => \|elem_size\| return .{ .scalar = len * elem_size },	1307	.scalar => \|elem_size\| return .{ .scalar = len * elem_size },
1212	.val => switch (strat) {	1308	.val => switch (strat) {
1213	.sema, .eager => unreachable,	1309	.sema, .eager => unreachable,
1214	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1310	.lazy => {
1215	.ty = .comptime_int_type,	1311	const pt = strat.pt(zcu, tid);
1216	.storage = .{ .lazy_size = ty.toIntern() },	1312	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1217	} })) },	1313	.ty = .comptime_int_type,
		1314	.storage = .{ .lazy_size = ty.toIntern() },
		1315	} })) };
		1316	},
1218	},	1317	},
1219	}	1318	}
1220	},	1319	},
...	@@ -1222,41 +1321,38 @@ pub fn abiSizeAdvanced(	...	@@ -1222,41 +1321,38 @@ pub fn abiSizeAdvanced(
1222	const sub_strat: ResolveStrat = switch (strat) {	1321	const sub_strat: ResolveStrat = switch (strat) {
1223	.sema => .sema,	1322	.sema => .sema,
1224	.eager => .normal,	1323	.eager => .normal,
1225	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1324	.lazy => {
1226	.ty = .comptime_int_type,	1325	const pt = strat.pt(zcu, tid);
1227	.storage = .{ .lazy_size = ty.toIntern() },	1326	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1228	} })) },	1327	.ty = .comptime_int_type,
1229	};	1328	.storage = .{ .lazy_size = ty.toIntern() },
1230	const alignment = switch (try ty.abiAlignmentAdvanced(pt, strat)) {	1329	} })) };
1231	.scalar => \|x\| x,	1330	},
1232	.val => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1233	.ty = .comptime_int_type,
1234	.storage = .{ .lazy_size = ty.toIntern() },
1235	} })) },
1236	};	1331	};
1237	const total_bytes = switch (mod.comp.getZigBackend()) {	1332	const alignment = (try ty.abiAlignmentInner(strat, zcu, tid)).scalar;
		1333	const total_bytes = switch (zcu.comp.getZigBackend()) {
1238	else => total_bytes: {	1334	else => total_bytes: {
1239	const elem_bits = try Type.fromInterned(vector_type.child).bitSizeAdvanced(pt, sub_strat);	1335	const elem_bits = try Type.fromInterned(vector_type.child).bitSizeInner(sub_strat, zcu, tid);
1240	const total_bits = elem_bits * vector_type.len;	1336	const total_bits = elem_bits * vector_type.len;
1241	break :total_bytes (total_bits + 7) / 8;	1337	break :total_bytes (total_bits + 7) / 8;
1242	},	1338	},
1243	.stage2_c => total_bytes: {	1339	.stage2_c => total_bytes: {
1244	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeAdvanced(pt, strat)).scalar);	1340	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
1245	break :total_bytes elem_bytes * vector_type.len;	1341	break :total_bytes elem_bytes * vector_type.len;
1246	},	1342	},
1247	.stage2_x86_64 => total_bytes: {	1343	.stage2_x86_64 => total_bytes: {
1248	if (vector_type.child == .bool_type) break :total_bytes std.math.divCeil(u32, vector_type.len, 8) catch unreachable;	1344	if (vector_type.child == .bool_type) break :total_bytes std.math.divCeil(u32, vector_type.len, 8) catch unreachable;
1249	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeAdvanced(pt, strat)).scalar);	1345	const elem_bytes: u32 = @intCast((try Type.fromInterned(vector_type.child).abiSizeInner(strat, zcu, tid)).scalar);
1250	break :total_bytes elem_bytes * vector_type.len;	1346	break :total_bytes elem_bytes * vector_type.len;
1251	},	1347	},
1252	};	1348	};
1253	return .{ .scalar = alignment.forward(total_bytes) };	1349	return .{ .scalar = alignment.forward(total_bytes) };
1254	},	1350	},
1255		1351
1256	.opt_type => return ty.abiSizeAdvancedOptional(pt, strat),	1352	.opt_type => return ty.abiSizeInnerOptional(strat, zcu, tid),
1257		1353
1258	.error_set_type, .inferred_error_set_type => {	1354	.error_set_type, .inferred_error_set_type => {
1259	const bits = mod.errorSetBits();	1355	const bits = zcu.errorSetBits();
1260	if (bits == 0) return .{ .scalar = 0 };	1356	if (bits == 0) return .{ .scalar = 0 };
1261	return .{ .scalar = intAbiSize(bits, target, use_llvm) };	1357	return .{ .scalar = intAbiSize(bits, target, use_llvm) };
1262	},	1358	},
...	@@ -1264,29 +1360,35 @@ pub fn abiSizeAdvanced(	...	@@ -1264,29 +1360,35 @@ pub fn abiSizeAdvanced(
1264	.error_union_type => \|error_union_type\| {	1360	.error_union_type => \|error_union_type\| {
1265	const payload_ty = Type.fromInterned(error_union_type.payload_type);	1361	const payload_ty = Type.fromInterned(error_union_type.payload_type);
1266	// This code needs to be kept in sync with the equivalent switch prong	1362	// This code needs to be kept in sync with the equivalent switch prong
1267	// in abiAlignmentAdvanced.	1363	// in abiAlignmentInner.
1268	const code_size = Type.anyerror.abiSize(pt);	1364	const code_size = Type.anyerror.abiSize(zcu);
1269	if (!(payload_ty.hasRuntimeBitsAdvanced(pt, false, strat) catch \|err\| switch (err) {	1365	if (!(payload_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch \|err\| switch (err) {
1270	error.NeedLazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1366	error.NeedLazy => if (strat == .lazy) {
1271	.ty = .comptime_int_type,	1367	const pt = strat.pt(zcu, tid);
1272	.storage = .{ .lazy_size = ty.toIntern() },	1368	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1273	} })) },	1369	.ty = .comptime_int_type,
		1370	.storage = .{ .lazy_size = ty.toIntern() },
		1371	} })) };
		1372	} else unreachable,
1274	else => \|e\| return e,	1373	else => \|e\| return e,
1275	})) {	1374	})) {
1276	// Same as anyerror.	1375	// Same as anyerror.
1277	return .{ .scalar = code_size };	1376	return .{ .scalar = code_size };
1278	}	1377	}
1279	const code_align = Type.anyerror.abiAlignment(pt);	1378	const code_align = Type.anyerror.abiAlignment(zcu);
1280	const payload_align = payload_ty.abiAlignment(pt);	1379	const payload_align = (try payload_ty.abiAlignmentInner(strat, zcu, tid)).scalar;
1281	const payload_size = switch (try payload_ty.abiSizeAdvanced(pt, strat)) {	1380	const payload_size = switch (try payload_ty.abiSizeInner(strat, zcu, tid)) {
1282	.scalar => \|elem_size\| elem_size,	1381	.scalar => \|elem_size\| elem_size,
1283	.val => switch (strat) {	1382	.val => switch (strat) {
1284	.sema => unreachable,	1383	.sema => unreachable,
1285	.eager => unreachable,	1384	.eager => unreachable,
1286	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1385	.lazy => {
1287	.ty = .comptime_int_type,	1386	const pt = strat.pt(zcu, tid);
1288	.storage = .{ .lazy_size = ty.toIntern() },	1387	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1289	} })) },	1388	.ty = .comptime_int_type,
		1389	.storage = .{ .lazy_size = ty.toIntern() },
		1390	} })) };
		1391	},
1290	},	1392	},
1291	};	1393	};
1292		1394
...	@@ -1314,7 +1416,7 @@ pub fn abiSizeAdvanced(	...	@@ -1314,7 +1416,7 @@ pub fn abiSizeAdvanced(
1314	.f128 => return .{ .scalar = 16 },	1416	.f128 => return .{ .scalar = 16 },
1315	.f80 => switch (target.cTypeBitSize(.longdouble)) {	1417	.f80 => switch (target.cTypeBitSize(.longdouble)) {
1316	80 => return .{ .scalar = target.cTypeByteSize(.longdouble) },	1418	80 => return .{ .scalar = target.cTypeByteSize(.longdouble) },
1317	else => return .{ .scalar = Type.u80.abiSize(pt) },	1419	else => return .{ .scalar = Type.u80.abiSize(zcu) },
1318	},	1420	},
1319		1421
1320	.usize,	1422	.usize,
...	@@ -1343,7 +1445,7 @@ pub fn abiSizeAdvanced(	...	@@ -1343,7 +1445,7 @@ pub fn abiSizeAdvanced(
1343	=> return .{ .scalar = 0 },	1445	=> return .{ .scalar = 0 },
1344		1446
1345	.anyerror, .adhoc_inferred_error_set => {	1447	.anyerror, .adhoc_inferred_error_set => {
1346	const bits = mod.errorSetBits();	1448	const bits = zcu.errorSetBits();
1347	if (bits == 0) return .{ .scalar = 0 };	1449	if (bits == 0) return .{ .scalar = 0 };
1348	return .{ .scalar = intAbiSize(bits, target, use_llvm) };	1450	return .{ .scalar = intAbiSize(bits, target, use_llvm) };
1349	},	1451	},
...	@@ -1354,30 +1456,33 @@ pub fn abiSizeAdvanced(	...	@@ -1354,30 +1456,33 @@ pub fn abiSizeAdvanced(
1354	.struct_type => {	1456	.struct_type => {
1355	const struct_type = ip.loadStructType(ty.toIntern());	1457	const struct_type = ip.loadStructType(ty.toIntern());
1356	switch (strat) {	1458	switch (strat) {
1357	.sema => try ty.resolveLayout(pt),	1459	.sema => try ty.resolveLayout(strat.pt(zcu, tid)),
1358	.lazy => switch (struct_type.layout) {	1460	.lazy => {
1359	.@"packed" => {	1461	const pt = strat.pt(zcu, tid);
1360	if (struct_type.backingIntTypeUnordered(ip) == .none) return .{	1462	switch (struct_type.layout) {
1361	.val = Value.fromInterned(try pt.intern(.{ .int = .{	1463	.@"packed" => {
1362	.ty = .comptime_int_type,	1464	if (struct_type.backingIntTypeUnordered(ip) == .none) return .{
1363	.storage = .{ .lazy_size = ty.toIntern() },	1465	.val = Value.fromInterned(try pt.intern(.{ .int = .{
1364	} })),	1466	.ty = .comptime_int_type,
1365	};	1467	.storage = .{ .lazy_size = ty.toIntern() },
1366	},	1468	} })),
1367	.auto, .@"extern" => {	1469	};
1368	if (!struct_type.haveLayout(ip)) return .{	1470	},
1369	.val = Value.fromInterned(try pt.intern(.{ .int = .{	1471	.auto, .@"extern" => {
1370	.ty = .comptime_int_type,	1472	if (!struct_type.haveLayout(ip)) return .{
1371	.storage = .{ .lazy_size = ty.toIntern() },	1473	.val = Value.fromInterned(try pt.intern(.{ .int = .{
1372	} })),	1474	.ty = .comptime_int_type,
1373	};	1475	.storage = .{ .lazy_size = ty.toIntern() },
1374	},	1476	} })),
		1477	};
		1478	},
		1479	}
1375	},	1480	},
1376	.eager => {},	1481	.eager => {},
1377	}	1482	}
1378	switch (struct_type.layout) {	1483	switch (struct_type.layout) {
1379	.@"packed" => return .{	1484	.@"packed" => return .{
1380	.scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiSize(pt),	1485	.scalar = Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).abiSize(zcu),
1381	},	1486	},
1382	.auto, .@"extern" => {	1487	.auto, .@"extern" => {
1383	assert(struct_type.haveLayout(ip));	1488	assert(struct_type.haveLayout(ip));
...	@@ -1387,25 +1492,28 @@ pub fn abiSizeAdvanced(	...	@@ -1387,25 +1492,28 @@ pub fn abiSizeAdvanced(
1387	},	1492	},
1388	.anon_struct_type => \|tuple\| {	1493	.anon_struct_type => \|tuple\| {
1389	switch (strat) {	1494	switch (strat) {
1390	.sema => try ty.resolveLayout(pt),	1495	.sema => try ty.resolveLayout(strat.pt(zcu, tid)),
1391	.lazy, .eager => {},	1496	.lazy, .eager => {},
1392	}	1497	}
1393	const field_count = tuple.types.len;	1498	const field_count = tuple.types.len;
1394	if (field_count == 0) {	1499	if (field_count == 0) {
1395	return .{ .scalar = 0 };	1500	return .{ .scalar = 0 };
1396	}	1501	}
1397	return .{ .scalar = ty.structFieldOffset(field_count, pt) };	1502	return .{ .scalar = ty.structFieldOffset(field_count, zcu) };
1398	},	1503	},
1399		1504
1400	.union_type => {	1505	.union_type => {
1401	const union_type = ip.loadUnionType(ty.toIntern());	1506	const union_type = ip.loadUnionType(ty.toIntern());
1402	switch (strat) {	1507	switch (strat) {
1403	.sema => try ty.resolveLayout(pt),	1508	.sema => try ty.resolveLayout(strat.pt(zcu, tid)),
1404	.lazy => if (!union_type.flagsUnordered(ip).status.haveLayout()) return .{	1509	.lazy => {
1405	.val = Value.fromInterned(try pt.intern(.{ .int = .{	1510	const pt = strat.pt(zcu, tid);
1406	.ty = .comptime_int_type,	1511	if (!union_type.flagsUnordered(ip).status.haveLayout()) return .{
1407	.storage = .{ .lazy_size = ty.toIntern() },	1512	.val = Value.fromInterned(try pt.intern(.{ .int = .{
1408	} })),	1513	.ty = .comptime_int_type,
		1514	.storage = .{ .lazy_size = ty.toIntern() },
		1515	} })),
		1516	};
1409	},	1517	},
1410	.eager => {},	1518	.eager => {},
1411	}	1519	}
...	@@ -1414,7 +1522,7 @@ pub fn abiSizeAdvanced(	...	@@ -1414,7 +1522,7 @@ pub fn abiSizeAdvanced(
1414	return .{ .scalar = union_type.sizeUnordered(ip) };	1522	return .{ .scalar = union_type.sizeUnordered(ip) };
1415	},	1523	},
1416	.opaque_type => unreachable, // no size available	1524	.opaque_type => unreachable, // no size available
1417	.enum_type => return .{ .scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiSize(pt) },	1525	.enum_type => return .{ .scalar = Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).abiSize(zcu) },
1418		1526
1419	// values, not types	1527	// values, not types
1420	.undef,	1528	.undef,
...	@@ -1441,36 +1549,39 @@ pub fn abiSizeAdvanced(	...	@@ -1441,36 +1549,39 @@ pub fn abiSizeAdvanced(
1441	}	1549	}
1442	}	1550	}
1443		1551
1444	fn abiSizeAdvancedOptional(	1552	fn abiSizeInnerOptional(
1445	ty: Type,	1553	ty: Type,
1446	pt: Zcu.PerThread,
1447	comptime strat: ResolveStratLazy,	1554	comptime strat: ResolveStratLazy,
1448	) SemaError!AbiSizeAdvanced {	1555	zcu: *Zcu,
1449	const mod = pt.zcu;	1556	tid: strat.Tid(),
1450	const child_ty = ty.optionalChild(mod);	1557	) SemaError!AbiSizeInner {
		1558	const child_ty = ty.optionalChild(zcu);
1451		1559
1452	if (child_ty.isNoReturn(mod)) {	1560	if (child_ty.isNoReturn(zcu)) {
1453	return .{ .scalar = 0 };	1561	return .{ .scalar = 0 };
1454	}	1562	}
1455		1563
1456	if (!(child_ty.hasRuntimeBitsAdvanced(pt, false, strat) catch \|err\| switch (err) {	1564	if (!(child_ty.hasRuntimeBitsInner(false, strat, zcu, tid) catch \|err\| switch (err) {
1457	error.NeedLazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1565	error.NeedLazy => if (strat == .lazy) {
1458	.ty = .comptime_int_type,	1566	const pt = strat.pt(zcu, tid);
1459	.storage = .{ .lazy_size = ty.toIntern() },	1567	return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{
1460	} })) },	1568	.ty = .comptime_int_type,
		1569	.storage = .{ .lazy_size = ty.toIntern() },
		1570	} })) };
		1571	} else unreachable,
1461	else => \|e\| return e,	1572	else => \|e\| return e,
1462	})) return .{ .scalar = 1 };	1573	})) return .{ .scalar = 1 };
1463		1574
1464	if (ty.optionalReprIsPayload(mod)) {	1575	if (ty.optionalReprIsPayload(zcu)) {
1465	return child_ty.abiSizeAdvanced(pt, strat);	1576	return child_ty.abiSizeInner(strat, zcu, tid);
1466	}	1577	}
1467		1578
1468	const payload_size = switch (try child_ty.abiSizeAdvanced(pt, strat)) {	1579	const payload_size = switch (try child_ty.abiSizeInner(strat, zcu, tid)) {
1469	.scalar => \|elem_size\| elem_size,	1580	.scalar => \|elem_size\| elem_size,
1470	.val => switch (strat) {	1581	.val => switch (strat) {
1471	.sema => unreachable,	1582	.sema => unreachable,
1472	.eager => unreachable,	1583	.eager => unreachable,
1473	.lazy => return .{ .val = Value.fromInterned(try pt.intern(.{ .int = .{	1584	.lazy => return .{ .val = Value.fromInterned(try strat.pt(zcu, tid).intern(.{ .int = .{
1474	.ty = .comptime_int_type,	1585	.ty = .comptime_int_type,
1475	.storage = .{ .lazy_size = ty.toIntern() },	1586	.storage = .{ .lazy_size = ty.toIntern() },
1476	} })) },	1587	} })) },
...	@@ -1482,7 +1593,7 @@ fn abiSizeAdvancedOptional(	...	@@ -1482,7 +1593,7 @@ fn abiSizeAdvancedOptional(
1482	// guaranteed to be >= that of bool's (1 byte) the added size is exactly equal	1593	// guaranteed to be >= that of bool's (1 byte) the added size is exactly equal
1483	// to the child type's ABI alignment.	1594	// to the child type's ABI alignment.
1484	return .{	1595	return .{
1485	.scalar = (child_ty.abiAlignment(pt).toByteUnits() orelse 0) + payload_size,	1596	.scalar = (child_ty.abiAlignment(zcu).toByteUnits() orelse 0) + payload_size,
1486	};	1597	};
1487	}	1598	}
1488		1599
...	@@ -1600,18 +1711,22 @@ pub fn maxIntAlignment(target: std.Target, use_llvm: bool) u16 {	...	@@ -1600,18 +1711,22 @@ pub fn maxIntAlignment(target: std.Target, use_llvm: bool) u16 {
1600	};	1711	};
1601	}	1712	}
1602		1713
1603	pub fn bitSize(ty: Type, pt: Zcu.PerThread) u64 {	1714	pub fn bitSize(ty: Type, zcu: *Zcu) u64 {
1604	return bitSizeAdvanced(ty, pt, .normal) catch unreachable;	1715	return bitSizeInner(ty, .normal, zcu, {}) catch unreachable;
1605	}	1716	}
1606		1717
1607	pub fn bitSizeAdvanced(	1718	pub fn bitSizeSema(ty: Type, pt: Zcu.PerThread) SemaError!u64 {
		1719	return bitSizeInner(ty, .sema, pt.zcu, pt.tid);
		1720	}
		1721
		1722	pub fn bitSizeInner(
1608	ty: Type,	1723	ty: Type,
1609	pt: Zcu.PerThread,
1610	comptime strat: ResolveStrat,	1724	comptime strat: ResolveStrat,
		1725	zcu: *Zcu,
		1726	tid: strat.Tid(),
1611	) SemaError!u64 {	1727	) SemaError!u64 {
1612	const mod = pt.zcu;	1728	const target = zcu.getTarget();
1613	const target = mod.getTarget();	1729	const ip = &zcu.intern_pool;
1614	const ip = &mod.intern_pool;
1615		1730
1616	const strat_lazy: ResolveStratLazy = strat.toLazy();	1731	const strat_lazy: ResolveStratLazy = strat.toLazy();
1617		1732
...	@@ -1628,30 +1743,30 @@ pub fn bitSizeAdvanced(	...	@@ -1628,30 +1743,30 @@ pub fn bitSizeAdvanced(
1628	if (len == 0) return 0;	1743	if (len == 0) return 0;
1629	const elem_ty = Type.fromInterned(array_type.child);	1744	const elem_ty = Type.fromInterned(array_type.child);
1630	const elem_size = @max(	1745	const elem_size = @max(
1631	(try elem_ty.abiAlignmentAdvanced(pt, strat_lazy)).scalar.toByteUnits() orelse 0,	1746	(try elem_ty.abiAlignmentInner(strat_lazy, zcu, tid)).scalar.toByteUnits() orelse 0,
1632	(try elem_ty.abiSizeAdvanced(pt, strat_lazy)).scalar,	1747	(try elem_ty.abiSizeInner(strat_lazy, zcu, tid)).scalar,
1633	);	1748	);
1634	if (elem_size == 0) return 0;	1749	if (elem_size == 0) return 0;
1635	const elem_bit_size = try elem_ty.bitSizeAdvanced(pt, strat);	1750	const elem_bit_size = try elem_ty.bitSizeInner(strat, zcu, tid);
1636	return (len - 1) * 8 * elem_size + elem_bit_size;	1751	return (len - 1) * 8 * elem_size + elem_bit_size;
1637	},	1752	},
1638	.vector_type => \|vector_type\| {	1753	.vector_type => \|vector_type\| {
1639	const child_ty = Type.fromInterned(vector_type.child);	1754	const child_ty = Type.fromInterned(vector_type.child);
1640	const elem_bit_size = try child_ty.bitSizeAdvanced(pt, strat);	1755	const elem_bit_size = try child_ty.bitSizeInner(strat, zcu, tid);
1641	return elem_bit_size * vector_type.len;	1756	return elem_bit_size * vector_type.len;
1642	},	1757	},
1643	.opt_type => {	1758	.opt_type => {
1644	// Optionals and error unions are not packed so their bitsize	1759	// Optionals and error unions are not packed so their bitsize
1645	// includes padding bits.	1760	// includes padding bits.
1646	return (try ty.abiSizeAdvanced(pt, strat_lazy)).scalar * 8;	1761	return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
1647	},	1762	},
1648		1763
1649	.error_set_type, .inferred_error_set_type => return mod.errorSetBits(),	1764	.error_set_type, .inferred_error_set_type => return zcu.errorSetBits(),
1650		1765
1651	.error_union_type => {	1766	.error_union_type => {
1652	// Optionals and error unions are not packed so their bitsize	1767	// Optionals and error unions are not packed so their bitsize
1653	// includes padding bits.	1768	// includes padding bits.
1654	return (try ty.abiSizeAdvanced(pt, strat_lazy)).scalar * 8;	1769	return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
1655	},	1770	},
1656	.func_type => unreachable, // represents machine code; not a pointer	1771	.func_type => unreachable, // represents machine code; not a pointer
1657	.simple_type => \|t\| switch (t) {	1772	.simple_type => \|t\| switch (t) {
...	@@ -1681,7 +1796,7 @@ pub fn bitSizeAdvanced(	...	@@ -1681,7 +1796,7 @@ pub fn bitSizeAdvanced(
1681		1796
1682	.anyerror,	1797	.anyerror,
1683	.adhoc_inferred_error_set,	1798	.adhoc_inferred_error_set,
1684	=> return mod.errorSetBits(),	1799	=> return zcu.errorSetBits(),
1685		1800
1686	.anyopaque => unreachable,	1801	.anyopaque => unreachable,
1687	.type => unreachable,	1802	.type => unreachable,
...	@@ -1697,42 +1812,46 @@ pub fn bitSizeAdvanced(	...	@@ -1697,42 +1812,46 @@ pub fn bitSizeAdvanced(
1697	const struct_type = ip.loadStructType(ty.toIntern());	1812	const struct_type = ip.loadStructType(ty.toIntern());
1698	const is_packed = struct_type.layout == .@"packed";	1813	const is_packed = struct_type.layout == .@"packed";
1699	if (strat == .sema) {	1814	if (strat == .sema) {
		1815	const pt = strat.pt(zcu, tid);
1700	try ty.resolveFields(pt);	1816	try ty.resolveFields(pt);
1701	if (is_packed) try ty.resolveLayout(pt);	1817	if (is_packed) try ty.resolveLayout(pt);
1702	}	1818	}
1703	if (is_packed) {	1819	if (is_packed) {
1704	return try Type.fromInterned(struct_type.backingIntTypeUnordered(ip)).bitSizeAdvanced(pt, strat);	1820	return try Type.fromInterned(struct_type.backingIntTypeUnordered(ip))
		1821	.bitSizeInner(strat, zcu, tid);
1705	}	1822	}
1706	return (try ty.abiSizeAdvanced(pt, strat_lazy)).scalar * 8;	1823	return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
1707	},	1824	},
1708		1825
1709	.anon_struct_type => {	1826	.anon_struct_type => {
1710	if (strat == .sema) try ty.resolveFields(pt);	1827	if (strat == .sema) try ty.resolveFields(strat.pt(zcu, tid));
1711	return (try ty.abiSizeAdvanced(pt, strat_lazy)).scalar * 8;	1828	return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
1712	},	1829	},
1713		1830
1714	.union_type => {	1831	.union_type => {
1715	const union_type = ip.loadUnionType(ty.toIntern());	1832	const union_type = ip.loadUnionType(ty.toIntern());
1716	const is_packed = ty.containerLayout(mod) == .@"packed";	1833	const is_packed = ty.containerLayout(zcu) == .@"packed";
1717	if (strat == .sema) {	1834	if (strat == .sema) {
		1835	const pt = strat.pt(zcu, tid);
1718	try ty.resolveFields(pt);	1836	try ty.resolveFields(pt);
1719	if (is_packed) try ty.resolveLayout(pt);	1837	if (is_packed) try ty.resolveLayout(pt);
1720	}	1838	}
1721	if (!is_packed) {	1839	if (!is_packed) {
1722	return (try ty.abiSizeAdvanced(pt, strat_lazy)).scalar * 8;	1840	return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
1723	}	1841	}
1724	assert(union_type.flagsUnordered(ip).status.haveFieldTypes());	1842	assert(union_type.flagsUnordered(ip).status.haveFieldTypes());
1725		1843
1726	var size: u64 = 0;	1844	var size: u64 = 0;
1727	for (0..union_type.field_types.len) \|field_index\| {	1845	for (0..union_type.field_types.len) \|field_index\| {
1728	const field_ty = union_type.field_types.get(ip)[field_index];	1846	const field_ty = union_type.field_types.get(ip)[field_index];
1729	size = @max(size, try Type.fromInterned(field_ty).bitSizeAdvanced(pt, strat));	1847	size = @max(size, try Type.fromInterned(field_ty).bitSizeInner(strat, zcu, tid));
1730	}	1848	}
1731		1849
1732	return size;	1850	return size;
1733	},	1851	},
1734	.opaque_type => unreachable,	1852	.opaque_type => unreachable,
1735	.enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).bitSizeAdvanced(pt, strat),	1853	.enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty)
		1854	.bitSizeInner(strat, zcu, tid),
1736		1855
1737	// values, not types	1856	// values, not types
1738	.undef,	1857	.undef,
...	@@ -1760,61 +1879,61 @@ pub fn bitSizeAdvanced(	...	@@ -1760,61 +1879,61 @@ pub fn bitSizeAdvanced(
1760		1879
1761	/// Returns true if the type's layout is already resolved and it is safe	1880	/// Returns true if the type's layout is already resolved and it is safe
1762	/// to use `abiSize`, `abiAlignment` and `bitSize` on it.	1881	/// to use `abiSize`, `abiAlignment` and `bitSize` on it.
1763	pub fn layoutIsResolved(ty: Type, mod: *Module) bool {	1882	pub fn layoutIsResolved(ty: Type, zcu: *const Zcu) bool {
1764	const ip = &mod.intern_pool;	1883	const ip = &zcu.intern_pool;
1765	return switch (ip.indexToKey(ty.toIntern())) {	1884	return switch (ip.indexToKey(ty.toIntern())) {
1766	.struct_type => ip.loadStructType(ty.toIntern()).haveLayout(ip),	1885	.struct_type => ip.loadStructType(ty.toIntern()).haveLayout(ip),
1767	.union_type => ip.loadUnionType(ty.toIntern()).haveLayout(ip),	1886	.union_type => ip.loadUnionType(ty.toIntern()).haveLayout(ip),
1768	.array_type => \|array_type\| {	1887	.array_type => \|array_type\| {
1769	if (array_type.lenIncludingSentinel() == 0) return true;	1888	if (array_type.lenIncludingSentinel() == 0) return true;
1770	return Type.fromInterned(array_type.child).layoutIsResolved(mod);	1889	return Type.fromInterned(array_type.child).layoutIsResolved(zcu);
1771	},	1890	},
1772	.opt_type => \|child\| Type.fromInterned(child).layoutIsResolved(mod),	1891	.opt_type => \|child\| Type.fromInterned(child).layoutIsResolved(zcu),
1773	.error_union_type => \|k\| Type.fromInterned(k.payload_type).layoutIsResolved(mod),	1892	.error_union_type => \|k\| Type.fromInterned(k.payload_type).layoutIsResolved(zcu),
1774	else => true,	1893	else => true,
1775	};	1894	};
1776	}	1895	}
1777		1896
1778	pub fn isSinglePointer(ty: Type, mod: *const Module) bool {	1897	pub fn isSinglePointer(ty: Type, zcu: *const Zcu) bool {
1779	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1898	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1780	.ptr_type => \|ptr_info\| ptr_info.flags.size == .One,	1899	.ptr_type => \|ptr_info\| ptr_info.flags.size == .One,
1781	else => false,	1900	else => false,
1782	};	1901	};
1783	}	1902	}
1784		1903
1785	/// Asserts `ty` is a pointer.	1904	/// Asserts `ty` is a pointer.
1786	pub fn ptrSize(ty: Type, mod: *const Module) std.builtin.Type.Pointer.Size {	1905	pub fn ptrSize(ty: Type, zcu: *const Zcu) std.builtin.Type.Pointer.Size {
1787	return ty.ptrSizeOrNull(mod).?;	1906	return ty.ptrSizeOrNull(zcu).?;
1788	}	1907	}
1789		1908
1790	/// Returns `null` if `ty` is not a pointer.	1909	/// Returns `null` if `ty` is not a pointer.
1791	pub fn ptrSizeOrNull(ty: Type, mod: *const Module) ?std.builtin.Type.Pointer.Size {	1910	pub fn ptrSizeOrNull(ty: Type, zcu: *const Zcu) ?std.builtin.Type.Pointer.Size {
1792	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1911	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1793	.ptr_type => \|ptr_info\| ptr_info.flags.size,	1912	.ptr_type => \|ptr_info\| ptr_info.flags.size,
1794	else => null,	1913	else => null,
1795	};	1914	};
1796	}	1915	}
1797		1916
1798	pub fn isSlice(ty: Type, mod: *const Module) bool {	1917	pub fn isSlice(ty: Type, zcu: *const Zcu) bool {
1799	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1918	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1800	.ptr_type => \|ptr_type\| ptr_type.flags.size == .Slice,	1919	.ptr_type => \|ptr_type\| ptr_type.flags.size == .Slice,
1801	else => false,	1920	else => false,
1802	};	1921	};
1803	}	1922	}
1804		1923
1805	pub fn slicePtrFieldType(ty: Type, mod: *const Module) Type {	1924	pub fn slicePtrFieldType(ty: Type, zcu: *const Zcu) Type {
1806	return Type.fromInterned(mod.intern_pool.slicePtrType(ty.toIntern()));	1925	return Type.fromInterned(zcu.intern_pool.slicePtrType(ty.toIntern()));
1807	}	1926	}
1808		1927
1809	pub fn isConstPtr(ty: Type, mod: *const Module) bool {	1928	pub fn isConstPtr(ty: Type, zcu: *const Zcu) bool {
1810	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1929	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1811	.ptr_type => \|ptr_type\| ptr_type.flags.is_const,	1930	.ptr_type => \|ptr_type\| ptr_type.flags.is_const,
1812	else => false,	1931	else => false,
1813	};	1932	};
1814	}	1933	}
1815		1934
1816	pub fn isVolatilePtr(ty: Type, mod: *const Module) bool {	1935	pub fn isVolatilePtr(ty: Type, zcu: *const Zcu) bool {
1817	return isVolatilePtrIp(ty, &mod.intern_pool);	1936	return isVolatilePtrIp(ty, &zcu.intern_pool);
1818	}	1937	}
1819		1938
1820	pub fn isVolatilePtrIp(ty: Type, ip: *const InternPool) bool {	1939	pub fn isVolatilePtrIp(ty: Type, ip: *const InternPool) bool {
...	@@ -1824,28 +1943,28 @@ pub fn isVolatilePtrIp(ty: Type, ip: *const InternPool) bool {	...	@@ -1824,28 +1943,28 @@ pub fn isVolatilePtrIp(ty: Type, ip: *const InternPool) bool {
1824	};	1943	};
1825	}	1944	}
1826		1945
1827	pub fn isAllowzeroPtr(ty: Type, mod: *const Module) bool {	1946	pub fn isAllowzeroPtr(ty: Type, zcu: *const Zcu) bool {
1828	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1947	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1829	.ptr_type => \|ptr_type\| ptr_type.flags.is_allowzero,	1948	.ptr_type => \|ptr_type\| ptr_type.flags.is_allowzero,
1830	.opt_type => true,	1949	.opt_type => true,
1831	else => false,	1950	else => false,
1832	};	1951	};
1833	}	1952	}
1834		1953
1835	pub fn isCPtr(ty: Type, mod: *const Module) bool {	1954	pub fn isCPtr(ty: Type, zcu: *const Zcu) bool {
1836	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1955	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1837	.ptr_type => \|ptr_type\| ptr_type.flags.size == .C,	1956	.ptr_type => \|ptr_type\| ptr_type.flags.size == .C,
1838	else => false,	1957	else => false,
1839	};	1958	};
1840	}	1959	}
1841		1960
1842	pub fn isPtrAtRuntime(ty: Type, mod: *const Module) bool {	1961	pub fn isPtrAtRuntime(ty: Type, zcu: *const Zcu) bool {
1843	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1962	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1844	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {	1963	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {
1845	.Slice => false,	1964	.Slice => false,
1846	.One, .Many, .C => true,	1965	.One, .Many, .C => true,
1847	},	1966	},
1848	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {	1967	.opt_type => \|child\| switch (zcu.intern_pool.indexToKey(child)) {
1849	.ptr_type => \|p\| switch (p.flags.size) {	1968	.ptr_type => \|p\| switch (p.flags.size) {
1850	.Slice, .C => false,	1969	.Slice, .C => false,
1851	.Many, .One => !p.flags.is_allowzero,	1970	.Many, .One => !p.flags.is_allowzero,
...	@@ -1858,17 +1977,17 @@ pub fn isPtrAtRuntime(ty: Type, mod: *const Module) bool {	...	@@ -1858,17 +1977,17 @@ pub fn isPtrAtRuntime(ty: Type, mod: *const Module) bool {
1858		1977
1859	/// For pointer-like optionals, returns true, otherwise returns the allowzero property	1978	/// For pointer-like optionals, returns true, otherwise returns the allowzero property
1860	/// of pointers.	1979	/// of pointers.
1861	pub fn ptrAllowsZero(ty: Type, mod: *const Module) bool {	1980	pub fn ptrAllowsZero(ty: Type, zcu: *const Zcu) bool {
1862	if (ty.isPtrLikeOptional(mod)) {	1981	if (ty.isPtrLikeOptional(zcu)) {
1863	return true;	1982	return true;
1864	}	1983	}
1865	return ty.ptrInfo(mod).flags.is_allowzero;	1984	return ty.ptrInfo(zcu).flags.is_allowzero;
1866	}	1985	}
1867		1986
1868	/// See also `isPtrLikeOptional`.	1987	/// See also `isPtrLikeOptional`.
1869	pub fn optionalReprIsPayload(ty: Type, mod: *const Module) bool {	1988	pub fn optionalReprIsPayload(ty: Type, zcu: *const Zcu) bool {
1870	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	1989	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1871	.opt_type => \|child_type\| child_type == .anyerror_type or switch (mod.intern_pool.indexToKey(child_type)) {	1990	.opt_type => \|child_type\| child_type == .anyerror_type or switch (zcu.intern_pool.indexToKey(child_type)) {
1872	.ptr_type => \|ptr_type\| ptr_type.flags.size != .C and !ptr_type.flags.is_allowzero,	1991	.ptr_type => \|ptr_type\| ptr_type.flags.size != .C and !ptr_type.flags.is_allowzero,
1873	.error_set_type, .inferred_error_set_type => true,	1992	.error_set_type, .inferred_error_set_type => true,
1874	else => false,	1993	else => false,
...	@@ -1881,10 +2000,10 @@ pub fn optionalReprIsPayload(ty: Type, mod: *const Module) bool {	...	@@ -1881,10 +2000,10 @@ pub fn optionalReprIsPayload(ty: Type, mod: *const Module) bool {
1881	/// Returns true if the type is optional and would be lowered to a single pointer	2000	/// Returns true if the type is optional and would be lowered to a single pointer
1882	/// address value, using 0 for null. Note that this returns true for C pointers.	2001	/// address value, using 0 for null. Note that this returns true for C pointers.
1883	/// This function must be kept in sync with `Sema.typePtrOrOptionalPtrTy`.	2002	/// This function must be kept in sync with `Sema.typePtrOrOptionalPtrTy`.
1884	pub fn isPtrLikeOptional(ty: Type, mod: *const Module) bool {	2003	pub fn isPtrLikeOptional(ty: Type, zcu: *const Zcu) bool {
1885	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2004	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1886	.ptr_type => \|ptr_type\| ptr_type.flags.size == .C,	2005	.ptr_type => \|ptr_type\| ptr_type.flags.size == .C,
1887	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {	2006	.opt_type => \|child\| switch (zcu.intern_pool.indexToKey(child)) {
1888	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {	2007	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {
1889	.Slice, .C => false,	2008	.Slice, .C => false,
1890	.Many, .One => !ptr_type.flags.is_allowzero,	2009	.Many, .One => !ptr_type.flags.is_allowzero,
...	@@ -1898,8 +2017,8 @@ pub fn isPtrLikeOptional(ty: Type, mod: *const Module) bool {	...	@@ -1898,8 +2017,8 @@ pub fn isPtrLikeOptional(ty: Type, mod: *const Module) bool {
1898	/// For *[N]T, returns [N]T.	2017	/// For *[N]T, returns [N]T.
1899	/// For *T, returns T.	2018	/// For *T, returns T.
1900	/// For [*]T, returns T.	2019	/// For [*]T, returns T.
1901	pub fn childType(ty: Type, mod: *const Module) Type {	2020	pub fn childType(ty: Type, zcu: *const Zcu) Type {
1902	return childTypeIp(ty, &mod.intern_pool);	2021	return childTypeIp(ty, &zcu.intern_pool);
1903	}	2022	}
1904		2023
1905	pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {	2024	pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {
...	@@ -1915,10 +2034,10 @@ pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {	...	@@ -1915,10 +2034,10 @@ pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {
1915	/// For [N]T, returns T.	2034	/// For [N]T, returns T.
1916	/// For []T, returns T.	2035	/// For []T, returns T.
1917	/// For anyframe->T, returns T.	2036	/// For anyframe->T, returns T.
1918	pub fn elemType2(ty: Type, mod: *const Module) Type {	2037	pub fn elemType2(ty: Type, zcu: *const Zcu) Type {
1919	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2038	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1920	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {	2039	.ptr_type => \|ptr_type\| switch (ptr_type.flags.size) {
1921	.One => Type.fromInterned(ptr_type.child).shallowElemType(mod),	2040	.One => Type.fromInterned(ptr_type.child).shallowElemType(zcu),
1922	.Many, .C, .Slice => Type.fromInterned(ptr_type.child),	2041	.Many, .C, .Slice => Type.fromInterned(ptr_type.child),
1923	},	2042	},
1924	.anyframe_type => \|child\| {	2043	.anyframe_type => \|child\| {
...	@@ -1927,30 +2046,30 @@ pub fn elemType2(ty: Type, mod: *const Module) Type {	...	@@ -1927,30 +2046,30 @@ pub fn elemType2(ty: Type, mod: *const Module) Type {
1927	},	2046	},
1928	.vector_type => \|vector_type\| Type.fromInterned(vector_type.child),	2047	.vector_type => \|vector_type\| Type.fromInterned(vector_type.child),
1929	.array_type => \|array_type\| Type.fromInterned(array_type.child),	2048	.array_type => \|array_type\| Type.fromInterned(array_type.child),
1930	.opt_type => \|child\| Type.fromInterned(mod.intern_pool.childType(child)),	2049	.opt_type => \|child\| Type.fromInterned(zcu.intern_pool.childType(child)),
1931	else => unreachable,	2050	else => unreachable,
1932	};	2051	};
1933	}	2052	}
1934		2053
1935	fn shallowElemType(child_ty: Type, mod: *const Module) Type {	2054	fn shallowElemType(child_ty: Type, zcu: *const Zcu) Type {
1936	return switch (child_ty.zigTypeTag(mod)) {	2055	return switch (child_ty.zigTypeTag(zcu)) {
1937	.Array, .Vector => child_ty.childType(mod),	2056	.Array, .Vector => child_ty.childType(zcu),
1938	else => child_ty,	2057	else => child_ty,
1939	};	2058	};
1940	}	2059	}
1941		2060
1942	/// For vectors, returns the element type. Otherwise returns self.	2061	/// For vectors, returns the element type. Otherwise returns self.
1943	pub fn scalarType(ty: Type, mod: *Module) Type {	2062	pub fn scalarType(ty: Type, zcu: *const Zcu) Type {
1944	return switch (ty.zigTypeTag(mod)) {	2063	return switch (ty.zigTypeTag(zcu)) {
1945	.Vector => ty.childType(mod),	2064	.Vector => ty.childType(zcu),
1946	else => ty,	2065	else => ty,
1947	};	2066	};
1948	}	2067	}
1949		2068
1950	/// Asserts that the type is an optional.	2069	/// Asserts that the type is an optional.
1951	/// Note that for C pointers this returns the type unmodified.	2070	/// Note that for C pointers this returns the type unmodified.
1952	pub fn optionalChild(ty: Type, mod: *const Module) Type {	2071	pub fn optionalChild(ty: Type, zcu: *const Zcu) Type {
1953	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2072	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
1954	.opt_type => \|child\| Type.fromInterned(child),	2073	.opt_type => \|child\| Type.fromInterned(child),
1955	.ptr_type => \|ptr_type\| b: {	2074	.ptr_type => \|ptr_type\| b: {
1956	assert(ptr_type.flags.size == .C);	2075	assert(ptr_type.flags.size == .C);
...	@@ -1962,8 +2081,8 @@ pub fn optionalChild(ty: Type, mod: *const Module) Type {	...	@@ -1962,8 +2081,8 @@ pub fn optionalChild(ty: Type, mod: *const Module) Type {
1962		2081
1963	/// Returns the tag type of a union, if the type is a union and it has a tag type.	2082	/// Returns the tag type of a union, if the type is a union and it has a tag type.
1964	/// Otherwise, returns `null`.	2083	/// Otherwise, returns `null`.
1965	pub fn unionTagType(ty: Type, mod: *Module) ?Type {	2084	pub fn unionTagType(ty: Type, zcu: *const Zcu) ?Type {
1966	const ip = &mod.intern_pool;	2085	const ip = &zcu.intern_pool;
1967	switch (ip.indexToKey(ty.toIntern())) {	2086	switch (ip.indexToKey(ty.toIntern())) {
1968	.union_type => {},	2087	.union_type => {},
1969	else => return null,	2088	else => return null,
...	@@ -1981,8 +2100,8 @@ pub fn unionTagType(ty: Type, mod: *Module) ?Type {	...	@@ -1981,8 +2100,8 @@ pub fn unionTagType(ty: Type, mod: *Module) ?Type {
1981		2100
1982	/// Same as `unionTagType` but includes safety tag.	2101	/// Same as `unionTagType` but includes safety tag.
1983	/// Codegen should use this version.	2102	/// Codegen should use this version.
1984	pub fn unionTagTypeSafety(ty: Type, mod: *Module) ?Type {	2103	pub fn unionTagTypeSafety(ty: Type, zcu: *const Zcu) ?Type {
1985	const ip = &mod.intern_pool;	2104	const ip = &zcu.intern_pool;
1986	return switch (ip.indexToKey(ty.toIntern())) {	2105	return switch (ip.indexToKey(ty.toIntern())) {
1987	.union_type => {	2106	.union_type => {
1988	const union_type = ip.loadUnionType(ty.toIntern());	2107	const union_type = ip.loadUnionType(ty.toIntern());
...	@@ -1996,35 +2115,35 @@ pub fn unionTagTypeSafety(ty: Type, mod: *Module) ?Type {	...	@@ -1996,35 +2115,35 @@ pub fn unionTagTypeSafety(ty: Type, mod: *Module) ?Type {
1996		2115
1997	/// Asserts the type is a union; returns the tag type, even if the tag will	2116	/// Asserts the type is a union; returns the tag type, even if the tag will
1998	/// not be stored at runtime.	2117	/// not be stored at runtime.
1999	pub fn unionTagTypeHypothetical(ty: Type, mod: *Module) Type {	2118	pub fn unionTagTypeHypothetical(ty: Type, zcu: *const Zcu) Type {
2000	const union_obj = mod.typeToUnion(ty).?;	2119	const union_obj = zcu.typeToUnion(ty).?;
2001	return Type.fromInterned(union_obj.enum_tag_ty);	2120	return Type.fromInterned(union_obj.enum_tag_ty);
2002	}	2121	}
2003		2122
2004	pub fn unionFieldType(ty: Type, enum_tag: Value, mod: *Module) ?Type {	2123	pub fn unionFieldType(ty: Type, enum_tag: Value, zcu: *const Zcu) ?Type {
2005	const ip = &mod.intern_pool;	2124	const ip = &zcu.intern_pool;
2006	const union_obj = mod.typeToUnion(ty).?;	2125	const union_obj = zcu.typeToUnion(ty).?;
2007	const union_fields = union_obj.field_types.get(ip);	2126	const union_fields = union_obj.field_types.get(ip);
2008	const index = mod.unionTagFieldIndex(union_obj, enum_tag) orelse return null;	2127	const index = zcu.unionTagFieldIndex(union_obj, enum_tag) orelse return null;
2009	return Type.fromInterned(union_fields[index]);	2128	return Type.fromInterned(union_fields[index]);
2010	}	2129	}
2011		2130
2012	pub fn unionFieldTypeByIndex(ty: Type, index: usize, mod: *Module) Type {	2131	pub fn unionFieldTypeByIndex(ty: Type, index: usize, zcu: *const Zcu) Type {
2013	const ip = &mod.intern_pool;	2132	const ip = &zcu.intern_pool;
2014	const union_obj = mod.typeToUnion(ty).?;	2133	const union_obj = zcu.typeToUnion(ty).?;
2015	return Type.fromInterned(union_obj.field_types.get(ip)[index]);	2134	return Type.fromInterned(union_obj.field_types.get(ip)[index]);
2016	}	2135	}
2017		2136
2018	pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?u32 {	2137	pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
2019	const union_obj = mod.typeToUnion(ty).?;	2138	const union_obj = zcu.typeToUnion(ty).?;
2020	return mod.unionTagFieldIndex(union_obj, enum_tag);	2139	return zcu.unionTagFieldIndex(union_obj, enum_tag);
2021	}	2140	}
2022		2141
2023	pub fn unionHasAllZeroBitFieldTypes(ty: Type, pt: Zcu.PerThread) bool {	2142	pub fn unionHasAllZeroBitFieldTypes(ty: Type, zcu: *Zcu) bool {
2024	const ip = &pt.zcu.intern_pool;	2143	const ip = &zcu.intern_pool;
2025	const union_obj = pt.zcu.typeToUnion(ty).?;	2144	const union_obj = zcu.typeToUnion(ty).?;
2026	for (union_obj.field_types.get(ip)) \|field_ty\| {	2145	for (union_obj.field_types.get(ip)) \|field_ty\| {
2027	if (Type.fromInterned(field_ty).hasRuntimeBits(pt)) return false;	2146	if (Type.fromInterned(field_ty).hasRuntimeBits(zcu)) return false;
2028	}	2147	}
2029	return true;	2148	return true;
2030	}	2149	}
...	@@ -2032,20 +2151,21 @@ pub fn unionHasAllZeroBitFieldTypes(ty: Type, pt: Zcu.PerThread) bool {	...	@@ -2032,20 +2151,21 @@ pub fn unionHasAllZeroBitFieldTypes(ty: Type, pt: Zcu.PerThread) bool {
2032	/// Returns the type used for backing storage of this union during comptime operations.	2151	/// Returns the type used for backing storage of this union during comptime operations.
2033	/// Asserts the type is either an extern or packed union.	2152	/// Asserts the type is either an extern or packed union.
2034	pub fn unionBackingType(ty: Type, pt: Zcu.PerThread) !Type {	2153	pub fn unionBackingType(ty: Type, pt: Zcu.PerThread) !Type {
2035	return switch (ty.containerLayout(pt.zcu)) {	2154	const zcu = pt.zcu;
2036	.@"extern" => try pt.arrayType(.{ .len = ty.abiSize(pt), .child = .u8_type }),	2155	return switch (ty.containerLayout(zcu)) {
2037	.@"packed" => try pt.intType(.unsigned, @intCast(ty.bitSize(pt))),	2156	.@"extern" => try pt.arrayType(.{ .len = ty.abiSize(zcu), .child = .u8_type }),
		2157	.@"packed" => try pt.intType(.unsigned, @intCast(ty.bitSize(zcu))),
2038	.auto => unreachable,	2158	.auto => unreachable,
2039	};	2159	};
2040	}	2160	}
2041		2161
2042	pub fn unionGetLayout(ty: Type, pt: Zcu.PerThread) Module.UnionLayout {	2162	pub fn unionGetLayout(ty: Type, zcu: *Zcu) Zcu.UnionLayout {
2043	const union_obj = pt.zcu.intern_pool.loadUnionType(ty.toIntern());	2163	const union_obj = zcu.intern_pool.loadUnionType(ty.toIntern());
2044	return pt.getUnionLayout(union_obj);	2164	return Type.getUnionLayout(union_obj, zcu);
2045	}	2165	}
2046		2166
2047	pub fn containerLayout(ty: Type, mod: *Module) std.builtin.Type.ContainerLayout {	2167	pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayout {
2048	const ip = &mod.intern_pool;	2168	const ip = &zcu.intern_pool;
2049	return switch (ip.indexToKey(ty.toIntern())) {	2169	return switch (ip.indexToKey(ty.toIntern())) {
2050	.struct_type => ip.loadStructType(ty.toIntern()).layout,	2170	.struct_type => ip.loadStructType(ty.toIntern()).layout,
2051	.anon_struct_type => .auto,	2171	.anon_struct_type => .auto,
...	@@ -2055,18 +2175,18 @@ pub fn containerLayout(ty: Type, mod: *Module) std.builtin.Type.ContainerLayout	...	@@ -2055,18 +2175,18 @@ pub fn containerLayout(ty: Type, mod: *Module) std.builtin.Type.ContainerLayout
2055	}	2175	}
2056		2176
2057	/// Asserts that the type is an error union.	2177	/// Asserts that the type is an error union.
2058	pub fn errorUnionPayload(ty: Type, mod: *Module) Type {	2178	pub fn errorUnionPayload(ty: Type, zcu: *const Zcu) Type {
2059	return Type.fromInterned(mod.intern_pool.indexToKey(ty.toIntern()).error_union_type.payload_type);	2179	return Type.fromInterned(zcu.intern_pool.indexToKey(ty.toIntern()).error_union_type.payload_type);
2060	}	2180	}
2061		2181
2062	/// Asserts that the type is an error union.	2182	/// Asserts that the type is an error union.
2063	pub fn errorUnionSet(ty: Type, mod: *Module) Type {	2183	pub fn errorUnionSet(ty: Type, zcu: *const Zcu) Type {
2064	return Type.fromInterned(mod.intern_pool.errorUnionSet(ty.toIntern()));	2184	return Type.fromInterned(zcu.intern_pool.errorUnionSet(ty.toIntern()));
2065	}	2185	}
2066		2186
2067	/// Returns false for unresolved inferred error sets.	2187	/// Returns false for unresolved inferred error sets.
2068	pub fn errorSetIsEmpty(ty: Type, mod: *Module) bool {	2188	pub fn errorSetIsEmpty(ty: Type, zcu: *const Zcu) bool {
2069	const ip = &mod.intern_pool;	2189	const ip = &zcu.intern_pool;
2070	return switch (ty.toIntern()) {	2190	return switch (ty.toIntern()) {
2071	.anyerror_type, .adhoc_inferred_error_set_type => false,	2191	.anyerror_type, .adhoc_inferred_error_set_type => false,
2072	else => switch (ip.indexToKey(ty.toIntern())) {	2192	else => switch (ip.indexToKey(ty.toIntern())) {
...	@@ -2083,20 +2203,20 @@ pub fn errorSetIsEmpty(ty: Type, mod: *Module) bool {	...	@@ -2083,20 +2203,20 @@ pub fn errorSetIsEmpty(ty: Type, mod: *Module) bool {
2083	/// Returns true if it is an error set that includes anyerror, false otherwise.	2203	/// Returns true if it is an error set that includes anyerror, false otherwise.
2084	/// Note that the result may be a false negative if the type did not get error set	2204	/// Note that the result may be a false negative if the type did not get error set
2085	/// resolution prior to this call.	2205	/// resolution prior to this call.
2086	pub fn isAnyError(ty: Type, mod: *Module) bool {	2206	pub fn isAnyError(ty: Type, zcu: *const Zcu) bool {
2087	const ip = &mod.intern_pool;	2207	const ip = &zcu.intern_pool;
2088	return switch (ty.toIntern()) {	2208	return switch (ty.toIntern()) {
2089	.anyerror_type => true,	2209	.anyerror_type => true,
2090	.adhoc_inferred_error_set_type => false,	2210	.adhoc_inferred_error_set_type => false,
2091	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2211	else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2092	.inferred_error_set_type => \|i\| ip.funcIesResolvedUnordered(i) == .anyerror_type,	2212	.inferred_error_set_type => \|i\| ip.funcIesResolvedUnordered(i) == .anyerror_type,
2093	else => false,	2213	else => false,
2094	},	2214	},
2095	};	2215	};
2096	}	2216	}
2097		2217
2098	pub fn isError(ty: Type, mod: *const Module) bool {	2218	pub fn isError(ty: Type, zcu: *const Zcu) bool {
2099	return switch (ty.zigTypeTag(mod)) {	2219	return switch (ty.zigTypeTag(zcu)) {
2100	.ErrorUnion, .ErrorSet => true,	2220	.ErrorUnion, .ErrorSet => true,
2101	else => false,	2221	else => false,
2102	};	2222	};
...	@@ -2127,8 +2247,8 @@ pub fn errorSetHasFieldIp(	...	@@ -2127,8 +2247,8 @@ pub fn errorSetHasFieldIp(
2127	/// Returns whether ty, which must be an error set, includes an error `name`.	2247	/// Returns whether ty, which must be an error set, includes an error `name`.
2128	/// Might return a false negative if `ty` is an inferred error set and not fully	2248	/// Might return a false negative if `ty` is an inferred error set and not fully
2129	/// resolved yet.	2249	/// resolved yet.
2130	pub fn errorSetHasField(ty: Type, name: []const u8, mod: *Module) bool {	2250	pub fn errorSetHasField(ty: Type, name: []const u8, zcu: *const Zcu) bool {
2131	const ip = &mod.intern_pool;	2251	const ip = &zcu.intern_pool;
2132	return switch (ty.toIntern()) {	2252	return switch (ty.toIntern()) {
2133	.anyerror_type => true,	2253	.anyerror_type => true,
2134	else => switch (ip.indexToKey(ty.toIntern())) {	2254	else => switch (ip.indexToKey(ty.toIntern())) {
...	@@ -2152,20 +2272,20 @@ pub fn errorSetHasField(ty: Type, name: []const u8, mod: *Module) bool {	...	@@ -2152,20 +2272,20 @@ pub fn errorSetHasField(ty: Type, name: []const u8, mod: *Module) bool {
2152	}	2272	}
2153		2273
2154	/// Asserts the type is an array or vector or struct.	2274	/// Asserts the type is an array or vector or struct.
2155	pub fn arrayLen(ty: Type, mod: *const Module) u64 {	2275	pub fn arrayLen(ty: Type, zcu: *const Zcu) u64 {
2156	return ty.arrayLenIp(&mod.intern_pool);	2276	return ty.arrayLenIp(&zcu.intern_pool);
2157	}	2277	}
2158		2278
2159	pub fn arrayLenIp(ty: Type, ip: *const InternPool) u64 {	2279	pub fn arrayLenIp(ty: Type, ip: *const InternPool) u64 {
2160	return ip.aggregateTypeLen(ty.toIntern());	2280	return ip.aggregateTypeLen(ty.toIntern());
2161	}	2281	}
2162		2282
2163	pub fn arrayLenIncludingSentinel(ty: Type, mod: *const Module) u64 {	2283	pub fn arrayLenIncludingSentinel(ty: Type, zcu: *const Zcu) u64 {
2164	return mod.intern_pool.aggregateTypeLenIncludingSentinel(ty.toIntern());	2284	return zcu.intern_pool.aggregateTypeLenIncludingSentinel(ty.toIntern());
2165	}	2285	}
2166		2286
2167	pub fn vectorLen(ty: Type, mod: *const Module) u32 {	2287	pub fn vectorLen(ty: Type, zcu: *const Zcu) u32 {
2168	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2288	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2169	.vector_type => \|vector_type\| vector_type.len,	2289	.vector_type => \|vector_type\| vector_type.len,
2170	.anon_struct_type => \|tuple\| @intCast(tuple.types.len),	2290	.anon_struct_type => \|tuple\| @intCast(tuple.types.len),
2171	else => unreachable,	2291	else => unreachable,
...	@@ -2173,8 +2293,8 @@ pub fn vectorLen(ty: Type, mod: *const Module) u32 {	...	@@ -2173,8 +2293,8 @@ pub fn vectorLen(ty: Type, mod: *const Module) u32 {
2173	}	2293	}
2174		2294
2175	/// Asserts the type is an array, pointer or vector.	2295	/// Asserts the type is an array, pointer or vector.
2176	pub fn sentinel(ty: Type, mod: *const Module) ?Value {	2296	pub fn sentinel(ty: Type, zcu: *const Zcu) ?Value {
2177	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2297	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2178	.vector_type,	2298	.vector_type,
2179	.struct_type,	2299	.struct_type,
2180	.anon_struct_type,	2300	.anon_struct_type,
...	@@ -2188,17 +2308,17 @@ pub fn sentinel(ty: Type, mod: *const Module) ?Value {	...	@@ -2188,17 +2308,17 @@ pub fn sentinel(ty: Type, mod: *const Module) ?Value {
2188	}	2308	}
2189		2309
2190	/// Returns true if and only if the type is a fixed-width integer.	2310	/// Returns true if and only if the type is a fixed-width integer.
2191	pub fn isInt(self: Type, mod: *const Module) bool {	2311	pub fn isInt(self: Type, zcu: *const Zcu) bool {
2192	return self.toIntern() != .comptime_int_type and	2312	return self.toIntern() != .comptime_int_type and
2193	mod.intern_pool.isIntegerType(self.toIntern());	2313	zcu.intern_pool.isIntegerType(self.toIntern());
2194	}	2314	}
2195		2315
2196	/// Returns true if and only if the type is a fixed-width, signed integer.	2316	/// Returns true if and only if the type is a fixed-width, signed integer.
2197	pub fn isSignedInt(ty: Type, mod: *const Module) bool {	2317	pub fn isSignedInt(ty: Type, zcu: *const Zcu) bool {
2198	return switch (ty.toIntern()) {	2318	return switch (ty.toIntern()) {
2199	.c_char_type => mod.getTarget().charSignedness() == .signed,	2319	.c_char_type => zcu.getTarget().charSignedness() == .signed,
2200	.isize_type, .c_short_type, .c_int_type, .c_long_type, .c_longlong_type => true,	2320	.isize_type, .c_short_type, .c_int_type, .c_long_type, .c_longlong_type => true,
2201	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2321	else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2202	.int_type => \|int_type\| int_type.signedness == .signed,	2322	.int_type => \|int_type\| int_type.signedness == .signed,
2203	else => false,	2323	else => false,
2204	},	2324	},
...	@@ -2206,11 +2326,11 @@ pub fn isSignedInt(ty: Type, mod: *const Module) bool {	...	@@ -2206,11 +2326,11 @@ pub fn isSignedInt(ty: Type, mod: *const Module) bool {
2206	}	2326	}
2207		2327
2208	/// Returns true if and only if the type is a fixed-width, unsigned integer.	2328	/// Returns true if and only if the type is a fixed-width, unsigned integer.
2209	pub fn isUnsignedInt(ty: Type, mod: *const Module) bool {	2329	pub fn isUnsignedInt(ty: Type, zcu: *const Zcu) bool {
2210	return switch (ty.toIntern()) {	2330	return switch (ty.toIntern()) {
2211	.c_char_type => mod.getTarget().charSignedness() == .unsigned,	2331	.c_char_type => zcu.getTarget().charSignedness() == .unsigned,
2212	.usize_type, .c_ushort_type, .c_uint_type, .c_ulong_type, .c_ulonglong_type => true,	2332	.usize_type, .c_ushort_type, .c_uint_type, .c_ulong_type, .c_ulonglong_type => true,
2213	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2333	else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2214	.int_type => \|int_type\| int_type.signedness == .unsigned,	2334	.int_type => \|int_type\| int_type.signedness == .unsigned,
2215	else => false,	2335	else => false,
2216	},	2336	},
...	@@ -2219,27 +2339,27 @@ pub fn isUnsignedInt(ty: Type, mod: *const Module) bool {	...	@@ -2219,27 +2339,27 @@ pub fn isUnsignedInt(ty: Type, mod: *const Module) bool {
2219		2339
2220	/// Returns true for integers, enums, error sets, and packed structs.	2340	/// Returns true for integers, enums, error sets, and packed structs.
2221	/// If this function returns true, then intInfo() can be called on the type.	2341	/// If this function returns true, then intInfo() can be called on the type.
2222	pub fn isAbiInt(ty: Type, mod: *Module) bool {	2342	pub fn isAbiInt(ty: Type, zcu: *const Zcu) bool {
2223	return switch (ty.zigTypeTag(mod)) {	2343	return switch (ty.zigTypeTag(zcu)) {
2224	.Int, .Enum, .ErrorSet => true,	2344	.Int, .Enum, .ErrorSet => true,
2225	.Struct => ty.containerLayout(mod) == .@"packed",	2345	.Struct => ty.containerLayout(zcu) == .@"packed",
2226	else => false,	2346	else => false,
2227	};	2347	};
2228	}	2348	}
2229		2349
2230	/// Asserts the type is an integer, enum, error set, or vector of one of them.	2350	/// Asserts the type is an integer, enum, error set, or vector of one of them.
2231	pub fn intInfo(starting_ty: Type, mod: *Module) InternPool.Key.IntType {	2351	pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
2232	const ip = &mod.intern_pool;	2352	const ip = &zcu.intern_pool;
2233	const target = mod.getTarget();	2353	const target = zcu.getTarget();
2234	var ty = starting_ty;	2354	var ty = starting_ty;
2235		2355
2236	while (true) switch (ty.toIntern()) {	2356	while (true) switch (ty.toIntern()) {
2237	.anyerror_type, .adhoc_inferred_error_set_type => {	2357	.anyerror_type, .adhoc_inferred_error_set_type => {
2238	return .{ .signedness = .unsigned, .bits = mod.errorSetBits() };	2358	return .{ .signedness = .unsigned, .bits = zcu.errorSetBits() };
2239	},	2359	},
2240	.usize_type => return .{ .signedness = .unsigned, .bits = target.ptrBitWidth() },	2360	.usize_type => return .{ .signedness = .unsigned, .bits = target.ptrBitWidth() },
2241	.isize_type => return .{ .signedness = .signed, .bits = target.ptrBitWidth() },	2361	.isize_type => return .{ .signedness = .signed, .bits = target.ptrBitWidth() },
2242	.c_char_type => return .{ .signedness = mod.getTarget().charSignedness(), .bits = target.cTypeBitSize(.char) },	2362	.c_char_type => return .{ .signedness = zcu.getTarget().charSignedness(), .bits = target.cTypeBitSize(.char) },
2243	.c_short_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.short) },	2363	.c_short_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.short) },
2244	.c_ushort_type => return .{ .signedness = .unsigned, .bits = target.cTypeBitSize(.ushort) },	2364	.c_ushort_type => return .{ .signedness = .unsigned, .bits = target.cTypeBitSize(.ushort) },
2245	.c_int_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.int) },	2365	.c_int_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.int) },
...	@@ -2255,7 +2375,7 @@ pub fn intInfo(starting_ty: Type, mod: *Module) InternPool.Key.IntType {	...	@@ -2255,7 +2375,7 @@ pub fn intInfo(starting_ty: Type, mod: *Module) InternPool.Key.IntType {
2255	.vector_type => \|vector_type\| ty = Type.fromInterned(vector_type.child),	2375	.vector_type => \|vector_type\| ty = Type.fromInterned(vector_type.child),
2256		2376
2257	.error_set_type, .inferred_error_set_type => {	2377	.error_set_type, .inferred_error_set_type => {
2258	return .{ .signedness = .unsigned, .bits = mod.errorSetBits() };	2378	return .{ .signedness = .unsigned, .bits = zcu.errorSetBits() };
2259	},	2379	},
2260		2380
2261	.anon_struct_type => unreachable,	2381	.anon_struct_type => unreachable,
...	@@ -2363,35 +2483,35 @@ pub fn floatBits(ty: Type, target: Target) u16 {	...	@@ -2363,35 +2483,35 @@ pub fn floatBits(ty: Type, target: Target) u16 {
2363	}	2483	}
2364		2484
2365	/// Asserts the type is a function or a function pointer.	2485	/// Asserts the type is a function or a function pointer.
2366	pub fn fnReturnType(ty: Type, mod: *Module) Type {	2486	pub fn fnReturnType(ty: Type, zcu: *const Zcu) Type {
2367	return Type.fromInterned(mod.intern_pool.funcTypeReturnType(ty.toIntern()));	2487	return Type.fromInterned(zcu.intern_pool.funcTypeReturnType(ty.toIntern()));
2368	}	2488	}
2369		2489
2370	/// Asserts the type is a function.	2490	/// Asserts the type is a function.
2371	pub fn fnCallingConvention(ty: Type, mod: *Module) std.builtin.CallingConvention {	2491	pub fn fnCallingConvention(ty: Type, zcu: *const Zcu) std.builtin.CallingConvention {
2372	return mod.intern_pool.indexToKey(ty.toIntern()).func_type.cc;	2492	return zcu.intern_pool.indexToKey(ty.toIntern()).func_type.cc;
2373	}	2493	}
2374		2494
2375	pub fn isValidParamType(self: Type, mod: *const Module) bool {	2495	pub fn isValidParamType(self: Type, zcu: *const Zcu) bool {
2376	return switch (self.zigTypeTagOrPoison(mod) catch return true) {	2496	return switch (self.zigTypeTagOrPoison(zcu) catch return true) {
2377	.Opaque, .NoReturn => false,	2497	.Opaque, .NoReturn => false,
2378	else => true,	2498	else => true,
2379	};	2499	};
2380	}	2500	}
2381		2501
2382	pub fn isValidReturnType(self: Type, mod: *const Module) bool {	2502	pub fn isValidReturnType(self: Type, zcu: *const Zcu) bool {
2383	return switch (self.zigTypeTagOrPoison(mod) catch return true) {	2503	return switch (self.zigTypeTagOrPoison(zcu) catch return true) {
2384	.Opaque => false,	2504	.Opaque => false,
2385	else => true,	2505	else => true,
2386	};	2506	};
2387	}	2507	}
2388		2508
2389	/// Asserts the type is a function.	2509	/// Asserts the type is a function.
2390	pub fn fnIsVarArgs(ty: Type, mod: *Module) bool {	2510	pub fn fnIsVarArgs(ty: Type, zcu: *const Zcu) bool {
2391	return mod.intern_pool.indexToKey(ty.toIntern()).func_type.is_var_args;	2511	return zcu.intern_pool.indexToKey(ty.toIntern()).func_type.is_var_args;
2392	}	2512	}
2393		2513
2394	pub fn isNumeric(ty: Type, mod: *const Module) bool {	2514	pub fn isNumeric(ty: Type, zcu: *const Zcu) bool {
2395	return switch (ty.toIntern()) {	2515	return switch (ty.toIntern()) {
2396	.f16_type,	2516	.f16_type,
2397	.f32_type,	2517	.f32_type,
...	@@ -2414,7 +2534,7 @@ pub fn isNumeric(ty: Type, mod: *const Module) bool {	...	@@ -2414,7 +2534,7 @@ pub fn isNumeric(ty: Type, mod: *const Module) bool {
2414	.c_ulonglong_type,	2534	.c_ulonglong_type,
2415	=> true,	2535	=> true,
2416		2536
2417	else => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	2537	else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
2418	.int_type => true,	2538	.int_type => true,
2419	else => false,	2539	else => false,
2420	},	2540	},
...	@@ -2424,9 +2544,9 @@ pub fn isNumeric(ty: Type, mod: *const Module) bool {	...	@@ -2424,9 +2544,9 @@ pub fn isNumeric(ty: Type, mod: *const Module) bool {
2424	/// During semantic analysis, instead call `Sema.typeHasOnePossibleValue` which	2544	/// During semantic analysis, instead call `Sema.typeHasOnePossibleValue` which
2425	/// resolves field types rather than asserting they are already resolved.	2545	/// resolves field types rather than asserting they are already resolved.
2426	pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	2546	pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2427	const mod = pt.zcu;	2547	const zcu = pt.zcu;
2428	var ty = starting_type;	2548	var ty = starting_type;
2429	const ip = &mod.intern_pool;	2549	const ip = &zcu.intern_pool;
2430	while (true) switch (ty.toIntern()) {	2550	while (true) switch (ty.toIntern()) {
2431	.empty_struct_type => return Value.empty_struct,	2551	.empty_struct_type => return Value.empty_struct,
2432		2552
...	@@ -2509,8 +2629,8 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2509,8 +2629,8 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2509	assert(struct_type.haveFieldTypes(ip));	2629	assert(struct_type.haveFieldTypes(ip));
2510	if (struct_type.knownNonOpv(ip))	2630	if (struct_type.knownNonOpv(ip))
2511	return null;	2631	return null;
2512	const field_vals = try mod.gpa.alloc(InternPool.Index, struct_type.field_types.len);	2632	const field_vals = try zcu.gpa.alloc(InternPool.Index, struct_type.field_types.len);
2513	defer mod.gpa.free(field_vals);	2633	defer zcu.gpa.free(field_vals);
2514	for (field_vals, 0..) \|*field_val, i_usize\| {	2634	for (field_vals, 0..) \|*field_val, i_usize\| {
2515	const i: u32 = @intCast(i_usize);	2635	const i: u32 = @intCast(i_usize);
2516	if (struct_type.fieldIsComptime(ip, i)) {	2636	if (struct_type.fieldIsComptime(ip, i)) {
...	@@ -2539,8 +2659,8 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2539,8 +2659,8 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2539	// In this case the struct has all comptime-known fields and	2659	// In this case the struct has all comptime-known fields and
2540	// therefore has one possible value.	2660	// therefore has one possible value.
2541	// TODO: write something like getCoercedInts to avoid needing to dupe	2661	// TODO: write something like getCoercedInts to avoid needing to dupe
2542	const duped_values = try mod.gpa.dupe(InternPool.Index, tuple.values.get(ip));	2662	const duped_values = try zcu.gpa.dupe(InternPool.Index, tuple.values.get(ip));
2543	defer mod.gpa.free(duped_values);	2663	defer zcu.gpa.free(duped_values);
2544	return Value.fromInterned(try pt.intern(.{ .aggregate = .{	2664	return Value.fromInterned(try pt.intern(.{ .aggregate = .{
2545	.ty = ty.toIntern(),	2665	.ty = ty.toIntern(),
2546	.storage = .{ .elems = duped_values },	2666	.storage = .{ .elems = duped_values },
...	@@ -2583,7 +2703,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2583,7 +2703,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2583	return null;	2703	return null;
2584	},	2704	},
2585	.auto, .explicit => {	2705	.auto, .explicit => {
2586	if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(pt)) return null;	2706	if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(zcu)) return null;
2587		2707
2588	switch (enum_type.names.len) {	2708	switch (enum_type.names.len) {
2589	0 => {	2709	0 => {
...	@@ -2635,17 +2755,25 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2635,17 +2755,25 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2635	};	2755	};
2636	}	2756	}
2637		2757
2638	/// During semantic analysis, instead call `Sema.typeRequiresComptime` which	2758	/// During semantic analysis, instead call `ty.comptimeOnlySema` which
2639	/// resolves field types rather than asserting they are already resolved.	2759	/// resolves field types rather than asserting they are already resolved.
2640	pub fn comptimeOnly(ty: Type, pt: Zcu.PerThread) bool {	2760	pub fn comptimeOnly(ty: Type, zcu: *Zcu) bool {
2641	return ty.comptimeOnlyAdvanced(pt, .normal) catch unreachable;	2761	return ty.comptimeOnlyInner(.normal, zcu, {}) catch unreachable;
		2762	}
		2763
		2764	pub fn comptimeOnlySema(ty: Type, pt: Zcu.PerThread) SemaError!bool {
		2765	return try ty.comptimeOnlyInner(.sema, pt.zcu, pt.tid);
2642	}	2766	}
2643		2767
2644	/// `generic_poison` will return false.	2768	/// `generic_poison` will return false.
2645	/// May return false negatives when structs and unions are having their field types resolved.	2769	/// May return false negatives when structs and unions are having their field types resolved.
2646	pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) SemaError!bool {	2770	pub fn comptimeOnlyInner(
2647	const mod = pt.zcu;	2771	ty: Type,
2648	const ip = &mod.intern_pool;	2772	comptime strat: ResolveStrat,
		2773	zcu: *Zcu,
		2774	tid: strat.Tid(),
		2775	) SemaError!bool {
		2776	const ip = &zcu.intern_pool;
2649	return switch (ty.toIntern()) {	2777	return switch (ty.toIntern()) {
2650	.empty_struct_type => false,	2778	.empty_struct_type => false,
2651		2779
...	@@ -2653,20 +2781,20 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2653,20 +2781,20 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2653	.int_type => false,	2781	.int_type => false,
2654	.ptr_type => \|ptr_type\| {	2782	.ptr_type => \|ptr_type\| {
2655	const child_ty = Type.fromInterned(ptr_type.child);	2783	const child_ty = Type.fromInterned(ptr_type.child);
2656	switch (child_ty.zigTypeTag(mod)) {	2784	switch (child_ty.zigTypeTag(zcu)) {
2657	.Fn => return !try child_ty.fnHasRuntimeBitsAdvanced(pt, strat),	2785	.Fn => return !try child_ty.fnHasRuntimeBitsInner(strat, zcu, tid),
2658	.Opaque => return false,	2786	.Opaque => return false,
2659	else => return child_ty.comptimeOnlyAdvanced(pt, strat),	2787	else => return child_ty.comptimeOnlyInner(strat, zcu, tid),
2660	}	2788	}
2661	},	2789	},
2662	.anyframe_type => \|child\| {	2790	.anyframe_type => \|child\| {
2663	if (child == .none) return false;	2791	if (child == .none) return false;
2664	return Type.fromInterned(child).comptimeOnlyAdvanced(pt, strat);	2792	return Type.fromInterned(child).comptimeOnlyInner(strat, zcu, tid);
2665	},	2793	},
2666	.array_type => \|array_type\| return Type.fromInterned(array_type.child).comptimeOnlyAdvanced(pt, strat),	2794	.array_type => \|array_type\| return Type.fromInterned(array_type.child).comptimeOnlyInner(strat, zcu, tid),
2667	.vector_type => \|vector_type\| return Type.fromInterned(vector_type.child).comptimeOnlyAdvanced(pt, strat),	2795	.vector_type => \|vector_type\| return Type.fromInterned(vector_type.child).comptimeOnlyInner(strat, zcu, tid),
2668	.opt_type => \|child\| return Type.fromInterned(child).comptimeOnlyAdvanced(pt, strat),	2796	.opt_type => \|child\| return Type.fromInterned(child).comptimeOnlyInner(strat, zcu, tid),
2669	.error_union_type => \|error_union_type\| return Type.fromInterned(error_union_type.payload_type).comptimeOnlyAdvanced(pt, strat),	2797	.error_union_type => \|error_union_type\| return Type.fromInterned(error_union_type.payload_type).comptimeOnlyInner(strat, zcu, tid),
2670		2798
2671	.error_set_type,	2799	.error_set_type,
2672	.inferred_error_set_type,	2800	.inferred_error_set_type,
...	@@ -2732,13 +2860,14 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2732,13 +2860,14 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2732		2860
2733	errdefer struct_type.setRequiresComptime(ip, .unknown);	2861	errdefer struct_type.setRequiresComptime(ip, .unknown);
2734		2862
		2863	const pt = strat.pt(zcu, tid);
2735	try ty.resolveFields(pt);	2864	try ty.resolveFields(pt);
2736		2865
2737	for (0..struct_type.field_types.len) \|i_usize\| {	2866	for (0..struct_type.field_types.len) \|i_usize\| {
2738	const i: u32 = @intCast(i_usize);	2867	const i: u32 = @intCast(i_usize);
2739	if (struct_type.fieldIsComptime(ip, i)) continue;	2868	if (struct_type.fieldIsComptime(ip, i)) continue;
2740	const field_ty = struct_type.field_types.get(ip)[i];	2869	const field_ty = struct_type.field_types.get(ip)[i];
2741	if (try Type.fromInterned(field_ty).comptimeOnlyAdvanced(pt, strat)) {	2870	if (try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) {
2742	// Note that this does not cause the layout to	2871	// Note that this does not cause the layout to
2743	// be considered resolved. Comptime-only types	2872	// be considered resolved. Comptime-only types
2744	// still maintain a layout of their	2873	// still maintain a layout of their
...	@@ -2757,7 +2886,7 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2757,7 +2886,7 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2757	.anon_struct_type => \|tuple\| {	2886	.anon_struct_type => \|tuple\| {
2758	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {	2887	for (tuple.types.get(ip), tuple.values.get(ip)) \|field_ty, val\| {
2759	const have_comptime_val = val != .none;	2888	const have_comptime_val = val != .none;
2760	if (!have_comptime_val and try Type.fromInterned(field_ty).comptimeOnlyAdvanced(pt, strat)) return true;	2889	if (!have_comptime_val and try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) return true;
2761	}	2890	}
2762	return false;	2891	return false;
2763	},	2892	},
...	@@ -2778,11 +2907,12 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2778,11 +2907,12 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2778		2907
2779	errdefer union_type.setRequiresComptime(ip, .unknown);	2908	errdefer union_type.setRequiresComptime(ip, .unknown);
2780		2909
		2910	const pt = strat.pt(zcu, tid);
2781	try ty.resolveFields(pt);	2911	try ty.resolveFields(pt);
2782		2912
2783	for (0..union_type.field_types.len) \|field_idx\| {	2913	for (0..union_type.field_types.len) \|field_idx\| {
2784	const field_ty = union_type.field_types.get(ip)[field_idx];	2914	const field_ty = union_type.field_types.get(ip)[field_idx];
2785	if (try Type.fromInterned(field_ty).comptimeOnlyAdvanced(pt, strat)) {	2915	if (try Type.fromInterned(field_ty).comptimeOnlyInner(strat, zcu, tid)) {
2786	union_type.setRequiresComptime(ip, .yes);	2916	union_type.setRequiresComptime(ip, .yes);
2787	return true;	2917	return true;
2788	}	2918	}
...	@@ -2796,7 +2926,7 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2796,7 +2926,7 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2796		2926
2797	.opaque_type => false,	2927	.opaque_type => false,
2798		2928
2799	.enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).comptimeOnlyAdvanced(pt, strat),	2929	.enum_type => return Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty).comptimeOnlyInner(strat, zcu, tid),
2800		2930
2801	// values, not types	2931	// values, not types
2802	.undef,	2932	.undef,
...	@@ -2823,53 +2953,53 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2823,53 +2953,53 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2823	};	2953	};
2824	}	2954	}
2825		2955
2826	pub fn isVector(ty: Type, mod: *const Module) bool {	2956	pub fn isVector(ty: Type, zcu: *const Zcu) bool {
2827	return ty.zigTypeTag(mod) == .Vector;	2957	return ty.zigTypeTag(zcu) == .Vector;
2828	}	2958	}
2829		2959
2830	/// Returns 0 if not a vector, otherwise returns @bitSizeOf(Element) * vector_len.	2960	/// Returns 0 if not a vector, otherwise returns @bitSizeOf(Element) * vector_len.
2831	pub fn totalVectorBits(ty: Type, pt: Zcu.PerThread) u64 {	2961	pub fn totalVectorBits(ty: Type, zcu: *Zcu) u64 {
2832	if (!ty.isVector(pt.zcu)) return 0;	2962	if (!ty.isVector(zcu)) return 0;
2833	const v = pt.zcu.intern_pool.indexToKey(ty.toIntern()).vector_type;	2963	const v = zcu.intern_pool.indexToKey(ty.toIntern()).vector_type;
2834	return v.len * Type.fromInterned(v.child).bitSize(pt);	2964	return v.len * Type.fromInterned(v.child).bitSize(zcu);
2835	}	2965	}
2836		2966
2837	pub fn isArrayOrVector(ty: Type, mod: *const Module) bool {	2967	pub fn isArrayOrVector(ty: Type, zcu: *const Zcu) bool {
2838	return switch (ty.zigTypeTag(mod)) {	2968	return switch (ty.zigTypeTag(zcu)) {
2839	.Array, .Vector => true,	2969	.Array, .Vector => true,
2840	else => false,	2970	else => false,
2841	};	2971	};
2842	}	2972	}
2843		2973
2844	pub fn isIndexable(ty: Type, mod: *Module) bool {	2974	pub fn isIndexable(ty: Type, zcu: *const Zcu) bool {
2845	return switch (ty.zigTypeTag(mod)) {	2975	return switch (ty.zigTypeTag(zcu)) {
2846	.Array, .Vector => true,	2976	.Array, .Vector => true,
2847	.Pointer => switch (ty.ptrSize(mod)) {	2977	.Pointer => switch (ty.ptrSize(zcu)) {
2848	.Slice, .Many, .C => true,	2978	.Slice, .Many, .C => true,
2849	.One => switch (ty.childType(mod).zigTypeTag(mod)) {	2979	.One => switch (ty.childType(zcu).zigTypeTag(zcu)) {
2850	.Array, .Vector => true,	2980	.Array, .Vector => true,
2851	.Struct => ty.childType(mod).isTuple(mod),	2981	.Struct => ty.childType(zcu).isTuple(zcu),
2852	else => false,	2982	else => false,
2853	},	2983	},
2854	},	2984	},
2855	.Struct => ty.isTuple(mod),	2985	.Struct => ty.isTuple(zcu),
2856	else => false,	2986	else => false,
2857	};	2987	};
2858	}	2988	}
2859		2989
2860	pub fn indexableHasLen(ty: Type, mod: *Module) bool {	2990	pub fn indexableHasLen(ty: Type, zcu: *const Zcu) bool {
2861	return switch (ty.zigTypeTag(mod)) {	2991	return switch (ty.zigTypeTag(zcu)) {
2862	.Array, .Vector => true,	2992	.Array, .Vector => true,
2863	.Pointer => switch (ty.ptrSize(mod)) {	2993	.Pointer => switch (ty.ptrSize(zcu)) {
2864	.Many, .C => false,	2994	.Many, .C => false,
2865	.Slice => true,	2995	.Slice => true,
2866	.One => switch (ty.childType(mod).zigTypeTag(mod)) {	2996	.One => switch (ty.childType(zcu).zigTypeTag(zcu)) {
2867	.Array, .Vector => true,	2997	.Array, .Vector => true,
2868	.Struct => ty.childType(mod).isTuple(mod),	2998	.Struct => ty.childType(zcu).isTuple(zcu),
2869	else => false,	2999	else => false,
2870	},	3000	},
2871	},	3001	},
2872	.Struct => ty.isTuple(mod),	3002	.Struct => ty.isTuple(zcu),
2873	else => false,	3003	else => false,
2874	};	3004	};
2875	}	3005	}
...	@@ -2898,9 +3028,9 @@ pub fn getParentNamespace(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex	...	@@ -2898,9 +3028,9 @@ pub fn getParentNamespace(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex
2898		3028
2899	// Works for vectors and vectors of integers.	3029	// Works for vectors and vectors of integers.
2900	pub fn minInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	3030	pub fn minInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2901	const mod = pt.zcu;	3031	const zcu = pt.zcu;
2902	const scalar = try minIntScalar(ty.scalarType(mod), pt, dest_ty.scalarType(mod));	3032	const scalar = try minIntScalar(ty.scalarType(zcu), pt, dest_ty.scalarType(zcu));
2903	return if (ty.zigTypeTag(mod) == .Vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{	3033	return if (ty.zigTypeTag(zcu) == .Vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{
2904	.ty = dest_ty.toIntern(),	3034	.ty = dest_ty.toIntern(),
2905	.storage = .{ .repeated_elem = scalar.toIntern() },	3035	.storage = .{ .repeated_elem = scalar.toIntern() },
2906	} })) else scalar;	3036	} })) else scalar;
...	@@ -2908,8 +3038,8 @@ pub fn minInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	...	@@ -2908,8 +3038,8 @@ pub fn minInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2908		3038
2909	/// Asserts that the type is an integer.	3039	/// Asserts that the type is an integer.
2910	pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	3040	pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2911	const mod = pt.zcu;	3041	const zcu = pt.zcu;
2912	const info = ty.intInfo(mod);	3042	const info = ty.intInfo(zcu);
2913	if (info.signedness == .unsigned) return pt.intValue(dest_ty, 0);	3043	if (info.signedness == .unsigned) return pt.intValue(dest_ty, 0);
2914	if (info.bits == 0) return pt.intValue(dest_ty, -1);	3044	if (info.bits == 0) return pt.intValue(dest_ty, -1);
2915		3045
...	@@ -2918,7 +3048,7 @@ pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	...	@@ -2918,7 +3048,7 @@ pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2918	return pt.intValue(dest_ty, n);	3048	return pt.intValue(dest_ty, n);
2919	}	3049	}
2920		3050
2921	var res = try std.math.big.int.Managed.init(mod.gpa);	3051	var res = try std.math.big.int.Managed.init(zcu.gpa);
2922	defer res.deinit();	3052	defer res.deinit();
2923		3053
2924	try res.setTwosCompIntLimit(.min, info.signedness, info.bits);	3054	try res.setTwosCompIntLimit(.min, info.signedness, info.bits);
...	@@ -2929,9 +3059,9 @@ pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	...	@@ -2929,9 +3059,9 @@ pub fn minIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2929	// Works for vectors and vectors of integers.	3059	// Works for vectors and vectors of integers.
2930	/// The returned Value will have type dest_ty.	3060	/// The returned Value will have type dest_ty.
2931	pub fn maxInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	3061	pub fn maxInt(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2932	const mod = pt.zcu;	3062	const zcu = pt.zcu;
2933	const scalar = try maxIntScalar(ty.scalarType(mod), pt, dest_ty.scalarType(mod));	3063	const scalar = try maxIntScalar(ty.scalarType(zcu), pt, dest_ty.scalarType(zcu));
2934	return if (ty.zigTypeTag(mod) == .Vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{	3064	return if (ty.zigTypeTag(zcu) == .Vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{
2935	.ty = dest_ty.toIntern(),	3065	.ty = dest_ty.toIntern(),
2936	.storage = .{ .repeated_elem = scalar.toIntern() },	3066	.storage = .{ .repeated_elem = scalar.toIntern() },
2937	} })) else scalar;	3067	} })) else scalar;
...	@@ -2973,17 +3103,17 @@ pub fn maxIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {	...	@@ -2973,17 +3103,17 @@ pub fn maxIntScalar(ty: Type, pt: Zcu.PerThread, dest_ty: Type) !Value {
2973	}	3103	}
2974		3104
2975	/// Asserts the type is an enum or a union.	3105	/// Asserts the type is an enum or a union.
2976	pub fn intTagType(ty: Type, mod: *Module) Type {	3106	pub fn intTagType(ty: Type, zcu: *const Zcu) Type {
2977	const ip = &mod.intern_pool;	3107	const ip = &zcu.intern_pool;
2978	return switch (ip.indexToKey(ty.toIntern())) {	3108	return switch (ip.indexToKey(ty.toIntern())) {
2979	.union_type => Type.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_ty).intTagType(mod),	3109	.union_type => Type.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_ty).intTagType(zcu),
2980	.enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty),	3110	.enum_type => Type.fromInterned(ip.loadEnumType(ty.toIntern()).tag_ty),
2981	else => unreachable,	3111	else => unreachable,
2982	};	3112	};
2983	}	3113	}
2984		3114
2985	pub fn isNonexhaustiveEnum(ty: Type, mod: *Module) bool {	3115	pub fn isNonexhaustiveEnum(ty: Type, zcu: *const Zcu) bool {
2986	const ip = &mod.intern_pool;	3116	const ip = &zcu.intern_pool;
2987	return switch (ip.indexToKey(ty.toIntern())) {	3117	return switch (ip.indexToKey(ty.toIntern())) {
2988	.enum_type => switch (ip.loadEnumType(ty.toIntern()).tag_mode) {	3118	.enum_type => switch (ip.loadEnumType(ty.toIntern()).tag_mode) {
2989	.nonexhaustive => true,	3119	.nonexhaustive => true,
...	@@ -2995,8 +3125,8 @@ pub fn isNonexhaustiveEnum(ty: Type, mod: *Module) bool {	...	@@ -2995,8 +3125,8 @@ pub fn isNonexhaustiveEnum(ty: Type, mod: *Module) bool {
2995		3125
2996	// Asserts that `ty` is an error set and not `anyerror`.	3126	// Asserts that `ty` is an error set and not `anyerror`.
2997	// Asserts that `ty` is resolved if it is an inferred error set.	3127	// Asserts that `ty` is resolved if it is an inferred error set.
2998	pub fn errorSetNames(ty: Type, mod: *Module) InternPool.NullTerminatedString.Slice {	3128	pub fn errorSetNames(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.Slice {
2999	const ip = &mod.intern_pool;	3129	const ip = &zcu.intern_pool;
3000	return switch (ip.indexToKey(ty.toIntern())) {	3130	return switch (ip.indexToKey(ty.toIntern())) {
3001	.error_set_type => \|x\| x.names,	3131	.error_set_type => \|x\| x.names,
3002	.inferred_error_set_type => \|i\| switch (ip.funcIesResolvedUnordered(i)) {	3132	.inferred_error_set_type => \|i\| switch (ip.funcIesResolvedUnordered(i)) {
...	@@ -3008,21 +3138,21 @@ pub fn errorSetNames(ty: Type, mod: *Module) InternPool.NullTerminatedString.Sli	...	@@ -3008,21 +3138,21 @@ pub fn errorSetNames(ty: Type, mod: *Module) InternPool.NullTerminatedString.Sli
3008	};	3138	};
3009	}	3139	}
3010		3140
3011	pub fn enumFields(ty: Type, mod: *Module) InternPool.NullTerminatedString.Slice {	3141	pub fn enumFields(ty: Type, zcu: *const Zcu) InternPool.NullTerminatedString.Slice {
3012	return mod.intern_pool.loadEnumType(ty.toIntern()).names;	3142	return zcu.intern_pool.loadEnumType(ty.toIntern()).names;
3013	}	3143	}
3014		3144
3015	pub fn enumFieldCount(ty: Type, mod: *Module) usize {	3145	pub fn enumFieldCount(ty: Type, zcu: *const Zcu) usize {
3016	return mod.intern_pool.loadEnumType(ty.toIntern()).names.len;	3146	return zcu.intern_pool.loadEnumType(ty.toIntern()).names.len;
3017	}	3147	}
3018		3148
3019	pub fn enumFieldName(ty: Type, field_index: usize, mod: *Module) InternPool.NullTerminatedString {	3149	pub fn enumFieldName(ty: Type, field_index: usize, zcu: *const Zcu) InternPool.NullTerminatedString {
3020	const ip = &mod.intern_pool;	3150	const ip = &zcu.intern_pool;
3021	return ip.loadEnumType(ty.toIntern()).names.get(ip)[field_index];	3151	return ip.loadEnumType(ty.toIntern()).names.get(ip)[field_index];
3022	}	3152	}
3023		3153
3024	pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, mod: *Module) ?u32 {	3154	pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, zcu: *const Zcu) ?u32 {
3025	const ip = &mod.intern_pool;	3155	const ip = &zcu.intern_pool;
3026	const enum_type = ip.loadEnumType(ty.toIntern());	3156	const enum_type = ip.loadEnumType(ty.toIntern());
3027	return enum_type.nameIndex(ip, field_name);	3157	return enum_type.nameIndex(ip, field_name);
3028	}	3158	}
...	@@ -3030,8 +3160,8 @@ pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, mod	...	@@ -3030,8 +3160,8 @@ pub fn enumFieldIndex(ty: Type, field_name: InternPool.NullTerminatedString, mod
3030	/// Asserts `ty` is an enum. `enum_tag` can either be `enum_field_index` or	3160	/// Asserts `ty` is an enum. `enum_tag` can either be `enum_field_index` or
3031	/// an integer which represents the enum value. Returns the field index in	3161	/// an integer which represents the enum value. Returns the field index in
3032	/// declaration order, or `null` if `enum_tag` does not match any field.	3162	/// declaration order, or `null` if `enum_tag` does not match any field.
3033	pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?u32 {	3163	pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, zcu: *const Zcu) ?u32 {
3034	const ip = &mod.intern_pool;	3164	const ip = &zcu.intern_pool;
3035	const enum_type = ip.loadEnumType(ty.toIntern());	3165	const enum_type = ip.loadEnumType(ty.toIntern());
3036	const int_tag = switch (ip.indexToKey(enum_tag.toIntern())) {	3166	const int_tag = switch (ip.indexToKey(enum_tag.toIntern())) {
3037	.int => enum_tag.toIntern(),	3167	.int => enum_tag.toIntern(),
...	@@ -3043,8 +3173,8 @@ pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?u32 {	...	@@ -3043,8 +3173,8 @@ pub fn enumTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?u32 {
3043	}	3173	}
3044		3174
3045	/// Returns none in the case of a tuple which uses the integer index as the field name.	3175	/// Returns none in the case of a tuple which uses the integer index as the field name.
3046	pub fn structFieldName(ty: Type, index: usize, mod: *Module) InternPool.OptionalNullTerminatedString {	3176	pub fn structFieldName(ty: Type, index: usize, zcu: *const Zcu) InternPool.OptionalNullTerminatedString {
3047	const ip = &mod.intern_pool;	3177	const ip = &zcu.intern_pool;
3048	return switch (ip.indexToKey(ty.toIntern())) {	3178	return switch (ip.indexToKey(ty.toIntern())) {
3049	.struct_type => ip.loadStructType(ty.toIntern()).fieldName(ip, index),	3179	.struct_type => ip.loadStructType(ty.toIntern()).fieldName(ip, index),
3050	.anon_struct_type => \|anon_struct\| anon_struct.fieldName(ip, index),	3180	.anon_struct_type => \|anon_struct\| anon_struct.fieldName(ip, index),
...	@@ -3052,8 +3182,8 @@ pub fn structFieldName(ty: Type, index: usize, mod: *Module) InternPool.Optional	...	@@ -3052,8 +3182,8 @@ pub fn structFieldName(ty: Type, index: usize, mod: *Module) InternPool.Optional
3052	};	3182	};
3053	}	3183	}
3054		3184
3055	pub fn structFieldCount(ty: Type, mod: *Module) u32 {	3185	pub fn structFieldCount(ty: Type, zcu: *const Zcu) u32 {
3056	const ip = &mod.intern_pool;	3186	const ip = &zcu.intern_pool;
3057	return switch (ip.indexToKey(ty.toIntern())) {	3187	return switch (ip.indexToKey(ty.toIntern())) {
3058	.struct_type => ip.loadStructType(ty.toIntern()).field_types.len,	3188	.struct_type => ip.loadStructType(ty.toIntern()).field_types.len,
3059	.anon_struct_type => \|anon_struct\| anon_struct.types.len,	3189	.anon_struct_type => \|anon_struct\| anon_struct.types.len,
...	@@ -3061,9 +3191,9 @@ pub fn structFieldCount(ty: Type, mod: *Module) u32 {	...	@@ -3061,9 +3191,9 @@ pub fn structFieldCount(ty: Type, mod: *Module) u32 {
3061	};	3191	};
3062	}	3192	}
3063		3193
3064	/// Supports structs and unions.	3194	/// Returns the field type. Supports structs and unions.
3065	pub fn structFieldType(ty: Type, index: usize, mod: *Module) Type {	3195	pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
3066	const ip = &mod.intern_pool;	3196	const ip = &zcu.intern_pool;
3067	return switch (ip.indexToKey(ty.toIntern())) {	3197	return switch (ip.indexToKey(ty.toIntern())) {
3068	.struct_type => Type.fromInterned(ip.loadStructType(ty.toIntern()).field_types.get(ip)[index]),	3198	.struct_type => Type.fromInterned(ip.loadStructType(ty.toIntern()).field_types.get(ip)[index]),
3069	.union_type => {	3199	.union_type => {
...	@@ -3075,33 +3205,150 @@ pub fn structFieldType(ty: Type, index: usize, mod: *Module) Type {	...	@@ -3075,33 +3205,150 @@ pub fn structFieldType(ty: Type, index: usize, mod: *Module) Type {
3075	};	3205	};
3076	}	3206	}
3077		3207
3078	pub fn structFieldAlign(ty: Type, index: usize, pt: Zcu.PerThread) Alignment {	3208	pub fn fieldAlignment(ty: Type, index: usize, zcu: *Zcu) Alignment {
3079	return ty.structFieldAlignAdvanced(index, pt, .normal) catch unreachable;	3209	return ty.fieldAlignmentInner(index, .normal, zcu, {}) catch unreachable;
3080	}	3210	}
3081		3211
3082	pub fn structFieldAlignAdvanced(ty: Type, index: usize, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Alignment {	3212	pub fn fieldAlignmentSema(ty: Type, index: usize, pt: Zcu.PerThread) SemaError!Alignment {
3083	const ip = &pt.zcu.intern_pool;	3213	return try ty.fieldAlignmentInner(index, .sema, pt.zcu, pt.tid);
		3214	}
		3215
		3216	/// Returns the field alignment. Supports structs and unions.
		3217	/// If `strat` is `.sema`, may perform type resolution.
		3218	/// Asserts the layout is not packed.
		3219	///
		3220	/// Provide the struct field as the `ty`.
		3221	pub fn fieldAlignmentInner(
		3222	ty: Type,
		3223	index: usize,
		3224	comptime strat: ResolveStrat,
		3225	zcu: *Zcu,
		3226	tid: strat.Tid(),
		3227	) SemaError!Alignment {
		3228	const ip = &zcu.intern_pool;
3084	switch (ip.indexToKey(ty.toIntern())) {	3229	switch (ip.indexToKey(ty.toIntern())) {
3085	.struct_type => {	3230	.struct_type => {
3086	const struct_type = ip.loadStructType(ty.toIntern());	3231	const struct_type = ip.loadStructType(ty.toIntern());
3087	assert(struct_type.layout != .@"packed");	3232	assert(struct_type.layout != .@"packed");
3088	const explicit_align = struct_type.fieldAlign(ip, index);	3233	const explicit_align = struct_type.fieldAlign(ip, index);
3089	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[index]);	3234	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[index]);
3090	return pt.structFieldAlignmentAdvanced(explicit_align, field_ty, struct_type.layout, strat);	3235	return field_ty.structFieldAlignmentInner(explicit_align, struct_type.layout, strat, zcu, tid);
3091	},	3236	},
3092	.anon_struct_type => \|anon_struct\| {	3237	.anon_struct_type => \|anon_struct\| {
3093	return (try Type.fromInterned(anon_struct.types.get(ip)[index]).abiAlignmentAdvanced(pt, strat.toLazy())).scalar;	3238	return (try Type.fromInterned(anon_struct.types.get(ip)[index]).abiAlignmentInner(
		3239	strat.toLazy(),
		3240	zcu,
		3241	tid,
		3242	)).scalar;
3094	},	3243	},
3095	.union_type => {	3244	.union_type => {
3096	const union_obj = ip.loadUnionType(ty.toIntern());	3245	const union_obj = ip.loadUnionType(ty.toIntern());
3097	return pt.unionFieldNormalAlignmentAdvanced(union_obj, @intCast(index), strat);	3246	const layout = union_obj.flagsUnordered(ip).layout;
		3247	assert(layout != .@"packed");
		3248	const explicit_align = union_obj.fieldAlign(ip, index);
		3249	const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[index]);
		3250	return field_ty.unionFieldAlignmentInner(explicit_align, layout, strat, zcu, tid);
3098	},	3251	},
3099	else => unreachable,	3252	else => unreachable,
3100	}	3253	}
3101	}	3254	}
3102		3255
3103	pub fn structFieldDefaultValue(ty: Type, index: usize, mod: *Module) Value {	3256	/// Returns the alignment of a non-packed struct field. Assert the layout is not packed.
3104	const ip = &mod.intern_pool;	3257	///
		3258	/// Asserts that all resolution needed was done.
		3259	pub fn structFieldAlignment(
		3260	field_ty: Type,
		3261	explicit_alignment: InternPool.Alignment,
		3262	layout: std.builtin.Type.ContainerLayout,
		3263	zcu: *Zcu,
		3264	) Alignment {
		3265	return field_ty.structFieldAlignmentInner(
		3266	explicit_alignment,
		3267	layout,
		3268	.normal,
		3269	zcu,
		3270	{},
		3271	) catch unreachable;
		3272	}
		3273
		3274	/// Returns the alignment of a non-packed struct field. Assert the layout is not packed.
		3275	/// May do type resolution when needed.
		3276	/// Asserts that all resolution needed was done.
		3277	pub fn structFieldAlignmentSema(
		3278	field_ty: Type,
		3279	explicit_alignment: InternPool.Alignment,
		3280	layout: std.builtin.Type.ContainerLayout,
		3281	pt: Zcu.PerThread,
		3282	) SemaError!Alignment {
		3283	return try field_ty.structFieldAlignmentInner(
		3284	explicit_alignment,
		3285	layout,
		3286	.sema,
		3287	pt.zcu,
		3288	pt.tid,
		3289	);
		3290	}
		3291
		3292	/// Returns the alignment of a non-packed struct field. Asserts the layout is not packed.
		3293	/// If `strat` is `.sema`, may perform type resolution.
		3294	pub fn structFieldAlignmentInner(
		3295	field_ty: Type,
		3296	explicit_alignment: Alignment,
		3297	layout: std.builtin.Type.ContainerLayout,
		3298	comptime strat: Type.ResolveStrat,
		3299	zcu: *Zcu,
		3300	tid: strat.Tid(),
		3301	) SemaError!Alignment {
		3302	assert(layout != .@"packed");
		3303	if (explicit_alignment != .none) return explicit_alignment;
		3304	const ty_abi_align = (try field_ty.abiAlignmentInner(
		3305	strat.toLazy(),
		3306	zcu,
		3307	tid,
		3308	)).scalar;
		3309	switch (layout) {
		3310	.@"packed" => unreachable,
		3311	.auto => if (zcu.getTarget().ofmt != .c) return ty_abi_align,
		3312	.@"extern" => {},
		3313	}
		3314	// extern
		3315	if (field_ty.isAbiInt(zcu) and field_ty.intInfo(zcu).bits >= 128) {
		3316	return ty_abi_align.maxStrict(.@"16");
		3317	}
		3318	return ty_abi_align;
		3319	}
		3320
		3321	pub fn unionFieldAlignmentSema(
		3322	field_ty: Type,
		3323	explicit_alignment: Alignment,
		3324	layout: std.builtin.Type.ContainerLayout,
		3325	pt: Zcu.PerThread,
		3326	) SemaError!Alignment {
		3327	return field_ty.unionFieldAlignmentInner(
		3328	explicit_alignment,
		3329	layout,
		3330	.sema,
		3331	pt.zcu,
		3332	pt.tid,
		3333	);
		3334	}
		3335
		3336	pub fn unionFieldAlignmentInner(
		3337	field_ty: Type,
		3338	explicit_alignment: Alignment,
		3339	layout: std.builtin.Type.ContainerLayout,
		3340	comptime strat: Type.ResolveStrat,
		3341	zcu: *Zcu,
		3342	tid: strat.Tid(),
		3343	) SemaError!Alignment {
		3344	assert(layout != .@"packed");
		3345	if (explicit_alignment != .none) return explicit_alignment;
		3346	if (field_ty.isNoReturn(zcu)) return .none;
		3347	return (try field_ty.abiAlignmentInner(strat.toLazy(), zcu, tid)).scalar;
		3348	}
		3349
		3350	pub fn structFieldDefaultValue(ty: Type, index: usize, zcu: *const Zcu) Value {
		3351	const ip = &zcu.intern_pool;
3105	switch (ip.indexToKey(ty.toIntern())) {	3352	switch (ip.indexToKey(ty.toIntern())) {
3106	.struct_type => {	3353	.struct_type => {
3107	const struct_type = ip.loadStructType(ty.toIntern());	3354	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -3121,8 +3368,8 @@ pub fn structFieldDefaultValue(ty: Type, index: usize, mod: *Module) Value {	...	@@ -3121,8 +3368,8 @@ pub fn structFieldDefaultValue(ty: Type, index: usize, mod: *Module) Value {
3121	}	3368	}
3122		3369
3123	pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Value {	3370	pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Value {
3124	const mod = pt.zcu;	3371	const zcu = pt.zcu;
3125	const ip = &mod.intern_pool;	3372	const ip = &zcu.intern_pool;
3126	switch (ip.indexToKey(ty.toIntern())) {	3373	switch (ip.indexToKey(ty.toIntern())) {
3127	.struct_type => {	3374	.struct_type => {
3128	const struct_type = ip.loadStructType(ty.toIntern());	3375	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -3145,8 +3392,8 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val	...	@@ -3145,8 +3392,8 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
3145	}	3392	}
3146	}	3393	}
3147		3394
3148	pub fn structFieldIsComptime(ty: Type, index: usize, mod: *Module) bool {	3395	pub fn structFieldIsComptime(ty: Type, index: usize, zcu: *const Zcu) bool {
3149	const ip = &mod.intern_pool;	3396	const ip = &zcu.intern_pool;
3150	return switch (ip.indexToKey(ty.toIntern())) {	3397	return switch (ip.indexToKey(ty.toIntern())) {
3151	.struct_type => ip.loadStructType(ty.toIntern()).fieldIsComptime(ip, index),	3398	.struct_type => ip.loadStructType(ty.toIntern()).fieldIsComptime(ip, index),
3152	.anon_struct_type => \|anon_struct\| anon_struct.values.get(ip)[index] != .none,	3399	.anon_struct_type => \|anon_struct\| anon_struct.values.get(ip)[index] != .none,
...	@@ -3160,9 +3407,12 @@ pub const FieldOffset = struct {	...	@@ -3160,9 +3407,12 @@ pub const FieldOffset = struct {
3160	};	3407	};
3161		3408
3162	/// Supports structs and unions.	3409	/// Supports structs and unions.
3163	pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {	3410	pub fn structFieldOffset(
3164	const mod = pt.zcu;	3411	ty: Type,
3165	const ip = &mod.intern_pool;	3412	index: usize,
		3413	zcu: *Zcu,
		3414	) u64 {
		3415	const ip = &zcu.intern_pool;
3166	switch (ip.indexToKey(ty.toIntern())) {	3416	switch (ip.indexToKey(ty.toIntern())) {
3167	.struct_type => {	3417	.struct_type => {
3168	const struct_type = ip.loadStructType(ty.toIntern());	3418	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -3176,17 +3426,17 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {	...	@@ -3176,17 +3426,17 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {
3176	var big_align: Alignment = .none;	3426	var big_align: Alignment = .none;
3177		3427
3178	for (tuple.types.get(ip), tuple.values.get(ip), 0..) \|field_ty, field_val, i\| {	3428	for (tuple.types.get(ip), tuple.values.get(ip), 0..) \|field_ty, field_val, i\| {
3179	if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(pt)) {	3429	if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) {
3180	// comptime field	3430	// comptime field
3181	if (i == index) return offset;	3431	if (i == index) return offset;
3182	continue;	3432	continue;
3183	}	3433	}
3184		3434
3185	const field_align = Type.fromInterned(field_ty).abiAlignment(pt);	3435	const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
3186	big_align = big_align.max(field_align);	3436	big_align = big_align.max(field_align);
3187	offset = field_align.forward(offset);	3437	offset = field_align.forward(offset);
3188	if (i == index) return offset;	3438	if (i == index) return offset;
3189	offset += Type.fromInterned(field_ty).abiSize(pt);	3439	offset += Type.fromInterned(field_ty).abiSize(zcu);
3190	}	3440	}
3191	offset = big_align.max(.@"1").forward(offset);	3441	offset = big_align.max(.@"1").forward(offset);
3192	return offset;	3442	return offset;
...	@@ -3196,7 +3446,7 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {	...	@@ -3196,7 +3446,7 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {
3196	const union_type = ip.loadUnionType(ty.toIntern());	3446	const union_type = ip.loadUnionType(ty.toIntern());
3197	if (!union_type.hasTag(ip))	3447	if (!union_type.hasTag(ip))
3198	return 0;	3448	return 0;
3199	const layout = pt.getUnionLayout(union_type);	3449	const layout = Type.getUnionLayout(union_type, zcu);
3200	if (layout.tag_align.compare(.gte, layout.payload_align)) {	3450	if (layout.tag_align.compare(.gte, layout.payload_align)) {
3201	// {Tag, Payload}	3451	// {Tag, Payload}
3202	return layout.payload_align.forward(layout.tag_size);	3452	return layout.payload_align.forward(layout.tag_size);
...	@@ -3210,7 +3460,7 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {	...	@@ -3210,7 +3460,7 @@ pub fn structFieldOffset(ty: Type, index: usize, pt: Zcu.PerThread) u64 {
3210	}	3460	}
3211	}	3461	}
3212		3462
3213	pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Module.LazySrcLoc {	3463	pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Zcu.LazySrcLoc {
3214	const ip = &zcu.intern_pool;	3464	const ip = &zcu.intern_pool;
3215	return .{	3465	return .{
3216	.base_node_inst = switch (ip.indexToKey(ty.toIntern())) {	3466	.base_node_inst = switch (ip.indexToKey(ty.toIntern())) {
...	@@ -3222,11 +3472,11 @@ pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Module.LazySrcLoc {	...	@@ -3222,11 +3472,11 @@ pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Module.LazySrcLoc {
3222	},	3472	},
3223	else => return null,	3473	else => return null,
3224	},	3474	},
3225	.offset = Module.LazySrcLoc.Offset.nodeOffset(0),	3475	.offset = Zcu.LazySrcLoc.Offset.nodeOffset(0),
3226	};	3476	};
3227	}	3477	}
3228		3478
3229	pub fn srcLoc(ty: Type, zcu: *Zcu) Module.LazySrcLoc {	3479	pub fn srcLoc(ty: Type, zcu: *Zcu) Zcu.LazySrcLoc {
3230	return ty.srcLocOrNull(zcu).?;	3480	return ty.srcLocOrNull(zcu).?;
3231	}	3481	}
3232		3482
...	@@ -3234,8 +3484,8 @@ pub fn isGenericPoison(ty: Type) bool {	...	@@ -3234,8 +3484,8 @@ pub fn isGenericPoison(ty: Type) bool {
3234	return ty.toIntern() == .generic_poison_type;	3484	return ty.toIntern() == .generic_poison_type;
3235	}	3485	}
3236		3486
3237	pub fn isTuple(ty: Type, mod: *Module) bool {	3487	pub fn isTuple(ty: Type, zcu: *const Zcu) bool {
3238	const ip = &mod.intern_pool;	3488	const ip = &zcu.intern_pool;
3239	return switch (ip.indexToKey(ty.toIntern())) {	3489	return switch (ip.indexToKey(ty.toIntern())) {
3240	.struct_type => {	3490	.struct_type => {
3241	const struct_type = ip.loadStructType(ty.toIntern());	3491	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -3248,16 +3498,16 @@ pub fn isTuple(ty: Type, mod: *Module) bool {	...	@@ -3248,16 +3498,16 @@ pub fn isTuple(ty: Type, mod: *Module) bool {
3248	};	3498	};
3249	}	3499	}
3250		3500
3251	pub fn isAnonStruct(ty: Type, mod: *Module) bool {	3501	pub fn isAnonStruct(ty: Type, zcu: *const Zcu) bool {
3252	if (ty.toIntern() == .empty_struct_type) return true;	3502	if (ty.toIntern() == .empty_struct_type) return true;
3253	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	3503	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
3254	.anon_struct_type => \|anon_struct_type\| anon_struct_type.names.len > 0,	3504	.anon_struct_type => \|anon_struct_type\| anon_struct_type.names.len > 0,
3255	else => false,	3505	else => false,
3256	};	3506	};
3257	}	3507	}
3258		3508
3259	pub fn isTupleOrAnonStruct(ty: Type, mod: *Module) bool {	3509	pub fn isTupleOrAnonStruct(ty: Type, zcu: *const Zcu) bool {
3260	const ip = &mod.intern_pool;	3510	const ip = &zcu.intern_pool;
3261	return switch (ip.indexToKey(ty.toIntern())) {	3511	return switch (ip.indexToKey(ty.toIntern())) {
3262	.struct_type => {	3512	.struct_type => {
3263	const struct_type = ip.loadStructType(ty.toIntern());	3513	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -3270,15 +3520,15 @@ pub fn isTupleOrAnonStruct(ty: Type, mod: *Module) bool {	...	@@ -3270,15 +3520,15 @@ pub fn isTupleOrAnonStruct(ty: Type, mod: *Module) bool {
3270	};	3520	};
3271	}	3521	}
3272		3522
3273	pub fn isSimpleTuple(ty: Type, mod: *Module) bool {	3523	pub fn isSimpleTuple(ty: Type, zcu: *const Zcu) bool {
3274	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	3524	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
3275	.anon_struct_type => \|anon_struct_type\| anon_struct_type.names.len == 0,	3525	.anon_struct_type => \|anon_struct_type\| anon_struct_type.names.len == 0,
3276	else => false,	3526	else => false,
3277	};	3527	};
3278	}	3528	}
3279		3529
3280	pub fn isSimpleTupleOrAnonStruct(ty: Type, mod: *Module) bool {	3530	pub fn isSimpleTupleOrAnonStruct(ty: Type, zcu: *const Zcu) bool {
3281	return switch (mod.intern_pool.indexToKey(ty.toIntern())) {	3531	return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
3282	.anon_struct_type => true,	3532	.anon_struct_type => true,
3283	else => false,	3533	else => false,
3284	};	3534	};
...	@@ -3286,22 +3536,22 @@ pub fn isSimpleTupleOrAnonStruct(ty: Type, mod: *Module) bool {	...	@@ -3286,22 +3536,22 @@ pub fn isSimpleTupleOrAnonStruct(ty: Type, mod: *Module) bool {
3286		3536
3287	/// Traverses optional child types and error union payloads until the type	3537	/// Traverses optional child types and error union payloads until the type
3288	/// is not a pointer. For `E!?u32`, returns `u32`; for `u8`, returns `u8`.	3538	/// is not a pointer. For `E!?u32`, returns `u32`; for `u8`, returns `u8`.
3289	pub fn optEuBaseType(ty: Type, mod: *Module) Type {	3539	pub fn optEuBaseType(ty: Type, zcu: *const Zcu) Type {
3290	var cur = ty;	3540	var cur = ty;
3291	while (true) switch (cur.zigTypeTag(mod)) {	3541	while (true) switch (cur.zigTypeTag(zcu)) {
3292	.Optional => cur = cur.optionalChild(mod),	3542	.Optional => cur = cur.optionalChild(zcu),
3293	.ErrorUnion => cur = cur.errorUnionPayload(mod),	3543	.ErrorUnion => cur = cur.errorUnionPayload(zcu),
3294	else => return cur,	3544	else => return cur,
3295	};	3545	};
3296	}	3546	}
3297		3547
3298	pub fn toUnsigned(ty: Type, pt: Zcu.PerThread) !Type {	3548	pub fn toUnsigned(ty: Type, pt: Zcu.PerThread) !Type {
3299	const mod = pt.zcu;	3549	const zcu = pt.zcu;
3300	return switch (ty.zigTypeTag(mod)) {	3550	return switch (ty.zigTypeTag(zcu)) {
3301	.Int => pt.intType(.unsigned, ty.intInfo(mod).bits),	3551	.Int => pt.intType(.unsigned, ty.intInfo(zcu).bits),
3302	.Vector => try pt.vectorType(.{	3552	.Vector => try pt.vectorType(.{
3303	.len = ty.vectorLen(mod),	3553	.len = ty.vectorLen(zcu),
3304	.child = (try ty.childType(mod).toUnsigned(pt)).toIntern(),	3554	.child = (try ty.childType(zcu).toUnsigned(pt)).toIntern(),
3305	}),	3555	}),
3306	else => unreachable,	3556	else => unreachable,
3307	};	3557	};
...	@@ -3397,16 +3647,16 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:	...	@@ -3397,16 +3647,16 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:
3397		3647
3398	const zcu = pt.zcu;	3648	const zcu = pt.zcu;
3399	const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu);	3649	const parent_ptr_info = parent_ptr_ty.ptrInfo(zcu);
3400	const field_ty = struct_ty.structFieldType(field_idx, zcu);	3650	const field_ty = struct_ty.fieldType(field_idx, zcu);
3401		3651
3402	var bit_offset: u16 = 0;	3652	var bit_offset: u16 = 0;
3403	var running_bits: u16 = 0;	3653	var running_bits: u16 = 0;
3404	for (0..struct_ty.structFieldCount(zcu)) \|i\| {	3654	for (0..struct_ty.structFieldCount(zcu)) \|i\| {
3405	const f_ty = struct_ty.structFieldType(i, zcu);	3655	const f_ty = struct_ty.fieldType(i, zcu);
3406	if (i == field_idx) {	3656	if (i == field_idx) {
3407	bit_offset = running_bits;	3657	bit_offset = running_bits;
3408	}	3658	}
3409	running_bits += @intCast(f_ty.bitSize(pt));	3659	running_bits += @intCast(f_ty.bitSize(zcu));
3410	}	3660	}
3411		3661
3412	const res_host_size: u16, const res_bit_offset: u16 = if (parent_ptr_info.packed_offset.host_size != 0)	3662	const res_host_size: u16, const res_bit_offset: u16 = if (parent_ptr_info.packed_offset.host_size != 0)
...	@@ -3423,9 +3673,9 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:	...	@@ -3423,9 +3673,9 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:
3423	// targets before adding the necessary complications to this code. This will not	3673	// targets before adding the necessary complications to this code. This will not
3424	// cause miscompilations; it only means the field pointer uses bit masking when it	3674	// cause miscompilations; it only means the field pointer uses bit masking when it
3425	// might not be strictly necessary.	3675	// might not be strictly necessary.
3426	if (res_bit_offset % 8 == 0 and field_ty.bitSize(pt) == field_ty.abiSize(pt) * 8 and zcu.getTarget().cpu.arch.endian() == .little) {	3676	if (res_bit_offset % 8 == 0 and field_ty.bitSize(zcu) == field_ty.abiSize(zcu) * 8 and zcu.getTarget().cpu.arch.endian() == .little) {
3427	const byte_offset = res_bit_offset / 8;	3677	const byte_offset = res_bit_offset / 8;
3428	const new_align = Alignment.fromLog2Units(@ctz(byte_offset \| parent_ptr_ty.ptrAlignment(pt).toByteUnits().?));	3678	const new_align = Alignment.fromLog2Units(@ctz(byte_offset \| parent_ptr_ty.ptrAlignment(zcu).toByteUnits().?));
3429	return .{ .byte_ptr = .{	3679	return .{ .byte_ptr = .{
3430	.offset = byte_offset,	3680	.offset = byte_offset,
3431	.alignment = new_align,	3681	.alignment = new_align,
...	@@ -3661,11 +3911,12 @@ fn resolveStructInner(	...	@@ -3661,11 +3911,12 @@ fn resolveStructInner(
3661	var comptime_err_ret_trace = std.ArrayList(Zcu.LazySrcLoc).init(gpa);	3911	var comptime_err_ret_trace = std.ArrayList(Zcu.LazySrcLoc).init(gpa);
3662	defer comptime_err_ret_trace.deinit();	3912	defer comptime_err_ret_trace.deinit();
3663		3913
		3914	const zir = zcu.namespacePtr(struct_obj.namespace.unwrap().?).fileScope(zcu).zir;
3664	var sema: Sema = .{	3915	var sema: Sema = .{
3665	.pt = pt,	3916	.pt = pt,
3666	.gpa = gpa,	3917	.gpa = gpa,
3667	.arena = analysis_arena.allocator(),	3918	.arena = analysis_arena.allocator(),
3668	.code = undefined, // This ZIR will not be used.	3919	.code = zir,
3669	.owner = owner,	3920	.owner = owner,
3670	.func_index = .none,	3921	.func_index = .none,
3671	.func_is_naked = false,	3922	.func_is_naked = false,
...	@@ -3676,7 +3927,7 @@ fn resolveStructInner(	...	@@ -3676,7 +3927,7 @@ fn resolveStructInner(
3676	defer sema.deinit();	3927	defer sema.deinit();
3677		3928
3678	(switch (resolution) {	3929	(switch (resolution) {
3679	.fields => sema.resolveTypeFieldsStruct(ty.toIntern(), struct_obj),	3930	.fields => sema.resolveStructFieldTypes(ty.toIntern(), struct_obj),
3680	.inits => sema.resolveStructFieldInits(ty),	3931	.inits => sema.resolveStructFieldInits(ty),
3681	.alignment => sema.resolveStructAlignment(ty.toIntern(), struct_obj),	3932	.alignment => sema.resolveStructAlignment(ty.toIntern(), struct_obj),
3682	.layout => sema.resolveStructLayout(ty),	3933	.layout => sema.resolveStructLayout(ty),
...	@@ -3714,11 +3965,12 @@ fn resolveUnionInner(	...	@@ -3714,11 +3965,12 @@ fn resolveUnionInner(
3714	var comptime_err_ret_trace = std.ArrayList(Zcu.LazySrcLoc).init(gpa);	3965	var comptime_err_ret_trace = std.ArrayList(Zcu.LazySrcLoc).init(gpa);
3715	defer comptime_err_ret_trace.deinit();	3966	defer comptime_err_ret_trace.deinit();
3716		3967
		3968	const zir = zcu.namespacePtr(union_obj.namespace).fileScope(zcu).zir;
3717	var sema: Sema = .{	3969	var sema: Sema = .{
3718	.pt = pt,	3970	.pt = pt,
3719	.gpa = gpa,	3971	.gpa = gpa,
3720	.arena = analysis_arena.allocator(),	3972	.arena = analysis_arena.allocator(),
3721	.code = undefined, // This ZIR will not be used.	3973	.code = zir,
3722	.owner = owner,	3974	.owner = owner,
3723	.func_index = .none,	3975	.func_index = .none,
3724	.func_is_naked = false,	3976	.func_is_naked = false,
...	@@ -3729,7 +3981,7 @@ fn resolveUnionInner(	...	@@ -3729,7 +3981,7 @@ fn resolveUnionInner(
3729	defer sema.deinit();	3981	defer sema.deinit();
3730		3982
3731	(switch (resolution) {	3983	(switch (resolution) {
3732	.fields => sema.resolveTypeFieldsUnion(ty, union_obj),	3984	.fields => sema.resolveUnionFieldTypes(ty, union_obj),
3733	.alignment => sema.resolveUnionAlignment(ty, union_obj),	3985	.alignment => sema.resolveUnionAlignment(ty, union_obj),
3734	.layout => sema.resolveUnionLayout(ty),	3986	.layout => sema.resolveUnionLayout(ty),
3735	.full => sema.resolveUnionFully(ty),	3987	.full => sema.resolveUnionFully(ty),
...	@@ -3744,6 +3996,65 @@ fn resolveUnionInner(	...	@@ -3744,6 +3996,65 @@ fn resolveUnionInner(
3744	};	3996	};
3745	}	3997	}
3746		3998
		3999	pub fn getUnionLayout(loaded_union: InternPool.LoadedUnionType, zcu: *Zcu) Zcu.UnionLayout {
		4000	const ip = &zcu.intern_pool;
		4001	assert(loaded_union.haveLayout(ip));
		4002	var most_aligned_field: u32 = undefined;
		4003	var most_aligned_field_size: u64 = undefined;
		4004	var biggest_field: u32 = undefined;
		4005	var payload_size: u64 = 0;
		4006	var payload_align: InternPool.Alignment = .@"1";
		4007	for (loaded_union.field_types.get(ip), 0..) \|field_ty, field_index\| {
		4008	if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
		4009
		4010	const explicit_align = loaded_union.fieldAlign(ip, field_index);
		4011	const field_align = if (explicit_align != .none)
		4012	explicit_align
		4013	else
		4014	Type.fromInterned(field_ty).abiAlignment(zcu);
		4015	const field_size = Type.fromInterned(field_ty).abiSize(zcu);
		4016	if (field_size > payload_size) {
		4017	payload_size = field_size;
		4018	biggest_field = @intCast(field_index);
		4019	}
		4020	if (field_align.compare(.gte, payload_align)) {
		4021	payload_align = field_align;
		4022	most_aligned_field = @intCast(field_index);
		4023	most_aligned_field_size = field_size;
		4024	}
		4025	}
		4026	const have_tag = loaded_union.flagsUnordered(ip).runtime_tag.hasTag();
		4027	if (!have_tag or !Type.fromInterned(loaded_union.enum_tag_ty).hasRuntimeBits(zcu)) {
		4028	return .{
		4029	.abi_size = payload_align.forward(payload_size),
		4030	.abi_align = payload_align,
		4031	.most_aligned_field = most_aligned_field,
		4032	.most_aligned_field_size = most_aligned_field_size,
		4033	.biggest_field = biggest_field,
		4034	.payload_size = payload_size,
		4035	.payload_align = payload_align,
		4036	.tag_align = .none,
		4037	.tag_size = 0,
		4038	.padding = 0,
		4039	};
		4040	}
		4041
		4042	const tag_size = Type.fromInterned(loaded_union.enum_tag_ty).abiSize(zcu);
		4043	const tag_align = Type.fromInterned(loaded_union.enum_tag_ty).abiAlignment(zcu).max(.@"1");
		4044	return .{
		4045	.abi_size = loaded_union.sizeUnordered(ip),
		4046	.abi_align = tag_align.max(payload_align),
		4047	.most_aligned_field = most_aligned_field,
		4048	.most_aligned_field_size = most_aligned_field_size,
		4049	.biggest_field = biggest_field,
		4050	.payload_size = payload_size,
		4051	.payload_align = payload_align,
		4052	.tag_align = tag_align,
		4053	.tag_size = tag_size,
		4054	.padding = loaded_union.paddingUnordered(ip),
		4055	};
		4056	}
		4057
3747	/// Returns the type of a pointer to an element.	4058	/// Returns the type of a pointer to an element.
3748	/// Asserts that the type is a pointer, and that the element type is indexable.	4059	/// Asserts that the type is a pointer, and that the element type is indexable.
3749	/// If the element index is comptime-known, it must be passed in `offset`.	4060	/// If the element index is comptime-known, it must be passed in `offset`.
...	@@ -3768,14 +4079,14 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {	...	@@ -3768,14 +4079,14 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
3768	alignment: Alignment = .none,	4079	alignment: Alignment = .none,
3769	vector_index: VI = .none,	4080	vector_index: VI = .none,
3770	} = if (parent_ty.isVector(zcu) and ptr_info.flags.size == .One) blk: {	4081	} = if (parent_ty.isVector(zcu) and ptr_info.flags.size == .One) blk: {
3771	const elem_bits = elem_ty.bitSize(pt);	4082	const elem_bits = elem_ty.bitSize(zcu);
3772	if (elem_bits == 0) break :blk .{};	4083	if (elem_bits == 0) break :blk .{};
3773	const is_packed = elem_bits < 8 or !std.math.isPowerOfTwo(elem_bits);	4084	const is_packed = elem_bits < 8 or !std.math.isPowerOfTwo(elem_bits);
3774	if (!is_packed) break :blk .{};	4085	if (!is_packed) break :blk .{};
3775		4086
3776	break :blk .{	4087	break :blk .{
3777	.host_size = @intCast(parent_ty.arrayLen(zcu)),	4088	.host_size = @intCast(parent_ty.arrayLen(zcu)),
3778	.alignment = parent_ty.abiAlignment(pt),	4089	.alignment = parent_ty.abiAlignment(zcu),
3779	.vector_index = if (offset) \|some\| @enumFromInt(some) else .runtime,	4090	.vector_index = if (offset) \|some\| @enumFromInt(some) else .runtime,
3780	};	4091	};
3781	} else .{};	4092	} else .{};
...	@@ -3789,7 +4100,7 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {	...	@@ -3789,7 +4100,7 @@ pub fn elemPtrType(ptr_ty: Type, offset: ?usize, pt: Zcu.PerThread) !Type {
3789	}	4100	}
3790	// If the addend is not a comptime-known value we can still count on	4101	// If the addend is not a comptime-known value we can still count on
3791	// it being a multiple of the type size.	4102	// it being a multiple of the type size.
3792	const elem_size = (try elem_ty.abiSizeAdvanced(pt, .sema)).scalar;	4103	const elem_size = (try elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar;
3793	const addend = if (offset) \|off\| elem_size * off else elem_size;	4104	const addend = if (offset) \|off\| elem_size * off else elem_size;
3794		4105
3795	// The resulting pointer is aligned to the lcd between the offset (an	4106	// The resulting pointer is aligned to the lcd between the offset (an

src/Value.zig+767-699

...	@@ -7,8 +7,6 @@ const BigIntMutable = std.math.big.int.Mutable;	...	@@ -7,8 +7,6 @@ const BigIntMutable = std.math.big.int.Mutable;
7	const Target = std.Target;	7	const Target = std.Target;
8	const Allocator = std.mem.Allocator;	8	const Allocator = std.mem.Allocator;
9	const Zcu = @import("Zcu.zig");	9	const Zcu = @import("Zcu.zig");
10	/// Deprecated.
11	const Module = Zcu;
12	const Sema = @import("Sema.zig");	10	const Sema = @import("Sema.zig");
13	const InternPool = @import("InternPool.zig");	11	const InternPool = @import("InternPool.zig");
14	const print_value = @import("print_value.zig");	12	const print_value = @import("print_value.zig");
...	@@ -65,19 +63,19 @@ pub fn fmtValueSemaFull(ctx: print_value.FormatContext) std.fmt.Formatter(print_	...	@@ -65,19 +63,19 @@ pub fn fmtValueSemaFull(ctx: print_value.FormatContext) std.fmt.Formatter(print_
65	/// Converts `val` to a null-terminated string stored in the InternPool.	63	/// Converts `val` to a null-terminated string stored in the InternPool.
66	/// Asserts `val` is an array of `u8`	64	/// Asserts `val` is an array of `u8`
67	pub fn toIpString(val: Value, ty: Type, pt: Zcu.PerThread) !InternPool.NullTerminatedString {	65	pub fn toIpString(val: Value, ty: Type, pt: Zcu.PerThread) !InternPool.NullTerminatedString {
68	const mod = pt.zcu;	66	const zcu = pt.zcu;
69	assert(ty.zigTypeTag(mod) == .Array);	67	assert(ty.zigTypeTag(zcu) == .Array);
70	assert(ty.childType(mod).toIntern() == .u8_type);	68	assert(ty.childType(zcu).toIntern() == .u8_type);
71	const ip = &mod.intern_pool;	69	const ip = &zcu.intern_pool;
72	switch (mod.intern_pool.indexToKey(val.toIntern()).aggregate.storage) {	70	switch (zcu.intern_pool.indexToKey(val.toIntern()).aggregate.storage) {
73	.bytes => \|bytes\| return bytes.toNullTerminatedString(ty.arrayLen(mod), ip),	71	.bytes => \|bytes\| return bytes.toNullTerminatedString(ty.arrayLen(zcu), ip),
74	.elems => return arrayToIpString(val, ty.arrayLen(mod), pt),	72	.elems => return arrayToIpString(val, ty.arrayLen(zcu), pt),
75	.repeated_elem => \|elem\| {	73	.repeated_elem => \|elem\| {
76	const byte: u8 = @intCast(Value.fromInterned(elem).toUnsignedInt(pt));	74	const byte: u8 = @intCast(Value.fromInterned(elem).toUnsignedInt(zcu));
77	const len: u32 = @intCast(ty.arrayLen(mod));	75	const len: u32 = @intCast(ty.arrayLen(zcu));
78	const strings = ip.getLocal(pt.tid).getMutableStrings(mod.gpa);	76	const strings = ip.getLocal(pt.tid).getMutableStrings(zcu.gpa);
79	try strings.appendNTimes(.{byte}, len);	77	try strings.appendNTimes(.{byte}, len);
80	return ip.getOrPutTrailingString(mod.gpa, pt.tid, len, .no_embedded_nulls);	78	return ip.getOrPutTrailingString(zcu.gpa, pt.tid, len, .no_embedded_nulls);
81	},	79	},
82	}	80	}
83	}	81	}
...	@@ -85,17 +83,17 @@ pub fn toIpString(val: Value, ty: Type, pt: Zcu.PerThread) !InternPool.NullTermi	...	@@ -85,17 +83,17 @@ pub fn toIpString(val: Value, ty: Type, pt: Zcu.PerThread) !InternPool.NullTermi
85	/// Asserts that the value is representable as an array of bytes.	83	/// Asserts that the value is representable as an array of bytes.
86	/// Copies the value into a freshly allocated slice of memory, which is owned by the caller.	84	/// Copies the value into a freshly allocated slice of memory, which is owned by the caller.
87	pub fn toAllocatedBytes(val: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) ![]u8 {	85	pub fn toAllocatedBytes(val: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) ![]u8 {
88	const mod = pt.zcu;	86	const zcu = pt.zcu;
89	const ip = &mod.intern_pool;	87	const ip = &zcu.intern_pool;
90	return switch (ip.indexToKey(val.toIntern())) {	88	return switch (ip.indexToKey(val.toIntern())) {
91	.enum_literal => \|enum_literal\| allocator.dupe(u8, enum_literal.toSlice(ip)),	89	.enum_literal => \|enum_literal\| allocator.dupe(u8, enum_literal.toSlice(ip)),
92	.slice => \|slice\| try arrayToAllocatedBytes(val, Value.fromInterned(slice.len).toUnsignedInt(pt), allocator, pt),	90	.slice => \|slice\| try arrayToAllocatedBytes(val, Value.fromInterned(slice.len).toUnsignedInt(zcu), allocator, pt),
93	.aggregate => \|aggregate\| switch (aggregate.storage) {	91	.aggregate => \|aggregate\| switch (aggregate.storage) {
94	.bytes => \|bytes\| try allocator.dupe(u8, bytes.toSlice(ty.arrayLenIncludingSentinel(mod), ip)),	92	.bytes => \|bytes\| try allocator.dupe(u8, bytes.toSlice(ty.arrayLenIncludingSentinel(zcu), ip)),
95	.elems => try arrayToAllocatedBytes(val, ty.arrayLen(mod), allocator, pt),	93	.elems => try arrayToAllocatedBytes(val, ty.arrayLen(zcu), allocator, pt),
96	.repeated_elem => \|elem\| {	94	.repeated_elem => \|elem\| {
97	const byte: u8 = @intCast(Value.fromInterned(elem).toUnsignedInt(pt));	95	const byte: u8 = @intCast(Value.fromInterned(elem).toUnsignedInt(zcu));
98	const result = try allocator.alloc(u8, @intCast(ty.arrayLen(mod)));	96	const result = try allocator.alloc(u8, @intCast(ty.arrayLen(zcu)));
99	@memset(result, byte);	97	@memset(result, byte);
100	return result;	98	return result;
101	},	99	},
...	@@ -108,15 +106,15 @@ fn arrayToAllocatedBytes(val: Value, len: u64, allocator: Allocator, pt: Zcu.Per	...	@@ -108,15 +106,15 @@ fn arrayToAllocatedBytes(val: Value, len: u64, allocator: Allocator, pt: Zcu.Per
108	const result = try allocator.alloc(u8, @intCast(len));	106	const result = try allocator.alloc(u8, @intCast(len));
109	for (result, 0..) \|*elem, i\| {	107	for (result, 0..) \|*elem, i\| {
110	const elem_val = try val.elemValue(pt, i);	108	const elem_val = try val.elemValue(pt, i);
111	elem.* = @intCast(elem_val.toUnsignedInt(pt));	109	elem.* = @intCast(elem_val.toUnsignedInt(pt.zcu));
112	}	110	}
113	return result;	111	return result;
114	}	112	}
115		113
116	fn arrayToIpString(val: Value, len_u64: u64, pt: Zcu.PerThread) !InternPool.NullTerminatedString {	114	fn arrayToIpString(val: Value, len_u64: u64, pt: Zcu.PerThread) !InternPool.NullTerminatedString {
117	const mod = pt.zcu;	115	const zcu = pt.zcu;
118	const gpa = mod.gpa;	116	const gpa = zcu.gpa;
119	const ip = &mod.intern_pool;	117	const ip = &zcu.intern_pool;
120	const len: u32 = @intCast(len_u64);	118	const len: u32 = @intCast(len_u64);
121	const strings = ip.getLocal(pt.tid).getMutableStrings(gpa);	119	const strings = ip.getLocal(pt.tid).getMutableStrings(gpa);
122	try strings.ensureUnusedCapacity(len);	120	try strings.ensureUnusedCapacity(len);
...	@@ -126,7 +124,7 @@ fn arrayToIpString(val: Value, len_u64: u64, pt: Zcu.PerThread) !InternPool.Null	...	@@ -126,7 +124,7 @@ fn arrayToIpString(val: Value, len_u64: u64, pt: Zcu.PerThread) !InternPool.Null
126	const prev_len = strings.mutate.len;	124	const prev_len = strings.mutate.len;
127	const elem_val = try val.elemValue(pt, i);	125	const elem_val = try val.elemValue(pt, i);
128	assert(strings.mutate.len == prev_len);	126	assert(strings.mutate.len == prev_len);
129	const byte: u8 = @intCast(elem_val.toUnsignedInt(pt));	127	const byte: u8 = @intCast(elem_val.toUnsignedInt(zcu));
130	strings.appendAssumeCapacity(.{byte});	128	strings.appendAssumeCapacity(.{byte});
131	}	129	}
132	return ip.getOrPutTrailingString(gpa, pt.tid, len, .no_embedded_nulls);	130	return ip.getOrPutTrailingString(gpa, pt.tid, len, .no_embedded_nulls);
...	@@ -178,56 +176,61 @@ pub fn intFromEnum(val: Value, ty: Type, pt: Zcu.PerThread) Allocator.Error!Valu	...	@@ -178,56 +176,61 @@ pub fn intFromEnum(val: Value, ty: Type, pt: Zcu.PerThread) Allocator.Error!Valu
178	pub const ResolveStrat = Type.ResolveStrat;	176	pub const ResolveStrat = Type.ResolveStrat;
179		177
180	/// Asserts the value is an integer.	178	/// Asserts the value is an integer.
181	pub fn toBigInt(val: Value, space: *BigIntSpace, pt: Zcu.PerThread) BigIntConst {	179	pub fn toBigInt(val: Value, space: BigIntSpace, zcu: Zcu) BigIntConst {
182	return val.toBigIntAdvanced(space, pt, .normal) catch unreachable;	180	return val.toBigIntAdvanced(space, .normal, zcu, {}) catch unreachable;
		181	}
		182
		183	pub fn toBigIntSema(val: Value, space: *BigIntSpace, pt: Zcu.PerThread) !BigIntConst {
		184	return try val.toBigIntAdvanced(space, .sema, pt.zcu, pt.tid);
183	}	185	}
184		186
185	/// Asserts the value is an integer.	187	/// Asserts the value is an integer.
186	pub fn toBigIntAdvanced(	188	pub fn toBigIntAdvanced(
187	val: Value,	189	val: Value,
188	space: *BigIntSpace,	190	space: *BigIntSpace,
189	pt: Zcu.PerThread,
190	comptime strat: ResolveStrat,	191	comptime strat: ResolveStrat,
191	) Module.CompileError!BigIntConst {	192	zcu: *Zcu,
		193	tid: strat.Tid(),
		194	) Zcu.CompileError!BigIntConst {
192	return switch (val.toIntern()) {	195	return switch (val.toIntern()) {
193	.bool_false => BigIntMutable.init(&space.limbs, 0).toConst(),	196	.bool_false => BigIntMutable.init(&space.limbs, 0).toConst(),
194	.bool_true => BigIntMutable.init(&space.limbs, 1).toConst(),	197	.bool_true => BigIntMutable.init(&space.limbs, 1).toConst(),
195	.null_value => BigIntMutable.init(&space.limbs, 0).toConst(),	198	.null_value => BigIntMutable.init(&space.limbs, 0).toConst(),
196	else => switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {	199	else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
197	.int => \|int\| switch (int.storage) {	200	.int => \|int\| switch (int.storage) {
198	.u64, .i64, .big_int => int.storage.toBigInt(space),	201	.u64, .i64, .big_int => int.storage.toBigInt(space),
199	.lazy_align, .lazy_size => \|ty\| {	202	.lazy_align, .lazy_size => \|ty\| {
200	if (strat == .sema) try Type.fromInterned(ty).resolveLayout(pt);	203	if (strat == .sema) try Type.fromInterned(ty).resolveLayout(strat.pt(zcu, tid));
201	const x = switch (int.storage) {	204	const x = switch (int.storage) {
202	else => unreachable,	205	else => unreachable,
203	.lazy_align => Type.fromInterned(ty).abiAlignment(pt).toByteUnits() orelse 0,	206	.lazy_align => Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0,
204	.lazy_size => Type.fromInterned(ty).abiSize(pt),	207	.lazy_size => Type.fromInterned(ty).abiSize(zcu),
205	};	208	};
206	return BigIntMutable.init(&space.limbs, x).toConst();	209	return BigIntMutable.init(&space.limbs, x).toConst();
207	},	210	},
208	},	211	},
209	.enum_tag => \|enum_tag\| Value.fromInterned(enum_tag.int).toBigIntAdvanced(space, pt, strat),	212	.enum_tag => \|enum_tag\| Value.fromInterned(enum_tag.int).toBigIntAdvanced(space, strat, zcu, tid),
210	.opt, .ptr => BigIntMutable.init(	213	.opt, .ptr => BigIntMutable.init(
211	&space.limbs,	214	&space.limbs,
212	(try val.getUnsignedIntAdvanced(pt, strat)).?,	215	(try val.getUnsignedIntInner(strat, zcu, tid)).?,
213	).toConst(),	216	).toConst(),
214	else => unreachable,	217	else => unreachable,
215	},	218	},
216	};	219	};
217	}	220	}
218		221
219	pub fn isFuncBody(val: Value, mod: *Module) bool {	222	pub fn isFuncBody(val: Value, zcu: *Zcu) bool {
220	return mod.intern_pool.isFuncBody(val.toIntern());	223	return zcu.intern_pool.isFuncBody(val.toIntern());
221	}	224	}
222		225
223	pub fn getFunction(val: Value, mod: *Module) ?InternPool.Key.Func {	226	pub fn getFunction(val: Value, zcu: *Zcu) ?InternPool.Key.Func {
224	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	227	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
225	.func => \|x\| x,	228	.func => \|x\| x,
226	else => null,	229	else => null,
227	};	230	};
228	}	231	}
229		232
230	pub fn getVariable(val: Value, mod: *Module) ?InternPool.Key.Variable {	233	pub fn getVariable(val: Value, mod: *Zcu) ?InternPool.Key.Variable {
231	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	234	return switch (mod.intern_pool.indexToKey(val.toIntern())) {
232	.variable => \|variable\| variable,	235	.variable => \|variable\| variable,
233	else => null,	236	else => null,
...	@@ -236,68 +239,79 @@ pub fn getVariable(val: Value, mod: *Module) ?InternPool.Key.Variable {	...	@@ -236,68 +239,79 @@ pub fn getVariable(val: Value, mod: *Module) ?InternPool.Key.Variable {
236		239
237	/// If the value fits in a u64, return it, otherwise null.	240	/// If the value fits in a u64, return it, otherwise null.
238	/// Asserts not undefined.	241	/// Asserts not undefined.
239	pub fn getUnsignedInt(val: Value, pt: Zcu.PerThread) ?u64 {	242	pub fn getUnsignedInt(val: Value, zcu: *Zcu) ?u64 {
240	return getUnsignedIntAdvanced(val, pt, .normal) catch unreachable;	243	return getUnsignedIntInner(val, .normal, zcu, {}) catch unreachable;
		244	}
		245
		246	/// Asserts the value is an integer and it fits in a u64
		247	pub fn toUnsignedInt(val: Value, zcu: *Zcu) u64 {
		248	return getUnsignedInt(val, zcu).?;
		249	}
		250
		251	pub fn getUnsignedIntSema(val: Value, pt: Zcu.PerThread) !?u64 {
		252	return try val.getUnsignedIntInner(.sema, pt.zcu, pt.tid);
241	}	253	}
242		254
243	/// If the value fits in a u64, return it, otherwise null.	255	/// If the value fits in a u64, return it, otherwise null.
244	/// Asserts not undefined.	256	/// Asserts not undefined.
245	pub fn getUnsignedIntAdvanced(val: Value, pt: Zcu.PerThread, comptime strat: ResolveStrat) !?u64 {	257	pub fn getUnsignedIntInner(
246	const mod = pt.zcu;	258	val: Value,
		259	comptime strat: ResolveStrat,
		260	zcu: *Zcu,
		261	tid: strat.Tid(),
		262	) !?u64 {
247	return switch (val.toIntern()) {	263	return switch (val.toIntern()) {
248	.undef => unreachable,	264	.undef => unreachable,
249	.bool_false => 0,	265	.bool_false => 0,
250	.bool_true => 1,	266	.bool_true => 1,
251	else => switch (mod.intern_pool.indexToKey(val.toIntern())) {	267	else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
252	.undef => unreachable,	268	.undef => unreachable,
253	.int => \|int\| switch (int.storage) {	269	.int => \|int\| switch (int.storage) {
254	.big_int => \|big_int\| big_int.to(u64) catch null,	270	.big_int => \|big_int\| big_int.to(u64) catch null,
255	.u64 => \|x\| x,	271	.u64 => \|x\| x,
256	.i64 => \|x\| std.math.cast(u64, x),	272	.i64 => \|x\| std.math.cast(u64, x),
257	.lazy_align => \|ty\| (try Type.fromInterned(ty).abiAlignmentAdvanced(pt, strat.toLazy())).scalar.toByteUnits() orelse 0,	273	.lazy_align => \|ty\| (try Type.fromInterned(ty).abiAlignmentInner(strat.toLazy(), zcu, tid)).scalar.toByteUnits() orelse 0,
258	.lazy_size => \|ty\| (try Type.fromInterned(ty).abiSizeAdvanced(pt, strat.toLazy())).scalar,	274	.lazy_size => \|ty\| (try Type.fromInterned(ty).abiSizeInner(strat.toLazy(), zcu, tid)).scalar,
259	},	275	},
260	.ptr => \|ptr\| switch (ptr.base_addr) {	276	.ptr => \|ptr\| switch (ptr.base_addr) {
261	.int => ptr.byte_offset,	277	.int => ptr.byte_offset,
262	.field => \|field\| {	278	.field => \|field\| {
263	const base_addr = (try Value.fromInterned(field.base).getUnsignedIntAdvanced(pt, strat)) orelse return null;	279	const base_addr = (try Value.fromInterned(field.base).getUnsignedIntInner(strat, zcu, tid)) orelse return null;
264	const struct_ty = Value.fromInterned(field.base).typeOf(mod).childType(mod);	280	const struct_ty = Value.fromInterned(field.base).typeOf(zcu).childType(zcu);
265	if (strat == .sema) try struct_ty.resolveLayout(pt);	281	if (strat == .sema) {
266	return base_addr + struct_ty.structFieldOffset(@intCast(field.index), pt) + ptr.byte_offset;	282	const pt = strat.pt(zcu, tid);
		283	try struct_ty.resolveLayout(pt);
		284	}
		285	return base_addr + struct_ty.structFieldOffset(@intCast(field.index), zcu) + ptr.byte_offset;
267	},	286	},
268	else => null,	287	else => null,
269	},	288	},
270	.opt => \|opt\| switch (opt.val) {	289	.opt => \|opt\| switch (opt.val) {
271	.none => 0,	290	.none => 0,
272	else => \|payload\| Value.fromInterned(payload).getUnsignedIntAdvanced(pt, strat),	291	else => \|payload\| Value.fromInterned(payload).getUnsignedIntInner(strat, zcu, tid),
273	},	292	},
274	else => null,	293	else => null,
275	},	294	},
276	};	295	};
277	}	296	}
278		297
279	/// Asserts the value is an integer and it fits in a u64
280	pub fn toUnsignedInt(val: Value, pt: Zcu.PerThread) u64 {
281	return getUnsignedInt(val, pt).?;
282	}
283
284	/// Asserts the value is an integer and it fits in a u64	298	/// Asserts the value is an integer and it fits in a u64
285	pub fn toUnsignedIntSema(val: Value, pt: Zcu.PerThread) !u64 {	299	pub fn toUnsignedIntSema(val: Value, pt: Zcu.PerThread) !u64 {
286	return (try getUnsignedIntAdvanced(val, pt, .sema)).?;	300	return (try getUnsignedIntInner(val, .sema, pt.zcu, pt.tid)).?;
287	}	301	}
288		302
289	/// Asserts the value is an integer and it fits in a i64	303	/// Asserts the value is an integer and it fits in a i64
290	pub fn toSignedInt(val: Value, pt: Zcu.PerThread) i64 {	304	pub fn toSignedInt(val: Value, zcu: *Zcu) i64 {
291	return switch (val.toIntern()) {	305	return switch (val.toIntern()) {
292	.bool_false => 0,	306	.bool_false => 0,
293	.bool_true => 1,	307	.bool_true => 1,
294	else => switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {	308	else => switch (zcu.intern_pool.indexToKey(val.toIntern())) {
295	.int => \|int\| switch (int.storage) {	309	.int => \|int\| switch (int.storage) {
296	.big_int => \|big_int\| big_int.to(i64) catch unreachable,	310	.big_int => \|big_int\| big_int.to(i64) catch unreachable,
297	.i64 => \|x\| x,	311	.i64 => \|x\| x,
298	.u64 => \|x\| @intCast(x),	312	.u64 => \|x\| @intCast(x),
299	.lazy_align => \|ty\| @intCast(Type.fromInterned(ty).abiAlignment(pt).toByteUnits() orelse 0),	313	.lazy_align => \|ty\| @intCast(Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0),
300	.lazy_size => \|ty\| @intCast(Type.fromInterned(ty).abiSize(pt)),	314	.lazy_size => \|ty\| @intCast(Type.fromInterned(ty).abiSize(zcu)),
301	},	315	},
302	else => unreachable,	316	else => unreachable,
303	},	317	},
...	@@ -326,41 +340,41 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -326,41 +340,41 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
326	Unimplemented,	340	Unimplemented,
327	OutOfMemory,	341	OutOfMemory,
328	}!void {	342	}!void {
329	const mod = pt.zcu;	343	const zcu = pt.zcu;
330	const target = mod.getTarget();	344	const target = zcu.getTarget();
331	const endian = target.cpu.arch.endian();	345	const endian = target.cpu.arch.endian();
332	if (val.isUndef(mod)) {	346	if (val.isUndef(zcu)) {
333	const size: usize = @intCast(ty.abiSize(pt));	347	const size: usize = @intCast(ty.abiSize(zcu));
334	@memset(buffer[0..size], 0xaa);	348	@memset(buffer[0..size], 0xaa);
335	return;	349	return;
336	}	350	}
337	const ip = &mod.intern_pool;	351	const ip = &zcu.intern_pool;
338	switch (ty.zigTypeTag(mod)) {	352	switch (ty.zigTypeTag(zcu)) {
339	.Void => {},	353	.Void => {},
340	.Bool => {	354	.Bool => {
341	buffer[0] = @intFromBool(val.toBool());	355	buffer[0] = @intFromBool(val.toBool());
342	},	356	},
343	.Int, .Enum => {	357	.Int, .Enum => {
344	const int_info = ty.intInfo(mod);	358	const int_info = ty.intInfo(zcu);
345	const bits = int_info.bits;	359	const bits = int_info.bits;
346	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);	360	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);
347		361
348	var bigint_buffer: BigIntSpace = undefined;	362	var bigint_buffer: BigIntSpace = undefined;
349	const bigint = val.toBigInt(&bigint_buffer, pt);	363	const bigint = val.toBigInt(&bigint_buffer, zcu);
350	bigint.writeTwosComplement(buffer[0..byte_count], endian);	364	bigint.writeTwosComplement(buffer[0..byte_count], endian);
351	},	365	},
352	.Float => switch (ty.floatBits(target)) {	366	.Float => switch (ty.floatBits(target)) {
353	16 => std.mem.writeInt(u16, buffer[0..2], @bitCast(val.toFloat(f16, pt)), endian),	367	16 => std.mem.writeInt(u16, buffer[0..2], @bitCast(val.toFloat(f16, zcu)), endian),
354	32 => std.mem.writeInt(u32, buffer[0..4], @bitCast(val.toFloat(f32, pt)), endian),	368	32 => std.mem.writeInt(u32, buffer[0..4], @bitCast(val.toFloat(f32, zcu)), endian),
355	64 => std.mem.writeInt(u64, buffer[0..8], @bitCast(val.toFloat(f64, pt)), endian),	369	64 => std.mem.writeInt(u64, buffer[0..8], @bitCast(val.toFloat(f64, zcu)), endian),
356	80 => std.mem.writeInt(u80, buffer[0..10], @bitCast(val.toFloat(f80, pt)), endian),	370	80 => std.mem.writeInt(u80, buffer[0..10], @bitCast(val.toFloat(f80, zcu)), endian),
357	128 => std.mem.writeInt(u128, buffer[0..16], @bitCast(val.toFloat(f128, pt)), endian),	371	128 => std.mem.writeInt(u128, buffer[0..16], @bitCast(val.toFloat(f128, zcu)), endian),
358	else => unreachable,	372	else => unreachable,
359	},	373	},
360	.Array => {	374	.Array => {
361	const len = ty.arrayLen(mod);	375	const len = ty.arrayLen(zcu);
362	const elem_ty = ty.childType(mod);	376	const elem_ty = ty.childType(zcu);
363	const elem_size: usize = @intCast(elem_ty.abiSize(pt));	377	const elem_size: usize = @intCast(elem_ty.abiSize(zcu));
364	var elem_i: usize = 0;	378	var elem_i: usize = 0;
365	var buf_off: usize = 0;	379	var buf_off: usize = 0;
366	while (elem_i < len) : (elem_i += 1) {	380	while (elem_i < len) : (elem_i += 1) {
...	@@ -372,15 +386,15 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -372,15 +386,15 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
372	.Vector => {	386	.Vector => {
373	// We use byte_count instead of abi_size here, so that any padding bytes	387	// We use byte_count instead of abi_size here, so that any padding bytes
374	// follow the data bytes, on both big- and little-endian systems.	388	// follow the data bytes, on both big- and little-endian systems.
375	const byte_count = (@as(usize, @intCast(ty.bitSize(pt))) + 7) / 8;	389	const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
376	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);	390	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
377	},	391	},
378	.Struct => {	392	.Struct => {
379	const struct_type = mod.typeToStruct(ty) orelse return error.IllDefinedMemoryLayout;	393	const struct_type = zcu.typeToStruct(ty) orelse return error.IllDefinedMemoryLayout;
380	switch (struct_type.layout) {	394	switch (struct_type.layout) {
381	.auto => return error.IllDefinedMemoryLayout,	395	.auto => return error.IllDefinedMemoryLayout,
382	.@"extern" => for (0..struct_type.field_types.len) \|field_index\| {	396	.@"extern" => for (0..struct_type.field_types.len) \|field_index\| {
383	const off: usize = @intCast(ty.structFieldOffset(field_index, pt));	397	const off: usize = @intCast(ty.structFieldOffset(field_index, zcu));
384	const field_val = Value.fromInterned(switch (ip.indexToKey(val.toIntern()).aggregate.storage) {	398	const field_val = Value.fromInterned(switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
385	.bytes => \|bytes\| {	399	.bytes => \|bytes\| {
386	buffer[off] = bytes.at(field_index, ip);	400	buffer[off] = bytes.at(field_index, ip);
...	@@ -393,13 +407,13 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -393,13 +407,13 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
393	try writeToMemory(field_val, field_ty, pt, buffer[off..]);	407	try writeToMemory(field_val, field_ty, pt, buffer[off..]);
394	},	408	},
395	.@"packed" => {	409	.@"packed" => {
396	const byte_count = (@as(usize, @intCast(ty.bitSize(pt))) + 7) / 8;	410	const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
397	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);	411	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
398	},	412	},
399	}	413	}
400	},	414	},
401	.ErrorSet => {	415	.ErrorSet => {
402	const bits = mod.errorSetBits();	416	const bits = zcu.errorSetBits();
403	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);	417	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);
404		418
405	const name = switch (ip.indexToKey(val.toIntern())) {	419	const name = switch (ip.indexToKey(val.toIntern())) {
...	@@ -414,37 +428,37 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -414,37 +428,37 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
414	).toConst();	428	).toConst();
415	bigint.writeTwosComplement(buffer[0..byte_count], endian);	429	bigint.writeTwosComplement(buffer[0..byte_count], endian);
416	},	430	},
417	.Union => switch (ty.containerLayout(mod)) {	431	.Union => switch (ty.containerLayout(zcu)) {
418	.auto => return error.IllDefinedMemoryLayout, // Sema is supposed to have emitted a compile error already	432	.auto => return error.IllDefinedMemoryLayout, // Sema is supposed to have emitted a compile error already
419	.@"extern" => {	433	.@"extern" => {
420	if (val.unionTag(mod)) \|union_tag\| {	434	if (val.unionTag(zcu)) \|union_tag\| {
421	const union_obj = mod.typeToUnion(ty).?;	435	const union_obj = zcu.typeToUnion(ty).?;
422	const field_index = mod.unionTagFieldIndex(union_obj, union_tag).?;	436	const field_index = zcu.unionTagFieldIndex(union_obj, union_tag).?;
423	const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);	437	const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
424	const field_val = try val.fieldValue(pt, field_index);	438	const field_val = try val.fieldValue(pt, field_index);
425	const byte_count: usize = @intCast(field_type.abiSize(pt));	439	const byte_count: usize = @intCast(field_type.abiSize(zcu));
426	return writeToMemory(field_val, field_type, pt, buffer[0..byte_count]);	440	return writeToMemory(field_val, field_type, pt, buffer[0..byte_count]);
427	} else {	441	} else {
428	const backing_ty = try ty.unionBackingType(pt);	442	const backing_ty = try ty.unionBackingType(pt);
429	const byte_count: usize = @intCast(backing_ty.abiSize(pt));	443	const byte_count: usize = @intCast(backing_ty.abiSize(zcu));
430	return writeToMemory(val.unionValue(mod), backing_ty, pt, buffer[0..byte_count]);	444	return writeToMemory(val.unionValue(zcu), backing_ty, pt, buffer[0..byte_count]);
431	}	445	}
432	},	446	},
433	.@"packed" => {	447	.@"packed" => {
434	const backing_ty = try ty.unionBackingType(pt);	448	const backing_ty = try ty.unionBackingType(pt);
435	const byte_count: usize = @intCast(backing_ty.abiSize(pt));	449	const byte_count: usize = @intCast(backing_ty.abiSize(zcu));
436	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);	450	return writeToPackedMemory(val, ty, pt, buffer[0..byte_count], 0);
437	},	451	},
438	},	452	},
439	.Pointer => {	453	.Pointer => {
440	if (ty.isSlice(mod)) return error.IllDefinedMemoryLayout;	454	if (ty.isSlice(zcu)) return error.IllDefinedMemoryLayout;
441	if (!val.ptrHasIntAddr(mod)) return error.ReinterpretDeclRef;	455	if (!val.ptrHasIntAddr(zcu)) return error.ReinterpretDeclRef;
442	return val.writeToMemory(Type.usize, pt, buffer);	456	return val.writeToMemory(Type.usize, pt, buffer);
443	},	457	},
444	.Optional => {	458	.Optional => {
445	if (!ty.isPtrLikeOptional(mod)) return error.IllDefinedMemoryLayout;	459	if (!ty.isPtrLikeOptional(zcu)) return error.IllDefinedMemoryLayout;
446	const child = ty.optionalChild(mod);	460	const child = ty.optionalChild(zcu);
447	const opt_val = val.optionalValue(mod);	461	const opt_val = val.optionalValue(zcu);
448	if (opt_val) \|some\| {	462	if (opt_val) \|some\| {
449	return some.writeToMemory(child, pt, buffer);	463	return some.writeToMemory(child, pt, buffer);
450	} else {	464	} else {
...	@@ -466,18 +480,18 @@ pub fn writeToPackedMemory(	...	@@ -466,18 +480,18 @@ pub fn writeToPackedMemory(
466	buffer: []u8,	480	buffer: []u8,
467	bit_offset: usize,	481	bit_offset: usize,
468	) error{ ReinterpretDeclRef, OutOfMemory }!void {	482	) error{ ReinterpretDeclRef, OutOfMemory }!void {
469	const mod = pt.zcu;	483	const zcu = pt.zcu;
470	const ip = &mod.intern_pool;	484	const ip = &zcu.intern_pool;
471	const target = mod.getTarget();	485	const target = zcu.getTarget();
472	const endian = target.cpu.arch.endian();	486	const endian = target.cpu.arch.endian();
473	if (val.isUndef(mod)) {	487	if (val.isUndef(zcu)) {
474	const bit_size: usize = @intCast(ty.bitSize(pt));	488	const bit_size: usize = @intCast(ty.bitSize(zcu));
475	if (bit_size != 0) {	489	if (bit_size != 0) {
476	std.mem.writeVarPackedInt(buffer, bit_offset, bit_size, @as(u1, 0), endian);	490	std.mem.writeVarPackedInt(buffer, bit_offset, bit_size, @as(u1, 0), endian);
477	}	491	}
478	return;	492	return;
479	}	493	}
480	switch (ty.zigTypeTag(mod)) {	494	switch (ty.zigTypeTag(zcu)) {
481	.Void => {},	495	.Void => {},
482	.Bool => {	496	.Bool => {
483	const byte_index = switch (endian) {	497	const byte_index = switch (endian) {
...	@@ -492,34 +506,34 @@ pub fn writeToPackedMemory(	...	@@ -492,34 +506,34 @@ pub fn writeToPackedMemory(
492	},	506	},
493	.Int, .Enum => {	507	.Int, .Enum => {
494	if (buffer.len == 0) return;	508	if (buffer.len == 0) return;
495	const bits = ty.intInfo(mod).bits;	509	const bits = ty.intInfo(zcu).bits;
496	if (bits == 0) return;	510	if (bits == 0) return;
497		511
498	switch (ip.indexToKey((try val.intFromEnum(ty, pt)).toIntern()).int.storage) {	512	switch (ip.indexToKey((try val.intFromEnum(ty, pt)).toIntern()).int.storage) {
499	inline .u64, .i64 => \|int\| std.mem.writeVarPackedInt(buffer, bit_offset, bits, int, endian),	513	inline .u64, .i64 => \|int\| std.mem.writeVarPackedInt(buffer, bit_offset, bits, int, endian),
500	.big_int => \|bigint\| bigint.writePackedTwosComplement(buffer, bit_offset, bits, endian),	514	.big_int => \|bigint\| bigint.writePackedTwosComplement(buffer, bit_offset, bits, endian),
501	.lazy_align => \|lazy_align\| {	515	.lazy_align => \|lazy_align\| {
502	const num = Type.fromInterned(lazy_align).abiAlignment(pt).toByteUnits() orelse 0;	516	const num = Type.fromInterned(lazy_align).abiAlignment(zcu).toByteUnits() orelse 0;
503	std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);	517	std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);
504	},	518	},
505	.lazy_size => \|lazy_size\| {	519	.lazy_size => \|lazy_size\| {
506	const num = Type.fromInterned(lazy_size).abiSize(pt);	520	const num = Type.fromInterned(lazy_size).abiSize(zcu);
507	std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);	521	std.mem.writeVarPackedInt(buffer, bit_offset, bits, num, endian);
508	},	522	},
509	}	523	}
510	},	524	},
511	.Float => switch (ty.floatBits(target)) {	525	.Float => switch (ty.floatBits(target)) {
512	16 => std.mem.writePackedInt(u16, buffer, bit_offset, @bitCast(val.toFloat(f16, pt)), endian),	526	16 => std.mem.writePackedInt(u16, buffer, bit_offset, @bitCast(val.toFloat(f16, zcu)), endian),
513	32 => std.mem.writePackedInt(u32, buffer, bit_offset, @bitCast(val.toFloat(f32, pt)), endian),	527	32 => std.mem.writePackedInt(u32, buffer, bit_offset, @bitCast(val.toFloat(f32, zcu)), endian),
514	64 => std.mem.writePackedInt(u64, buffer, bit_offset, @bitCast(val.toFloat(f64, pt)), endian),	528	64 => std.mem.writePackedInt(u64, buffer, bit_offset, @bitCast(val.toFloat(f64, zcu)), endian),
515	80 => std.mem.writePackedInt(u80, buffer, bit_offset, @bitCast(val.toFloat(f80, pt)), endian),	529	80 => std.mem.writePackedInt(u80, buffer, bit_offset, @bitCast(val.toFloat(f80, zcu)), endian),
516	128 => std.mem.writePackedInt(u128, buffer, bit_offset, @bitCast(val.toFloat(f128, pt)), endian),	530	128 => std.mem.writePackedInt(u128, buffer, bit_offset, @bitCast(val.toFloat(f128, zcu)), endian),
517	else => unreachable,	531	else => unreachable,
518	},	532	},
519	.Vector => {	533	.Vector => {
520	const elem_ty = ty.childType(mod);	534	const elem_ty = ty.childType(zcu);
521	const elem_bit_size: u16 = @intCast(elem_ty.bitSize(pt));	535	const elem_bit_size: u16 = @intCast(elem_ty.bitSize(zcu));
522	const len: usize = @intCast(ty.arrayLen(mod));	536	const len: usize = @intCast(ty.arrayLen(zcu));
523		537
524	var bits: u16 = 0;	538	var bits: u16 = 0;
525	var elem_i: usize = 0;	539	var elem_i: usize = 0;
...	@@ -544,37 +558,37 @@ pub fn writeToPackedMemory(	...	@@ -544,37 +558,37 @@ pub fn writeToPackedMemory(
544	.repeated_elem => \|elem\| elem,	558	.repeated_elem => \|elem\| elem,
545	});	559	});
546	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);	560	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
547	const field_bits: u16 = @intCast(field_ty.bitSize(pt));	561	const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
548	try field_val.writeToPackedMemory(field_ty, pt, buffer, bit_offset + bits);	562	try field_val.writeToPackedMemory(field_ty, pt, buffer, bit_offset + bits);
549	bits += field_bits;	563	bits += field_bits;
550	}	564	}
551	},	565	},
552	.Union => {	566	.Union => {
553	const union_obj = mod.typeToUnion(ty).?;	567	const union_obj = zcu.typeToUnion(ty).?;
554	switch (union_obj.flagsUnordered(ip).layout) {	568	switch (union_obj.flagsUnordered(ip).layout) {
555	.auto, .@"extern" => unreachable, // Handled in non-packed writeToMemory	569	.auto, .@"extern" => unreachable, // Handled in non-packed writeToMemory
556	.@"packed" => {	570	.@"packed" => {
557	if (val.unionTag(mod)) \|union_tag\| {	571	if (val.unionTag(zcu)) \|union_tag\| {
558	const field_index = mod.unionTagFieldIndex(union_obj, union_tag).?;	572	const field_index = zcu.unionTagFieldIndex(union_obj, union_tag).?;
559	const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);	573	const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
560	const field_val = try val.fieldValue(pt, field_index);	574	const field_val = try val.fieldValue(pt, field_index);
561	return field_val.writeToPackedMemory(field_type, pt, buffer, bit_offset);	575	return field_val.writeToPackedMemory(field_type, pt, buffer, bit_offset);
562	} else {	576	} else {
563	const backing_ty = try ty.unionBackingType(pt);	577	const backing_ty = try ty.unionBackingType(pt);
564	return val.unionValue(mod).writeToPackedMemory(backing_ty, pt, buffer, bit_offset);	578	return val.unionValue(zcu).writeToPackedMemory(backing_ty, pt, buffer, bit_offset);
565	}	579	}
566	},	580	},
567	}	581	}
568	},	582	},
569	.Pointer => {	583	.Pointer => {
570	assert(!ty.isSlice(mod)); // No well defined layout.	584	assert(!ty.isSlice(zcu)); // No well defined layout.
571	if (!val.ptrHasIntAddr(mod)) return error.ReinterpretDeclRef;	585	if (!val.ptrHasIntAddr(zcu)) return error.ReinterpretDeclRef;
572	return val.writeToPackedMemory(Type.usize, pt, buffer, bit_offset);	586	return val.writeToPackedMemory(Type.usize, pt, buffer, bit_offset);
573	},	587	},
574	.Optional => {	588	.Optional => {
575	assert(ty.isPtrLikeOptional(mod));	589	assert(ty.isPtrLikeOptional(zcu));
576	const child = ty.optionalChild(mod);	590	const child = ty.optionalChild(zcu);
577	const opt_val = val.optionalValue(mod);	591	const opt_val = val.optionalValue(zcu);
578	if (opt_val) \|some\| {	592	if (opt_val) \|some\| {
579	return some.writeToPackedMemory(child, pt, buffer, bit_offset);	593	return some.writeToPackedMemory(child, pt, buffer, bit_offset);
580	} else {	594	} else {
...	@@ -599,11 +613,11 @@ pub fn readFromMemory(	...	@@ -599,11 +613,11 @@ pub fn readFromMemory(
599	Unimplemented,	613	Unimplemented,
600	OutOfMemory,	614	OutOfMemory,
601	}!Value {	615	}!Value {
602	const mod = pt.zcu;	616	const zcu = pt.zcu;
603	const ip = &mod.intern_pool;	617	const ip = &zcu.intern_pool;
604	const target = mod.getTarget();	618	const target = zcu.getTarget();
605	const endian = target.cpu.arch.endian();	619	const endian = target.cpu.arch.endian();
606	switch (ty.zigTypeTag(mod)) {	620	switch (ty.zigTypeTag(zcu)) {
607	.Void => return Value.void,	621	.Void => return Value.void,
608	.Bool => {	622	.Bool => {
609	if (buffer[0] == 0) {	623	if (buffer[0] == 0) {
...	@@ -615,24 +629,24 @@ pub fn readFromMemory(	...	@@ -615,24 +629,24 @@ pub fn readFromMemory(
615	.Int, .Enum => \|ty_tag\| {	629	.Int, .Enum => \|ty_tag\| {
616	const int_ty = switch (ty_tag) {	630	const int_ty = switch (ty_tag) {
617	.Int => ty,	631	.Int => ty,
618	.Enum => ty.intTagType(mod),	632	.Enum => ty.intTagType(zcu),
619	else => unreachable,	633	else => unreachable,
620	};	634	};
621	const int_info = int_ty.intInfo(mod);	635	const int_info = int_ty.intInfo(zcu);
622	const bits = int_info.bits;	636	const bits = int_info.bits;
623	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);	637	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);
624	if (bits == 0 or buffer.len == 0) return mod.getCoerced(try mod.intValue(int_ty, 0), ty);	638	if (bits == 0 or buffer.len == 0) return zcu.getCoerced(try zcu.intValue(int_ty, 0), ty);
625		639
626	if (bits <= 64) switch (int_info.signedness) { // Fast path for integers <= u64	640	if (bits <= 64) switch (int_info.signedness) { // Fast path for integers <= u64
627	.signed => {	641	.signed => {
628	const val = std.mem.readVarInt(i64, buffer[0..byte_count], endian);	642	const val = std.mem.readVarInt(i64, buffer[0..byte_count], endian);
629	const result = (val << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));	643	const result = (val << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));
630	return mod.getCoerced(try mod.intValue(int_ty, result), ty);	644	return zcu.getCoerced(try zcu.intValue(int_ty, result), ty);
631	},	645	},
632	.unsigned => {	646	.unsigned => {
633	const val = std.mem.readVarInt(u64, buffer[0..byte_count], endian);	647	const val = std.mem.readVarInt(u64, buffer[0..byte_count], endian);
634	const result = (val << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));	648	const result = (val << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));
635	return mod.getCoerced(try mod.intValue(int_ty, result), ty);	649	return zcu.getCoerced(try zcu.intValue(int_ty, result), ty);
636	},	650	},
637	} else { // Slow path, we have to construct a big-int	651	} else { // Slow path, we have to construct a big-int
638	const Limb = std.math.big.Limb;	652	const Limb = std.math.big.Limb;
...	@@ -641,7 +655,7 @@ pub fn readFromMemory(	...	@@ -641,7 +655,7 @@ pub fn readFromMemory(
641		655
642	var bigint = BigIntMutable.init(limbs_buffer, 0);	656	var bigint = BigIntMutable.init(limbs_buffer, 0);
643	bigint.readTwosComplement(buffer[0..byte_count], bits, endian, int_info.signedness);	657	bigint.readTwosComplement(buffer[0..byte_count], bits, endian, int_info.signedness);
644	return mod.getCoerced(try mod.intValue_big(int_ty, bigint.toConst()), ty);	658	return zcu.getCoerced(try zcu.intValue_big(int_ty, bigint.toConst()), ty);
645	}	659	}
646	},	660	},
647	.Float => return Value.fromInterned(try pt.intern(.{ .float = .{	661	.Float => return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -656,12 +670,12 @@ pub fn readFromMemory(	...	@@ -656,12 +670,12 @@ pub fn readFromMemory(
656	},	670	},
657	} })),	671	} })),
658	.Array => {	672	.Array => {
659	const elem_ty = ty.childType(mod);	673	const elem_ty = ty.childType(zcu);
660	const elem_size = elem_ty.abiSize(pt);	674	const elem_size = elem_ty.abiSize(zcu);
661	const elems = try arena.alloc(InternPool.Index, @intCast(ty.arrayLen(mod)));	675	const elems = try arena.alloc(InternPool.Index, @intCast(ty.arrayLen(zcu)));
662	var offset: usize = 0;	676	var offset: usize = 0;
663	for (elems) \|*elem\| {	677	for (elems) \|*elem\| {
664	elem.* = (try readFromMemory(elem_ty, mod, buffer[offset..], arena)).toIntern();	678	elem.* = (try readFromMemory(elem_ty, zcu, buffer[offset..], arena)).toIntern();
665	offset += @intCast(elem_size);	679	offset += @intCast(elem_size);
666	}	680	}
667	return Value.fromInterned(try pt.intern(.{ .aggregate = .{	681	return Value.fromInterned(try pt.intern(.{ .aggregate = .{
...	@@ -672,11 +686,11 @@ pub fn readFromMemory(	...	@@ -672,11 +686,11 @@ pub fn readFromMemory(
672	.Vector => {	686	.Vector => {
673	// We use byte_count instead of abi_size here, so that any padding bytes	687	// We use byte_count instead of abi_size here, so that any padding bytes
674	// follow the data bytes, on both big- and little-endian systems.	688	// follow the data bytes, on both big- and little-endian systems.
675	const byte_count = (@as(usize, @intCast(ty.bitSize(pt))) + 7) / 8;	689	const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
676	return readFromPackedMemory(ty, mod, buffer[0..byte_count], 0, arena);	690	return readFromPackedMemory(ty, zcu, buffer[0..byte_count], 0, arena);
677	},	691	},
678	.Struct => {	692	.Struct => {
679	const struct_type = mod.typeToStruct(ty).?;	693	const struct_type = zcu.typeToStruct(ty).?;
680	switch (struct_type.layout) {	694	switch (struct_type.layout) {
681	.auto => unreachable, // Sema is supposed to have emitted a compile error already	695	.auto => unreachable, // Sema is supposed to have emitted a compile error already
682	.@"extern" => {	696	.@"extern" => {
...	@@ -684,9 +698,9 @@ pub fn readFromMemory(	...	@@ -684,9 +698,9 @@ pub fn readFromMemory(
684	const field_vals = try arena.alloc(InternPool.Index, field_types.len);	698	const field_vals = try arena.alloc(InternPool.Index, field_types.len);
685	for (field_vals, 0..) \|*field_val, i\| {	699	for (field_vals, 0..) \|*field_val, i\| {
686	const field_ty = Type.fromInterned(field_types.get(ip)[i]);	700	const field_ty = Type.fromInterned(field_types.get(ip)[i]);
687	const off: usize = @intCast(ty.structFieldOffset(i, mod));	701	const off: usize = @intCast(ty.structFieldOffset(i, zcu));
688	const sz: usize = @intCast(field_ty.abiSize(pt));	702	const sz: usize = @intCast(field_ty.abiSize(zcu));
689	field_val.* = (try readFromMemory(field_ty, mod, buffer[off..(off + sz)], arena)).toIntern();	703	field_val.* = (try readFromMemory(field_ty, zcu, buffer[off..(off + sz)], arena)).toIntern();
690	}	704	}
691	return Value.fromInterned(try pt.intern(.{ .aggregate = .{	705	return Value.fromInterned(try pt.intern(.{ .aggregate = .{
692	.ty = ty.toIntern(),	706	.ty = ty.toIntern(),
...	@@ -694,29 +708,29 @@ pub fn readFromMemory(	...	@@ -694,29 +708,29 @@ pub fn readFromMemory(
694	} }));	708	} }));
695	},	709	},
696	.@"packed" => {	710	.@"packed" => {
697	const byte_count = (@as(usize, @intCast(ty.bitSize(pt))) + 7) / 8;	711	const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
698	return readFromPackedMemory(ty, mod, buffer[0..byte_count], 0, arena);	712	return readFromPackedMemory(ty, zcu, buffer[0..byte_count], 0, arena);
699	},	713	},
700	}	714	}
701	},	715	},
702	.ErrorSet => {	716	.ErrorSet => {
703	const bits = mod.errorSetBits();	717	const bits = zcu.errorSetBits();
704	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);	718	const byte_count: u16 = @intCast((@as(u17, bits) + 7) / 8);
705	const int = std.mem.readVarInt(u64, buffer[0..byte_count], endian);	719	const int = std.mem.readVarInt(u64, buffer[0..byte_count], endian);
706	const index = (int << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));	720	const index = (int << @as(u6, @intCast(64 - bits))) >> @as(u6, @intCast(64 - bits));
707	const name = mod.global_error_set.keys()[@intCast(index)];	721	const name = zcu.global_error_set.keys()[@intCast(index)];
708		722
709	return Value.fromInterned(try pt.intern(.{ .err = .{	723	return Value.fromInterned(try pt.intern(.{ .err = .{
710	.ty = ty.toIntern(),	724	.ty = ty.toIntern(),
711	.name = name,	725	.name = name,
712	} }));	726	} }));
713	},	727	},
714	.Union => switch (ty.containerLayout(mod)) {	728	.Union => switch (ty.containerLayout(zcu)) {
715	.auto => return error.IllDefinedMemoryLayout,	729	.auto => return error.IllDefinedMemoryLayout,
716	.@"extern" => {	730	.@"extern" => {
717	const union_size = ty.abiSize(pt);	731	const union_size = ty.abiSize(zcu);
718	const array_ty = try mod.arrayType(.{ .len = union_size, .child = .u8_type });	732	const array_ty = try zcu.arrayType(.{ .len = union_size, .child = .u8_type });
719	const val = (try readFromMemory(array_ty, mod, buffer, arena)).toIntern();	733	const val = (try readFromMemory(array_ty, zcu, buffer, arena)).toIntern();
720	return Value.fromInterned(try pt.intern(.{ .un = .{	734	return Value.fromInterned(try pt.intern(.{ .un = .{
721	.ty = ty.toIntern(),	735	.ty = ty.toIntern(),
722	.tag = .none,	736	.tag = .none,
...	@@ -724,23 +738,23 @@ pub fn readFromMemory(	...	@@ -724,23 +738,23 @@ pub fn readFromMemory(
724	} }));	738	} }));
725	},	739	},
726	.@"packed" => {	740	.@"packed" => {
727	const byte_count = (@as(usize, @intCast(ty.bitSize(pt))) + 7) / 8;	741	const byte_count = (@as(usize, @intCast(ty.bitSize(zcu))) + 7) / 8;
728	return readFromPackedMemory(ty, mod, buffer[0..byte_count], 0, arena);	742	return readFromPackedMemory(ty, zcu, buffer[0..byte_count], 0, arena);
729	},	743	},
730	},	744	},
731	.Pointer => {	745	.Pointer => {
732	assert(!ty.isSlice(mod)); // No well defined layout.	746	assert(!ty.isSlice(zcu)); // No well defined layout.
733	const int_val = try readFromMemory(Type.usize, mod, buffer, arena);	747	const int_val = try readFromMemory(Type.usize, zcu, buffer, arena);
734	return Value.fromInterned(try pt.intern(.{ .ptr = .{	748	return Value.fromInterned(try pt.intern(.{ .ptr = .{
735	.ty = ty.toIntern(),	749	.ty = ty.toIntern(),
736	.base_addr = .int,	750	.base_addr = .int,
737	.byte_offset = int_val.toUnsignedInt(pt),	751	.byte_offset = int_val.toUnsignedInt(zcu),
738	} }));	752	} }));
739	},	753	},
740	.Optional => {	754	.Optional => {
741	assert(ty.isPtrLikeOptional(mod));	755	assert(ty.isPtrLikeOptional(zcu));
742	const child_ty = ty.optionalChild(mod);	756	const child_ty = ty.optionalChild(zcu);
743	const child_val = try readFromMemory(child_ty, mod, buffer, arena);	757	const child_val = try readFromMemory(child_ty, zcu, buffer, arena);
744	return Value.fromInterned(try pt.intern(.{ .opt = .{	758	return Value.fromInterned(try pt.intern(.{ .opt = .{
745	.ty = ty.toIntern(),	759	.ty = ty.toIntern(),
746	.val = switch (child_val.orderAgainstZero(pt)) {	760	.val = switch (child_val.orderAgainstZero(pt)) {
...	@@ -768,11 +782,11 @@ pub fn readFromPackedMemory(	...	@@ -768,11 +782,11 @@ pub fn readFromPackedMemory(
768	IllDefinedMemoryLayout,	782	IllDefinedMemoryLayout,
769	OutOfMemory,	783	OutOfMemory,
770	}!Value {	784	}!Value {
771	const mod = pt.zcu;	785	const zcu = pt.zcu;
772	const ip = &mod.intern_pool;	786	const ip = &zcu.intern_pool;
773	const target = mod.getTarget();	787	const target = zcu.getTarget();
774	const endian = target.cpu.arch.endian();	788	const endian = target.cpu.arch.endian();
775	switch (ty.zigTypeTag(mod)) {	789	switch (ty.zigTypeTag(zcu)) {
776	.Void => return Value.void,	790	.Void => return Value.void,
777	.Bool => {	791	.Bool => {
778	const byte = switch (endian) {	792	const byte = switch (endian) {
...	@@ -787,7 +801,7 @@ pub fn readFromPackedMemory(	...	@@ -787,7 +801,7 @@ pub fn readFromPackedMemory(
787	},	801	},
788	.Int => {	802	.Int => {
789	if (buffer.len == 0) return pt.intValue(ty, 0);	803	if (buffer.len == 0) return pt.intValue(ty, 0);
790	const int_info = ty.intInfo(mod);	804	const int_info = ty.intInfo(zcu);
791	const bits = int_info.bits;	805	const bits = int_info.bits;
792	if (bits == 0) return pt.intValue(ty, 0);	806	if (bits == 0) return pt.intValue(ty, 0);
793		807
...	@@ -800,7 +814,7 @@ pub fn readFromPackedMemory(	...	@@ -800,7 +814,7 @@ pub fn readFromPackedMemory(
800	};	814	};
801		815
802	// Slow path, we have to construct a big-int	816	// Slow path, we have to construct a big-int
803	const abi_size: usize = @intCast(ty.abiSize(pt));	817	const abi_size: usize = @intCast(ty.abiSize(zcu));
804	const Limb = std.math.big.Limb;	818	const Limb = std.math.big.Limb;
805	const limb_count = (abi_size + @sizeOf(Limb) - 1) / @sizeOf(Limb);	819	const limb_count = (abi_size + @sizeOf(Limb) - 1) / @sizeOf(Limb);
806	const limbs_buffer = try arena.alloc(Limb, limb_count);	820	const limbs_buffer = try arena.alloc(Limb, limb_count);
...	@@ -810,7 +824,7 @@ pub fn readFromPackedMemory(	...	@@ -810,7 +824,7 @@ pub fn readFromPackedMemory(
810	return pt.intValue_big(ty, bigint.toConst());	824	return pt.intValue_big(ty, bigint.toConst());
811	},	825	},
812	.Enum => {	826	.Enum => {
813	const int_ty = ty.intTagType(mod);	827	const int_ty = ty.intTagType(zcu);
814	const int_val = try Value.readFromPackedMemory(int_ty, pt, buffer, bit_offset, arena);	828	const int_val = try Value.readFromPackedMemory(int_ty, pt, buffer, bit_offset, arena);
815	return pt.getCoerced(int_val, ty);	829	return pt.getCoerced(int_val, ty);
816	},	830	},
...	@@ -826,11 +840,11 @@ pub fn readFromPackedMemory(	...	@@ -826,11 +840,11 @@ pub fn readFromPackedMemory(
826	},	840	},
827	} })),	841	} })),
828	.Vector => {	842	.Vector => {
829	const elem_ty = ty.childType(mod);	843	const elem_ty = ty.childType(zcu);
830	const elems = try arena.alloc(InternPool.Index, @intCast(ty.arrayLen(mod)));	844	const elems = try arena.alloc(InternPool.Index, @intCast(ty.arrayLen(zcu)));
831		845
832	var bits: u16 = 0;	846	var bits: u16 = 0;
833	const elem_bit_size: u16 = @intCast(elem_ty.bitSize(pt));	847	const elem_bit_size: u16 = @intCast(elem_ty.bitSize(zcu));
834	for (elems, 0..) \|_, i\| {	848	for (elems, 0..) \|_, i\| {
835	// On big-endian systems, LLVM reverses the element order of vectors by default	849	// On big-endian systems, LLVM reverses the element order of vectors by default
836	const tgt_elem_i = if (endian == .big) elems.len - i - 1 else i;	850	const tgt_elem_i = if (endian == .big) elems.len - i - 1 else i;
...	@@ -845,12 +859,12 @@ pub fn readFromPackedMemory(	...	@@ -845,12 +859,12 @@ pub fn readFromPackedMemory(
845	.Struct => {	859	.Struct => {
846	// Sema is supposed to have emitted a compile error already for Auto layout structs,	860	// Sema is supposed to have emitted a compile error already for Auto layout structs,
847	// and Extern is handled by non-packed readFromMemory.	861	// and Extern is handled by non-packed readFromMemory.
848	const struct_type = mod.typeToPackedStruct(ty).?;	862	const struct_type = zcu.typeToPackedStruct(ty).?;
849	var bits: u16 = 0;	863	var bits: u16 = 0;
850	const field_vals = try arena.alloc(InternPool.Index, struct_type.field_types.len);	864	const field_vals = try arena.alloc(InternPool.Index, struct_type.field_types.len);
851	for (field_vals, 0..) \|*field_val, i\| {	865	for (field_vals, 0..) \|*field_val, i\| {
852	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);	866	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
853	const field_bits: u16 = @intCast(field_ty.bitSize(pt));	867	const field_bits: u16 = @intCast(field_ty.bitSize(zcu));
854	field_val.* = (try readFromPackedMemory(field_ty, pt, buffer, bit_offset + bits, arena)).toIntern();	868	field_val.* = (try readFromPackedMemory(field_ty, pt, buffer, bit_offset + bits, arena)).toIntern();
855	bits += field_bits;	869	bits += field_bits;
856	}	870	}
...	@@ -859,7 +873,7 @@ pub fn readFromPackedMemory(	...	@@ -859,7 +873,7 @@ pub fn readFromPackedMemory(
859	.storage = .{ .elems = field_vals },	873	.storage = .{ .elems = field_vals },
860	} }));	874	} }));
861	},	875	},
862	.Union => switch (ty.containerLayout(mod)) {	876	.Union => switch (ty.containerLayout(zcu)) {
863	.auto, .@"extern" => unreachable, // Handled by non-packed readFromMemory	877	.auto, .@"extern" => unreachable, // Handled by non-packed readFromMemory
864	.@"packed" => {	878	.@"packed" => {
865	const backing_ty = try ty.unionBackingType(pt);	879	const backing_ty = try ty.unionBackingType(pt);
...	@@ -872,21 +886,21 @@ pub fn readFromPackedMemory(	...	@@ -872,21 +886,21 @@ pub fn readFromPackedMemory(
872	},	886	},
873	},	887	},
874	.Pointer => {	888	.Pointer => {
875	assert(!ty.isSlice(mod)); // No well defined layout.	889	assert(!ty.isSlice(zcu)); // No well defined layout.
876	const int_val = try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena);	890	const int_val = try readFromPackedMemory(Type.usize, pt, buffer, bit_offset, arena);
877	return Value.fromInterned(try pt.intern(.{ .ptr = .{	891	return Value.fromInterned(try pt.intern(.{ .ptr = .{
878	.ty = ty.toIntern(),	892	.ty = ty.toIntern(),
879	.base_addr = .int,	893	.base_addr = .int,
880	.byte_offset = int_val.toUnsignedInt(pt),	894	.byte_offset = int_val.toUnsignedInt(zcu),
881	} }));	895	} }));
882	},	896	},
883	.Optional => {	897	.Optional => {
884	assert(ty.isPtrLikeOptional(mod));	898	assert(ty.isPtrLikeOptional(zcu));
885	const child_ty = ty.optionalChild(mod);	899	const child_ty = ty.optionalChild(zcu);
886	const child_val = try readFromPackedMemory(child_ty, pt, buffer, bit_offset, arena);	900	const child_val = try readFromPackedMemory(child_ty, pt, buffer, bit_offset, arena);
887	return Value.fromInterned(try pt.intern(.{ .opt = .{	901	return Value.fromInterned(try pt.intern(.{ .opt = .{
888	.ty = ty.toIntern(),	902	.ty = ty.toIntern(),
889	.val = switch (child_val.orderAgainstZero(pt)) {	903	.val = switch (child_val.orderAgainstZero(zcu)) {
890	.lt => unreachable,	904	.lt => unreachable,
891	.eq => .none,	905	.eq => .none,
892	.gt => child_val.toIntern(),	906	.gt => child_val.toIntern(),
...	@@ -898,8 +912,8 @@ pub fn readFromPackedMemory(	...	@@ -898,8 +912,8 @@ pub fn readFromPackedMemory(
898	}	912	}
899		913
900	/// Asserts that the value is a float or an integer.	914	/// Asserts that the value is a float or an integer.
901	pub fn toFloat(val: Value, comptime T: type, pt: Zcu.PerThread) T {	915	pub fn toFloat(val: Value, comptime T: type, zcu: *Zcu) T {
902	return switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {	916	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
903	.int => \|int\| switch (int.storage) {	917	.int => \|int\| switch (int.storage) {
904	.big_int => \|big_int\| @floatCast(bigIntToFloat(big_int.limbs, big_int.positive)),	918	.big_int => \|big_int\| @floatCast(bigIntToFloat(big_int.limbs, big_int.positive)),
905	inline .u64, .i64 => \|x\| {	919	inline .u64, .i64 => \|x\| {
...	@@ -908,8 +922,8 @@ pub fn toFloat(val: Value, comptime T: type, pt: Zcu.PerThread) T {	...	@@ -908,8 +922,8 @@ pub fn toFloat(val: Value, comptime T: type, pt: Zcu.PerThread) T {
908	}	922	}
909	return @floatFromInt(x);	923	return @floatFromInt(x);
910	},	924	},
911	.lazy_align => \|ty\| @floatFromInt(Type.fromInterned(ty).abiAlignment(pt).toByteUnits() orelse 0),	925	.lazy_align => \|ty\| @floatFromInt(Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0),
912	.lazy_size => \|ty\| @floatFromInt(Type.fromInterned(ty).abiSize(pt)),	926	.lazy_size => \|ty\| @floatFromInt(Type.fromInterned(ty).abiSize(zcu)),
913	},	927	},
914	.float => \|float\| switch (float.storage) {	928	.float => \|float\| switch (float.storage) {
915	inline else => \|x\| @floatCast(x),	929	inline else => \|x\| @floatCast(x),
...	@@ -937,30 +951,30 @@ fn bigIntToFloat(limbs: []const std.math.big.Limb, positive: bool) f128 {	...	@@ -937,30 +951,30 @@ fn bigIntToFloat(limbs: []const std.math.big.Limb, positive: bool) f128 {
937	}	951	}
938	}	952	}
939		953
940	pub fn clz(val: Value, ty: Type, pt: Zcu.PerThread) u64 {	954	pub fn clz(val: Value, ty: Type, zcu: *Zcu) u64 {
941	var bigint_buf: BigIntSpace = undefined;	955	var bigint_buf: BigIntSpace = undefined;
942	const bigint = val.toBigInt(&bigint_buf, pt);	956	const bigint = val.toBigInt(&bigint_buf, zcu);
943	return bigint.clz(ty.intInfo(pt.zcu).bits);	957	return bigint.clz(ty.intInfo(zcu).bits);
944	}	958	}
945		959
946	pub fn ctz(val: Value, ty: Type, pt: Zcu.PerThread) u64 {	960	pub fn ctz(val: Value, ty: Type, zcu: *Zcu) u64 {
947	var bigint_buf: BigIntSpace = undefined;	961	var bigint_buf: BigIntSpace = undefined;
948	const bigint = val.toBigInt(&bigint_buf, pt);	962	const bigint = val.toBigInt(&bigint_buf, zcu);
949	return bigint.ctz(ty.intInfo(pt.zcu).bits);	963	return bigint.ctz(ty.intInfo(zcu).bits);
950	}	964	}
951		965
952	pub fn popCount(val: Value, ty: Type, pt: Zcu.PerThread) u64 {	966	pub fn popCount(val: Value, ty: Type, zcu: *Zcu) u64 {
953	var bigint_buf: BigIntSpace = undefined;	967	var bigint_buf: BigIntSpace = undefined;
954	const bigint = val.toBigInt(&bigint_buf, pt);	968	const bigint = val.toBigInt(&bigint_buf, zcu);
955	return @intCast(bigint.popCount(ty.intInfo(pt.zcu).bits));	969	return @intCast(bigint.popCount(ty.intInfo(zcu).bits));
956	}	970	}
957		971
958	pub fn bitReverse(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Value {	972	pub fn bitReverse(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Value {
959	const mod = pt.zcu;	973	const zcu = pt.zcu;
960	const info = ty.intInfo(mod);	974	const info = ty.intInfo(zcu);
961		975
962	var buffer: Value.BigIntSpace = undefined;	976	var buffer: Value.BigIntSpace = undefined;
963	const operand_bigint = val.toBigInt(&buffer, pt);	977	const operand_bigint = val.toBigInt(&buffer, zcu);
964		978
965	const limbs = try arena.alloc(	979	const limbs = try arena.alloc(
966	std.math.big.Limb,	980	std.math.big.Limb,
...	@@ -973,14 +987,14 @@ pub fn bitReverse(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Va	...	@@ -973,14 +987,14 @@ pub fn bitReverse(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Va
973	}	987	}
974		988
975	pub fn byteSwap(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Value {	989	pub fn byteSwap(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Value {
976	const mod = pt.zcu;	990	const zcu = pt.zcu;
977	const info = ty.intInfo(mod);	991	const info = ty.intInfo(zcu);
978		992
979	// Bit count must be evenly divisible by 8	993	// Bit count must be evenly divisible by 8
980	assert(info.bits % 8 == 0);	994	assert(info.bits % 8 == 0);
981		995
982	var buffer: Value.BigIntSpace = undefined;	996	var buffer: Value.BigIntSpace = undefined;
983	const operand_bigint = val.toBigInt(&buffer, pt);	997	const operand_bigint = val.toBigInt(&buffer, zcu);
984		998
985	const limbs = try arena.alloc(	999	const limbs = try arena.alloc(
986	std.math.big.Limb,	1000	std.math.big.Limb,
...	@@ -994,33 +1008,34 @@ pub fn byteSwap(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Valu	...	@@ -994,33 +1008,34 @@ pub fn byteSwap(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) !Valu
994		1008
995	/// Asserts the value is an integer and not undefined.	1009	/// Asserts the value is an integer and not undefined.
996	/// Returns the number of bits the value requires to represent stored in twos complement form.	1010	/// Returns the number of bits the value requires to represent stored in twos complement form.
997	pub fn intBitCountTwosComp(self: Value, pt: Zcu.PerThread) usize {	1011	pub fn intBitCountTwosComp(self: Value, zcu: *Zcu) usize {
998	var buffer: BigIntSpace = undefined;	1012	var buffer: BigIntSpace = undefined;
999	const big_int = self.toBigInt(&buffer, pt);	1013	const big_int = self.toBigInt(&buffer, zcu);
1000	return big_int.bitCountTwosComp();	1014	return big_int.bitCountTwosComp();
1001	}	1015	}
1002		1016
1003	/// Converts an integer or a float to a float. May result in a loss of information.	1017	/// Converts an integer or a float to a float. May result in a loss of information.
1004	/// Caller can find out by equality checking the result against the operand.	1018	/// Caller can find out by equality checking the result against the operand.
1005	pub fn floatCast(val: Value, dest_ty: Type, pt: Zcu.PerThread) !Value {	1019	pub fn floatCast(val: Value, dest_ty: Type, pt: Zcu.PerThread) !Value {
1006	const target = pt.zcu.getTarget();	1020	const zcu = pt.zcu;
1007	if (val.isUndef(pt.zcu)) return pt.undefValue(dest_ty);	1021	const target = zcu.getTarget();
		1022	if (val.isUndef(zcu)) return pt.undefValue(dest_ty);
1008	return Value.fromInterned(try pt.intern(.{ .float = .{	1023	return Value.fromInterned(try pt.intern(.{ .float = .{
1009	.ty = dest_ty.toIntern(),	1024	.ty = dest_ty.toIntern(),
1010	.storage = switch (dest_ty.floatBits(target)) {	1025	.storage = switch (dest_ty.floatBits(target)) {
1011	16 => .{ .f16 = val.toFloat(f16, pt) },	1026	16 => .{ .f16 = val.toFloat(f16, zcu) },
1012	32 => .{ .f32 = val.toFloat(f32, pt) },	1027	32 => .{ .f32 = val.toFloat(f32, zcu) },
1013	64 => .{ .f64 = val.toFloat(f64, pt) },	1028	64 => .{ .f64 = val.toFloat(f64, zcu) },
1014	80 => .{ .f80 = val.toFloat(f80, pt) },	1029	80 => .{ .f80 = val.toFloat(f80, zcu) },
1015	128 => .{ .f128 = val.toFloat(f128, pt) },	1030	128 => .{ .f128 = val.toFloat(f128, zcu) },
1016	else => unreachable,	1031	else => unreachable,
1017	},	1032	},
1018	} }));	1033	} }));
1019	}	1034	}
1020		1035
1021	/// Asserts the value is a float	1036	/// Asserts the value is a float
1022	pub fn floatHasFraction(self: Value, mod: *const Module) bool {	1037	pub fn floatHasFraction(self: Value, zcu: *const Zcu) bool {
1023	return switch (mod.intern_pool.indexToKey(self.toIntern())) {	1038	return switch (zcu.intern_pool.indexToKey(self.toIntern())) {
1024	.float => \|float\| switch (float.storage) {	1039	.float => \|float\| switch (float.storage) {
1025	inline else => \|x\| @rem(x, 1) != 0,	1040	inline else => \|x\| @rem(x, 1) != 0,
1026	},	1041	},
...	@@ -1028,19 +1043,24 @@ pub fn floatHasFraction(self: Value, mod: *const Module) bool {	...	@@ -1028,19 +1043,24 @@ pub fn floatHasFraction(self: Value, mod: *const Module) bool {
1028	};	1043	};
1029	}	1044	}
1030		1045
1031	pub fn orderAgainstZero(lhs: Value, pt: Zcu.PerThread) std.math.Order {	1046	pub fn orderAgainstZero(lhs: Value, zcu: *Zcu) std.math.Order {
1032	return orderAgainstZeroAdvanced(lhs, pt, .normal) catch unreachable;	1047	return orderAgainstZeroInner(lhs, .normal, zcu, {}) catch unreachable;
1033	}	1048	}
1034		1049
1035	pub fn orderAgainstZeroAdvanced(	1050	pub fn orderAgainstZeroSema(lhs: Value, pt: Zcu.PerThread) !std.math.Order {
		1051	return try orderAgainstZeroInner(lhs, .sema, pt.zcu, pt.tid);
		1052	}
		1053
		1054	pub fn orderAgainstZeroInner(
1036	lhs: Value,	1055	lhs: Value,
1037	pt: Zcu.PerThread,
1038	comptime strat: ResolveStrat,	1056	comptime strat: ResolveStrat,
1039	) Module.CompileError!std.math.Order {	1057	zcu: *Zcu,
		1058	tid: strat.Tid(),
		1059	) Zcu.CompileError!std.math.Order {
1040	return switch (lhs.toIntern()) {	1060	return switch (lhs.toIntern()) {
1041	.bool_false => .eq,	1061	.bool_false => .eq,
1042	.bool_true => .gt,	1062	.bool_true => .gt,
1043	else => switch (pt.zcu.intern_pool.indexToKey(lhs.toIntern())) {	1063	else => switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
1044	.ptr => \|ptr\| if (ptr.byte_offset > 0) .gt else switch (ptr.base_addr) {	1064	.ptr => \|ptr\| if (ptr.byte_offset > 0) .gt else switch (ptr.base_addr) {
1045	.nav, .comptime_alloc, .comptime_field => .gt,	1065	.nav, .comptime_alloc, .comptime_field => .gt,
1046	.int => .eq,	1066	.int => .eq,
...	@@ -1050,16 +1070,17 @@ pub fn orderAgainstZeroAdvanced(	...	@@ -1050,16 +1070,17 @@ pub fn orderAgainstZeroAdvanced(
1050	.big_int => \|big_int\| big_int.orderAgainstScalar(0),	1070	.big_int => \|big_int\| big_int.orderAgainstScalar(0),
1051	inline .u64, .i64 => \|x\| std.math.order(x, 0),	1071	inline .u64, .i64 => \|x\| std.math.order(x, 0),
1052	.lazy_align => .gt, // alignment is never 0	1072	.lazy_align => .gt, // alignment is never 0
1053	.lazy_size => \|ty\| return if (Type.fromInterned(ty).hasRuntimeBitsAdvanced(	1073	.lazy_size => \|ty\| return if (Type.fromInterned(ty).hasRuntimeBitsInner(
1054	pt,
1055	false,	1074	false,
1056	strat.toLazy(),	1075	strat.toLazy(),
		1076	zcu,
		1077	tid,
1057	) catch \|err\| switch (err) {	1078	) catch \|err\| switch (err) {
1058	error.NeedLazy => unreachable,	1079	error.NeedLazy => unreachable,
1059	else => \|e\| return e,	1080	else => \|e\| return e,
1060	}) .gt else .eq,	1081	}) .gt else .eq,
1061	},	1082	},
1062	.enum_tag => \|enum_tag\| Value.fromInterned(enum_tag.int).orderAgainstZeroAdvanced(pt, strat),	1083	.enum_tag => \|enum_tag\| Value.fromInterned(enum_tag.int).orderAgainstZeroInner(strat, zcu, tid),
1063	.float => \|float\| switch (float.storage) {	1084	.float => \|float\| switch (float.storage) {
1064	inline else => \|x\| std.math.order(x, 0),	1085	inline else => \|x\| std.math.order(x, 0),
1065	},	1086	},
...	@@ -1069,14 +1090,20 @@ pub fn orderAgainstZeroAdvanced(	...	@@ -1069,14 +1090,20 @@ pub fn orderAgainstZeroAdvanced(
1069	}	1090	}
1070		1091
1071	/// Asserts the value is comparable.	1092	/// Asserts the value is comparable.
1072	pub fn order(lhs: Value, rhs: Value, pt: Zcu.PerThread) std.math.Order {	1093	pub fn order(lhs: Value, rhs: Value, zcu: *Zcu) std.math.Order {
1073	return orderAdvanced(lhs, rhs, pt, .normal) catch unreachable;	1094	return orderAdvanced(lhs, rhs, .normal, zcu, {}) catch unreachable;
1074	}	1095	}
1075		1096
1076	/// Asserts the value is comparable.	1097	/// Asserts the value is comparable.
1077	pub fn orderAdvanced(lhs: Value, rhs: Value, pt: Zcu.PerThread, comptime strat: ResolveStrat) !std.math.Order {	1098	pub fn orderAdvanced(
1078	const lhs_against_zero = try lhs.orderAgainstZeroAdvanced(pt, strat);	1099	lhs: Value,
1079	const rhs_against_zero = try rhs.orderAgainstZeroAdvanced(pt, strat);	1100	rhs: Value,
		1101	comptime strat: ResolveStrat,
		1102	zcu: *Zcu,
		1103	tid: strat.Tid(),
		1104	) !std.math.Order {
		1105	const lhs_against_zero = try lhs.orderAgainstZeroInner(strat, zcu, tid);
		1106	const rhs_against_zero = try rhs.orderAgainstZeroInner(strat, zcu, tid);
1080	switch (lhs_against_zero) {	1107	switch (lhs_against_zero) {
1081	.lt => if (rhs_against_zero != .lt) return .lt,	1108	.lt => if (rhs_against_zero != .lt) return .lt,
1082	.eq => return rhs_against_zero.invert(),	1109	.eq => return rhs_against_zero.invert(),
...	@@ -1088,34 +1115,39 @@ pub fn orderAdvanced(lhs: Value, rhs: Value, pt: Zcu.PerThread, comptime strat:	...	@@ -1088,34 +1115,39 @@ pub fn orderAdvanced(lhs: Value, rhs: Value, pt: Zcu.PerThread, comptime strat:
1088	.gt => {},	1115	.gt => {},
1089	}	1116	}
1090		1117
1091	if (lhs.isFloat(pt.zcu) or rhs.isFloat(pt.zcu)) {	1118	if (lhs.isFloat(zcu) or rhs.isFloat(zcu)) {
1092	const lhs_f128 = lhs.toFloat(f128, pt);	1119	const lhs_f128 = lhs.toFloat(f128, zcu);
1093	const rhs_f128 = rhs.toFloat(f128, pt);	1120	const rhs_f128 = rhs.toFloat(f128, zcu);
1094	return std.math.order(lhs_f128, rhs_f128);	1121	return std.math.order(lhs_f128, rhs_f128);
1095	}	1122	}
1096		1123
1097	var lhs_bigint_space: BigIntSpace = undefined;	1124	var lhs_bigint_space: BigIntSpace = undefined;
1098	var rhs_bigint_space: BigIntSpace = undefined;	1125	var rhs_bigint_space: BigIntSpace = undefined;
1099	const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_bigint_space, pt, strat);	1126	const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_bigint_space, strat, zcu, tid);
1100	const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_bigint_space, pt, strat);	1127	const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_bigint_space, strat, zcu, tid);
1101	return lhs_bigint.order(rhs_bigint);	1128	return lhs_bigint.order(rhs_bigint);
1102	}	1129	}
1103		1130
1104	/// Asserts the value is comparable. Does not take a type parameter because it supports	1131	/// Asserts the value is comparable. Does not take a type parameter because it supports
1105	/// comparisons between heterogeneous types.	1132	/// comparisons between heterogeneous types.
1106	pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, pt: Zcu.PerThread) bool {	1133	pub fn compareHetero(lhs: Value, op: std.math.CompareOperator, rhs: Value, zcu: *Zcu) bool {
1107	return compareHeteroAdvanced(lhs, op, rhs, pt, .normal) catch unreachable;	1134	return compareHeteroAdvanced(lhs, op, rhs, .normal, zcu, {}) catch unreachable;
		1135	}
		1136
		1137	pub fn compareHeteroSema(lhs: Value, op: std.math.CompareOperator, rhs: Value, pt: Zcu.PerThread) !bool {
		1138	return try compareHeteroAdvanced(lhs, op, rhs, .sema, pt.zcu, pt.tid);
1108	}	1139	}
1109		1140
1110	pub fn compareHeteroAdvanced(	1141	pub fn compareHeteroAdvanced(
1111	lhs: Value,	1142	lhs: Value,
1112	op: std.math.CompareOperator,	1143	op: std.math.CompareOperator,
1113	rhs: Value,	1144	rhs: Value,
1114	pt: Zcu.PerThread,
1115	comptime strat: ResolveStrat,	1145	comptime strat: ResolveStrat,
		1146	zcu: *Zcu,
		1147	tid: strat.Tid(),
1116	) !bool {	1148	) !bool {
1117	if (lhs.pointerNav(pt.zcu)) \|lhs_nav\| {	1149	if (lhs.pointerNav(zcu)) \|lhs_nav\| {
1118	if (rhs.pointerNav(pt.zcu)) \|rhs_nav\| {	1150	if (rhs.pointerNav(zcu)) \|rhs_nav\| {
1119	switch (op) {	1151	switch (op) {
1120	.eq => return lhs_nav == rhs_nav,	1152	.eq => return lhs_nav == rhs_nav,
1121	.neq => return lhs_nav != rhs_nav,	1153	.neq => return lhs_nav != rhs_nav,
...	@@ -1128,32 +1160,32 @@ pub fn compareHeteroAdvanced(	...	@@ -1128,32 +1160,32 @@ pub fn compareHeteroAdvanced(
1128	else => {},	1160	else => {},
1129	}	1161	}
1130	}	1162	}
1131	} else if (rhs.pointerNav(pt.zcu)) \|_\| {	1163	} else if (rhs.pointerNav(zcu)) \|_\| {
1132	switch (op) {	1164	switch (op) {
1133	.eq => return false,	1165	.eq => return false,
1134	.neq => return true,	1166	.neq => return true,
1135	else => {},	1167	else => {},
1136	}	1168	}
1137	}	1169	}
1138	return (try orderAdvanced(lhs, rhs, pt, strat)).compare(op);	1170	return (try orderAdvanced(lhs, rhs, strat, zcu, tid)).compare(op);
1139	}	1171	}
1140		1172
1141	/// Asserts the values are comparable. Both operands have type `ty`.	1173	/// Asserts the values are comparable. Both operands have type `ty`.
1142	/// For vectors, returns true if comparison is true for ALL elements.	1174	/// For vectors, returns true if comparison is true for ALL elements.
1143	pub fn compareAll(lhs: Value, op: std.math.CompareOperator, rhs: Value, ty: Type, pt: Zcu.PerThread) !bool {	1175	pub fn compareAll(lhs: Value, op: std.math.CompareOperator, rhs: Value, ty: Type, pt: Zcu.PerThread) !bool {
1144	const mod = pt.zcu;	1176	const zcu = pt.zcu;
1145	if (ty.zigTypeTag(mod) == .Vector) {	1177	if (ty.zigTypeTag(zcu) == .Vector) {
1146	const scalar_ty = ty.scalarType(mod);	1178	const scalar_ty = ty.scalarType(zcu);
1147	for (0..ty.vectorLen(mod)) \|i\| {	1179	for (0..ty.vectorLen(zcu)) \|i\| {
1148	const lhs_elem = try lhs.elemValue(pt, i);	1180	const lhs_elem = try lhs.elemValue(pt, i);
1149	const rhs_elem = try rhs.elemValue(pt, i);	1181	const rhs_elem = try rhs.elemValue(pt, i);
1150	if (!compareScalar(lhs_elem, op, rhs_elem, scalar_ty, pt)) {	1182	if (!compareScalar(lhs_elem, op, rhs_elem, scalar_ty, zcu)) {
1151	return false;	1183	return false;
1152	}	1184	}
1153	}	1185	}
1154	return true;	1186	return true;
1155	}	1187	}
1156	return compareScalar(lhs, op, rhs, ty, pt);	1188	return compareScalar(lhs, op, rhs, ty, zcu);
1157	}	1189	}
1158		1190
1159	/// Asserts the values are comparable. Both operands have type `ty`.	1191	/// Asserts the values are comparable. Both operands have type `ty`.
...	@@ -1162,12 +1194,12 @@ pub fn compareScalar(	...	@@ -1162,12 +1194,12 @@ pub fn compareScalar(
1162	op: std.math.CompareOperator,	1194	op: std.math.CompareOperator,
1163	rhs: Value,	1195	rhs: Value,
1164	ty: Type,	1196	ty: Type,
1165	pt: Zcu.PerThread,	1197	zcu: *Zcu,
1166	) bool {	1198	) bool {
1167	return switch (op) {	1199	return switch (op) {
1168	.eq => lhs.eql(rhs, ty, pt.zcu),	1200	.eq => lhs.eql(rhs, ty, zcu),
1169	.neq => !lhs.eql(rhs, ty, pt.zcu),	1201	.neq => !lhs.eql(rhs, ty, zcu),
1170	else => compareHetero(lhs, op, rhs, pt),	1202	else => compareHetero(lhs, op, rhs, zcu),
1171	};	1203	};
1172	}	1204	}
1173		1205
...	@@ -1176,56 +1208,56 @@ pub fn compareScalar(	...	@@ -1176,56 +1208,56 @@ pub fn compareScalar(
1176	/// Returns `false` if the value or any vector element is undefined.	1208	/// Returns `false` if the value or any vector element is undefined.
1177	///	1209	///
1178	/// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)`	1210	/// Note that `!compareAllWithZero(.eq, ...) != compareAllWithZero(.neq, ...)`
1179	pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, pt: Zcu.PerThread) bool {	1211	pub fn compareAllWithZero(lhs: Value, op: std.math.CompareOperator, zcu: *Zcu) bool {
1180	return compareAllWithZeroAdvancedExtra(lhs, op, pt, .normal) catch unreachable;	1212	return compareAllWithZeroAdvancedExtra(lhs, op, .normal, zcu, {}) catch unreachable;
1181	}	1213	}
1182		1214
1183	pub fn compareAllWithZeroSema(	1215	pub fn compareAllWithZeroSema(
1184	lhs: Value,	1216	lhs: Value,
1185	op: std.math.CompareOperator,	1217	op: std.math.CompareOperator,
1186	pt: Zcu.PerThread,	1218	pt: Zcu.PerThread,
1187	) Module.CompileError!bool {	1219	) Zcu.CompileError!bool {
1188	return compareAllWithZeroAdvancedExtra(lhs, op, pt, .sema);	1220	return compareAllWithZeroAdvancedExtra(lhs, op, .sema, pt.zcu, pt.tid);
1189	}	1221	}
1190		1222
1191	pub fn compareAllWithZeroAdvancedExtra(	1223	pub fn compareAllWithZeroAdvancedExtra(
1192	lhs: Value,	1224	lhs: Value,
1193	op: std.math.CompareOperator,	1225	op: std.math.CompareOperator,
1194	pt: Zcu.PerThread,
1195	comptime strat: ResolveStrat,	1226	comptime strat: ResolveStrat,
1196	) Module.CompileError!bool {	1227	zcu: *Zcu,
1197	const mod = pt.zcu;	1228	tid: strat.Tid(),
1198	if (lhs.isInf(mod)) {	1229	) Zcu.CompileError!bool {
		1230	if (lhs.isInf(zcu)) {
1199	switch (op) {	1231	switch (op) {
1200	.neq => return true,	1232	.neq => return true,
1201	.eq => return false,	1233	.eq => return false,
1202	.gt, .gte => return !lhs.isNegativeInf(mod),	1234	.gt, .gte => return !lhs.isNegativeInf(zcu),
1203	.lt, .lte => return lhs.isNegativeInf(mod),	1235	.lt, .lte => return lhs.isNegativeInf(zcu),
1204	}	1236	}
1205	}	1237	}
1206		1238
1207	switch (mod.intern_pool.indexToKey(lhs.toIntern())) {	1239	switch (zcu.intern_pool.indexToKey(lhs.toIntern())) {
1208	.float => \|float\| switch (float.storage) {	1240	.float => \|float\| switch (float.storage) {
1209	inline else => \|x\| if (std.math.isNan(x)) return op == .neq,	1241	inline else => \|x\| if (std.math.isNan(x)) return op == .neq,
1210	},	1242	},
1211	.aggregate => \|aggregate\| return switch (aggregate.storage) {	1243	.aggregate => \|aggregate\| return switch (aggregate.storage) {
1212	.bytes => \|bytes\| for (bytes.toSlice(lhs.typeOf(mod).arrayLenIncludingSentinel(mod), &mod.intern_pool)) \|byte\| {	1244	.bytes => \|bytes\| for (bytes.toSlice(lhs.typeOf(zcu).arrayLenIncludingSentinel(zcu), &zcu.intern_pool)) \|byte\| {
1213	if (!std.math.order(byte, 0).compare(op)) break false;	1245	if (!std.math.order(byte, 0).compare(op)) break false;
1214	} else true,	1246	} else true,
1215	.elems => \|elems\| for (elems) \|elem\| {	1247	.elems => \|elems\| for (elems) \|elem\| {
1216	if (!try Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, pt, strat)) break false;	1248	if (!try Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, strat, zcu, tid)) break false;
1217	} else true,	1249	} else true,
1218	.repeated_elem => \|elem\| Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, pt, strat),	1250	.repeated_elem => \|elem\| Value.fromInterned(elem).compareAllWithZeroAdvancedExtra(op, strat, zcu, tid),
1219	},	1251	},
1220	.undef => return false,	1252	.undef => return false,
1221	else => {},	1253	else => {},
1222	}	1254	}
1223	return (try orderAgainstZeroAdvanced(lhs, pt, strat)).compare(op);	1255	return (try orderAgainstZeroInner(lhs, strat, zcu, tid)).compare(op);
1224	}	1256	}
1225		1257
1226	pub fn eql(a: Value, b: Value, ty: Type, mod: *Module) bool {	1258	pub fn eql(a: Value, b: Value, ty: Type, zcu: *Zcu) bool {
1227	assert(mod.intern_pool.typeOf(a.toIntern()) == ty.toIntern());	1259	assert(zcu.intern_pool.typeOf(a.toIntern()) == ty.toIntern());
1228	assert(mod.intern_pool.typeOf(b.toIntern()) == ty.toIntern());	1260	assert(zcu.intern_pool.typeOf(b.toIntern()) == ty.toIntern());
1229	return a.toIntern() == b.toIntern();	1261	return a.toIntern() == b.toIntern();
1230	}	1262	}
1231		1263
...	@@ -1260,8 +1292,8 @@ pub fn canMutateComptimeVarState(val: Value, zcu: *Zcu) bool {	...	@@ -1260,8 +1292,8 @@ pub fn canMutateComptimeVarState(val: Value, zcu: *Zcu) bool {
1260	/// Gets the `Nav` referenced by this pointer. If the pointer does not point	1292	/// Gets the `Nav` referenced by this pointer. If the pointer does not point
1261	/// to a `Nav`, or if it points to some part of one (like a field or element),	1293	/// to a `Nav`, or if it points to some part of one (like a field or element),
1262	/// returns null.	1294	/// returns null.
1263	pub fn pointerNav(val: Value, mod: *Module) ?InternPool.Nav.Index {	1295	pub fn pointerNav(val: Value, zcu: *Zcu) ?InternPool.Nav.Index {
1264	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1296	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1265	// TODO: these 3 cases are weird; these aren't pointer values!	1297	// TODO: these 3 cases are weird; these aren't pointer values!
1266	.variable => \|v\| v.owner_nav,	1298	.variable => \|v\| v.owner_nav,
1267	.@"extern" => \|e\| e.owner_nav,	1299	.@"extern" => \|e\| e.owner_nav,
...	@@ -1277,8 +1309,8 @@ pub fn pointerNav(val: Value, mod: *Module) ?InternPool.Nav.Index {	...	@@ -1277,8 +1309,8 @@ pub fn pointerNav(val: Value, mod: *Module) ?InternPool.Nav.Index {
1277	pub const slice_ptr_index = 0;	1309	pub const slice_ptr_index = 0;
1278	pub const slice_len_index = 1;	1310	pub const slice_len_index = 1;
1279		1311
1280	pub fn slicePtr(val: Value, mod: *Module) Value {	1312	pub fn slicePtr(val: Value, zcu: *Zcu) Value {
1281	return Value.fromInterned(mod.intern_pool.slicePtr(val.toIntern()));	1313	return Value.fromInterned(zcu.intern_pool.slicePtr(val.toIntern()));
1282	}	1314	}
1283		1315
1284	/// Gets the `len` field of a slice value as a `u64`.	1316	/// Gets the `len` field of a slice value as a `u64`.
...	@@ -1312,15 +1344,15 @@ pub fn elemValue(val: Value, pt: Zcu.PerThread, index: usize) Allocator.Error!Va	...	@@ -1312,15 +1344,15 @@ pub fn elemValue(val: Value, pt: Zcu.PerThread, index: usize) Allocator.Error!Va
1312	}	1344	}
1313	}	1345	}
1314		1346
1315	pub fn isLazyAlign(val: Value, mod: *Module) bool {	1347	pub fn isLazyAlign(val: Value, zcu: *Zcu) bool {
1316	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1348	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1317	.int => \|int\| int.storage == .lazy_align,	1349	.int => \|int\| int.storage == .lazy_align,
1318	else => false,	1350	else => false,
1319	};	1351	};
1320	}	1352	}
1321		1353
1322	pub fn isLazySize(val: Value, mod: *Module) bool {	1354	pub fn isLazySize(val: Value, zcu: *Zcu) bool {
1323	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1355	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1324	.int => \|int\| int.storage == .lazy_size,	1356	.int => \|int\| int.storage == .lazy_size,
1325	else => false,	1357	else => false,
1326	};	1358	};
...	@@ -1377,15 +1409,15 @@ pub fn sliceArray(	...	@@ -1377,15 +1409,15 @@ pub fn sliceArray(
1377	}	1409	}
1378		1410
1379	pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {	1411	pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {
1380	const mod = pt.zcu;	1412	const zcu = pt.zcu;
1381	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1413	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1382	.undef => \|ty\| Value.fromInterned(try pt.intern(.{	1414	.undef => \|ty\| Value.fromInterned(try pt.intern(.{
1383	.undef = Type.fromInterned(ty).structFieldType(index, mod).toIntern(),	1415	.undef = Type.fromInterned(ty).fieldType(index, zcu).toIntern(),
1384	})),	1416	})),
1385	.aggregate => \|aggregate\| Value.fromInterned(switch (aggregate.storage) {	1417	.aggregate => \|aggregate\| Value.fromInterned(switch (aggregate.storage) {
1386	.bytes => \|bytes\| try pt.intern(.{ .int = .{	1418	.bytes => \|bytes\| try pt.intern(.{ .int = .{
1387	.ty = .u8_type,	1419	.ty = .u8_type,
1388	.storage = .{ .u64 = bytes.at(index, &mod.intern_pool) },	1420	.storage = .{ .u64 = bytes.at(index, &zcu.intern_pool) },
1389	} }),	1421	} }),
1390	.elems => \|elems\| elems[index],	1422	.elems => \|elems\| elems[index],
1391	.repeated_elem => \|elem\| elem,	1423	.repeated_elem => \|elem\| elem,
...	@@ -1396,40 +1428,40 @@ pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {	...	@@ -1396,40 +1428,40 @@ pub fn fieldValue(val: Value, pt: Zcu.PerThread, index: usize) !Value {
1396	};	1428	};
1397	}	1429	}
1398		1430
1399	pub fn unionTag(val: Value, mod: *Module) ?Value {	1431	pub fn unionTag(val: Value, zcu: *Zcu) ?Value {
1400	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1432	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1401	.undef, .enum_tag => val,	1433	.undef, .enum_tag => val,
1402	.un => \|un\| if (un.tag != .none) Value.fromInterned(un.tag) else return null,	1434	.un => \|un\| if (un.tag != .none) Value.fromInterned(un.tag) else return null,
1403	else => unreachable,	1435	else => unreachable,
1404	};	1436	};
1405	}	1437	}
1406		1438
1407	pub fn unionValue(val: Value, mod: *Module) Value {	1439	pub fn unionValue(val: Value, zcu: *Zcu) Value {
1408	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1440	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1409	.un => \|un\| Value.fromInterned(un.val),	1441	.un => \|un\| Value.fromInterned(un.val),
1410	else => unreachable,	1442	else => unreachable,
1411	};	1443	};
1412	}	1444	}
1413		1445
1414	pub fn isUndef(val: Value, mod: *Module) bool {	1446	pub fn isUndef(val: Value, zcu: *Zcu) bool {
1415	return mod.intern_pool.isUndef(val.toIntern());	1447	return zcu.intern_pool.isUndef(val.toIntern());
1416	}	1448	}
1417		1449
1418	/// TODO: check for cases such as array that is not marked undef but all the element	1450	/// TODO: check for cases such as array that is not marked undef but all the element
1419	/// values are marked undef, or struct that is not marked undef but all fields are marked	1451	/// values are marked undef, or struct that is not marked undef but all fields are marked
1420	/// undef, etc.	1452	/// undef, etc.
1421	pub fn isUndefDeep(val: Value, mod: *Module) bool {	1453	pub fn isUndefDeep(val: Value, zcu: *Zcu) bool {
1422	return val.isUndef(mod);	1454	return val.isUndef(zcu);
1423	}	1455	}
1424		1456
1425	/// Asserts the value is not undefined and not unreachable.	1457	/// Asserts the value is not undefined and not unreachable.
1426	/// C pointers with an integer value of 0 are also considered null.	1458	/// C pointers with an integer value of 0 are also considered null.
1427	pub fn isNull(val: Value, mod: *Module) bool {	1459	pub fn isNull(val: Value, zcu: *Zcu) bool {
1428	return switch (val.toIntern()) {	1460	return switch (val.toIntern()) {
1429	.undef => unreachable,	1461	.undef => unreachable,
1430	.unreachable_value => unreachable,	1462	.unreachable_value => unreachable,
1431	.null_value => true,	1463	.null_value => true,
1432	else => return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1464	else => return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1433	.undef => unreachable,	1465	.undef => unreachable,
1434	.ptr => \|ptr\| switch (ptr.base_addr) {	1466	.ptr => \|ptr\| switch (ptr.base_addr) {
1435	.int => ptr.byte_offset == 0,	1467	.int => ptr.byte_offset == 0,
...	@@ -1442,8 +1474,8 @@ pub fn isNull(val: Value, mod: *Module) bool {	...	@@ -1442,8 +1474,8 @@ pub fn isNull(val: Value, mod: *Module) bool {
1442	}	1474	}
1443		1475
1444	/// Valid only for error (union) types. Asserts the value is not undefined and not unreachable.	1476	/// Valid only for error (union) types. Asserts the value is not undefined and not unreachable.
1445	pub fn getErrorName(val: Value, mod: *const Module) InternPool.OptionalNullTerminatedString {	1477	pub fn getErrorName(val: Value, zcu: *const Zcu) InternPool.OptionalNullTerminatedString {
1446	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1478	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1447	.err => \|err\| err.name.toOptional(),	1479	.err => \|err\| err.name.toOptional(),
1448	.error_union => \|error_union\| switch (error_union.val) {	1480	.error_union => \|error_union\| switch (error_union.val) {
1449	.err_name => \|err_name\| err_name.toOptional(),	1481	.err_name => \|err_name\| err_name.toOptional(),
...	@@ -1453,7 +1485,7 @@ pub fn getErrorName(val: Value, mod: *const Module) InternPool.OptionalNullTermi	...	@@ -1453,7 +1485,7 @@ pub fn getErrorName(val: Value, mod: *const Module) InternPool.OptionalNullTermi
1453	};	1485	};
1454	}	1486	}
1455		1487
1456	pub fn getErrorInt(val: Value, zcu: *Zcu) Module.ErrorInt {	1488	pub fn getErrorInt(val: Value, zcu: *Zcu) Zcu.ErrorInt {
1457	return if (getErrorName(val, zcu).unwrap()) \|err_name\|	1489	return if (getErrorName(val, zcu).unwrap()) \|err_name\|
1458	zcu.intern_pool.getErrorValueIfExists(err_name).?	1490	zcu.intern_pool.getErrorValueIfExists(err_name).?
1459	else	1491	else
...	@@ -1462,13 +1494,13 @@ pub fn getErrorInt(val: Value, zcu: *Zcu) Module.ErrorInt {	...	@@ -1462,13 +1494,13 @@ pub fn getErrorInt(val: Value, zcu: *Zcu) Module.ErrorInt {
1462		1494
1463	/// Assumes the type is an error union. Returns true if and only if the value is	1495	/// Assumes the type is an error union. Returns true if and only if the value is
1464	/// the error union payload, not an error.	1496	/// the error union payload, not an error.
1465	pub fn errorUnionIsPayload(val: Value, mod: *const Module) bool {	1497	pub fn errorUnionIsPayload(val: Value, zcu: *const Zcu) bool {
1466	return mod.intern_pool.indexToKey(val.toIntern()).error_union.val == .payload;	1498	return zcu.intern_pool.indexToKey(val.toIntern()).error_union.val == .payload;
1467	}	1499	}
1468		1500
1469	/// Value of the optional, null if optional has no payload.	1501	/// Value of the optional, null if optional has no payload.
1470	pub fn optionalValue(val: Value, mod: *const Module) ?Value {	1502	pub fn optionalValue(val: Value, zcu: *const Zcu) ?Value {
1471	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1503	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1472	.opt => \|opt\| switch (opt.val) {	1504	.opt => \|opt\| switch (opt.val) {
1473	.none => null,	1505	.none => null,
1474	else => \|payload\| Value.fromInterned(payload),	1506	else => \|payload\| Value.fromInterned(payload),
...	@@ -1479,10 +1511,10 @@ pub fn optionalValue(val: Value, mod: *const Module) ?Value {	...	@@ -1479,10 +1511,10 @@ pub fn optionalValue(val: Value, mod: *const Module) ?Value {
1479	}	1511	}
1480		1512
1481	/// Valid for all types. Asserts the value is not undefined.	1513	/// Valid for all types. Asserts the value is not undefined.
1482	pub fn isFloat(self: Value, mod: *const Module) bool {	1514	pub fn isFloat(self: Value, zcu: *const Zcu) bool {
1483	return switch (self.toIntern()) {	1515	return switch (self.toIntern()) {
1484	.undef => unreachable,	1516	.undef => unreachable,
1485	else => switch (mod.intern_pool.indexToKey(self.toIntern())) {	1517	else => switch (zcu.intern_pool.indexToKey(self.toIntern())) {
1486	.undef => unreachable,	1518	.undef => unreachable,
1487	.float => true,	1519	.float => true,
1488	else => false,	1520	else => false,
...	@@ -1490,8 +1522,8 @@ pub fn isFloat(self: Value, mod: *const Module) bool {	...	@@ -1490,8 +1522,8 @@ pub fn isFloat(self: Value, mod: *const Module) bool {
1490	};	1522	};
1491	}	1523	}
1492		1524
1493	pub fn floatFromInt(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, mod: *Module) !Value {	1525	pub fn floatFromInt(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, zcu: *Zcu) !Value {
1494	return floatFromIntAdvanced(val, arena, int_ty, float_ty, mod, .normal) catch \|err\| switch (err) {	1526	return floatFromIntAdvanced(val, arena, int_ty, float_ty, zcu, .normal) catch \|err\| switch (err) {
1495	error.OutOfMemory => return error.OutOfMemory,	1527	error.OutOfMemory => return error.OutOfMemory,
1496	else => unreachable,	1528	else => unreachable,
1497	};	1529	};
...	@@ -1505,10 +1537,10 @@ pub fn floatFromIntAdvanced(	...	@@ -1505,10 +1537,10 @@ pub fn floatFromIntAdvanced(
1505	pt: Zcu.PerThread,	1537	pt: Zcu.PerThread,
1506	comptime strat: ResolveStrat,	1538	comptime strat: ResolveStrat,
1507	) !Value {	1539	) !Value {
1508	const mod = pt.zcu;	1540	const zcu = pt.zcu;
1509	if (int_ty.zigTypeTag(mod) == .Vector) {	1541	if (int_ty.zigTypeTag(zcu) == .Vector) {
1510	const result_data = try arena.alloc(InternPool.Index, int_ty.vectorLen(mod));	1542	const result_data = try arena.alloc(InternPool.Index, int_ty.vectorLen(zcu));
1511	const scalar_ty = float_ty.scalarType(mod);	1543	const scalar_ty = float_ty.scalarType(zcu);
1512	for (result_data, 0..) \|*scalar, i\| {	1544	for (result_data, 0..) \|*scalar, i\| {
1513	const elem_val = try val.elemValue(pt, i);	1545	const elem_val = try val.elemValue(pt, i);
1514	scalar.* = (try floatFromIntScalar(elem_val, scalar_ty, pt, strat)).toIntern();	1546	scalar.* = (try floatFromIntScalar(elem_val, scalar_ty, pt, strat)).toIntern();
...	@@ -1522,8 +1554,8 @@ pub fn floatFromIntAdvanced(	...	@@ -1522,8 +1554,8 @@ pub fn floatFromIntAdvanced(
1522	}	1554	}
1523		1555
1524	pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Value {	1556	pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Value {
1525	const mod = pt.zcu;	1557	const zcu = pt.zcu;
1526	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	1558	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
1527	.undef => try pt.undefValue(float_ty),	1559	.undef => try pt.undefValue(float_ty),
1528	.int => \|int\| switch (int.storage) {	1560	.int => \|int\| switch (int.storage) {
1529	.big_int => \|big_int\| {	1561	.big_int => \|big_int\| {
...	@@ -1531,8 +1563,8 @@ pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptim	...	@@ -1531,8 +1563,8 @@ pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptim
1531	return pt.floatValue(float_ty, float);	1563	return pt.floatValue(float_ty, float);
1532	},	1564	},
1533	inline .u64, .i64 => \|x\| floatFromIntInner(x, float_ty, pt),	1565	inline .u64, .i64 => \|x\| floatFromIntInner(x, float_ty, pt),
1534	.lazy_align => \|ty\| return floatFromIntInner((try Type.fromInterned(ty).abiAlignmentAdvanced(pt, strat.toLazy())).scalar.toByteUnits() orelse 0, float_ty, pt),	1566	.lazy_align => \|ty\| return floatFromIntInner((try Type.fromInterned(ty).abiAlignmentInner(strat.toLazy(), pt.zcu, pt.tid)).scalar.toByteUnits() orelse 0, float_ty, pt),
1535	.lazy_size => \|ty\| return floatFromIntInner((try Type.fromInterned(ty).abiSizeAdvanced(pt, strat.toLazy())).scalar, float_ty, pt),	1567	.lazy_size => \|ty\| return floatFromIntInner((try Type.fromInterned(ty).abiSizeInner(strat.toLazy(), pt.zcu, pt.tid)).scalar, float_ty, pt),
1536	},	1568	},
1537	else => unreachable,	1569	else => unreachable,
1538	};	1570	};
...	@@ -1600,15 +1632,16 @@ pub fn intAddSatScalar(	...	@@ -1600,15 +1632,16 @@ pub fn intAddSatScalar(
1600	arena: Allocator,	1632	arena: Allocator,
1601	pt: Zcu.PerThread,	1633	pt: Zcu.PerThread,
1602	) !Value {	1634	) !Value {
1603	assert(!lhs.isUndef(pt.zcu));	1635	const zcu = pt.zcu;
1604	assert(!rhs.isUndef(pt.zcu));	1636	assert(!lhs.isUndef(zcu));
		1637	assert(!rhs.isUndef(zcu));
1605		1638
1606	const info = ty.intInfo(pt.zcu);	1639	const info = ty.intInfo(zcu);
1607		1640
1608	var lhs_space: Value.BigIntSpace = undefined;	1641	var lhs_space: Value.BigIntSpace = undefined;
1609	var rhs_space: Value.BigIntSpace = undefined;	1642	var rhs_space: Value.BigIntSpace = undefined;
1610	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	1643	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
1611	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	1644	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
1612	const limbs = try arena.alloc(	1645	const limbs = try arena.alloc(
1613	std.math.big.Limb,	1646	std.math.big.Limb,
1614	std.math.big.int.calcTwosCompLimbCount(info.bits),	1647	std.math.big.int.calcTwosCompLimbCount(info.bits),
...	@@ -1650,15 +1683,17 @@ pub fn intSubSatScalar(	...	@@ -1650,15 +1683,17 @@ pub fn intSubSatScalar(
1650	arena: Allocator,	1683	arena: Allocator,
1651	pt: Zcu.PerThread,	1684	pt: Zcu.PerThread,
1652	) !Value {	1685	) !Value {
1653	assert(!lhs.isUndef(pt.zcu));	1686	const zcu = pt.zcu;
1654	assert(!rhs.isUndef(pt.zcu));
1655		1687
1656	const info = ty.intInfo(pt.zcu);	1688	assert(!lhs.isUndef(zcu));
		1689	assert(!rhs.isUndef(zcu));
		1690
		1691	const info = ty.intInfo(zcu);
1657		1692
1658	var lhs_space: Value.BigIntSpace = undefined;	1693	var lhs_space: Value.BigIntSpace = undefined;
1659	var rhs_space: Value.BigIntSpace = undefined;	1694	var rhs_space: Value.BigIntSpace = undefined;
1660	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	1695	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
1661	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	1696	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
1662	const limbs = try arena.alloc(	1697	const limbs = try arena.alloc(
1663	std.math.big.Limb,	1698	std.math.big.Limb,
1664	std.math.big.int.calcTwosCompLimbCount(info.bits),	1699	std.math.big.int.calcTwosCompLimbCount(info.bits),
...	@@ -1675,12 +1710,12 @@ pub fn intMulWithOverflow(	...	@@ -1675,12 +1710,12 @@ pub fn intMulWithOverflow(
1675	arena: Allocator,	1710	arena: Allocator,
1676	pt: Zcu.PerThread,	1711	pt: Zcu.PerThread,
1677	) !OverflowArithmeticResult {	1712	) !OverflowArithmeticResult {
1678	const mod = pt.zcu;	1713	const zcu = pt.zcu;
1679	if (ty.zigTypeTag(mod) == .Vector) {	1714	if (ty.zigTypeTag(zcu) == .Vector) {
1680	const vec_len = ty.vectorLen(mod);	1715	const vec_len = ty.vectorLen(zcu);
1681	const overflowed_data = try arena.alloc(InternPool.Index, vec_len);	1716	const overflowed_data = try arena.alloc(InternPool.Index, vec_len);
1682	const result_data = try arena.alloc(InternPool.Index, vec_len);	1717	const result_data = try arena.alloc(InternPool.Index, vec_len);
1683	const scalar_ty = ty.scalarType(mod);	1718	const scalar_ty = ty.scalarType(zcu);
1684	for (overflowed_data, result_data, 0..) \|of, scalar, i\| {	1719	for (overflowed_data, result_data, 0..) \|of, scalar, i\| {
1685	const lhs_elem = try lhs.elemValue(pt, i);	1720	const lhs_elem = try lhs.elemValue(pt, i);
1686	const rhs_elem = try rhs.elemValue(pt, i);	1721	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -1709,10 +1744,10 @@ pub fn intMulWithOverflowScalar(	...	@@ -1709,10 +1744,10 @@ pub fn intMulWithOverflowScalar(
1709	arena: Allocator,	1744	arena: Allocator,
1710	pt: Zcu.PerThread,	1745	pt: Zcu.PerThread,
1711	) !OverflowArithmeticResult {	1746	) !OverflowArithmeticResult {
1712	const mod = pt.zcu;	1747	const zcu = pt.zcu;
1713	const info = ty.intInfo(mod);	1748	const info = ty.intInfo(zcu);
1714		1749
1715	if (lhs.isUndef(mod) or rhs.isUndef(mod)) {	1750	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
1716	return .{	1751	return .{
1717	.overflow_bit = try pt.undefValue(Type.u1),	1752	.overflow_bit = try pt.undefValue(Type.u1),
1718	.wrapped_result = try pt.undefValue(ty),	1753	.wrapped_result = try pt.undefValue(ty),
...	@@ -1721,8 +1756,8 @@ pub fn intMulWithOverflowScalar(	...	@@ -1721,8 +1756,8 @@ pub fn intMulWithOverflowScalar(
1721		1756
1722	var lhs_space: Value.BigIntSpace = undefined;	1757	var lhs_space: Value.BigIntSpace = undefined;
1723	var rhs_space: Value.BigIntSpace = undefined;	1758	var rhs_space: Value.BigIntSpace = undefined;
1724	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	1759	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
1725	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	1760	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
1726	const limbs = try arena.alloc(	1761	const limbs = try arena.alloc(
1727	std.math.big.Limb,	1762	std.math.big.Limb,
1728	lhs_bigint.limbs.len + rhs_bigint.limbs.len,	1763	lhs_bigint.limbs.len + rhs_bigint.limbs.len,
...	@@ -1753,10 +1788,10 @@ pub fn numberMulWrap(	...	@@ -1753,10 +1788,10 @@ pub fn numberMulWrap(
1753	arena: Allocator,	1788	arena: Allocator,
1754	pt: Zcu.PerThread,	1789	pt: Zcu.PerThread,
1755	) !Value {	1790	) !Value {
1756	const mod = pt.zcu;	1791	const zcu = pt.zcu;
1757	if (ty.zigTypeTag(mod) == .Vector) {	1792	if (ty.zigTypeTag(zcu) == .Vector) {
1758	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(mod));	1793	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(zcu));
1759	const scalar_ty = ty.scalarType(mod);	1794	const scalar_ty = ty.scalarType(zcu);
1760	for (result_data, 0..) \|*scalar, i\| {	1795	for (result_data, 0..) \|*scalar, i\| {
1761	const lhs_elem = try lhs.elemValue(pt, i);	1796	const lhs_elem = try lhs.elemValue(pt, i);
1762	const rhs_elem = try rhs.elemValue(pt, i);	1797	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -1778,10 +1813,10 @@ pub fn numberMulWrapScalar(	...	@@ -1778,10 +1813,10 @@ pub fn numberMulWrapScalar(
1778	arena: Allocator,	1813	arena: Allocator,
1779	pt: Zcu.PerThread,	1814	pt: Zcu.PerThread,
1780	) !Value {	1815	) !Value {
1781	const mod = pt.zcu;	1816	const zcu = pt.zcu;
1782	if (lhs.isUndef(mod) or rhs.isUndef(mod)) return Value.undef;	1817	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return Value.undef;
1783		1818
1784	if (ty.zigTypeTag(mod) == .ComptimeInt) {	1819	if (ty.zigTypeTag(zcu) == .ComptimeInt) {
1785	return intMul(lhs, rhs, ty, undefined, arena, pt);	1820	return intMul(lhs, rhs, ty, undefined, arena, pt);
1786	}	1821	}
1787		1822
...	@@ -1825,15 +1860,17 @@ pub fn intMulSatScalar(	...	@@ -1825,15 +1860,17 @@ pub fn intMulSatScalar(
1825	arena: Allocator,	1860	arena: Allocator,
1826	pt: Zcu.PerThread,	1861	pt: Zcu.PerThread,
1827	) !Value {	1862	) !Value {
1828	assert(!lhs.isUndef(pt.zcu));	1863	const zcu = pt.zcu;
1829	assert(!rhs.isUndef(pt.zcu));	1864
		1865	assert(!lhs.isUndef(zcu));
		1866	assert(!rhs.isUndef(zcu));
1830		1867
1831	const info = ty.intInfo(pt.zcu);	1868	const info = ty.intInfo(zcu);
1832		1869
1833	var lhs_space: Value.BigIntSpace = undefined;	1870	var lhs_space: Value.BigIntSpace = undefined;
1834	var rhs_space: Value.BigIntSpace = undefined;	1871	var rhs_space: Value.BigIntSpace = undefined;
1835	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	1872	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
1836	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	1873	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
1837	const limbs = try arena.alloc(	1874	const limbs = try arena.alloc(
1838	std.math.big.Limb,	1875	std.math.big.Limb,
1839	@max(	1876	@max(
...	@@ -1853,24 +1890,24 @@ pub fn intMulSatScalar(	...	@@ -1853,24 +1890,24 @@ pub fn intMulSatScalar(
1853	}	1890	}
1854		1891
1855	/// Supports both floats and ints; handles undefined.	1892	/// Supports both floats and ints; handles undefined.
1856	pub fn numberMax(lhs: Value, rhs: Value, pt: Zcu.PerThread) Value {	1893	pub fn numberMax(lhs: Value, rhs: Value, zcu: *Zcu) Value {
1857	if (lhs.isUndef(pt.zcu) or rhs.isUndef(pt.zcu)) return undef;	1894	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return undef;
1858	if (lhs.isNan(pt.zcu)) return rhs;	1895	if (lhs.isNan(zcu)) return rhs;
1859	if (rhs.isNan(pt.zcu)) return lhs;	1896	if (rhs.isNan(zcu)) return lhs;
1860		1897
1861	return switch (order(lhs, rhs, pt)) {	1898	return switch (order(lhs, rhs, zcu)) {
1862	.lt => rhs,	1899	.lt => rhs,
1863	.gt, .eq => lhs,	1900	.gt, .eq => lhs,
1864	};	1901	};
1865	}	1902	}
1866		1903
1867	/// Supports both floats and ints; handles undefined.	1904	/// Supports both floats and ints; handles undefined.
1868	pub fn numberMin(lhs: Value, rhs: Value, pt: Zcu.PerThread) Value {	1905	pub fn numberMin(lhs: Value, rhs: Value, zcu: *Zcu) Value {
1869	if (lhs.isUndef(pt.zcu) or rhs.isUndef(pt.zcu)) return undef;	1906	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return undef;
1870	if (lhs.isNan(pt.zcu)) return rhs;	1907	if (lhs.isNan(zcu)) return rhs;
1871	if (rhs.isNan(pt.zcu)) return lhs;	1908	if (rhs.isNan(zcu)) return lhs;
1872		1909
1873	return switch (order(lhs, rhs, pt)) {	1910	return switch (order(lhs, rhs, zcu)) {
1874	.lt => lhs,	1911	.lt => lhs,
1875	.gt, .eq => rhs,	1912	.gt, .eq => rhs,
1876	};	1913	};
...	@@ -1878,10 +1915,10 @@ pub fn numberMin(lhs: Value, rhs: Value, pt: Zcu.PerThread) Value {	...	@@ -1878,10 +1915,10 @@ pub fn numberMin(lhs: Value, rhs: Value, pt: Zcu.PerThread) Value {
1878		1915
1879	/// operands must be (vectors of) integers; handles undefined scalars.	1916	/// operands must be (vectors of) integers; handles undefined scalars.
1880	pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	1917	pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
1881	const mod = pt.zcu;	1918	const zcu = pt.zcu;
1882	if (ty.zigTypeTag(mod) == .Vector) {	1919	if (ty.zigTypeTag(zcu) == .Vector) {
1883	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(mod));	1920	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(zcu));
1884	const scalar_ty = ty.scalarType(mod);	1921	const scalar_ty = ty.scalarType(zcu);
1885	for (result_data, 0..) \|*scalar, i\| {	1922	for (result_data, 0..) \|*scalar, i\| {
1886	const elem_val = try val.elemValue(pt, i);	1923	const elem_val = try val.elemValue(pt, i);
1887	scalar.* = (try bitwiseNotScalar(elem_val, scalar_ty, arena, pt)).toIntern();	1924	scalar.* = (try bitwiseNotScalar(elem_val, scalar_ty, arena, pt)).toIntern();
...	@@ -1896,11 +1933,11 @@ pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Va	...	@@ -1896,11 +1933,11 @@ pub fn bitwiseNot(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Va
1896		1933
1897	/// operands must be integers; handles undefined.	1934	/// operands must be integers; handles undefined.
1898	pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	1935	pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
1899	const mod = pt.zcu;	1936	const zcu = pt.zcu;
1900	if (val.isUndef(mod)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));	1937	if (val.isUndef(zcu)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
1901	if (ty.toIntern() == .bool_type) return makeBool(!val.toBool());	1938	if (ty.toIntern() == .bool_type) return makeBool(!val.toBool());
1902		1939
1903	const info = ty.intInfo(mod);	1940	const info = ty.intInfo(zcu);
1904		1941
1905	if (info.bits == 0) {	1942	if (info.bits == 0) {
1906	return val;	1943	return val;
...	@@ -1909,7 +1946,7 @@ pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThrea	...	@@ -1909,7 +1946,7 @@ pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThrea
1909	// TODO is this a performance issue? maybe we should try the operation without	1946	// TODO is this a performance issue? maybe we should try the operation without
1910	// resorting to BigInt first.	1947	// resorting to BigInt first.
1911	var val_space: Value.BigIntSpace = undefined;	1948	var val_space: Value.BigIntSpace = undefined;
1912	const val_bigint = val.toBigInt(&val_space, pt);	1949	const val_bigint = val.toBigInt(&val_space, zcu);
1913	const limbs = try arena.alloc(	1950	const limbs = try arena.alloc(
1914	std.math.big.Limb,	1951	std.math.big.Limb,
1915	std.math.big.int.calcTwosCompLimbCount(info.bits),	1952	std.math.big.int.calcTwosCompLimbCount(info.bits),
...	@@ -1922,10 +1959,10 @@ pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThrea	...	@@ -1922,10 +1959,10 @@ pub fn bitwiseNotScalar(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThrea
1922		1959
1923	/// operands must be (vectors of) integers; handles undefined scalars.	1960	/// operands must be (vectors of) integers; handles undefined scalars.
1924	pub fn bitwiseAnd(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	1961	pub fn bitwiseAnd(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
1925	const mod = pt.zcu;	1962	const zcu = pt.zcu;
1926	if (ty.zigTypeTag(mod) == .Vector) {	1963	if (ty.zigTypeTag(zcu) == .Vector) {
1927	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	1964	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
1928	const scalar_ty = ty.scalarType(mod);	1965	const scalar_ty = ty.scalarType(zcu);
1929	for (result_data, 0..) \|*scalar, i\| {	1966	for (result_data, 0..) \|*scalar, i\| {
1930	const lhs_elem = try lhs.elemValue(pt, i);	1967	const lhs_elem = try lhs.elemValue(pt, i);
1931	const rhs_elem = try rhs.elemValue(pt, i);	1968	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -1962,8 +1999,8 @@ pub fn bitwiseAndScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloc	...	@@ -1962,8 +1999,8 @@ pub fn bitwiseAndScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloc
1962	// resorting to BigInt first.	1999	// resorting to BigInt first.
1963	var lhs_space: Value.BigIntSpace = undefined;	2000	var lhs_space: Value.BigIntSpace = undefined;
1964	var rhs_space: Value.BigIntSpace = undefined;	2001	var rhs_space: Value.BigIntSpace = undefined;
1965	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2002	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
1966	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2003	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
1967	const limbs = try arena.alloc(	2004	const limbs = try arena.alloc(
1968	std.math.big.Limb,	2005	std.math.big.Limb,
1969	// + 1 for negatives	2006	// + 1 for negatives
...	@@ -1995,10 +2032,10 @@ fn intValueAa(ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	...	@@ -1995,10 +2032,10 @@ fn intValueAa(ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
1995		2032
1996	/// operands must be (vectors of) integers; handles undefined scalars.	2033	/// operands must be (vectors of) integers; handles undefined scalars.
1997	pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	2034	pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
1998	const mod = pt.zcu;	2035	const zcu = pt.zcu;
1999	if (ty.zigTypeTag(mod) == .Vector) {	2036	if (ty.zigTypeTag(zcu) == .Vector) {
2000	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(mod));	2037	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(zcu));
2001	const scalar_ty = ty.scalarType(mod);	2038	const scalar_ty = ty.scalarType(zcu);
2002	for (result_data, 0..) \|*scalar, i\| {	2039	for (result_data, 0..) \|*scalar, i\| {
2003	const lhs_elem = try lhs.elemValue(pt, i);	2040	const lhs_elem = try lhs.elemValue(pt, i);
2004	const rhs_elem = try rhs.elemValue(pt, i);	2041	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2014,21 +2051,21 @@ pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.P	...	@@ -2014,21 +2051,21 @@ pub fn bitwiseNand(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.P
2014		2051
2015	/// operands must be integers; handles undefined.	2052	/// operands must be integers; handles undefined.
2016	pub fn bitwiseNandScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	2053	pub fn bitwiseNandScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
2017	const mod = pt.zcu;	2054	const zcu = pt.zcu;
2018	if (lhs.isUndef(mod) or rhs.isUndef(mod)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));	2055	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
2019	if (ty.toIntern() == .bool_type) return makeBool(!(lhs.toBool() and rhs.toBool()));	2056	if (ty.toIntern() == .bool_type) return makeBool(!(lhs.toBool() and rhs.toBool()));
2020		2057
2021	const anded = try bitwiseAnd(lhs, rhs, ty, arena, pt);	2058	const anded = try bitwiseAnd(lhs, rhs, ty, arena, pt);
2022	const all_ones = if (ty.isSignedInt(mod)) try pt.intValue(ty, -1) else try ty.maxIntScalar(pt, ty);	2059	const all_ones = if (ty.isSignedInt(zcu)) try pt.intValue(ty, -1) else try ty.maxIntScalar(pt, ty);
2023	return bitwiseXor(anded, all_ones, ty, arena, pt);	2060	return bitwiseXor(anded, all_ones, ty, arena, pt);
2024	}	2061	}
2025		2062
2026	/// operands must be (vectors of) integers; handles undefined scalars.	2063	/// operands must be (vectors of) integers; handles undefined scalars.
2027	pub fn bitwiseOr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2064	pub fn bitwiseOr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2028	const mod = pt.zcu;	2065	const zcu = pt.zcu;
2029	if (ty.zigTypeTag(mod) == .Vector) {	2066	if (ty.zigTypeTag(zcu) == .Vector) {
2030	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	2067	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
2031	const scalar_ty = ty.scalarType(mod);	2068	const scalar_ty = ty.scalarType(zcu);
2032	for (result_data, 0..) \|*scalar, i\| {	2069	for (result_data, 0..) \|*scalar, i\| {
2033	const lhs_elem = try lhs.elemValue(pt, i);	2070	const lhs_elem = try lhs.elemValue(pt, i);
2034	const rhs_elem = try rhs.elemValue(pt, i);	2071	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2047,9 +2084,10 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca	...	@@ -2047,9 +2084,10 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca
2047	// If one operand is defined, we turn the other into `0xAA` so the bitwise AND can	2084	// If one operand is defined, we turn the other into `0xAA` so the bitwise AND can
2048	// still zero out some bits.	2085	// still zero out some bits.
2049	// TODO: ideally we'd still like tracking for the undef bits. Related: #19634.	2086	// TODO: ideally we'd still like tracking for the undef bits. Related: #19634.
		2087	const zcu = pt.zcu;
2050	const lhs: Value, const rhs: Value = make_defined: {	2088	const lhs: Value, const rhs: Value = make_defined: {
2051	const lhs_undef = orig_lhs.isUndef(pt.zcu);	2089	const lhs_undef = orig_lhs.isUndef(zcu);
2052	const rhs_undef = orig_rhs.isUndef(pt.zcu);	2090	const rhs_undef = orig_rhs.isUndef(zcu);
2053	break :make_defined switch ((@as(u2, @intFromBool(lhs_undef)) << 1) \| @intFromBool(rhs_undef)) {	2091	break :make_defined switch ((@as(u2, @intFromBool(lhs_undef)) << 1) \| @intFromBool(rhs_undef)) {
2054	0b00 => .{ orig_lhs, orig_rhs },	2092	0b00 => .{ orig_lhs, orig_rhs },
2055	0b01 => .{ orig_lhs, try intValueAa(ty, arena, pt) },	2093	0b01 => .{ orig_lhs, try intValueAa(ty, arena, pt) },
...	@@ -2064,8 +2102,8 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca	...	@@ -2064,8 +2102,8 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca
2064	// resorting to BigInt first.	2102	// resorting to BigInt first.
2065	var lhs_space: Value.BigIntSpace = undefined;	2103	var lhs_space: Value.BigIntSpace = undefined;
2066	var rhs_space: Value.BigIntSpace = undefined;	2104	var rhs_space: Value.BigIntSpace = undefined;
2067	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2105	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2068	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2106	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2069	const limbs = try arena.alloc(	2107	const limbs = try arena.alloc(
2070	std.math.big.Limb,	2108	std.math.big.Limb,
2071	@max(lhs_bigint.limbs.len, rhs_bigint.limbs.len),	2109	@max(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
...	@@ -2077,10 +2115,10 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca	...	@@ -2077,10 +2115,10 @@ pub fn bitwiseOrScalar(orig_lhs: Value, orig_rhs: Value, ty: Type, arena: Alloca
2077		2115
2078	/// operands must be (vectors of) integers; handles undefined scalars.	2116	/// operands must be (vectors of) integers; handles undefined scalars.
2079	pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2117	pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2080	const mod = pt.zcu;	2118	const zcu = pt.zcu;
2081	if (ty.zigTypeTag(mod) == .Vector) {	2119	if (ty.zigTypeTag(zcu) == .Vector) {
2082	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	2120	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
2083	const scalar_ty = ty.scalarType(mod);	2121	const scalar_ty = ty.scalarType(zcu);
2084	for (result_data, 0..) \|*scalar, i\| {	2122	for (result_data, 0..) \|*scalar, i\| {
2085	const lhs_elem = try lhs.elemValue(pt, i);	2123	const lhs_elem = try lhs.elemValue(pt, i);
2086	const rhs_elem = try rhs.elemValue(pt, i);	2124	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2096,16 +2134,16 @@ pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zc	...	@@ -2096,16 +2134,16 @@ pub fn bitwiseXor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zc
2096		2134
2097	/// operands must be integers; handles undefined.	2135	/// operands must be integers; handles undefined.
2098	pub fn bitwiseXorScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	2136	pub fn bitwiseXorScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
2099	const mod = pt.zcu;	2137	const zcu = pt.zcu;
2100	if (lhs.isUndef(mod) or rhs.isUndef(mod)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));	2138	if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return Value.fromInterned(try pt.intern(.{ .undef = ty.toIntern() }));
2101	if (ty.toIntern() == .bool_type) return makeBool(lhs.toBool() != rhs.toBool());	2139	if (ty.toIntern() == .bool_type) return makeBool(lhs.toBool() != rhs.toBool());
2102		2140
2103	// TODO is this a performance issue? maybe we should try the operation without	2141	// TODO is this a performance issue? maybe we should try the operation without
2104	// resorting to BigInt first.	2142	// resorting to BigInt first.
2105	var lhs_space: Value.BigIntSpace = undefined;	2143	var lhs_space: Value.BigIntSpace = undefined;
2106	var rhs_space: Value.BigIntSpace = undefined;	2144	var rhs_space: Value.BigIntSpace = undefined;
2107	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2145	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2108	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2146	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2109	const limbs = try arena.alloc(	2147	const limbs = try arena.alloc(
2110	std.math.big.Limb,	2148	std.math.big.Limb,
2111	// + 1 for negatives	2149	// + 1 for negatives
...	@@ -2164,10 +2202,11 @@ fn intDivInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator	...	@@ -2164,10 +2202,11 @@ fn intDivInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator
2164	pub fn intDivScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2202	pub fn intDivScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2165	// TODO is this a performance issue? maybe we should try the operation without	2203	// TODO is this a performance issue? maybe we should try the operation without
2166	// resorting to BigInt first.	2204	// resorting to BigInt first.
		2205	const zcu = pt.zcu;
2167	var lhs_space: Value.BigIntSpace = undefined;	2206	var lhs_space: Value.BigIntSpace = undefined;
2168	var rhs_space: Value.BigIntSpace = undefined;	2207	var rhs_space: Value.BigIntSpace = undefined;
2169	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2208	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2170	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2209	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2171	const limbs_q = try allocator.alloc(	2210	const limbs_q = try allocator.alloc(
2172	std.math.big.Limb,	2211	std.math.big.Limb,
2173	lhs_bigint.limbs.len,	2212	lhs_bigint.limbs.len,
...	@@ -2212,10 +2251,11 @@ pub fn intDivFloor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Z	...	@@ -2212,10 +2251,11 @@ pub fn intDivFloor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Z
2212	pub fn intDivFloorScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2251	pub fn intDivFloorScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2213	// TODO is this a performance issue? maybe we should try the operation without	2252	// TODO is this a performance issue? maybe we should try the operation without
2214	// resorting to BigInt first.	2253	// resorting to BigInt first.
		2254	const zcu = pt.zcu;
2215	var lhs_space: Value.BigIntSpace = undefined;	2255	var lhs_space: Value.BigIntSpace = undefined;
2216	var rhs_space: Value.BigIntSpace = undefined;	2256	var rhs_space: Value.BigIntSpace = undefined;
2217	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2257	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2218	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2258	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2219	const limbs_q = try allocator.alloc(	2259	const limbs_q = try allocator.alloc(
2220	std.math.big.Limb,	2260	std.math.big.Limb,
2221	lhs_bigint.limbs.len,	2261	lhs_bigint.limbs.len,
...	@@ -2254,10 +2294,11 @@ pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.Pe	...	@@ -2254,10 +2294,11 @@ pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.Pe
2254	pub fn intModScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2294	pub fn intModScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2255	// TODO is this a performance issue? maybe we should try the operation without	2295	// TODO is this a performance issue? maybe we should try the operation without
2256	// resorting to BigInt first.	2296	// resorting to BigInt first.
		2297	const zcu = pt.zcu;
2257	var lhs_space: Value.BigIntSpace = undefined;	2298	var lhs_space: Value.BigIntSpace = undefined;
2258	var rhs_space: Value.BigIntSpace = undefined;	2299	var rhs_space: Value.BigIntSpace = undefined;
2259	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2300	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2260	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2301	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2261	const limbs_q = try allocator.alloc(	2302	const limbs_q = try allocator.alloc(
2262	std.math.big.Limb,	2303	std.math.big.Limb,
2263	lhs_bigint.limbs.len,	2304	lhs_bigint.limbs.len,
...	@@ -2277,8 +2318,8 @@ pub fn intModScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt:	...	@@ -2277,8 +2318,8 @@ pub fn intModScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt:
2277	}	2318	}
2278		2319
2279	/// Returns true if the value is a floating point type and is NaN. Returns false otherwise.	2320	/// Returns true if the value is a floating point type and is NaN. Returns false otherwise.
2280	pub fn isNan(val: Value, mod: *const Module) bool {	2321	pub fn isNan(val: Value, zcu: *const Zcu) bool {
2281	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	2322	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
2282	.float => \|float\| switch (float.storage) {	2323	.float => \|float\| switch (float.storage) {
2283	inline else => \|x\| std.math.isNan(x),	2324	inline else => \|x\| std.math.isNan(x),
2284	},	2325	},
...	@@ -2287,8 +2328,8 @@ pub fn isNan(val: Value, mod: *const Module) bool {	...	@@ -2287,8 +2328,8 @@ pub fn isNan(val: Value, mod: *const Module) bool {
2287	}	2328	}
2288		2329
2289	/// Returns true if the value is a floating point type and is infinite. Returns false otherwise.	2330	/// Returns true if the value is a floating point type and is infinite. Returns false otherwise.
2290	pub fn isInf(val: Value, mod: *const Module) bool {	2331	pub fn isInf(val: Value, zcu: *const Zcu) bool {
2291	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	2332	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
2292	.float => \|float\| switch (float.storage) {	2333	.float => \|float\| switch (float.storage) {
2293	inline else => \|x\| std.math.isInf(x),	2334	inline else => \|x\| std.math.isInf(x),
2294	},	2335	},
...	@@ -2296,8 +2337,8 @@ pub fn isInf(val: Value, mod: *const Module) bool {	...	@@ -2296,8 +2337,8 @@ pub fn isInf(val: Value, mod: *const Module) bool {
2296	};	2337	};
2297	}	2338	}
2298		2339
2299	pub fn isNegativeInf(val: Value, mod: *const Module) bool {	2340	pub fn isNegativeInf(val: Value, zcu: *const Zcu) bool {
2300	return switch (mod.intern_pool.indexToKey(val.toIntern())) {	2341	return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
2301	.float => \|float\| switch (float.storage) {	2342	.float => \|float\| switch (float.storage) {
2302	inline else => \|x\| std.math.isNegativeInf(x),	2343	inline else => \|x\| std.math.isNegativeInf(x),
2303	},	2344	},
...	@@ -2323,13 +2364,14 @@ pub fn floatRem(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, pt:	...	@@ -2323,13 +2364,14 @@ pub fn floatRem(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, pt:
2323	}	2364	}
2324		2365
2325	pub fn floatRemScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThread) !Value {	2366	pub fn floatRemScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThread) !Value {
		2367	const zcu = pt.zcu;
2326	const target = pt.zcu.getTarget();	2368	const target = pt.zcu.getTarget();
2327	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2369	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2328	16 => .{ .f16 = @rem(lhs.toFloat(f16, pt), rhs.toFloat(f16, pt)) },	2370	16 => .{ .f16 = @rem(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
2329	32 => .{ .f32 = @rem(lhs.toFloat(f32, pt), rhs.toFloat(f32, pt)) },	2371	32 => .{ .f32 = @rem(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
2330	64 => .{ .f64 = @rem(lhs.toFloat(f64, pt), rhs.toFloat(f64, pt)) },	2372	64 => .{ .f64 = @rem(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
2331	80 => .{ .f80 = @rem(lhs.toFloat(f80, pt), rhs.toFloat(f80, pt)) },	2373	80 => .{ .f80 = @rem(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
2332	128 => .{ .f128 = @rem(lhs.toFloat(f128, pt), rhs.toFloat(f128, pt)) },	2374	128 => .{ .f128 = @rem(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
2333	else => unreachable,	2375	else => unreachable,
2334	};	2376	};
2335	return Value.fromInterned(try pt.intern(.{ .float = .{	2377	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2356,13 +2398,14 @@ pub fn floatMod(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, pt:	...	@@ -2356,13 +2398,14 @@ pub fn floatMod(lhs: Value, rhs: Value, float_type: Type, arena: Allocator, pt:
2356	}	2398	}
2357		2399
2358	pub fn floatModScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThread) !Value {	2400	pub fn floatModScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThread) !Value {
2359	const target = pt.zcu.getTarget();	2401	const zcu = pt.zcu;
		2402	const target = zcu.getTarget();
2360	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2403	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2361	16 => .{ .f16 = @mod(lhs.toFloat(f16, pt), rhs.toFloat(f16, pt)) },	2404	16 => .{ .f16 = @mod(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
2362	32 => .{ .f32 = @mod(lhs.toFloat(f32, pt), rhs.toFloat(f32, pt)) },	2405	32 => .{ .f32 = @mod(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
2363	64 => .{ .f64 = @mod(lhs.toFloat(f64, pt), rhs.toFloat(f64, pt)) },	2406	64 => .{ .f64 = @mod(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
2364	80 => .{ .f80 = @mod(lhs.toFloat(f80, pt), rhs.toFloat(f80, pt)) },	2407	80 => .{ .f80 = @mod(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
2365	128 => .{ .f128 = @mod(lhs.toFloat(f128, pt), rhs.toFloat(f128, pt)) },	2408	128 => .{ .f128 = @mod(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
2366	else => unreachable,	2409	else => unreachable,
2367	};	2410	};
2368	return Value.fromInterned(try pt.intern(.{ .float = .{	2411	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2374,14 +2417,14 @@ pub fn floatModScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThrea	...	@@ -2374,14 +2417,14 @@ pub fn floatModScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThrea
2374	/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting	2417	/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
2375	/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).	2418	/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).
2376	pub fn intMul(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator: Allocator, pt: Zcu.PerThread) !Value {	2419	pub fn intMul(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
2377	const mod = pt.zcu;	2420	const zcu = pt.zcu;
2378	var overflow: usize = undefined;	2421	var overflow: usize = undefined;
2379	return intMulInner(lhs, rhs, ty, &overflow, allocator, pt) catch \|err\| switch (err) {	2422	return intMulInner(lhs, rhs, ty, &overflow, allocator, pt) catch \|err\| switch (err) {
2380	error.Overflow => {	2423	error.Overflow => {
2381	const is_vec = ty.isVector(mod);	2424	const is_vec = ty.isVector(zcu);
2382	overflow_idx.* = if (is_vec) overflow else 0;	2425	overflow_idx.* = if (is_vec) overflow else 0;
2383	const safe_ty = if (is_vec) try pt.vectorType(.{	2426	const safe_ty = if (is_vec) try pt.vectorType(.{
2384	.len = ty.vectorLen(mod),	2427	.len = ty.vectorLen(zcu),
2385	.child = .comptime_int_type,	2428	.child = .comptime_int_type,
2386	}) else Type.comptime_int;	2429	}) else Type.comptime_int;
2387	return intMulInner(lhs, rhs, safe_ty, undefined, allocator, pt) catch \|err1\| switch (err1) {	2430	return intMulInner(lhs, rhs, safe_ty, undefined, allocator, pt) catch \|err1\| switch (err1) {
...	@@ -2394,10 +2437,10 @@ pub fn intMul(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator	...	@@ -2394,10 +2437,10 @@ pub fn intMul(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator
2394	}	2437	}
2395		2438
2396	fn intMulInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator: Allocator, pt: Zcu.PerThread) !Value {	2439	fn intMulInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
2397	const mod = pt.zcu;	2440	const zcu = pt.zcu;
2398	if (ty.zigTypeTag(mod) == .Vector) {	2441	if (ty.zigTypeTag(zcu) == .Vector) {
2399	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	2442	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
2400	const scalar_ty = ty.scalarType(mod);	2443	const scalar_ty = ty.scalarType(zcu);
2401	for (result_data, 0..) \|*scalar, i\| {	2444	for (result_data, 0..) \|*scalar, i\| {
2402	const lhs_elem = try lhs.elemValue(pt, i);	2445	const lhs_elem = try lhs.elemValue(pt, i);
2403	const rhs_elem = try rhs.elemValue(pt, i);	2446	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2419,17 +2462,18 @@ fn intMulInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator	...	@@ -2419,17 +2462,18 @@ fn intMulInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator
2419	}	2462	}
2420		2463
2421	pub fn intMulScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2464	pub fn intMulScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
		2465	const zcu = pt.zcu;
2422	if (ty.toIntern() != .comptime_int_type) {	2466	if (ty.toIntern() != .comptime_int_type) {
2423	const res = try intMulWithOverflowScalar(lhs, rhs, ty, allocator, pt);	2467	const res = try intMulWithOverflowScalar(lhs, rhs, ty, allocator, pt);
2424	if (res.overflow_bit.compareAllWithZero(.neq, pt)) return error.Overflow;	2468	if (res.overflow_bit.compareAllWithZero(.neq, zcu)) return error.Overflow;
2425	return res.wrapped_result;	2469	return res.wrapped_result;
2426	}	2470	}
2427	// TODO is this a performance issue? maybe we should try the operation without	2471	// TODO is this a performance issue? maybe we should try the operation without
2428	// resorting to BigInt first.	2472	// resorting to BigInt first.
2429	var lhs_space: Value.BigIntSpace = undefined;	2473	var lhs_space: Value.BigIntSpace = undefined;
2430	var rhs_space: Value.BigIntSpace = undefined;	2474	var rhs_space: Value.BigIntSpace = undefined;
2431	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2475	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2432	const rhs_bigint = rhs.toBigInt(&rhs_space, pt);	2476	const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
2433	const limbs = try allocator.alloc(	2477	const limbs = try allocator.alloc(
2434	std.math.big.Limb,	2478	std.math.big.Limb,
2435	lhs_bigint.limbs.len + rhs_bigint.limbs.len,	2479	lhs_bigint.limbs.len + rhs_bigint.limbs.len,
...	@@ -2445,10 +2489,10 @@ pub fn intMulScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt:	...	@@ -2445,10 +2489,10 @@ pub fn intMulScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt:
2445	}	2489	}
2446		2490
2447	pub fn intTrunc(val: Value, ty: Type, allocator: Allocator, signedness: std.builtin.Signedness, bits: u16, pt: Zcu.PerThread) !Value {	2491	pub fn intTrunc(val: Value, ty: Type, allocator: Allocator, signedness: std.builtin.Signedness, bits: u16, pt: Zcu.PerThread) !Value {
2448	const mod = pt.zcu;	2492	const zcu = pt.zcu;
2449	if (ty.zigTypeTag(mod) == .Vector) {	2493	if (ty.zigTypeTag(zcu) == .Vector) {
2450	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	2494	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
2451	const scalar_ty = ty.scalarType(mod);	2495	const scalar_ty = ty.scalarType(zcu);
2452	for (result_data, 0..) \|*scalar, i\| {	2496	for (result_data, 0..) \|*scalar, i\| {
2453	const elem_val = try val.elemValue(pt, i);	2497	const elem_val = try val.elemValue(pt, i);
2454	scalar.* = (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, bits, pt)).toIntern();	2498	scalar.* = (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, bits, pt)).toIntern();
...	@@ -2470,20 +2514,21 @@ pub fn intTruncBitsAsValue(	...	@@ -2470,20 +2514,21 @@ pub fn intTruncBitsAsValue(
2470	bits: Value,	2514	bits: Value,
2471	pt: Zcu.PerThread,	2515	pt: Zcu.PerThread,
2472	) !Value {	2516	) !Value {
2473	if (ty.zigTypeTag(pt.zcu) == .Vector) {	2517	const zcu = pt.zcu;
2474	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));	2518	if (ty.zigTypeTag(zcu) == .Vector) {
2475	const scalar_ty = ty.scalarType(pt.zcu);	2519	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
		2520	const scalar_ty = ty.scalarType(zcu);
2476	for (result_data, 0..) \|*scalar, i\| {	2521	for (result_data, 0..) \|*scalar, i\| {
2477	const elem_val = try val.elemValue(pt, i);	2522	const elem_val = try val.elemValue(pt, i);
2478	const bits_elem = try bits.elemValue(pt, i);	2523	const bits_elem = try bits.elemValue(pt, i);
2479	scalar.* = (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, @intCast(bits_elem.toUnsignedInt(pt)), pt)).toIntern();	2524	scalar.* = (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, @intCast(bits_elem.toUnsignedInt(zcu)), pt)).toIntern();
2480	}	2525	}
2481	return Value.fromInterned(try pt.intern(.{ .aggregate = .{	2526	return Value.fromInterned(try pt.intern(.{ .aggregate = .{
2482	.ty = ty.toIntern(),	2527	.ty = ty.toIntern(),
2483	.storage = .{ .elems = result_data },	2528	.storage = .{ .elems = result_data },
2484	} }));	2529	} }));
2485	}	2530	}
2486	return intTruncScalar(val, ty, allocator, signedness, @intCast(bits.toUnsignedInt(pt)), pt);	2531	return intTruncScalar(val, ty, allocator, signedness, @intCast(bits.toUnsignedInt(zcu)), pt);
2487	}	2532	}
2488		2533
2489	pub fn intTruncScalar(	2534	pub fn intTruncScalar(
...	@@ -2500,7 +2545,7 @@ pub fn intTruncScalar(	...	@@ -2500,7 +2545,7 @@ pub fn intTruncScalar(
2500	if (val.isUndef(zcu)) return pt.undefValue(ty);	2545	if (val.isUndef(zcu)) return pt.undefValue(ty);
2501		2546
2502	var val_space: Value.BigIntSpace = undefined;	2547	var val_space: Value.BigIntSpace = undefined;
2503	const val_bigint = val.toBigInt(&val_space, pt);	2548	const val_bigint = val.toBigInt(&val_space, zcu);
2504		2549
2505	const limbs = try allocator.alloc(	2550	const limbs = try allocator.alloc(
2506	std.math.big.Limb,	2551	std.math.big.Limb,
...	@@ -2513,10 +2558,10 @@ pub fn intTruncScalar(	...	@@ -2513,10 +2558,10 @@ pub fn intTruncScalar(
2513	}	2558	}
2514		2559
2515	pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2560	pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2516	const mod = pt.zcu;	2561	const zcu = pt.zcu;
2517	if (ty.zigTypeTag(mod) == .Vector) {	2562	if (ty.zigTypeTag(zcu) == .Vector) {
2518	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(mod));	2563	const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
2519	const scalar_ty = ty.scalarType(mod);	2564	const scalar_ty = ty.scalarType(zcu);
2520	for (result_data, 0..) \|*scalar, i\| {	2565	for (result_data, 0..) \|*scalar, i\| {
2521	const lhs_elem = try lhs.elemValue(pt, i);	2566	const lhs_elem = try lhs.elemValue(pt, i);
2522	const rhs_elem = try rhs.elemValue(pt, i);	2567	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2533,9 +2578,10 @@ pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerTh	...	@@ -2533,9 +2578,10 @@ pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerTh
2533	pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2578	pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2534	// TODO is this a performance issue? maybe we should try the operation without	2579	// TODO is this a performance issue? maybe we should try the operation without
2535	// resorting to BigInt first.	2580	// resorting to BigInt first.
		2581	const zcu = pt.zcu;
2536	var lhs_space: Value.BigIntSpace = undefined;	2582	var lhs_space: Value.BigIntSpace = undefined;
2537	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2583	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2538	const shift: usize = @intCast(rhs.toUnsignedInt(pt));	2584	const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
2539	const limbs = try allocator.alloc(	2585	const limbs = try allocator.alloc(
2540	std.math.big.Limb,	2586	std.math.big.Limb,
2541	lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,	2587	lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
...	@@ -2547,7 +2593,7 @@ pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu	...	@@ -2547,7 +2593,7 @@ pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu
2547	};	2593	};
2548	result_bigint.shiftLeft(lhs_bigint, shift);	2594	result_bigint.shiftLeft(lhs_bigint, shift);
2549	if (ty.toIntern() != .comptime_int_type) {	2595	if (ty.toIntern() != .comptime_int_type) {
2550	const int_info = ty.intInfo(pt.zcu);	2596	const int_info = ty.intInfo(zcu);
2551	result_bigint.truncate(result_bigint.toConst(), int_info.signedness, int_info.bits);	2597	result_bigint.truncate(result_bigint.toConst(), int_info.signedness, int_info.bits);
2552	}	2598	}
2553		2599
...	@@ -2594,10 +2640,11 @@ pub fn shlWithOverflowScalar(	...	@@ -2594,10 +2640,11 @@ pub fn shlWithOverflowScalar(
2594	allocator: Allocator,	2640	allocator: Allocator,
2595	pt: Zcu.PerThread,	2641	pt: Zcu.PerThread,
2596	) !OverflowArithmeticResult {	2642	) !OverflowArithmeticResult {
2597	const info = ty.intInfo(pt.zcu);	2643	const zcu = pt.zcu;
		2644	const info = ty.intInfo(zcu);
2598	var lhs_space: Value.BigIntSpace = undefined;	2645	var lhs_space: Value.BigIntSpace = undefined;
2599	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2646	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2600	const shift: usize = @intCast(rhs.toUnsignedInt(pt));	2647	const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
2601	const limbs = try allocator.alloc(	2648	const limbs = try allocator.alloc(
2602	std.math.big.Limb,	2649	std.math.big.Limb,
2603	lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,	2650	lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
...	@@ -2650,11 +2697,12 @@ pub fn shlSatScalar(	...	@@ -2650,11 +2697,12 @@ pub fn shlSatScalar(
2650	) !Value {	2697	) !Value {
2651	// TODO is this a performance issue? maybe we should try the operation without	2698	// TODO is this a performance issue? maybe we should try the operation without
2652	// resorting to BigInt first.	2699	// resorting to BigInt first.
2653	const info = ty.intInfo(pt.zcu);	2700	const zcu = pt.zcu;
		2701	const info = ty.intInfo(zcu);
2654		2702
2655	var lhs_space: Value.BigIntSpace = undefined;	2703	var lhs_space: Value.BigIntSpace = undefined;
2656	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2704	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2657	const shift: usize = @intCast(rhs.toUnsignedInt(pt));	2705	const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
2658	const limbs = try arena.alloc(	2706	const limbs = try arena.alloc(
2659	std.math.big.Limb,	2707	std.math.big.Limb,
2660	std.math.big.int.calcTwosCompLimbCount(info.bits) + 1,	2708	std.math.big.int.calcTwosCompLimbCount(info.bits) + 1,
...	@@ -2724,9 +2772,10 @@ pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerTh	...	@@ -2724,9 +2772,10 @@ pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerTh
2724	pub fn shrScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {	2772	pub fn shrScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
2725	// TODO is this a performance issue? maybe we should try the operation without	2773	// TODO is this a performance issue? maybe we should try the operation without
2726	// resorting to BigInt first.	2774	// resorting to BigInt first.
		2775	const zcu = pt.zcu;
2727	var lhs_space: Value.BigIntSpace = undefined;	2776	var lhs_space: Value.BigIntSpace = undefined;
2728	const lhs_bigint = lhs.toBigInt(&lhs_space, pt);	2777	const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
2729	const shift: usize = @intCast(rhs.toUnsignedInt(pt));	2778	const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
2730		2779
2731	const result_limbs = lhs_bigint.limbs.len -\| (shift / (@sizeOf(std.math.big.Limb) * 8));	2780	const result_limbs = lhs_bigint.limbs.len -\| (shift / (@sizeOf(std.math.big.Limb) * 8));
2732	if (result_limbs == 0) {	2781	if (result_limbs == 0) {
...	@@ -2758,10 +2807,10 @@ pub fn floatNeg(	...	@@ -2758,10 +2807,10 @@ pub fn floatNeg(
2758	arena: Allocator,	2807	arena: Allocator,
2759	pt: Zcu.PerThread,	2808	pt: Zcu.PerThread,
2760	) !Value {	2809	) !Value {
2761	const mod = pt.zcu;	2810	const zcu = pt.zcu;
2762	if (float_type.zigTypeTag(mod) == .Vector) {	2811	if (float_type.zigTypeTag(zcu) == .Vector) {
2763	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	2812	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
2764	const scalar_ty = float_type.scalarType(mod);	2813	const scalar_ty = float_type.scalarType(zcu);
2765	for (result_data, 0..) \|*scalar, i\| {	2814	for (result_data, 0..) \|*scalar, i\| {
2766	const elem_val = try val.elemValue(pt, i);	2815	const elem_val = try val.elemValue(pt, i);
2767	scalar.* = (try floatNegScalar(elem_val, scalar_ty, pt)).toIntern();	2816	scalar.* = (try floatNegScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -2775,13 +2824,14 @@ pub fn floatNeg(	...	@@ -2775,13 +2824,14 @@ pub fn floatNeg(
2775	}	2824	}
2776		2825
2777	pub fn floatNegScalar(val: Value, float_type: Type, pt: Zcu.PerThread) !Value {	2826	pub fn floatNegScalar(val: Value, float_type: Type, pt: Zcu.PerThread) !Value {
2778	const target = pt.zcu.getTarget();	2827	const zcu = pt.zcu;
		2828	const target = zcu.getTarget();
2779	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2829	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2780	16 => .{ .f16 = -val.toFloat(f16, pt) },	2830	16 => .{ .f16 = -val.toFloat(f16, zcu) },
2781	32 => .{ .f32 = -val.toFloat(f32, pt) },	2831	32 => .{ .f32 = -val.toFloat(f32, zcu) },
2782	64 => .{ .f64 = -val.toFloat(f64, pt) },	2832	64 => .{ .f64 = -val.toFloat(f64, zcu) },
2783	80 => .{ .f80 = -val.toFloat(f80, pt) },	2833	80 => .{ .f80 = -val.toFloat(f80, zcu) },
2784	128 => .{ .f128 = -val.toFloat(f128, pt) },	2834	128 => .{ .f128 = -val.toFloat(f128, zcu) },
2785	else => unreachable,	2835	else => unreachable,
2786	};	2836	};
2787	return Value.fromInterned(try pt.intern(.{ .float = .{	2837	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2797,10 +2847,10 @@ pub fn floatAdd(	...	@@ -2797,10 +2847,10 @@ pub fn floatAdd(
2797	arena: Allocator,	2847	arena: Allocator,
2798	pt: Zcu.PerThread,	2848	pt: Zcu.PerThread,
2799	) !Value {	2849	) !Value {
2800	const mod = pt.zcu;	2850	const zcu = pt.zcu;
2801	if (float_type.zigTypeTag(mod) == .Vector) {	2851	if (float_type.zigTypeTag(zcu) == .Vector) {
2802	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	2852	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
2803	const scalar_ty = float_type.scalarType(mod);	2853	const scalar_ty = float_type.scalarType(zcu);
2804	for (result_data, 0..) \|*scalar, i\| {	2854	for (result_data, 0..) \|*scalar, i\| {
2805	const lhs_elem = try lhs.elemValue(pt, i);	2855	const lhs_elem = try lhs.elemValue(pt, i);
2806	const rhs_elem = try rhs.elemValue(pt, i);	2856	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2820,14 +2870,14 @@ pub fn floatAddScalar(	...	@@ -2820,14 +2870,14 @@ pub fn floatAddScalar(
2820	float_type: Type,	2870	float_type: Type,
2821	pt: Zcu.PerThread,	2871	pt: Zcu.PerThread,
2822	) !Value {	2872	) !Value {
2823	const mod = pt.zcu;	2873	const zcu = pt.zcu;
2824	const target = mod.getTarget();	2874	const target = zcu.getTarget();
2825	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2875	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2826	16 => .{ .f16 = lhs.toFloat(f16, pt) + rhs.toFloat(f16, pt) },	2876	16 => .{ .f16 = lhs.toFloat(f16, zcu) + rhs.toFloat(f16, zcu) },
2827	32 => .{ .f32 = lhs.toFloat(f32, pt) + rhs.toFloat(f32, pt) },	2877	32 => .{ .f32 = lhs.toFloat(f32, zcu) + rhs.toFloat(f32, zcu) },
2828	64 => .{ .f64 = lhs.toFloat(f64, pt) + rhs.toFloat(f64, pt) },	2878	64 => .{ .f64 = lhs.toFloat(f64, zcu) + rhs.toFloat(f64, zcu) },
2829	80 => .{ .f80 = lhs.toFloat(f80, pt) + rhs.toFloat(f80, pt) },	2879	80 => .{ .f80 = lhs.toFloat(f80, zcu) + rhs.toFloat(f80, zcu) },
2830	128 => .{ .f128 = lhs.toFloat(f128, pt) + rhs.toFloat(f128, pt) },	2880	128 => .{ .f128 = lhs.toFloat(f128, zcu) + rhs.toFloat(f128, zcu) },
2831	else => unreachable,	2881	else => unreachable,
2832	};	2882	};
2833	return Value.fromInterned(try pt.intern(.{ .float = .{	2883	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2843,10 +2893,10 @@ pub fn floatSub(	...	@@ -2843,10 +2893,10 @@ pub fn floatSub(
2843	arena: Allocator,	2893	arena: Allocator,
2844	pt: Zcu.PerThread,	2894	pt: Zcu.PerThread,
2845	) !Value {	2895	) !Value {
2846	const mod = pt.zcu;	2896	const zcu = pt.zcu;
2847	if (float_type.zigTypeTag(mod) == .Vector) {	2897	if (float_type.zigTypeTag(zcu) == .Vector) {
2848	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	2898	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
2849	const scalar_ty = float_type.scalarType(mod);	2899	const scalar_ty = float_type.scalarType(zcu);
2850	for (result_data, 0..) \|*scalar, i\| {	2900	for (result_data, 0..) \|*scalar, i\| {
2851	const lhs_elem = try lhs.elemValue(pt, i);	2901	const lhs_elem = try lhs.elemValue(pt, i);
2852	const rhs_elem = try rhs.elemValue(pt, i);	2902	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -2866,14 +2916,14 @@ pub fn floatSubScalar(	...	@@ -2866,14 +2916,14 @@ pub fn floatSubScalar(
2866	float_type: Type,	2916	float_type: Type,
2867	pt: Zcu.PerThread,	2917	pt: Zcu.PerThread,
2868	) !Value {	2918	) !Value {
2869	const mod = pt.zcu;	2919	const zcu = pt.zcu;
2870	const target = mod.getTarget();	2920	const target = zcu.getTarget();
2871	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2921	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2872	16 => .{ .f16 = lhs.toFloat(f16, pt) - rhs.toFloat(f16, pt) },	2922	16 => .{ .f16 = lhs.toFloat(f16, zcu) - rhs.toFloat(f16, zcu) },
2873	32 => .{ .f32 = lhs.toFloat(f32, pt) - rhs.toFloat(f32, pt) },	2923	32 => .{ .f32 = lhs.toFloat(f32, zcu) - rhs.toFloat(f32, zcu) },
2874	64 => .{ .f64 = lhs.toFloat(f64, pt) - rhs.toFloat(f64, pt) },	2924	64 => .{ .f64 = lhs.toFloat(f64, zcu) - rhs.toFloat(f64, zcu) },
2875	80 => .{ .f80 = lhs.toFloat(f80, pt) - rhs.toFloat(f80, pt) },	2925	80 => .{ .f80 = lhs.toFloat(f80, zcu) - rhs.toFloat(f80, zcu) },
2876	128 => .{ .f128 = lhs.toFloat(f128, pt) - rhs.toFloat(f128, pt) },	2926	128 => .{ .f128 = lhs.toFloat(f128, zcu) - rhs.toFloat(f128, zcu) },
2877	else => unreachable,	2927	else => unreachable,
2878	};	2928	};
2879	return Value.fromInterned(try pt.intern(.{ .float = .{	2929	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2911,13 +2961,14 @@ pub fn floatDivScalar(	...	@@ -2911,13 +2961,14 @@ pub fn floatDivScalar(
2911	float_type: Type,	2961	float_type: Type,
2912	pt: Zcu.PerThread,	2962	pt: Zcu.PerThread,
2913	) !Value {	2963	) !Value {
2914	const target = pt.zcu.getTarget();	2964	const zcu = pt.zcu;
		2965	const target = zcu.getTarget();
2915	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	2966	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2916	16 => .{ .f16 = lhs.toFloat(f16, pt) / rhs.toFloat(f16, pt) },	2967	16 => .{ .f16 = lhs.toFloat(f16, zcu) / rhs.toFloat(f16, zcu) },
2917	32 => .{ .f32 = lhs.toFloat(f32, pt) / rhs.toFloat(f32, pt) },	2968	32 => .{ .f32 = lhs.toFloat(f32, zcu) / rhs.toFloat(f32, zcu) },
2918	64 => .{ .f64 = lhs.toFloat(f64, pt) / rhs.toFloat(f64, pt) },	2969	64 => .{ .f64 = lhs.toFloat(f64, zcu) / rhs.toFloat(f64, zcu) },
2919	80 => .{ .f80 = lhs.toFloat(f80, pt) / rhs.toFloat(f80, pt) },	2970	80 => .{ .f80 = lhs.toFloat(f80, zcu) / rhs.toFloat(f80, zcu) },
2920	128 => .{ .f128 = lhs.toFloat(f128, pt) / rhs.toFloat(f128, pt) },	2971	128 => .{ .f128 = lhs.toFloat(f128, zcu) / rhs.toFloat(f128, zcu) },
2921	else => unreachable,	2972	else => unreachable,
2922	};	2973	};
2923	return Value.fromInterned(try pt.intern(.{ .float = .{	2974	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2955,13 +3006,14 @@ pub fn floatDivFloorScalar(	...	@@ -2955,13 +3006,14 @@ pub fn floatDivFloorScalar(
2955	float_type: Type,	3006	float_type: Type,
2956	pt: Zcu.PerThread,	3007	pt: Zcu.PerThread,
2957	) !Value {	3008	) !Value {
2958	const target = pt.zcu.getTarget();	3009	const zcu = pt.zcu;
		3010	const target = zcu.getTarget();
2959	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3011	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
2960	16 => .{ .f16 = @divFloor(lhs.toFloat(f16, pt), rhs.toFloat(f16, pt)) },	3012	16 => .{ .f16 = @divFloor(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
2961	32 => .{ .f32 = @divFloor(lhs.toFloat(f32, pt), rhs.toFloat(f32, pt)) },	3013	32 => .{ .f32 = @divFloor(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
2962	64 => .{ .f64 = @divFloor(lhs.toFloat(f64, pt), rhs.toFloat(f64, pt)) },	3014	64 => .{ .f64 = @divFloor(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
2963	80 => .{ .f80 = @divFloor(lhs.toFloat(f80, pt), rhs.toFloat(f80, pt)) },	3015	80 => .{ .f80 = @divFloor(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
2964	128 => .{ .f128 = @divFloor(lhs.toFloat(f128, pt), rhs.toFloat(f128, pt)) },	3016	128 => .{ .f128 = @divFloor(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
2965	else => unreachable,	3017	else => unreachable,
2966	};	3018	};
2967	return Value.fromInterned(try pt.intern(.{ .float = .{	3019	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -2999,13 +3051,14 @@ pub fn floatDivTruncScalar(	...	@@ -2999,13 +3051,14 @@ pub fn floatDivTruncScalar(
2999	float_type: Type,	3051	float_type: Type,
3000	pt: Zcu.PerThread,	3052	pt: Zcu.PerThread,
3001	) !Value {	3053	) !Value {
3002	const target = pt.zcu.getTarget();	3054	const zcu = pt.zcu;
		3055	const target = zcu.getTarget();
3003	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3056	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3004	16 => .{ .f16 = @divTrunc(lhs.toFloat(f16, pt), rhs.toFloat(f16, pt)) },	3057	16 => .{ .f16 = @divTrunc(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
3005	32 => .{ .f32 = @divTrunc(lhs.toFloat(f32, pt), rhs.toFloat(f32, pt)) },	3058	32 => .{ .f32 = @divTrunc(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
3006	64 => .{ .f64 = @divTrunc(lhs.toFloat(f64, pt), rhs.toFloat(f64, pt)) },	3059	64 => .{ .f64 = @divTrunc(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
3007	80 => .{ .f80 = @divTrunc(lhs.toFloat(f80, pt), rhs.toFloat(f80, pt)) },	3060	80 => .{ .f80 = @divTrunc(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
3008	128 => .{ .f128 = @divTrunc(lhs.toFloat(f128, pt), rhs.toFloat(f128, pt)) },	3061	128 => .{ .f128 = @divTrunc(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
3009	else => unreachable,	3062	else => unreachable,
3010	};	3063	};
3011	return Value.fromInterned(try pt.intern(.{ .float = .{	3064	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3021,10 +3074,10 @@ pub fn floatMul(	...	@@ -3021,10 +3074,10 @@ pub fn floatMul(
3021	arena: Allocator,	3074	arena: Allocator,
3022	pt: Zcu.PerThread,	3075	pt: Zcu.PerThread,
3023	) !Value {	3076	) !Value {
3024	const mod = pt.zcu;	3077	const zcu = pt.zcu;
3025	if (float_type.zigTypeTag(mod) == .Vector) {	3078	if (float_type.zigTypeTag(zcu) == .Vector) {
3026	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3079	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3027	const scalar_ty = float_type.scalarType(mod);	3080	const scalar_ty = float_type.scalarType(zcu);
3028	for (result_data, 0..) \|*scalar, i\| {	3081	for (result_data, 0..) \|*scalar, i\| {
3029	const lhs_elem = try lhs.elemValue(pt, i);	3082	const lhs_elem = try lhs.elemValue(pt, i);
3030	const rhs_elem = try rhs.elemValue(pt, i);	3083	const rhs_elem = try rhs.elemValue(pt, i);
...	@@ -3044,14 +3097,14 @@ pub fn floatMulScalar(	...	@@ -3044,14 +3097,14 @@ pub fn floatMulScalar(
3044	float_type: Type,	3097	float_type: Type,
3045	pt: Zcu.PerThread,	3098	pt: Zcu.PerThread,
3046	) !Value {	3099	) !Value {
3047	const mod = pt.zcu;	3100	const zcu = pt.zcu;
3048	const target = mod.getTarget();	3101	const target = zcu.getTarget();
3049	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3102	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3050	16 => .{ .f16 = lhs.toFloat(f16, pt) * rhs.toFloat(f16, pt) },	3103	16 => .{ .f16 = lhs.toFloat(f16, zcu) * rhs.toFloat(f16, zcu) },
3051	32 => .{ .f32 = lhs.toFloat(f32, pt) * rhs.toFloat(f32, pt) },	3104	32 => .{ .f32 = lhs.toFloat(f32, zcu) * rhs.toFloat(f32, zcu) },
3052	64 => .{ .f64 = lhs.toFloat(f64, pt) * rhs.toFloat(f64, pt) },	3105	64 => .{ .f64 = lhs.toFloat(f64, zcu) * rhs.toFloat(f64, zcu) },
3053	80 => .{ .f80 = lhs.toFloat(f80, pt) * rhs.toFloat(f80, pt) },	3106	80 => .{ .f80 = lhs.toFloat(f80, zcu) * rhs.toFloat(f80, zcu) },
3054	128 => .{ .f128 = lhs.toFloat(f128, pt) * rhs.toFloat(f128, pt) },	3107	128 => .{ .f128 = lhs.toFloat(f128, zcu) * rhs.toFloat(f128, zcu) },
3055	else => unreachable,	3108	else => unreachable,
3056	};	3109	};
3057	return Value.fromInterned(try pt.intern(.{ .float = .{	3110	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3077,14 +3130,14 @@ pub fn sqrt(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !	...	@@ -3077,14 +3130,14 @@ pub fn sqrt(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !
3077	}	3130	}
3078		3131
3079	pub fn sqrtScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3132	pub fn sqrtScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3080	const mod = pt.zcu;	3133	const zcu = pt.zcu;
3081	const target = mod.getTarget();	3134	const target = zcu.getTarget();
3082	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3135	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3083	16 => .{ .f16 = @sqrt(val.toFloat(f16, pt)) },	3136	16 => .{ .f16 = @sqrt(val.toFloat(f16, zcu)) },
3084	32 => .{ .f32 = @sqrt(val.toFloat(f32, pt)) },	3137	32 => .{ .f32 = @sqrt(val.toFloat(f32, zcu)) },
3085	64 => .{ .f64 = @sqrt(val.toFloat(f64, pt)) },	3138	64 => .{ .f64 = @sqrt(val.toFloat(f64, zcu)) },
3086	80 => .{ .f80 = @sqrt(val.toFloat(f80, pt)) },	3139	80 => .{ .f80 = @sqrt(val.toFloat(f80, zcu)) },
3087	128 => .{ .f128 = @sqrt(val.toFloat(f128, pt)) },	3140	128 => .{ .f128 = @sqrt(val.toFloat(f128, zcu)) },
3088	else => unreachable,	3141	else => unreachable,
3089	};	3142	};
3090	return Value.fromInterned(try pt.intern(.{ .float = .{	3143	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3094,10 +3147,10 @@ pub fn sqrtScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err	...	@@ -3094,10 +3147,10 @@ pub fn sqrtScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err
3094	}	3147	}
3095		3148
3096	pub fn sin(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3149	pub fn sin(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3097	const mod = pt.zcu;	3150	const zcu = pt.zcu;
3098	if (float_type.zigTypeTag(mod) == .Vector) {	3151	if (float_type.zigTypeTag(zcu) == .Vector) {
3099	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3152	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3100	const scalar_ty = float_type.scalarType(mod);	3153	const scalar_ty = float_type.scalarType(zcu);
3101	for (result_data, 0..) \|*scalar, i\| {	3154	for (result_data, 0..) \|*scalar, i\| {
3102	const elem_val = try val.elemValue(pt, i);	3155	const elem_val = try val.elemValue(pt, i);
3103	scalar.* = (try sinScalar(elem_val, scalar_ty, pt)).toIntern();	3156	scalar.* = (try sinScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3111,14 +3164,14 @@ pub fn sin(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V	...	@@ -3111,14 +3164,14 @@ pub fn sin(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V
3111	}	3164	}
3112		3165
3113	pub fn sinScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3166	pub fn sinScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3114	const mod = pt.zcu;	3167	const zcu = pt.zcu;
3115	const target = mod.getTarget();	3168	const target = zcu.getTarget();
3116	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3169	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3117	16 => .{ .f16 = @sin(val.toFloat(f16, pt)) },	3170	16 => .{ .f16 = @sin(val.toFloat(f16, zcu)) },
3118	32 => .{ .f32 = @sin(val.toFloat(f32, pt)) },	3171	32 => .{ .f32 = @sin(val.toFloat(f32, zcu)) },
3119	64 => .{ .f64 = @sin(val.toFloat(f64, pt)) },	3172	64 => .{ .f64 = @sin(val.toFloat(f64, zcu)) },
3120	80 => .{ .f80 = @sin(val.toFloat(f80, pt)) },	3173	80 => .{ .f80 = @sin(val.toFloat(f80, zcu)) },
3121	128 => .{ .f128 = @sin(val.toFloat(f128, pt)) },	3174	128 => .{ .f128 = @sin(val.toFloat(f128, zcu)) },
3122	else => unreachable,	3175	else => unreachable,
3123	};	3176	};
3124	return Value.fromInterned(try pt.intern(.{ .float = .{	3177	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3128,10 +3181,10 @@ pub fn sinScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro	...	@@ -3128,10 +3181,10 @@ pub fn sinScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro
3128	}	3181	}
3129		3182
3130	pub fn cos(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3183	pub fn cos(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3131	const mod = pt.zcu;	3184	const zcu = pt.zcu;
3132	if (float_type.zigTypeTag(mod) == .Vector) {	3185	if (float_type.zigTypeTag(zcu) == .Vector) {
3133	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3186	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3134	const scalar_ty = float_type.scalarType(mod);	3187	const scalar_ty = float_type.scalarType(zcu);
3135	for (result_data, 0..) \|*scalar, i\| {	3188	for (result_data, 0..) \|*scalar, i\| {
3136	const elem_val = try val.elemValue(pt, i);	3189	const elem_val = try val.elemValue(pt, i);
3137	scalar.* = (try cosScalar(elem_val, scalar_ty, pt)).toIntern();	3190	scalar.* = (try cosScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3145,14 +3198,14 @@ pub fn cos(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V	...	@@ -3145,14 +3198,14 @@ pub fn cos(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V
3145	}	3198	}
3146		3199
3147	pub fn cosScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3200	pub fn cosScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3148	const mod = pt.zcu;	3201	const zcu = pt.zcu;
3149	const target = mod.getTarget();	3202	const target = zcu.getTarget();
3150	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3203	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3151	16 => .{ .f16 = @cos(val.toFloat(f16, pt)) },	3204	16 => .{ .f16 = @cos(val.toFloat(f16, zcu)) },
3152	32 => .{ .f32 = @cos(val.toFloat(f32, pt)) },	3205	32 => .{ .f32 = @cos(val.toFloat(f32, zcu)) },
3153	64 => .{ .f64 = @cos(val.toFloat(f64, pt)) },	3206	64 => .{ .f64 = @cos(val.toFloat(f64, zcu)) },
3154	80 => .{ .f80 = @cos(val.toFloat(f80, pt)) },	3207	80 => .{ .f80 = @cos(val.toFloat(f80, zcu)) },
3155	128 => .{ .f128 = @cos(val.toFloat(f128, pt)) },	3208	128 => .{ .f128 = @cos(val.toFloat(f128, zcu)) },
3156	else => unreachable,	3209	else => unreachable,
3157	};	3210	};
3158	return Value.fromInterned(try pt.intern(.{ .float = .{	3211	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3162,10 +3215,10 @@ pub fn cosScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro	...	@@ -3162,10 +3215,10 @@ pub fn cosScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro
3162	}	3215	}
3163		3216
3164	pub fn tan(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3217	pub fn tan(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3165	const mod = pt.zcu;	3218	const zcu = pt.zcu;
3166	if (float_type.zigTypeTag(mod) == .Vector) {	3219	if (float_type.zigTypeTag(zcu) == .Vector) {
3167	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3220	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3168	const scalar_ty = float_type.scalarType(mod);	3221	const scalar_ty = float_type.scalarType(zcu);
3169	for (result_data, 0..) \|*scalar, i\| {	3222	for (result_data, 0..) \|*scalar, i\| {
3170	const elem_val = try val.elemValue(pt, i);	3223	const elem_val = try val.elemValue(pt, i);
3171	scalar.* = (try tanScalar(elem_val, scalar_ty, pt)).toIntern();	3224	scalar.* = (try tanScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3179,14 +3232,14 @@ pub fn tan(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V	...	@@ -3179,14 +3232,14 @@ pub fn tan(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V
3179	}	3232	}
3180		3233
3181	pub fn tanScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3234	pub fn tanScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3182	const mod = pt.zcu;	3235	const zcu = pt.zcu;
3183	const target = mod.getTarget();	3236	const target = zcu.getTarget();
3184	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3237	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3185	16 => .{ .f16 = @tan(val.toFloat(f16, pt)) },	3238	16 => .{ .f16 = @tan(val.toFloat(f16, zcu)) },
3186	32 => .{ .f32 = @tan(val.toFloat(f32, pt)) },	3239	32 => .{ .f32 = @tan(val.toFloat(f32, zcu)) },
3187	64 => .{ .f64 = @tan(val.toFloat(f64, pt)) },	3240	64 => .{ .f64 = @tan(val.toFloat(f64, zcu)) },
3188	80 => .{ .f80 = @tan(val.toFloat(f80, pt)) },	3241	80 => .{ .f80 = @tan(val.toFloat(f80, zcu)) },
3189	128 => .{ .f128 = @tan(val.toFloat(f128, pt)) },	3242	128 => .{ .f128 = @tan(val.toFloat(f128, zcu)) },
3190	else => unreachable,	3243	else => unreachable,
3191	};	3244	};
3192	return Value.fromInterned(try pt.intern(.{ .float = .{	3245	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3196,10 +3249,10 @@ pub fn tanScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro	...	@@ -3196,10 +3249,10 @@ pub fn tanScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro
3196	}	3249	}
3197		3250
3198	pub fn exp(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3251	pub fn exp(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3199	const mod = pt.zcu;	3252	const zcu = pt.zcu;
3200	if (float_type.zigTypeTag(mod) == .Vector) {	3253	if (float_type.zigTypeTag(zcu) == .Vector) {
3201	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3254	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3202	const scalar_ty = float_type.scalarType(mod);	3255	const scalar_ty = float_type.scalarType(zcu);
3203	for (result_data, 0..) \|*scalar, i\| {	3256	for (result_data, 0..) \|*scalar, i\| {
3204	const elem_val = try val.elemValue(pt, i);	3257	const elem_val = try val.elemValue(pt, i);
3205	scalar.* = (try expScalar(elem_val, scalar_ty, pt)).toIntern();	3258	scalar.* = (try expScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3213,14 +3266,14 @@ pub fn exp(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V	...	@@ -3213,14 +3266,14 @@ pub fn exp(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V
3213	}	3266	}
3214		3267
3215	pub fn expScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3268	pub fn expScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3216	const mod = pt.zcu;	3269	const zcu = pt.zcu;
3217	const target = mod.getTarget();	3270	const target = zcu.getTarget();
3218	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3271	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3219	16 => .{ .f16 = @exp(val.toFloat(f16, pt)) },	3272	16 => .{ .f16 = @exp(val.toFloat(f16, zcu)) },
3220	32 => .{ .f32 = @exp(val.toFloat(f32, pt)) },	3273	32 => .{ .f32 = @exp(val.toFloat(f32, zcu)) },
3221	64 => .{ .f64 = @exp(val.toFloat(f64, pt)) },	3274	64 => .{ .f64 = @exp(val.toFloat(f64, zcu)) },
3222	80 => .{ .f80 = @exp(val.toFloat(f80, pt)) },	3275	80 => .{ .f80 = @exp(val.toFloat(f80, zcu)) },
3223	128 => .{ .f128 = @exp(val.toFloat(f128, pt)) },	3276	128 => .{ .f128 = @exp(val.toFloat(f128, zcu)) },
3224	else => unreachable,	3277	else => unreachable,
3225	};	3278	};
3226	return Value.fromInterned(try pt.intern(.{ .float = .{	3279	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3230,10 +3283,10 @@ pub fn expScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro	...	@@ -3230,10 +3283,10 @@ pub fn expScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro
3230	}	3283	}
3231		3284
3232	pub fn exp2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3285	pub fn exp2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3233	const mod = pt.zcu;	3286	const zcu = pt.zcu;
3234	if (float_type.zigTypeTag(mod) == .Vector) {	3287	if (float_type.zigTypeTag(zcu) == .Vector) {
3235	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3288	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3236	const scalar_ty = float_type.scalarType(mod);	3289	const scalar_ty = float_type.scalarType(zcu);
3237	for (result_data, 0..) \|*scalar, i\| {	3290	for (result_data, 0..) \|*scalar, i\| {
3238	const elem_val = try val.elemValue(pt, i);	3291	const elem_val = try val.elemValue(pt, i);
3239	scalar.* = (try exp2Scalar(elem_val, scalar_ty, pt)).toIntern();	3292	scalar.* = (try exp2Scalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3247,14 +3300,14 @@ pub fn exp2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !	...	@@ -3247,14 +3300,14 @@ pub fn exp2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !
3247	}	3300	}
3248		3301
3249	pub fn exp2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3302	pub fn exp2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3250	const mod = pt.zcu;	3303	const zcu = pt.zcu;
3251	const target = mod.getTarget();	3304	const target = zcu.getTarget();
3252	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3305	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3253	16 => .{ .f16 = @exp2(val.toFloat(f16, pt)) },	3306	16 => .{ .f16 = @exp2(val.toFloat(f16, zcu)) },
3254	32 => .{ .f32 = @exp2(val.toFloat(f32, pt)) },	3307	32 => .{ .f32 = @exp2(val.toFloat(f32, zcu)) },
3255	64 => .{ .f64 = @exp2(val.toFloat(f64, pt)) },	3308	64 => .{ .f64 = @exp2(val.toFloat(f64, zcu)) },
3256	80 => .{ .f80 = @exp2(val.toFloat(f80, pt)) },	3309	80 => .{ .f80 = @exp2(val.toFloat(f80, zcu)) },
3257	128 => .{ .f128 = @exp2(val.toFloat(f128, pt)) },	3310	128 => .{ .f128 = @exp2(val.toFloat(f128, zcu)) },
3258	else => unreachable,	3311	else => unreachable,
3259	};	3312	};
3260	return Value.fromInterned(try pt.intern(.{ .float = .{	3313	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3264,10 +3317,10 @@ pub fn exp2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err	...	@@ -3264,10 +3317,10 @@ pub fn exp2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err
3264	}	3317	}
3265		3318
3266	pub fn log(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3319	pub fn log(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3267	const mod = pt.zcu;	3320	const zcu = pt.zcu;
3268	if (float_type.zigTypeTag(mod) == .Vector) {	3321	if (float_type.zigTypeTag(zcu) == .Vector) {
3269	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3322	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3270	const scalar_ty = float_type.scalarType(mod);	3323	const scalar_ty = float_type.scalarType(zcu);
3271	for (result_data, 0..) \|*scalar, i\| {	3324	for (result_data, 0..) \|*scalar, i\| {
3272	const elem_val = try val.elemValue(pt, i);	3325	const elem_val = try val.elemValue(pt, i);
3273	scalar.* = (try logScalar(elem_val, scalar_ty, pt)).toIntern();	3326	scalar.* = (try logScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3281,14 +3334,14 @@ pub fn log(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V	...	@@ -3281,14 +3334,14 @@ pub fn log(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !V
3281	}	3334	}
3282		3335
3283	pub fn logScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3336	pub fn logScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3284	const mod = pt.zcu;	3337	const zcu = pt.zcu;
3285	const target = mod.getTarget();	3338	const target = zcu.getTarget();
3286	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3339	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3287	16 => .{ .f16 = @log(val.toFloat(f16, pt)) },	3340	16 => .{ .f16 = @log(val.toFloat(f16, zcu)) },
3288	32 => .{ .f32 = @log(val.toFloat(f32, pt)) },	3341	32 => .{ .f32 = @log(val.toFloat(f32, zcu)) },
3289	64 => .{ .f64 = @log(val.toFloat(f64, pt)) },	3342	64 => .{ .f64 = @log(val.toFloat(f64, zcu)) },
3290	80 => .{ .f80 = @log(val.toFloat(f80, pt)) },	3343	80 => .{ .f80 = @log(val.toFloat(f80, zcu)) },
3291	128 => .{ .f128 = @log(val.toFloat(f128, pt)) },	3344	128 => .{ .f128 = @log(val.toFloat(f128, zcu)) },
3292	else => unreachable,	3345	else => unreachable,
3293	};	3346	};
3294	return Value.fromInterned(try pt.intern(.{ .float = .{	3347	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3298,10 +3351,10 @@ pub fn logScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro	...	@@ -3298,10 +3351,10 @@ pub fn logScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Erro
3298	}	3351	}
3299		3352
3300	pub fn log2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3353	pub fn log2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3301	const mod = pt.zcu;	3354	const zcu = pt.zcu;
3302	if (float_type.zigTypeTag(mod) == .Vector) {	3355	if (float_type.zigTypeTag(zcu) == .Vector) {
3303	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3356	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3304	const scalar_ty = float_type.scalarType(mod);	3357	const scalar_ty = float_type.scalarType(zcu);
3305	for (result_data, 0..) \|*scalar, i\| {	3358	for (result_data, 0..) \|*scalar, i\| {
3306	const elem_val = try val.elemValue(pt, i);	3359	const elem_val = try val.elemValue(pt, i);
3307	scalar.* = (try log2Scalar(elem_val, scalar_ty, pt)).toIntern();	3360	scalar.* = (try log2Scalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3315,14 +3368,14 @@ pub fn log2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !	...	@@ -3315,14 +3368,14 @@ pub fn log2(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !
3315	}	3368	}
3316		3369
3317	pub fn log2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3370	pub fn log2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3318	const mod = pt.zcu;	3371	const zcu = pt.zcu;
3319	const target = mod.getTarget();	3372	const target = zcu.getTarget();
3320	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3373	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3321	16 => .{ .f16 = @log2(val.toFloat(f16, pt)) },	3374	16 => .{ .f16 = @log2(val.toFloat(f16, zcu)) },
3322	32 => .{ .f32 = @log2(val.toFloat(f32, pt)) },	3375	32 => .{ .f32 = @log2(val.toFloat(f32, zcu)) },
3323	64 => .{ .f64 = @log2(val.toFloat(f64, pt)) },	3376	64 => .{ .f64 = @log2(val.toFloat(f64, zcu)) },
3324	80 => .{ .f80 = @log2(val.toFloat(f80, pt)) },	3377	80 => .{ .f80 = @log2(val.toFloat(f80, zcu)) },
3325	128 => .{ .f128 = @log2(val.toFloat(f128, pt)) },	3378	128 => .{ .f128 = @log2(val.toFloat(f128, zcu)) },
3326	else => unreachable,	3379	else => unreachable,
3327	};	3380	};
3328	return Value.fromInterned(try pt.intern(.{ .float = .{	3381	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3332,10 +3385,10 @@ pub fn log2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err	...	@@ -3332,10 +3385,10 @@ pub fn log2Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err
3332	}	3385	}
3333		3386
3334	pub fn log10(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3387	pub fn log10(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3335	const mod = pt.zcu;	3388	const zcu = pt.zcu;
3336	if (float_type.zigTypeTag(mod) == .Vector) {	3389	if (float_type.zigTypeTag(zcu) == .Vector) {
3337	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3390	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3338	const scalar_ty = float_type.scalarType(mod);	3391	const scalar_ty = float_type.scalarType(zcu);
3339	for (result_data, 0..) \|*scalar, i\| {	3392	for (result_data, 0..) \|*scalar, i\| {
3340	const elem_val = try val.elemValue(pt, i);	3393	const elem_val = try val.elemValue(pt, i);
3341	scalar.* = (try log10Scalar(elem_val, scalar_ty, pt)).toIntern();	3394	scalar.* = (try log10Scalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3349,14 +3402,14 @@ pub fn log10(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)	...	@@ -3349,14 +3402,14 @@ pub fn log10(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)
3349	}	3402	}
3350		3403
3351	pub fn log10Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3404	pub fn log10Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3352	const mod = pt.zcu;	3405	const zcu = pt.zcu;
3353	const target = mod.getTarget();	3406	const target = zcu.getTarget();
3354	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3407	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3355	16 => .{ .f16 = @log10(val.toFloat(f16, pt)) },	3408	16 => .{ .f16 = @log10(val.toFloat(f16, zcu)) },
3356	32 => .{ .f32 = @log10(val.toFloat(f32, pt)) },	3409	32 => .{ .f32 = @log10(val.toFloat(f32, zcu)) },
3357	64 => .{ .f64 = @log10(val.toFloat(f64, pt)) },	3410	64 => .{ .f64 = @log10(val.toFloat(f64, zcu)) },
3358	80 => .{ .f80 = @log10(val.toFloat(f80, pt)) },	3411	80 => .{ .f80 = @log10(val.toFloat(f80, zcu)) },
3359	128 => .{ .f128 = @log10(val.toFloat(f128, pt)) },	3412	128 => .{ .f128 = @log10(val.toFloat(f128, zcu)) },
3360	else => unreachable,	3413	else => unreachable,
3361	};	3414	};
3362	return Value.fromInterned(try pt.intern(.{ .float = .{	3415	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3366,10 +3419,10 @@ pub fn log10Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er	...	@@ -3366,10 +3419,10 @@ pub fn log10Scalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er
3366	}	3419	}
3367		3420
3368	pub fn abs(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3421	pub fn abs(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3369	const mod = pt.zcu;	3422	const zcu = pt.zcu;
3370	if (ty.zigTypeTag(mod) == .Vector) {	3423	if (ty.zigTypeTag(zcu) == .Vector) {
3371	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(mod));	3424	const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(zcu));
3372	const scalar_ty = ty.scalarType(mod);	3425	const scalar_ty = ty.scalarType(zcu);
3373	for (result_data, 0..) \|*scalar, i\| {	3426	for (result_data, 0..) \|*scalar, i\| {
3374	const elem_val = try val.elemValue(pt, i);	3427	const elem_val = try val.elemValue(pt, i);
3375	scalar.* = (try absScalar(elem_val, scalar_ty, pt, arena)).toIntern();	3428	scalar.* = (try absScalar(elem_val, scalar_ty, pt, arena)).toIntern();
...	@@ -3383,30 +3436,30 @@ pub fn abs(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	...	@@ -3383,30 +3436,30 @@ pub fn abs(val: Value, ty: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3383	}	3436	}
3384		3437
3385	pub fn absScalar(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) Allocator.Error!Value {	3438	pub fn absScalar(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) Allocator.Error!Value {
3386	const mod = pt.zcu;	3439	const zcu = pt.zcu;
3387	switch (ty.zigTypeTag(mod)) {	3440	switch (ty.zigTypeTag(zcu)) {
3388	.Int => {	3441	.Int => {
3389	var buffer: Value.BigIntSpace = undefined;	3442	var buffer: Value.BigIntSpace = undefined;
3390	var operand_bigint = try val.toBigInt(&buffer, pt).toManaged(arena);	3443	var operand_bigint = try val.toBigInt(&buffer, zcu).toManaged(arena);
3391	operand_bigint.abs();	3444	operand_bigint.abs();
3392		3445
3393	return pt.intValue_big(try ty.toUnsigned(pt), operand_bigint.toConst());	3446	return pt.intValue_big(try ty.toUnsigned(pt), operand_bigint.toConst());
3394	},	3447	},
3395	.ComptimeInt => {	3448	.ComptimeInt => {
3396	var buffer: Value.BigIntSpace = undefined;	3449	var buffer: Value.BigIntSpace = undefined;
3397	var operand_bigint = try val.toBigInt(&buffer, pt).toManaged(arena);	3450	var operand_bigint = try val.toBigInt(&buffer, zcu).toManaged(arena);
3398	operand_bigint.abs();	3451	operand_bigint.abs();
3399		3452
3400	return pt.intValue_big(ty, operand_bigint.toConst());	3453	return pt.intValue_big(ty, operand_bigint.toConst());
3401	},	3454	},
3402	.ComptimeFloat, .Float => {	3455	.ComptimeFloat, .Float => {
3403	const target = mod.getTarget();	3456	const target = zcu.getTarget();
3404	const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {	3457	const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
3405	16 => .{ .f16 = @abs(val.toFloat(f16, pt)) },	3458	16 => .{ .f16 = @abs(val.toFloat(f16, zcu)) },
3406	32 => .{ .f32 = @abs(val.toFloat(f32, pt)) },	3459	32 => .{ .f32 = @abs(val.toFloat(f32, zcu)) },
3407	64 => .{ .f64 = @abs(val.toFloat(f64, pt)) },	3460	64 => .{ .f64 = @abs(val.toFloat(f64, zcu)) },
3408	80 => .{ .f80 = @abs(val.toFloat(f80, pt)) },	3461	80 => .{ .f80 = @abs(val.toFloat(f80, zcu)) },
3409	128 => .{ .f128 = @abs(val.toFloat(f128, pt)) },	3462	128 => .{ .f128 = @abs(val.toFloat(f128, zcu)) },
3410	else => unreachable,	3463	else => unreachable,
3411	};	3464	};
3412	return Value.fromInterned(try pt.intern(.{ .float = .{	3465	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3419,10 +3472,10 @@ pub fn absScalar(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) Allo	...	@@ -3419,10 +3472,10 @@ pub fn absScalar(val: Value, ty: Type, pt: Zcu.PerThread, arena: Allocator) Allo
3419	}	3472	}
3420		3473
3421	pub fn floor(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3474	pub fn floor(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3422	const mod = pt.zcu;	3475	const zcu = pt.zcu;
3423	if (float_type.zigTypeTag(mod) == .Vector) {	3476	if (float_type.zigTypeTag(zcu) == .Vector) {
3424	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3477	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3425	const scalar_ty = float_type.scalarType(mod);	3478	const scalar_ty = float_type.scalarType(zcu);
3426	for (result_data, 0..) \|*scalar, i\| {	3479	for (result_data, 0..) \|*scalar, i\| {
3427	const elem_val = try val.elemValue(pt, i);	3480	const elem_val = try val.elemValue(pt, i);
3428	scalar.* = (try floorScalar(elem_val, scalar_ty, pt)).toIntern();	3481	scalar.* = (try floorScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3436,14 +3489,14 @@ pub fn floor(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)	...	@@ -3436,14 +3489,14 @@ pub fn floor(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)
3436	}	3489	}
3437		3490
3438	pub fn floorScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3491	pub fn floorScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3439	const mod = pt.zcu;	3492	const zcu = pt.zcu;
3440	const target = mod.getTarget();	3493	const target = zcu.getTarget();
3441	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3494	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3442	16 => .{ .f16 = @floor(val.toFloat(f16, pt)) },	3495	16 => .{ .f16 = @floor(val.toFloat(f16, zcu)) },
3443	32 => .{ .f32 = @floor(val.toFloat(f32, pt)) },	3496	32 => .{ .f32 = @floor(val.toFloat(f32, zcu)) },
3444	64 => .{ .f64 = @floor(val.toFloat(f64, pt)) },	3497	64 => .{ .f64 = @floor(val.toFloat(f64, zcu)) },
3445	80 => .{ .f80 = @floor(val.toFloat(f80, pt)) },	3498	80 => .{ .f80 = @floor(val.toFloat(f80, zcu)) },
3446	128 => .{ .f128 = @floor(val.toFloat(f128, pt)) },	3499	128 => .{ .f128 = @floor(val.toFloat(f128, zcu)) },
3447	else => unreachable,	3500	else => unreachable,
3448	};	3501	};
3449	return Value.fromInterned(try pt.intern(.{ .float = .{	3502	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3453,10 +3506,10 @@ pub fn floorScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er	...	@@ -3453,10 +3506,10 @@ pub fn floorScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er
3453	}	3506	}
3454		3507
3455	pub fn ceil(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3508	pub fn ceil(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3456	const mod = pt.zcu;	3509	const zcu = pt.zcu;
3457	if (float_type.zigTypeTag(mod) == .Vector) {	3510	if (float_type.zigTypeTag(zcu) == .Vector) {
3458	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3511	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3459	const scalar_ty = float_type.scalarType(mod);	3512	const scalar_ty = float_type.scalarType(zcu);
3460	for (result_data, 0..) \|*scalar, i\| {	3513	for (result_data, 0..) \|*scalar, i\| {
3461	const elem_val = try val.elemValue(pt, i);	3514	const elem_val = try val.elemValue(pt, i);
3462	scalar.* = (try ceilScalar(elem_val, scalar_ty, pt)).toIntern();	3515	scalar.* = (try ceilScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3470,14 +3523,14 @@ pub fn ceil(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !	...	@@ -3470,14 +3523,14 @@ pub fn ceil(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !
3470	}	3523	}
3471		3524
3472	pub fn ceilScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3525	pub fn ceilScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3473	const mod = pt.zcu;	3526	const zcu = pt.zcu;
3474	const target = mod.getTarget();	3527	const target = zcu.getTarget();
3475	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3528	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3476	16 => .{ .f16 = @ceil(val.toFloat(f16, pt)) },	3529	16 => .{ .f16 = @ceil(val.toFloat(f16, zcu)) },
3477	32 => .{ .f32 = @ceil(val.toFloat(f32, pt)) },	3530	32 => .{ .f32 = @ceil(val.toFloat(f32, zcu)) },
3478	64 => .{ .f64 = @ceil(val.toFloat(f64, pt)) },	3531	64 => .{ .f64 = @ceil(val.toFloat(f64, zcu)) },
3479	80 => .{ .f80 = @ceil(val.toFloat(f80, pt)) },	3532	80 => .{ .f80 = @ceil(val.toFloat(f80, zcu)) },
3480	128 => .{ .f128 = @ceil(val.toFloat(f128, pt)) },	3533	128 => .{ .f128 = @ceil(val.toFloat(f128, zcu)) },
3481	else => unreachable,	3534	else => unreachable,
3482	};	3535	};
3483	return Value.fromInterned(try pt.intern(.{ .float = .{	3536	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3487,10 +3540,10 @@ pub fn ceilScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err	...	@@ -3487,10 +3540,10 @@ pub fn ceilScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Err
3487	}	3540	}
3488		3541
3489	pub fn round(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3542	pub fn round(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3490	const mod = pt.zcu;	3543	const zcu = pt.zcu;
3491	if (float_type.zigTypeTag(mod) == .Vector) {	3544	if (float_type.zigTypeTag(zcu) == .Vector) {
3492	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3545	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3493	const scalar_ty = float_type.scalarType(mod);	3546	const scalar_ty = float_type.scalarType(zcu);
3494	for (result_data, 0..) \|*scalar, i\| {	3547	for (result_data, 0..) \|*scalar, i\| {
3495	const elem_val = try val.elemValue(pt, i);	3548	const elem_val = try val.elemValue(pt, i);
3496	scalar.* = (try roundScalar(elem_val, scalar_ty, pt)).toIntern();	3549	scalar.* = (try roundScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3504,14 +3557,14 @@ pub fn round(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)	...	@@ -3504,14 +3557,14 @@ pub fn round(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)
3504	}	3557	}
3505		3558
3506	pub fn roundScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3559	pub fn roundScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3507	const mod = pt.zcu;	3560	const zcu = pt.zcu;
3508	const target = mod.getTarget();	3561	const target = zcu.getTarget();
3509	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3562	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3510	16 => .{ .f16 = @round(val.toFloat(f16, pt)) },	3563	16 => .{ .f16 = @round(val.toFloat(f16, zcu)) },
3511	32 => .{ .f32 = @round(val.toFloat(f32, pt)) },	3564	32 => .{ .f32 = @round(val.toFloat(f32, zcu)) },
3512	64 => .{ .f64 = @round(val.toFloat(f64, pt)) },	3565	64 => .{ .f64 = @round(val.toFloat(f64, zcu)) },
3513	80 => .{ .f80 = @round(val.toFloat(f80, pt)) },	3566	80 => .{ .f80 = @round(val.toFloat(f80, zcu)) },
3514	128 => .{ .f128 = @round(val.toFloat(f128, pt)) },	3567	128 => .{ .f128 = @round(val.toFloat(f128, zcu)) },
3515	else => unreachable,	3568	else => unreachable,
3516	};	3569	};
3517	return Value.fromInterned(try pt.intern(.{ .float = .{	3570	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3521,10 +3574,10 @@ pub fn roundScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er	...	@@ -3521,10 +3574,10 @@ pub fn roundScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Er
3521	}	3574	}
3522		3575
3523	pub fn trunc(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {	3576	pub fn trunc(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
3524	const mod = pt.zcu;	3577	const zcu = pt.zcu;
3525	if (float_type.zigTypeTag(mod) == .Vector) {	3578	if (float_type.zigTypeTag(zcu) == .Vector) {
3526	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3579	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3527	const scalar_ty = float_type.scalarType(mod);	3580	const scalar_ty = float_type.scalarType(zcu);
3528	for (result_data, 0..) \|*scalar, i\| {	3581	for (result_data, 0..) \|*scalar, i\| {
3529	const elem_val = try val.elemValue(pt, i);	3582	const elem_val = try val.elemValue(pt, i);
3530	scalar.* = (try truncScalar(elem_val, scalar_ty, pt)).toIntern();	3583	scalar.* = (try truncScalar(elem_val, scalar_ty, pt)).toIntern();
...	@@ -3538,14 +3591,14 @@ pub fn trunc(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)	...	@@ -3538,14 +3591,14 @@ pub fn trunc(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread)
3538	}	3591	}
3539		3592
3540	pub fn truncScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {	3593	pub fn truncScalar(val: Value, float_type: Type, pt: Zcu.PerThread) Allocator.Error!Value {
3541	const mod = pt.zcu;	3594	const zcu = pt.zcu;
3542	const target = mod.getTarget();	3595	const target = zcu.getTarget();
3543	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3596	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3544	16 => .{ .f16 = @trunc(val.toFloat(f16, pt)) },	3597	16 => .{ .f16 = @trunc(val.toFloat(f16, zcu)) },
3545	32 => .{ .f32 = @trunc(val.toFloat(f32, pt)) },	3598	32 => .{ .f32 = @trunc(val.toFloat(f32, zcu)) },
3546	64 => .{ .f64 = @trunc(val.toFloat(f64, pt)) },	3599	64 => .{ .f64 = @trunc(val.toFloat(f64, zcu)) },
3547	80 => .{ .f80 = @trunc(val.toFloat(f80, pt)) },	3600	80 => .{ .f80 = @trunc(val.toFloat(f80, zcu)) },
3548	128 => .{ .f128 = @trunc(val.toFloat(f128, pt)) },	3601	128 => .{ .f128 = @trunc(val.toFloat(f128, zcu)) },
3549	else => unreachable,	3602	else => unreachable,
3550	};	3603	};
3551	return Value.fromInterned(try pt.intern(.{ .float = .{	3604	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3562,10 +3615,10 @@ pub fn mulAdd(	...	@@ -3562,10 +3615,10 @@ pub fn mulAdd(
3562	arena: Allocator,	3615	arena: Allocator,
3563	pt: Zcu.PerThread,	3616	pt: Zcu.PerThread,
3564	) !Value {	3617	) !Value {
3565	const mod = pt.zcu;	3618	const zcu = pt.zcu;
3566	if (float_type.zigTypeTag(mod) == .Vector) {	3619	if (float_type.zigTypeTag(zcu) == .Vector) {
3567	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(mod));	3620	const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
3568	const scalar_ty = float_type.scalarType(mod);	3621	const scalar_ty = float_type.scalarType(zcu);
3569	for (result_data, 0..) \|*scalar, i\| {	3622	for (result_data, 0..) \|*scalar, i\| {
3570	const mulend1_elem = try mulend1.elemValue(pt, i);	3623	const mulend1_elem = try mulend1.elemValue(pt, i);
3571	const mulend2_elem = try mulend2.elemValue(pt, i);	3624	const mulend2_elem = try mulend2.elemValue(pt, i);
...	@@ -3587,14 +3640,14 @@ pub fn mulAddScalar(	...	@@ -3587,14 +3640,14 @@ pub fn mulAddScalar(
3587	addend: Value,	3640	addend: Value,
3588	pt: Zcu.PerThread,	3641	pt: Zcu.PerThread,
3589	) Allocator.Error!Value {	3642	) Allocator.Error!Value {
3590	const mod = pt.zcu;	3643	const zcu = pt.zcu;
3591	const target = mod.getTarget();	3644	const target = zcu.getTarget();
3592	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {	3645	const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
3593	16 => .{ .f16 = @mulAdd(f16, mulend1.toFloat(f16, pt), mulend2.toFloat(f16, pt), addend.toFloat(f16, pt)) },	3646	16 => .{ .f16 = @mulAdd(f16, mulend1.toFloat(f16, zcu), mulend2.toFloat(f16, zcu), addend.toFloat(f16, zcu)) },
3594	32 => .{ .f32 = @mulAdd(f32, mulend1.toFloat(f32, pt), mulend2.toFloat(f32, pt), addend.toFloat(f32, pt)) },	3647	32 => .{ .f32 = @mulAdd(f32, mulend1.toFloat(f32, zcu), mulend2.toFloat(f32, zcu), addend.toFloat(f32, zcu)) },
3595	64 => .{ .f64 = @mulAdd(f64, mulend1.toFloat(f64, pt), mulend2.toFloat(f64, pt), addend.toFloat(f64, pt)) },	3648	64 => .{ .f64 = @mulAdd(f64, mulend1.toFloat(f64, zcu), mulend2.toFloat(f64, zcu), addend.toFloat(f64, zcu)) },
3596	80 => .{ .f80 = @mulAdd(f80, mulend1.toFloat(f80, pt), mulend2.toFloat(f80, pt), addend.toFloat(f80, pt)) },	3649	80 => .{ .f80 = @mulAdd(f80, mulend1.toFloat(f80, zcu), mulend2.toFloat(f80, zcu), addend.toFloat(f80, zcu)) },
3597	128 => .{ .f128 = @mulAdd(f128, mulend1.toFloat(f128, pt), mulend2.toFloat(f128, pt), addend.toFloat(f128, pt)) },	3650	128 => .{ .f128 = @mulAdd(f128, mulend1.toFloat(f128, zcu), mulend2.toFloat(f128, zcu), addend.toFloat(f128, zcu)) },
3598	else => unreachable,	3651	else => unreachable,
3599	};	3652	};
3600	return Value.fromInterned(try pt.intern(.{ .float = .{	3653	return Value.fromInterned(try pt.intern(.{ .float = .{
...	@@ -3606,10 +3659,11 @@ pub fn mulAddScalar(	...	@@ -3606,10 +3659,11 @@ pub fn mulAddScalar(
3606	/// If the value is represented in-memory as a series of bytes that all	3659	/// If the value is represented in-memory as a series of bytes that all
3607	/// have the same value, return that byte value, otherwise null.	3660	/// have the same value, return that byte value, otherwise null.
3608	pub fn hasRepeatedByteRepr(val: Value, ty: Type, pt: Zcu.PerThread) !?u8 {	3661	pub fn hasRepeatedByteRepr(val: Value, ty: Type, pt: Zcu.PerThread) !?u8 {
3609	const abi_size = std.math.cast(usize, ty.abiSize(pt)) orelse return null;	3662	const zcu = pt.zcu;
		3663	const abi_size = std.math.cast(usize, ty.abiSize(zcu)) orelse return null;
3610	assert(abi_size >= 1);	3664	assert(abi_size >= 1);
3611	const byte_buffer = try pt.zcu.gpa.alloc(u8, abi_size);	3665	const byte_buffer = try zcu.gpa.alloc(u8, abi_size);
3612	defer pt.zcu.gpa.free(byte_buffer);	3666	defer zcu.gpa.free(byte_buffer);
3613		3667
3614	writeToMemory(val, ty, pt, byte_buffer) catch \|err\| switch (err) {	3668	writeToMemory(val, ty, pt, byte_buffer) catch \|err\| switch (err) {
3615	error.OutOfMemory => return error.OutOfMemory,	3669	error.OutOfMemory => return error.OutOfMemory,
...	@@ -3754,15 +3808,15 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3754,15 +3808,15 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3754	// `field_align` may be `.none` to represent the natural alignment of `field_ty`, but is not necessarily.	3808	// `field_align` may be `.none` to represent the natural alignment of `field_ty`, but is not necessarily.
3755	const field_ty: Type, const field_align: InternPool.Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {	3809	const field_ty: Type, const field_align: InternPool.Alignment = switch (aggregate_ty.zigTypeTag(zcu)) {
3756	.Struct => field: {	3810	.Struct => field: {
3757	const field_ty = aggregate_ty.structFieldType(field_idx, zcu);	3811	const field_ty = aggregate_ty.fieldType(field_idx, zcu);
3758	switch (aggregate_ty.containerLayout(zcu)) {	3812	switch (aggregate_ty.containerLayout(zcu)) {
3759	.auto => break :field .{ field_ty, try aggregate_ty.structFieldAlignAdvanced(@intCast(field_idx), pt, .sema) },	3813	.auto => break :field .{ field_ty, try aggregate_ty.fieldAlignmentSema(field_idx, pt) },
3760	.@"extern" => {	3814	.@"extern" => {
3761	// Well-defined layout, so just offset the pointer appropriately.	3815	// Well-defined layout, so just offset the pointer appropriately.
3762	const byte_off = aggregate_ty.structFieldOffset(field_idx, pt);	3816	const byte_off = aggregate_ty.structFieldOffset(field_idx, zcu);
3763	const field_align = a: {	3817	const field_align = a: {
3764	const parent_align = if (parent_ptr_info.flags.alignment == .none) pa: {	3818	const parent_align = if (parent_ptr_info.flags.alignment == .none) pa: {
3765	break :pa (try aggregate_ty.abiAlignmentAdvanced(pt, .sema)).scalar;	3819	break :pa try aggregate_ty.abiAlignmentSema(pt);
3766	} else parent_ptr_info.flags.alignment;	3820	} else parent_ptr_info.flags.alignment;
3767	break :a InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(byte_off)));	3821	break :a InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(byte_off)));
3768	};	3822	};
...	@@ -3781,7 +3835,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3781,7 +3835,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3781	new.packed_offset = packed_offset;	3835	new.packed_offset = packed_offset;
3782	new.child = field_ty.toIntern();	3836	new.child = field_ty.toIntern();
3783	if (new.flags.alignment == .none) {	3837	if (new.flags.alignment == .none) {
3784	new.flags.alignment = (try aggregate_ty.abiAlignmentAdvanced(pt, .sema)).scalar;	3838	new.flags.alignment = try aggregate_ty.abiAlignmentSema(pt);
3785	}	3839	}
3786	break :info new;	3840	break :info new;
3787	});	3841	});
...	@@ -3807,7 +3861,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3807,7 +3861,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3807	const union_obj = zcu.typeToUnion(aggregate_ty).?;	3861	const union_obj = zcu.typeToUnion(aggregate_ty).?;
3808	const field_ty = Type.fromInterned(union_obj.field_types.get(&zcu.intern_pool)[field_idx]);	3862	const field_ty = Type.fromInterned(union_obj.field_types.get(&zcu.intern_pool)[field_idx]);
3809	switch (aggregate_ty.containerLayout(zcu)) {	3863	switch (aggregate_ty.containerLayout(zcu)) {
3810	.auto => break :field .{ field_ty, try aggregate_ty.structFieldAlignAdvanced(@intCast(field_idx), pt, .sema) },	3864	.auto => break :field .{ field_ty, try aggregate_ty.fieldAlignmentSema(field_idx, pt) },
3811	.@"extern" => {	3865	.@"extern" => {
3812	// Point to the same address.	3866	// Point to the same address.
3813	const result_ty = try pt.ptrTypeSema(info: {	3867	const result_ty = try pt.ptrTypeSema(info: {
...	@@ -3820,17 +3874,17 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3820,17 +3874,17 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3820	.@"packed" => {	3874	.@"packed" => {
3821	// If the field has an ABI size matching its bit size, then we can continue to use a	3875	// If the field has an ABI size matching its bit size, then we can continue to use a
3822	// non-bit pointer if the parent pointer is also a non-bit pointer.	3876	// non-bit pointer if the parent pointer is also a non-bit pointer.
3823	if (parent_ptr_info.packed_offset.host_size == 0 and (try field_ty.abiSizeAdvanced(pt, .sema)).scalar * 8 == try field_ty.bitSizeAdvanced(pt, .sema)) {	3877	if (parent_ptr_info.packed_offset.host_size == 0 and (try field_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar * 8 == try field_ty.bitSizeSema(pt)) {
3824	// We must offset the pointer on big-endian targets, since the bits of packed memory don't align nicely.	3878	// We must offset the pointer on big-endian targets, since the bits of packed memory don't align nicely.
3825	const byte_offset = switch (zcu.getTarget().cpu.arch.endian()) {	3879	const byte_offset = switch (zcu.getTarget().cpu.arch.endian()) {
3826	.little => 0,	3880	.little => 0,
3827	.big => (try aggregate_ty.abiSizeAdvanced(pt, .sema)).scalar - (try field_ty.abiSizeAdvanced(pt, .sema)).scalar,	3881	.big => (try aggregate_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar - (try field_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar,
3828	};	3882	};
3829	const result_ty = try pt.ptrTypeSema(info: {	3883	const result_ty = try pt.ptrTypeSema(info: {
3830	var new = parent_ptr_info;	3884	var new = parent_ptr_info;
3831	new.child = field_ty.toIntern();	3885	new.child = field_ty.toIntern();
3832	new.flags.alignment = InternPool.Alignment.fromLog2Units(	3886	new.flags.alignment = InternPool.Alignment.fromLog2Units(
3833	@ctz(byte_offset \| (try parent_ptr_ty.ptrAlignmentAdvanced(pt, .sema)).toByteUnits().?),	3887	@ctz(byte_offset \| (try parent_ptr_ty.ptrAlignmentSema(pt)).toByteUnits().?),
3834	);	3888	);
3835	break :info new;	3889	break :info new;
3836	});	3890	});
...	@@ -3841,7 +3895,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3841,7 +3895,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3841	var new = parent_ptr_info;	3895	var new = parent_ptr_info;
3842	new.child = field_ty.toIntern();	3896	new.child = field_ty.toIntern();
3843	if (new.packed_offset.host_size == 0) {	3897	if (new.packed_offset.host_size == 0) {
3844	new.packed_offset.host_size = @intCast(((try aggregate_ty.bitSizeAdvanced(pt, .sema)) + 7) / 8);	3898	new.packed_offset.host_size = @intCast(((try aggregate_ty.bitSizeSema(pt)) + 7) / 8);
3845	assert(new.packed_offset.bit_offset == 0);	3899	assert(new.packed_offset.bit_offset == 0);
3846	}	3900	}
3847	break :info new;	3901	break :info new;
...	@@ -3854,8 +3908,8 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3854,8 +3908,8 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3854	.Pointer => field_ty: {	3908	.Pointer => field_ty: {
3855	assert(aggregate_ty.isSlice(zcu));	3909	assert(aggregate_ty.isSlice(zcu));
3856	break :field_ty switch (field_idx) {	3910	break :field_ty switch (field_idx) {
3857	Value.slice_ptr_index => .{ aggregate_ty.slicePtrFieldType(zcu), Type.usize.abiAlignment(pt) },	3911	Value.slice_ptr_index => .{ aggregate_ty.slicePtrFieldType(zcu), Type.usize.abiAlignment(zcu) },
3858	Value.slice_len_index => .{ Type.usize, Type.usize.abiAlignment(pt) },	3912	Value.slice_len_index => .{ Type.usize, Type.usize.abiAlignment(zcu) },
3859	else => unreachable,	3913	else => unreachable,
3860	};	3914	};
3861	},	3915	},
...	@@ -3863,7 +3917,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {	...	@@ -3863,7 +3917,7 @@ pub fn ptrField(parent_ptr: Value, field_idx: u32, pt: Zcu.PerThread) !Value {
3863	};	3917	};
3864		3918
3865	const new_align: InternPool.Alignment = if (parent_ptr_info.flags.alignment != .none) a: {	3919	const new_align: InternPool.Alignment = if (parent_ptr_info.flags.alignment != .none) a: {
3866	const ty_align = (try field_ty.abiAlignmentAdvanced(pt, .sema)).scalar;	3920	const ty_align = (try field_ty.abiAlignmentInner(.sema, zcu, pt.tid)).scalar;
3867	const true_field_align = if (field_align == .none) ty_align else field_align;	3921	const true_field_align = if (field_align == .none) ty_align else field_align;
3868	const new_align = true_field_align.min(parent_ptr_info.flags.alignment);	3922	const new_align = true_field_align.min(parent_ptr_info.flags.alignment);
3869	if (new_align == ty_align) break :a .none;	3923	if (new_align == ty_align) break :a .none;
...	@@ -3919,21 +3973,21 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value	...	@@ -3919,21 +3973,21 @@ pub fn ptrElem(orig_parent_ptr: Value, field_idx: u64, pt: Zcu.PerThread) !Value
3919		3973
3920	const strat: PtrStrat = switch (parent_ptr_ty.ptrSize(zcu)) {	3974	const strat: PtrStrat = switch (parent_ptr_ty.ptrSize(zcu)) {
3921	.One => switch (elem_ty.zigTypeTag(zcu)) {	3975	.One => switch (elem_ty.zigTypeTag(zcu)) {
3922	.Vector => .{ .offset = field_idx * @divExact(try elem_ty.childType(zcu).bitSizeAdvanced(pt, .sema), 8) },	3976	.Vector => .{ .offset = field_idx * @divExact(try elem_ty.childType(zcu).bitSizeSema(pt), 8) },
3923	.Array => strat: {	3977	.Array => strat: {
3924	const arr_elem_ty = elem_ty.childType(zcu);	3978	const arr_elem_ty = elem_ty.childType(zcu);
3925	if (try arr_elem_ty.comptimeOnlyAdvanced(pt, .sema)) {	3979	if (try arr_elem_ty.comptimeOnlySema(pt)) {
3926	break :strat .{ .elem_ptr = arr_elem_ty };	3980	break :strat .{ .elem_ptr = arr_elem_ty };
3927	}	3981	}
3928	break :strat .{ .offset = field_idx * (try arr_elem_ty.abiSizeAdvanced(pt, .sema)).scalar };	3982	break :strat .{ .offset = field_idx * (try arr_elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar };
3929	},	3983	},
3930	else => unreachable,	3984	else => unreachable,
3931	},	3985	},
3932		3986
3933	.Many, .C => if (try elem_ty.comptimeOnlyAdvanced(pt, .sema))	3987	.Many, .C => if (try elem_ty.comptimeOnlySema(pt))
3934	.{ .elem_ptr = elem_ty }	3988	.{ .elem_ptr = elem_ty }
3935	else	3989	else
3936	.{ .offset = field_idx * (try elem_ty.abiSizeAdvanced(pt, .sema)).scalar },	3990	.{ .offset = field_idx * (try elem_ty.abiSizeInner(.sema, zcu, pt.tid)).scalar },
3937		3991
3938	.Slice => unreachable,	3992	.Slice => unreachable,
3939	};	3993	};
...	@@ -4142,22 +4196,32 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4142,22 +4196,32 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4142	const base_ptr_ty = base_ptr.typeOf(zcu);	4196	const base_ptr_ty = base_ptr.typeOf(zcu);
4143	const agg_ty = base_ptr_ty.childType(zcu);	4197	const agg_ty = base_ptr_ty.childType(zcu);
4144	const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) {	4198	const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) {
4145	.Struct => .{ agg_ty.structFieldType(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, if (have_sema) .sema else .normal) },	4199	.Struct => .{ agg_ty.fieldType(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
4146	.Union => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, if (have_sema) .sema else .normal) },	4200	@intCast(field.index),
		4201	if (have_sema) .sema else .normal,
		4202	pt.zcu,
		4203	if (have_sema) pt.tid else {},
		4204	) },
		4205	.Union => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
		4206	@intCast(field.index),
		4207	if (have_sema) .sema else .normal,
		4208	pt.zcu,
		4209	if (have_sema) pt.tid else {},
		4210	) },
4147	.Pointer => .{ switch (field.index) {	4211	.Pointer => .{ switch (field.index) {
4148	Value.slice_ptr_index => agg_ty.slicePtrFieldType(zcu),	4212	Value.slice_ptr_index => agg_ty.slicePtrFieldType(zcu),
4149	Value.slice_len_index => Type.usize,	4213	Value.slice_len_index => Type.usize,
4150	else => unreachable,	4214	else => unreachable,
4151	}, Type.usize.abiAlignment(pt) },	4215	}, Type.usize.abiAlignment(zcu) },
4152	else => unreachable,	4216	else => unreachable,
4153	};	4217	};
4154	const base_align = base_ptr_ty.ptrAlignment(pt);	4218	const base_align = base_ptr_ty.ptrAlignment(zcu);
4155	const result_align = field_align.minStrict(base_align);	4219	const result_align = field_align.minStrict(base_align);
4156	const result_ty = try pt.ptrType(.{	4220	const result_ty = try pt.ptrType(.{
4157	.child = field_ty.toIntern(),	4221	.child = field_ty.toIntern(),
4158	.flags = flags: {	4222	.flags = flags: {
4159	var flags = base_ptr_ty.ptrInfo(zcu).flags;	4223	var flags = base_ptr_ty.ptrInfo(zcu).flags;
4160	if (result_align == field_ty.abiAlignment(pt)) {	4224	if (result_align == field_ty.abiAlignment(zcu)) {
4161	flags.alignment = .none;	4225	flags.alignment = .none;
4162	} else {	4226	} else {
4163	flags.alignment = result_align;	4227	flags.alignment = result_align;
...	@@ -4198,7 +4262,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4198,7 +4262,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4198	}	4262	}
4199		4263
4200	const need_child = Type.fromInterned(ptr.ty).childType(zcu);	4264	const need_child = Type.fromInterned(ptr.ty).childType(zcu);
4201	if (need_child.comptimeOnly(pt)) {	4265	if (need_child.comptimeOnly(zcu)) {
4202	// No refinement can happen - this pointer is presumably invalid.	4266	// No refinement can happen - this pointer is presumably invalid.
4203	// Just offset it.	4267	// Just offset it.
4204	const parent = try arena.create(PointerDeriveStep);	4268	const parent = try arena.create(PointerDeriveStep);
...	@@ -4209,7 +4273,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4209,7 +4273,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4209	.new_ptr_ty = Type.fromInterned(ptr.ty),	4273	.new_ptr_ty = Type.fromInterned(ptr.ty),
4210	} };	4274	} };
4211	}	4275	}
4212	const need_bytes = need_child.abiSize(pt);	4276	const need_bytes = need_child.abiSize(zcu);
4213		4277
4214	var cur_derive = base_derive;	4278	var cur_derive = base_derive;
4215	var cur_offset = ptr.byte_offset;	4279	var cur_offset = ptr.byte_offset;
...	@@ -4248,7 +4312,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4248,7 +4312,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4248		4312
4249	.Array => {	4313	.Array => {
4250	const elem_ty = cur_ty.childType(zcu);	4314	const elem_ty = cur_ty.childType(zcu);
4251	const elem_size = elem_ty.abiSize(pt);	4315	const elem_size = elem_ty.abiSize(zcu);
4252	const start_idx = cur_offset / elem_size;	4316	const start_idx = cur_offset / elem_size;
4253	const end_idx = (cur_offset + need_bytes + elem_size - 1) / elem_size;	4317	const end_idx = (cur_offset + need_bytes + elem_size - 1) / elem_size;
4254	if (end_idx == start_idx + 1) {	4318	if (end_idx == start_idx + 1) {
...	@@ -4278,12 +4342,12 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4278,12 +4342,12 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4278	.Struct => switch (cur_ty.containerLayout(zcu)) {	4342	.Struct => switch (cur_ty.containerLayout(zcu)) {
4279	.auto, .@"packed" => break,	4343	.auto, .@"packed" => break,
4280	.@"extern" => for (0..cur_ty.structFieldCount(zcu)) \|field_idx\| {	4344	.@"extern" => for (0..cur_ty.structFieldCount(zcu)) \|field_idx\| {
4281	const field_ty = cur_ty.structFieldType(field_idx, zcu);	4345	const field_ty = cur_ty.fieldType(field_idx, zcu);
4282	const start_off = cur_ty.structFieldOffset(field_idx, pt);	4346	const start_off = cur_ty.structFieldOffset(field_idx, zcu);
4283	const end_off = start_off + field_ty.abiSize(pt);	4347	const end_off = start_off + field_ty.abiSize(zcu);
4284	if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {	4348	if (cur_offset >= start_off and cur_offset + need_bytes <= end_off) {
4285	const old_ptr_ty = try cur_derive.ptrType(pt);	4349	const old_ptr_ty = try cur_derive.ptrType(pt);
4286	const parent_align = old_ptr_ty.ptrAlignment(pt);	4350	const parent_align = old_ptr_ty.ptrAlignment(zcu);
4287	const field_align = InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(start_off)));	4351	const field_align = InternPool.Alignment.fromLog2Units(@min(parent_align.toLog2Units(), @ctz(start_off)));
4288	const parent = try arena.create(PointerDeriveStep);	4352	const parent = try arena.create(PointerDeriveStep);
4289	parent.* = cur_derive;	4353	parent.* = cur_derive;
...	@@ -4291,7 +4355,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4291,7 +4355,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4291	.child = field_ty.toIntern(),	4355	.child = field_ty.toIntern(),
4292	.flags = flags: {	4356	.flags = flags: {
4293	var flags = old_ptr_ty.ptrInfo(zcu).flags;	4357	var flags = old_ptr_ty.ptrInfo(zcu).flags;
4294	if (field_align == field_ty.abiAlignment(pt)) {	4358	if (field_align == field_ty.abiAlignment(zcu)) {
4295	flags.alignment = .none;	4359	flags.alignment = .none;
4296	} else {	4360	} else {
4297	flags.alignment = field_align;	4361	flags.alignment = field_align;
...	@@ -4325,13 +4389,17 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh	...	@@ -4325,13 +4389,17 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
4325	} };	4389	} };
4326	}	4390	}
4327		4391
4328	pub fn resolveLazy(val: Value, arena: Allocator, pt: Zcu.PerThread) Zcu.SemaError!Value {	4392	pub fn resolveLazy(
		4393	val: Value,
		4394	arena: Allocator,
		4395	pt: Zcu.PerThread,
		4396	) Zcu.SemaError!Value {
4329	switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {	4397	switch (pt.zcu.intern_pool.indexToKey(val.toIntern())) {
4330	.int => \|int\| switch (int.storage) {	4398	.int => \|int\| switch (int.storage) {
4331	.u64, .i64, .big_int => return val,	4399	.u64, .i64, .big_int => return val,
4332	.lazy_align, .lazy_size => return pt.intValue(	4400	.lazy_align, .lazy_size => return pt.intValue(
4333	Type.fromInterned(int.ty),	4401	Type.fromInterned(int.ty),
4334	(try val.getUnsignedIntAdvanced(pt, .sema)).?,	4402	try val.toUnsignedIntSema(pt),
4335	),	4403	),
4336	},	4404	},
4337	.slice => \|slice\| {	4405	.slice => \|slice\| {

src/Zcu.zig+51-38

 @@ -2109,9 +2109,9 @@ pub const CompileError = error{
     ComptimeBreak,
 };
-pub fn init(mod: *Zcu, thread_count: usize) !void {
+pub fn init(zcu: *Zcu, thread_count: usize) !void {
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
-    try mod.intern_pool.init(gpa, thread_count);
+    try zcu.intern_pool.init(gpa, thread_count);
 }
 pub fn deinit(zcu: *Zcu) void {
 @@ -2204,8 +2204,8 @@ pub fn namespacePtr(zcu: *Zcu, index: Namespace.Index) *Namespace {
     return zcu.intern_pool.namespacePtr(index);
 }
-pub fn namespacePtrUnwrap(mod: *Zcu, index: Namespace.OptionalIndex) ?*Namespace {
+pub fn namespacePtrUnwrap(zcu: *Zcu, index: Namespace.OptionalIndex) ?*Namespace {
-    return mod.namespacePtr(index.unwrap() orelse return null);
+    return zcu.namespacePtr(index.unwrap() orelse return null);
 }
 // TODO https://github.com/ziglang/zig/issues/8643
 @@ -2682,7 +2682,7 @@ pub fn mapOldZirToNew(
 ///
 /// The caller is responsible for ensuring the function decl itself is already
 /// analyzed, and for ensuring it can exist at runtime (see
-/// `sema.fnHasRuntimeBits`). This function does *not* guarantee that the body
+/// `Type.fnHasRuntimeBitsSema`). This function does *not* guarantee that the body
 /// will be analyzed when it returns: for that, see `ensureFuncBodyAnalyzed`.
 pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !void {
     const ip = &zcu.intern_pool;
 @@ -2840,22 +2840,22 @@ pub fn addTypeReference(zcu: *Zcu, src_unit: AnalUnit, referenced_type: InternPo
     gop.value_ptr.* = @intCast(ref_idx);
 }
-pub fn errorSetBits(mod: *Zcu) u16 {
+pub fn errorSetBits(zcu: *const Zcu) u16 {
-    if (mod.error_limit == 0) return 0;
+    if (zcu.error_limit == 0) return 0;
-    return @as(u16, std.math.log2_int(ErrorInt, mod.error_limit)) + 1;
+    return @as(u16, std.math.log2_int(ErrorInt, zcu.error_limit)) + 1;
 }
 pub fn errNote(
-    mod: *Zcu,
+    zcu: *Zcu,
     src_loc: LazySrcLoc,
     parent: *ErrorMsg,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    const msg = try std.fmt.allocPrint(mod.gpa, format, args);
+    const msg = try std.fmt.allocPrint(zcu.gpa, format, args);
-    errdefer mod.gpa.free(msg);
+    errdefer zcu.gpa.free(msg);
-    parent.notes = try mod.gpa.realloc(parent.notes, parent.notes.len + 1);
+    parent.notes = try zcu.gpa.realloc(parent.notes, parent.notes.len + 1);
     parent.notes[parent.notes.len - 1] = .{
         .src_loc = src_loc,
         .msg = msg,
 @@ -2876,14 +2876,14 @@ pub fn optimizeMode(zcu: *const Zcu) std.builtin.OptimizeMode {
     return zcu.root_mod.optimize_mode;
 }
-fn lockAndClearFileCompileError(mod: *Zcu, file: *File) void {
+fn lockAndClearFileCompileError(zcu: *Zcu, file: *File) void {
     switch (file.status) {
         .success_zir, .retryable_failure => {},
         .never_loaded, .parse_failure, .astgen_failure => {
-            mod.comp.mutex.lock();
+            zcu.comp.mutex.lock();
-            defer mod.comp.mutex.unlock();
+            defer zcu.comp.mutex.unlock();
-            if (mod.failed_files.fetchSwapRemove(file)) |kv| {
+            if (zcu.failed_files.fetchSwapRemove(file)) |kv| {
-                if (kv.value) |msg| msg.destroy(mod.gpa); // Delete previous error message.
+                if (kv.value) |msg| msg.destroy(zcu.gpa); // Delete previous error message.
             }
         },
     }
 @@ -2923,10 +2923,23 @@ pub fn addGlobalAssembly(zcu: *Zcu, cau: InternPool.Cau.Index, source: []const u
 }
 pub const Feature = enum {
+    /// When this feature is enabled, Sema will emit calls to `std.builtin.panic`
+    /// for things like safety checks and unreachables. Otherwise traps will be emitted.
     panic_fn,
+    /// When this feature is enabled, Sema will emit calls to `std.builtin.panicUnwrapError`.
+    /// This error message requires more advanced formatting, hence it being seperate from `panic_fn`.
+    /// Otherwise traps will be emitted.
     panic_unwrap_error,
+    /// When this feature is enabled, Sema will emit calls to the more complex panic functions
+    /// that use formatting to add detail to error messages. Similar to `panic_unwrap_error`.
+    /// Otherwise traps will be emitted.
     safety_check_formatted,
+    /// When this feature is enabled, Sema will insert tracer functions for gathering a stack
+    /// trace for error returns.
     error_return_trace,
+    /// When this feature is enabled, Sema will emit the `is_named_enum_value` AIR instructions
+    /// and use it to check for corrupt switches. Backends currently need to implement their own
+    /// logic to determine whether an enum value is in the set of named values.
     is_named_enum_value,
     error_set_has_value,
     field_reordering,
 @@ -2965,11 +2978,11 @@ pub const AtomicPtrAlignmentDiagnostics = struct {
 // TODO this function does not take into account CPU features, which can affect
 // this value. Audit this!
 pub fn atomicPtrAlignment(
-    mod: *Zcu,
+    zcu: *Zcu,
     ty: Type,
     diags: *AtomicPtrAlignmentDiagnostics,
 ) AtomicPtrAlignmentError!Alignment {
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     const max_atomic_bits: u16 = switch (target.cpu.arch) {
         .avr,
         .msp430,
 @@ -3039,8 +3052,8 @@ pub fn atomicPtrAlignment(
         }
         return .none;
     }
-    if (ty.isAbiInt(mod)) {
+    if (ty.isAbiInt(zcu)) {
-        const bit_count = ty.intInfo(mod).bits;
+        const bit_count = ty.intInfo(zcu).bits;
         if (bit_count > max_atomic_bits) {
             diags.* = .{
                 .bits = bit_count,
 @@ -3050,7 +3063,7 @@ pub fn atomicPtrAlignment(
         }
         return .none;
     }
-    if (ty.isPtrAtRuntime(mod)) return .none;
+    if (ty.isPtrAtRuntime(zcu)) return .none;
     return error.BadType;
 }
 @@ -3058,45 +3071,45 @@ pub fn atomicPtrAlignment(
 /// * `@TypeOf(.{})`
 /// * A struct which has no fields (`struct {}`).
 /// * Not a struct.
-pub fn typeToStruct(mod: *Zcu, ty: Type) ?InternPool.LoadedStructType {
+pub fn typeToStruct(zcu: *Zcu, ty: Type) ?InternPool.LoadedStructType {
     if (ty.ip_index == .none) return null;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.ip_index)) {
         .struct_type => ip.loadStructType(ty.ip_index),
         else => null,
     };
 }
-pub fn typeToPackedStruct(mod: *Zcu, ty: Type) ?InternPool.LoadedStructType {
+pub fn typeToPackedStruct(zcu: *Zcu, ty: Type) ?InternPool.LoadedStructType {
-    const s = mod.typeToStruct(ty) orelse return null;
+    const s = zcu.typeToStruct(ty) orelse return null;
     if (s.layout != .@"packed") return null;
     return s;
 }
-pub fn typeToUnion(mod: *Zcu, ty: Type) ?InternPool.LoadedUnionType {
+pub fn typeToUnion(zcu: *const Zcu, ty: Type) ?InternPool.LoadedUnionType {
     if (ty.ip_index == .none) return null;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.ip_index)) {
         .union_type => ip.loadUnionType(ty.ip_index),
         else => null,
     };
 }
-pub fn typeToFunc(mod: *Zcu, ty: Type) ?InternPool.Key.FuncType {
+pub fn typeToFunc(zcu: *const Zcu, ty: Type) ?InternPool.Key.FuncType {
     if (ty.ip_index == .none) return null;
-    return mod.intern_pool.indexToFuncType(ty.toIntern());
+    return zcu.intern_pool.indexToFuncType(ty.toIntern());
 }
 pub fn iesFuncIndex(zcu: *const Zcu, ies_index: InternPool.Index) InternPool.Index {
     return zcu.intern_pool.iesFuncIndex(ies_index);
 }
-pub fn funcInfo(mod: *Zcu, func_index: InternPool.Index) InternPool.Key.Func {
+pub fn funcInfo(zcu: *const Zcu, func_index: InternPool.Index) InternPool.Key.Func {
-    return mod.intern_pool.indexToKey(func_index).func;
+    return zcu.intern_pool.indexToKey(func_index).func;
 }
-pub fn toEnum(mod: *Zcu, comptime E: type, val: Value) E {
+pub fn toEnum(zcu: *const Zcu, comptime E: type, val: Value) E {
-    return mod.intern_pool.toEnum(E, val.toIntern());
+    return zcu.intern_pool.toEnum(E, val.toIntern());
 }
 pub const UnionLayout = struct {
 @@ -3121,8 +3134,8 @@ pub const UnionLayout = struct {
 };
 /// Returns the index of the active field, given the current tag value
-pub fn unionTagFieldIndex(mod: *Zcu, loaded_union: InternPool.LoadedUnionType, enum_tag: Value) ?u32 {
+pub fn unionTagFieldIndex(zcu: *const Zcu, loaded_union: InternPool.LoadedUnionType, enum_tag: Value) ?u32 {
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     if (enum_tag.toIntern() == .none) return null;
     assert(ip.typeOf(enum_tag.toIntern()) == loaded_union.enum_tag_ty);
     return loaded_union.loadTagType(ip).tagValueIndex(ip, enum_tag.toIntern());
 @@ -3348,7 +3361,7 @@ pub fn resolveReferences(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolve
     return result;
 }
-pub fn fileByIndex(zcu: *Zcu, file_index: File.Index) *File {
+pub fn fileByIndex(zcu: *const Zcu, file_index: File.Index) *File {
     return zcu.intern_pool.filePtr(file_index);
 }

src/Zcu/PerThread.zig+32-172

...	@@ -1326,7 +1326,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {	...	@@ -1326,7 +1326,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
1326	try decl_ty.resolveFully(pt);	1326	try decl_ty.resolveFully(pt);
1327	}	1327	}
1328		1328
1329	if (!resolve_type or !decl_ty.hasRuntimeBits(pt)) {	1329	if (!resolve_type or !decl_ty.hasRuntimeBits(zcu)) {
1330	if (zcu.comp.config.use_llvm) break :queue_codegen;	1330	if (zcu.comp.config.use_llvm) break :queue_codegen;
1331	if (file.mod.strip) break :queue_codegen;	1331	if (file.mod.strip) break :queue_codegen;
1332	}	1332	}
...	@@ -1555,8 +1555,8 @@ pub fn embedFile(	...	@@ -1555,8 +1555,8 @@ pub fn embedFile(
1555	import_string: []const u8,	1555	import_string: []const u8,
1556	src_loc: Zcu.LazySrcLoc,	1556	src_loc: Zcu.LazySrcLoc,
1557	) !InternPool.Index {	1557	) !InternPool.Index {
1558	const mod = pt.zcu;	1558	const zcu = pt.zcu;
1559	const gpa = mod.gpa;	1559	const gpa = zcu.gpa;
1560		1560
1561	if (cur_file.mod.deps.get(import_string)) \|pkg\| {	1561	if (cur_file.mod.deps.get(import_string)) \|pkg\| {
1562	const resolved_path = try std.fs.path.resolve(gpa, &.{	1562	const resolved_path = try std.fs.path.resolve(gpa, &.{
...	@@ -1567,9 +1567,9 @@ pub fn embedFile(	...	@@ -1567,9 +1567,9 @@ pub fn embedFile(
1567	var keep_resolved_path = false;	1567	var keep_resolved_path = false;
1568	defer if (!keep_resolved_path) gpa.free(resolved_path);	1568	defer if (!keep_resolved_path) gpa.free(resolved_path);
1569		1569
1570	const gop = try mod.embed_table.getOrPut(gpa, resolved_path);	1570	const gop = try zcu.embed_table.getOrPut(gpa, resolved_path);
1571	errdefer {	1571	errdefer {
1572	assert(std.mem.eql(u8, mod.embed_table.pop().key, resolved_path));	1572	assert(std.mem.eql(u8, zcu.embed_table.pop().key, resolved_path));
1573	keep_resolved_path = false;	1573	keep_resolved_path = false;
1574	}	1574	}
1575	if (gop.found_existing) return gop.value_ptr.*.val;	1575	if (gop.found_existing) return gop.value_ptr.*.val;
...	@@ -1594,9 +1594,9 @@ pub fn embedFile(	...	@@ -1594,9 +1594,9 @@ pub fn embedFile(
1594	var keep_resolved_path = false;	1594	var keep_resolved_path = false;
1595	defer if (!keep_resolved_path) gpa.free(resolved_path);	1595	defer if (!keep_resolved_path) gpa.free(resolved_path);
1596		1596
1597	const gop = try mod.embed_table.getOrPut(gpa, resolved_path);	1597	const gop = try zcu.embed_table.getOrPut(gpa, resolved_path);
1598	errdefer {	1598	errdefer {
1599	assert(std.mem.eql(u8, mod.embed_table.pop().key, resolved_path));	1599	assert(std.mem.eql(u8, zcu.embed_table.pop().key, resolved_path));
1600	keep_resolved_path = false;	1600	keep_resolved_path = false;
1601	}	1601	}
1602	if (gop.found_existing) return gop.value_ptr.*.val;	1602	if (gop.found_existing) return gop.value_ptr.*.val;
...	@@ -1631,9 +1631,9 @@ fn newEmbedFile(	...	@@ -1631,9 +1631,9 @@ fn newEmbedFile(
1631	result: **Zcu.EmbedFile,	1631	result: **Zcu.EmbedFile,
1632	src_loc: Zcu.LazySrcLoc,	1632	src_loc: Zcu.LazySrcLoc,
1633	) !InternPool.Index {	1633	) !InternPool.Index {
1634	const mod = pt.zcu;	1634	const zcu = pt.zcu;
1635	const gpa = mod.gpa;	1635	const gpa = zcu.gpa;
1636	const ip = &mod.intern_pool;	1636	const ip = &zcu.intern_pool;
1637		1637
1638	const new_file = try gpa.create(Zcu.EmbedFile);	1638	const new_file = try gpa.create(Zcu.EmbedFile);
1639	errdefer gpa.destroy(new_file);	1639	errdefer gpa.destroy(new_file);
...	@@ -1655,7 +1655,7 @@ fn newEmbedFile(	...	@@ -1655,7 +1655,7 @@ fn newEmbedFile(
1655	if (actual_read != size) return error.UnexpectedEndOfFile;	1655	if (actual_read != size) return error.UnexpectedEndOfFile;
1656	bytes[0][size] = 0;	1656	bytes[0][size] = 0;
1657		1657
1658	const comp = mod.comp;	1658	const comp = zcu.comp;
1659	switch (comp.cache_use) {	1659	switch (comp.cache_use) {
1660	.whole => \|whole\| if (whole.cache_manifest) \|man\| {	1660	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
1661	const copied_resolved_path = try gpa.dupe(u8, resolved_path);	1661	const copied_resolved_path = try gpa.dupe(u8, resolved_path);
...	@@ -2756,7 +2756,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!	...	@@ -2756,7 +2756,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!
2756	// pointee type needs to be resolved more, that needs to be done before calling	2756	// pointee type needs to be resolved more, that needs to be done before calling
2757	// this ptr() function.	2757	// this ptr() function.
2758	if (info.flags.alignment != .none and	2758	if (info.flags.alignment != .none and
2759	info.flags.alignment == Type.fromInterned(info.child).abiAlignment(pt))	2759	info.flags.alignment == Type.fromInterned(info.child).abiAlignment(pt.zcu))
2760	{	2760	{
2761	canon_info.flags.alignment = .none;	2761	canon_info.flags.alignment = .none;
2762	}	2762	}
...	@@ -2766,7 +2766,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!	...	@@ -2766,7 +2766,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!
2766	// we change it to 0 here. If this causes an assertion trip, the pointee type	2766	// we change it to 0 here. If this causes an assertion trip, the pointee type
2767	// needs to be resolved before calling this ptr() function.	2767	// needs to be resolved before calling this ptr() function.
2768	.none => if (info.packed_offset.host_size != 0) {	2768	.none => if (info.packed_offset.host_size != 0) {
2769	const elem_bit_size = Type.fromInterned(info.child).bitSize(pt);	2769	const elem_bit_size = Type.fromInterned(info.child).bitSize(pt.zcu);
2770	assert(info.packed_offset.bit_offset + elem_bit_size <= info.packed_offset.host_size * 8);	2770	assert(info.packed_offset.bit_offset + elem_bit_size <= info.packed_offset.host_size * 8);
2771	if (info.packed_offset.host_size * 8 == elem_bit_size) {	2771	if (info.packed_offset.host_size * 8 == elem_bit_size) {
2772	canon_info.packed_offset.host_size = 0;	2772	canon_info.packed_offset.host_size = 0;
...	@@ -2784,7 +2784,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!	...	@@ -2784,7 +2784,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error!
2784	/// In general, prefer this function during semantic analysis.	2784	/// In general, prefer this function during semantic analysis.
2785	pub fn ptrTypeSema(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Zcu.SemaError!Type {	2785	pub fn ptrTypeSema(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Zcu.SemaError!Type {
2786	if (info.flags.alignment != .none) {	2786	if (info.flags.alignment != .none) {
2787	_ = try Type.fromInterned(info.child).abiAlignmentAdvanced(pt, .sema);	2787	_ = try Type.fromInterned(info.child).abiAlignmentSema(pt);
2788	}	2788	}
2789	return pt.ptrType(info);	2789	return pt.ptrType(info);
2790	}	2790	}
...	@@ -2857,9 +2857,9 @@ pub fn errorSetFromUnsortedNames(	...	@@ -2857,9 +2857,9 @@ pub fn errorSetFromUnsortedNames(
2857		2857
2858	/// Supports only pointers, not pointer-like optionals.	2858	/// Supports only pointers, not pointer-like optionals.
2859	pub fn ptrIntValue(pt: Zcu.PerThread, ty: Type, x: u64) Allocator.Error!Value {	2859	pub fn ptrIntValue(pt: Zcu.PerThread, ty: Type, x: u64) Allocator.Error!Value {
2860	const mod = pt.zcu;	2860	const zcu = pt.zcu;
2861	assert(ty.zigTypeTag(mod) == .Pointer and !ty.isSlice(mod));	2861	assert(ty.zigTypeTag(zcu) == .Pointer and !ty.isSlice(zcu));
2862	assert(x != 0 or ty.isAllowzeroPtr(mod));	2862	assert(x != 0 or ty.isAllowzeroPtr(zcu));
2863	return Value.fromInterned(try pt.intern(.{ .ptr = .{	2863	return Value.fromInterned(try pt.intern(.{ .ptr = .{
2864	.ty = ty.toIntern(),	2864	.ty = ty.toIntern(),
2865	.base_addr = .int,	2865	.base_addr = .int,
...	@@ -2984,15 +2984,15 @@ pub fn smallestUnsignedInt(pt: Zcu.PerThread, max: u64) Allocator.Error!Type {	...	@@ -2984,15 +2984,15 @@ pub fn smallestUnsignedInt(pt: Zcu.PerThread, max: u64) Allocator.Error!Type {
2984	/// `max`. Asserts that neither value is undef.	2984	/// `max`. Asserts that neither value is undef.
2985	/// TODO: if #3806 is implemented, this becomes trivial	2985	/// TODO: if #3806 is implemented, this becomes trivial
2986	pub fn intFittingRange(pt: Zcu.PerThread, min: Value, max: Value) !Type {	2986	pub fn intFittingRange(pt: Zcu.PerThread, min: Value, max: Value) !Type {
2987	const mod = pt.zcu;	2987	const zcu = pt.zcu;
2988	assert(!min.isUndef(mod));	2988	assert(!min.isUndef(zcu));
2989	assert(!max.isUndef(mod));	2989	assert(!max.isUndef(zcu));
2990		2990
2991	if (std.debug.runtime_safety) {	2991	if (std.debug.runtime_safety) {
2992	assert(Value.order(min, max, pt).compare(.lte));	2992	assert(Value.order(min, max, zcu).compare(.lte));
2993	}	2993	}
2994		2994
2995	const sign = min.orderAgainstZero(pt) == .lt;	2995	const sign = min.orderAgainstZero(zcu) == .lt;
2996		2996
2997	const min_val_bits = pt.intBitsForValue(min, sign);	2997	const min_val_bits = pt.intBitsForValue(min, sign);
2998	const max_val_bits = pt.intBitsForValue(max, sign);	2998	const max_val_bits = pt.intBitsForValue(max, sign);
...	@@ -3008,10 +3008,10 @@ pub fn intFittingRange(pt: Zcu.PerThread, min: Value, max: Value) !Type {	...	@@ -3008,10 +3008,10 @@ pub fn intFittingRange(pt: Zcu.PerThread, min: Value, max: Value) !Type {
3008	/// twos-complement integer; otherwise in an unsigned integer.	3008	/// twos-complement integer; otherwise in an unsigned integer.
3009	/// Asserts that `val` is not undef. If `val` is negative, asserts that `sign` is true.	3009	/// Asserts that `val` is not undef. If `val` is negative, asserts that `sign` is true.
3010	pub fn intBitsForValue(pt: Zcu.PerThread, val: Value, sign: bool) u16 {	3010	pub fn intBitsForValue(pt: Zcu.PerThread, val: Value, sign: bool) u16 {
3011	const mod = pt.zcu;	3011	const zcu = pt.zcu;
3012	assert(!val.isUndef(mod));	3012	assert(!val.isUndef(zcu));
3013		3013
3014	const key = mod.intern_pool.indexToKey(val.toIntern());	3014	const key = zcu.intern_pool.indexToKey(val.toIntern());
3015	switch (key.int.storage) {	3015	switch (key.int.storage) {
3016	.i64 => \|x\| {	3016	.i64 => \|x\| {
3017	if (std.math.cast(u64, x)) \|casted\| return Type.smallestUnsignedBits(casted) + @intFromBool(sign);	3017	if (std.math.cast(u64, x)) \|casted\| return Type.smallestUnsignedBits(casted) + @intFromBool(sign);
...	@@ -3032,154 +3032,14 @@ pub fn intBitsForValue(pt: Zcu.PerThread, val: Value, sign: bool) u16 {	...	@@ -3032,154 +3032,14 @@ pub fn intBitsForValue(pt: Zcu.PerThread, val: Value, sign: bool) u16 {
3032	return @as(u16, @intCast(big.bitCountTwosComp()));	3032	return @as(u16, @intCast(big.bitCountTwosComp()));
3033	},	3033	},
3034	.lazy_align => \|lazy_ty\| {	3034	.lazy_align => \|lazy_ty\| {
3035	return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiAlignment(pt).toByteUnits() orelse 0) + @intFromBool(sign);	3035	return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiAlignment(pt.zcu).toByteUnits() orelse 0) + @intFromBool(sign);
3036	},	3036	},
3037	.lazy_size => \|lazy_ty\| {	3037	.lazy_size => \|lazy_ty\| {
3038	return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiSize(pt)) + @intFromBool(sign);	3038	return Type.smallestUnsignedBits(Type.fromInterned(lazy_ty).abiSize(pt.zcu)) + @intFromBool(sign);
3039	},	3039	},
3040	}	3040	}
3041	}	3041	}
3042		3042
3043	pub fn getUnionLayout(pt: Zcu.PerThread, loaded_union: InternPool.LoadedUnionType) Zcu.UnionLayout {
3044	const mod = pt.zcu;
3045	const ip = &mod.intern_pool;
3046	assert(loaded_union.haveLayout(ip));
3047	var most_aligned_field: u32 = undefined;
3048	var most_aligned_field_size: u64 = undefined;
3049	var biggest_field: u32 = undefined;
3050	var payload_size: u64 = 0;
3051	var payload_align: InternPool.Alignment = .@"1";
3052	for (loaded_union.field_types.get(ip), 0..) \|field_ty, field_index\| {
3053	if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) continue;
3054
3055	const explicit_align = loaded_union.fieldAlign(ip, field_index);
3056	const field_align = if (explicit_align != .none)
3057	explicit_align
3058	else
3059	Type.fromInterned(field_ty).abiAlignment(pt);
3060	const field_size = Type.fromInterned(field_ty).abiSize(pt);
3061	if (field_size > payload_size) {
3062	payload_size = field_size;
3063	biggest_field = @intCast(field_index);
3064	}
3065	if (field_align.compare(.gte, payload_align)) {
3066	payload_align = field_align;
3067	most_aligned_field = @intCast(field_index);
3068	most_aligned_field_size = field_size;
3069	}
3070	}
3071	const have_tag = loaded_union.flagsUnordered(ip).runtime_tag.hasTag();
3072	if (!have_tag or !Type.fromInterned(loaded_union.enum_tag_ty).hasRuntimeBits(pt)) {
3073	return .{
3074	.abi_size = payload_align.forward(payload_size),
3075	.abi_align = payload_align,
3076	.most_aligned_field = most_aligned_field,
3077	.most_aligned_field_size = most_aligned_field_size,
3078	.biggest_field = biggest_field,
3079	.payload_size = payload_size,
3080	.payload_align = payload_align,
3081	.tag_align = .none,
3082	.tag_size = 0,
3083	.padding = 0,
3084	};
3085	}
3086
3087	const tag_size = Type.fromInterned(loaded_union.enum_tag_ty).abiSize(pt);
3088	const tag_align = Type.fromInterned(loaded_union.enum_tag_ty).abiAlignment(pt).max(.@"1");
3089	return .{
3090	.abi_size = loaded_union.sizeUnordered(ip),
3091	.abi_align = tag_align.max(payload_align),
3092	.most_aligned_field = most_aligned_field,
3093	.most_aligned_field_size = most_aligned_field_size,
3094	.biggest_field = biggest_field,
3095	.payload_size = payload_size,
3096	.payload_align = payload_align,
3097	.tag_align = tag_align,
3098	.tag_size = tag_size,
3099	.padding = loaded_union.paddingUnordered(ip),
3100	};
3101	}
3102
3103	pub fn unionAbiSize(mod: *Module, loaded_union: InternPool.LoadedUnionType) u64 {
3104	return mod.getUnionLayout(loaded_union).abi_size;
3105	}
3106
3107	/// Returns 0 if the union is represented with 0 bits at runtime.
3108	pub fn unionAbiAlignment(pt: Zcu.PerThread, loaded_union: InternPool.LoadedUnionType) InternPool.Alignment {
3109	const mod = pt.zcu;
3110	const ip = &mod.intern_pool;
3111	const have_tag = loaded_union.flagsPtr(ip).runtime_tag.hasTag();
3112	var max_align: InternPool.Alignment = .none;
3113	if (have_tag) max_align = Type.fromInterned(loaded_union.enum_tag_ty).abiAlignment(pt);
3114	for (loaded_union.field_types.get(ip), 0..) \|field_ty, field_index\| {
3115	if (!Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
3116
3117	const field_align = mod.unionFieldNormalAlignment(loaded_union, @intCast(field_index));
3118	max_align = max_align.max(field_align);
3119	}
3120	return max_align;
3121	}
3122
3123	/// Returns the field alignment of a non-packed union. Asserts the layout is not packed.
3124	pub fn unionFieldNormalAlignment(
3125	pt: Zcu.PerThread,
3126	loaded_union: InternPool.LoadedUnionType,
3127	field_index: u32,
3128	) InternPool.Alignment {
3129	return pt.unionFieldNormalAlignmentAdvanced(loaded_union, field_index, .normal) catch unreachable;
3130	}
3131
3132	/// Returns the field alignment of a non-packed union. Asserts the layout is not packed.
3133	/// If `strat` is `.sema`, may perform type resolution.
3134	pub fn unionFieldNormalAlignmentAdvanced(
3135	pt: Zcu.PerThread,
3136	loaded_union: InternPool.LoadedUnionType,
3137	field_index: u32,
3138	comptime strat: Type.ResolveStrat,
3139	) Zcu.SemaError!InternPool.Alignment {
3140	const ip = &pt.zcu.intern_pool;
3141	assert(loaded_union.flagsUnordered(ip).layout != .@"packed");
3142	const field_align = loaded_union.fieldAlign(ip, field_index);
3143	if (field_align != .none) return field_align;
3144	const field_ty = Type.fromInterned(loaded_union.field_types.get(ip)[field_index]);
3145	if (field_ty.isNoReturn(pt.zcu)) return .none;
3146	return (try field_ty.abiAlignmentAdvanced(pt, strat.toLazy())).scalar;
3147	}
3148
3149	/// Returns the field alignment of a non-packed struct. Asserts the layout is not packed.
3150	pub fn structFieldAlignment(
3151	pt: Zcu.PerThread,
3152	explicit_alignment: InternPool.Alignment,
3153	field_ty: Type,
3154	layout: std.builtin.Type.ContainerLayout,
3155	) InternPool.Alignment {
3156	return pt.structFieldAlignmentAdvanced(explicit_alignment, field_ty, layout, .normal) catch unreachable;
3157	}
3158
3159	/// Returns the field alignment of a non-packed struct. Asserts the layout is not packed.
3160	/// If `strat` is `.sema`, may perform type resolution.
3161	pub fn structFieldAlignmentAdvanced(
3162	pt: Zcu.PerThread,
3163	explicit_alignment: InternPool.Alignment,
3164	field_ty: Type,
3165	layout: std.builtin.Type.ContainerLayout,
3166	comptime strat: Type.ResolveStrat,
3167	) Zcu.SemaError!InternPool.Alignment {
3168	assert(layout != .@"packed");
3169	if (explicit_alignment != .none) return explicit_alignment;
3170	const ty_abi_align = (try field_ty.abiAlignmentAdvanced(pt, strat.toLazy())).scalar;
3171	switch (layout) {
3172	.@"packed" => unreachable,
3173	.auto => if (pt.zcu.getTarget().ofmt != .c) return ty_abi_align,
3174	.@"extern" => {},
3175	}
3176	// extern
3177	if (field_ty.isAbiInt(pt.zcu) and field_ty.intInfo(pt.zcu).bits >= 128) {
3178	return ty_abi_align.maxStrict(.@"16");
3179	}
3180	return ty_abi_align;
3181	}
3182
3183	/// https://github.com/ziglang/zig/issues/17178 explored storing these bit offsets	3043	/// https://github.com/ziglang/zig/issues/17178 explored storing these bit offsets
3184	/// into the packed struct InternPool data rather than computing this on the	3044	/// into the packed struct InternPool data rather than computing this on the
3185	/// fly, however it was found to perform worse when measured on real world	3045	/// fly, however it was found to perform worse when measured on real world
...	@@ -3189,8 +3049,8 @@ pub fn structPackedFieldBitOffset(	...	@@ -3189,8 +3049,8 @@ pub fn structPackedFieldBitOffset(
3189	struct_type: InternPool.LoadedStructType,	3049	struct_type: InternPool.LoadedStructType,
3190	field_index: u32,	3050	field_index: u32,
3191	) u16 {	3051	) u16 {
3192	const mod = pt.zcu;	3052	const zcu = pt.zcu;
3193	const ip = &mod.intern_pool;	3053	const ip = &zcu.intern_pool;
3194	assert(struct_type.layout == .@"packed");	3054	assert(struct_type.layout == .@"packed");
3195	assert(struct_type.haveLayout(ip));	3055	assert(struct_type.haveLayout(ip));
3196	var bit_sum: u64 = 0;	3056	var bit_sum: u64 = 0;
...	@@ -3199,7 +3059,7 @@ pub fn structPackedFieldBitOffset(	...	@@ -3199,7 +3059,7 @@ pub fn structPackedFieldBitOffset(
3199	return @intCast(bit_sum);	3059	return @intCast(bit_sum);
3200	}	3060	}
3201	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);	3061	const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
3202	bit_sum += field_ty.bitSize(pt);	3062	bit_sum += field_ty.bitSize(zcu);
3203	}	3063	}
3204	unreachable; // index out of bounds	3064	unreachable; // index out of bounds
3205	}	3065	}
...	@@ -3244,7 +3104,7 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.	...	@@ -3244,7 +3104,7 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.
3244	return pt.ptrType(.{	3104	return pt.ptrType(.{
3245	.child = ty.toIntern(),	3105	.child = ty.toIntern(),
3246	.flags = .{	3106	.flags = .{
3247	.alignment = if (r.alignment == ty.abiAlignment(pt))	3107	.alignment = if (r.alignment == ty.abiAlignment(zcu))
3248	.none	3108	.none
3249	else	3109	else
3250	r.alignment,	3110	r.alignment,
...	@@ -3274,7 +3134,7 @@ pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPo	...	@@ -3274,7 +3134,7 @@ pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPo
3274	const zcu = pt.zcu;	3134	const zcu = pt.zcu;
3275	const r = zcu.intern_pool.getNav(nav_index).status.resolved;	3135	const r = zcu.intern_pool.getNav(nav_index).status.resolved;
3276	if (r.alignment != .none) return r.alignment;	3136	if (r.alignment != .none) return r.alignment;
3277	return Value.fromInterned(r.val).typeOf(zcu).abiAlignment(pt);	3137	return Value.fromInterned(r.val).typeOf(zcu).abiAlignment(zcu);
3278	}	3138	}
3279		3139
3280	/// Given a container type requiring resolution, ensures that it is up-to-date.	3140	/// Given a container type requiring resolution, ensures that it is up-to-date.

src/arch/aarch64/CodeGen.zig+261-260

 @@ -467,8 +467,8 @@ pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {
 fn gen(self: *Self) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const cc = self.fn_type.fnCallingConvention(mod);
+    const cc = self.fn_type.fnCallingConvention(zcu);
     if (cc != .Naked) {
         // stp fp, lr, [sp, #-16]!
         _ = try self.addInst(.{
 @@ -517,8 +517,8 @@ fn gen(self: *Self) !void {
                     const ty = self.typeOfIndex(inst);
-                    const abi_size = @as(u32, @intCast(ty.abiSize(pt)));
+                    const abi_size = @as(u32, @intCast(ty.abiSize(zcu)));
-                    const abi_align = ty.abiAlignment(pt);
+                    const abi_align = ty.abiAlignment(zcu);
                     const stack_offset = try self.allocMem(abi_size, abi_align, inst);
                     try self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
 @@ -648,8 +648,8 @@ fn gen(self: *Self) !void {
 fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const air_tags = self.air.instructions.items(.tag);
     for (body) |inst| {
 @@ -1016,31 +1016,31 @@ fn allocMem(
 /// Use a pointer instruction as the basis for allocating stack memory.
 fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const elem_ty = self.typeOfIndex(inst).childType(mod);
+    const elem_ty = self.typeOfIndex(inst).childType(zcu);
-    if (!elem_ty.hasRuntimeBits(pt)) {
+    if (!elem_ty.hasRuntimeBits(zcu)) {
         // return the stack offset 0. Stack offset 0 will be where all
         // zero-sized stack allocations live as non-zero-sized
         // allocations will always have an offset > 0.
         return @as(u32, 0);
     }
-    const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {
+    const abi_size = math.cast(u32, elem_ty.abiSize(zcu)) orelse {
         return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
     };
     // TODO swap this for inst.ty.ptrAlign
-    const abi_align = elem_ty.abiAlignment(pt);
+    const abi_align = elem_ty.abiAlignment(zcu);
     return self.allocMem(abi_size, abi_align, inst);
 }
 fn allocRegOrMem(self: *Self, elem_ty: Type, reg_ok: bool, maybe_inst: ?Air.Inst.Index) !MCValue {
     const pt = self.pt;
-    const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {
+    const abi_size = math.cast(u32, elem_ty.abiSize(pt.zcu)) orelse {
         return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
     };
-    const abi_align = elem_ty.abiAlignment(pt);
+    const abi_align = elem_ty.abiAlignment(pt.zcu);
     if (reg_ok) {
         // Make sure the type can fit in a register before we try to allocate one.
 @@ -1128,13 +1128,13 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
 fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = switch (self.ret_mcv) {
         .none, .register => .{ .ptr_stack_offset = try self.allocMemPtr(inst) },
         .stack_offset => blk: {
             // self.ret_mcv is an address to where this function
             // should store its result into
-            const ret_ty = self.fn_type.fnReturnType(mod);
+            const ret_ty = self.fn_type.fnReturnType(zcu);
             const ptr_ty = try pt.singleMutPtrType(ret_ty);
             // addr_reg will contain the address of where to store the
 @@ -1166,14 +1166,14 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
         return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand = ty_op.operand;
     const operand_mcv = try self.resolveInst(operand);
     const operand_ty = self.typeOf(operand);
-    const operand_info = operand_ty.intInfo(mod);
+    const operand_info = operand_ty.intInfo(zcu);
     const dest_ty = self.typeOfIndex(inst);
-    const dest_info = dest_ty.intInfo(mod);
+    const dest_info = dest_ty.intInfo(zcu);
     const result: MCValue = result: {
         const operand_lock: ?RegisterLock = switch (operand_mcv) {
 @@ -1248,9 +1248,9 @@ fn trunc(
     dest_ty: Type,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const info_a = operand_ty.intInfo(mod);
+    const info_a = operand_ty.intInfo(zcu);
-    const info_b = dest_ty.intInfo(mod);
+    const info_b = dest_ty.intInfo(zcu);
     if (info_b.bits <= 64) {
         const operand_reg = switch (operand) {
 @@ -1312,7 +1312,7 @@ fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
 fn airNot(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
 @@ -1321,7 +1321,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
             .unreach => unreachable,
             .compare_flags => |cond| break :result MCValue{ .compare_flags = cond.negate() },
             else => {
-                switch (operand_ty.zigTypeTag(mod)) {
+                switch (operand_ty.zigTypeTag(zcu)) {
                     .Bool => {
                         // TODO convert this to mvn + and
                         const op_reg = switch (operand) {
 @@ -1355,7 +1355,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
                     },
                     .Vector => return self.fail("TODO bitwise not for vectors", .{}),
                     .Int => {
-                        const int_info = operand_ty.intInfo(mod);
+                        const int_info = operand_ty.intInfo(zcu);
                         if (int_info.bits <= 64) {
                             const op_reg = switch (operand) {
                                 .register => |r| r,
 @@ -1408,13 +1408,13 @@ fn minMax(
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO ARM min/max on floats", .{}),
         .Vector => return self.fail("TODO ARM min/max on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 var lhs_reg: Register = undefined;
                 var rhs_reg: Register = undefined;
 @@ -1899,13 +1899,13 @@ fn addSub(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO binary operations on floats", .{}),
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 const lhs_immediate = try lhs_bind.resolveToImmediate(self);
                 const rhs_immediate = try rhs_bind.resolveToImmediate(self);
 @@ -1961,12 +1961,12 @@ fn mul(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 // TODO add optimisations for multiplication
                 // with immediates, for example a * 2 can be
 @@ -1994,8 +1994,8 @@ fn divFloat(
     _ = maybe_inst;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO div_float", .{}),
         .Vector => return self.fail("TODO div_float on vectors", .{}),
         else => unreachable,
 @@ -2011,13 +2011,13 @@ fn divTrunc(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO div on floats", .{}),
         .Vector => return self.fail("TODO div on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 switch (int_info.signedness) {
                     .signed => {
 @@ -2046,13 +2046,13 @@ fn divFloor(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO div on floats", .{}),
         .Vector => return self.fail("TODO div on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 switch (int_info.signedness) {
                     .signed => {
 @@ -2080,13 +2080,13 @@ fn divExact(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO div on floats", .{}),
         .Vector => return self.fail("TODO div on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 switch (int_info.signedness) {
                     .signed => {
 @@ -2117,13 +2117,13 @@ fn rem(
     _ = maybe_inst;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
-        .Float => return self.fail("TODO rem/mod on floats", .{}),
+        .Float => return self.fail("TODO rem/zcu on floats", .{}),
-        .Vector => return self.fail("TODO rem/mod on vectors", .{}),
+        .Vector => return self.fail("TODO rem/zcu on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 var lhs_reg: Register = undefined;
                 var rhs_reg: Register = undefined;
 @@ -2168,7 +2168,7 @@ fn rem(
                 return MCValue{ .register = remainder_reg };
             } else {
-                return self.fail("TODO rem/mod for integers with bits > 64", .{});
+                return self.fail("TODO rem/zcu for integers with bits > 64", .{});
             }
         },
         else => unreachable,
 @@ -2189,11 +2189,11 @@ fn modulo(
     _ = maybe_inst;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
-        .Float => return self.fail("TODO mod on floats", .{}),
+        .Float => return self.fail("TODO zcu on floats", .{}),
-        .Vector => return self.fail("TODO mod on vectors", .{}),
+        .Vector => return self.fail("TODO zcu on vectors", .{}),
-        .Int => return self.fail("TODO mod on ints", .{}),
+        .Int => return self.fail("TODO zcu on ints", .{}),
         else => unreachable,
     }
 }
 @@ -2208,11 +2208,11 @@ fn wrappingArithmetic(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 // Generate an add/sub/mul
                 const result: MCValue = switch (tag) {
 @@ -2244,12 +2244,12 @@ fn bitwise(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            assert(lhs_ty.eql(rhs_ty, mod));
+            assert(lhs_ty.eql(rhs_ty, zcu));
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 // TODO implement bitwise operations with immediates
                 const mir_tag: Mir.Inst.Tag = switch (tag) {
 @@ -2280,11 +2280,11 @@ fn shiftExact(
     _ = rhs_ty;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 const rhs_immediate = try rhs_bind.resolveToImmediate(self);
 @@ -2331,11 +2331,11 @@ fn shiftNormal(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO binary operations on vectors", .{}),
         .Int => {
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 // Generate a shl_exact/shr_exact
                 const result: MCValue = switch (tag) {
 @@ -2372,8 +2372,8 @@ fn booleanOp(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Bool => {
             assert((try lhs_bind.resolveToImmediate(self)) == null); // should have been handled by Sema
             assert((try rhs_bind.resolveToImmediate(self)) == null); // should have been handled by Sema
 @@ -2400,17 +2400,17 @@ fn ptrArithmetic(
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Pointer => {
-            assert(rhs_ty.eql(Type.usize, mod));
+            assert(rhs_ty.eql(Type.usize, zcu));
             const ptr_ty = lhs_ty;
-            const elem_ty = switch (ptr_ty.ptrSize(mod)) {
+            const elem_ty = switch (ptr_ty.ptrSize(zcu)) {
-                .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
+                .One => ptr_ty.childType(zcu).childType(zcu), // ptr to array, so get array element type
-                else => ptr_ty.childType(mod),
+                else => ptr_ty.childType(zcu),
             };
-            const elem_size = elem_ty.abiSize(pt);
+            const elem_size = elem_ty.abiSize(zcu);
             const base_tag: Air.Inst.Tag = switch (tag) {
                 .ptr_add => .add,
 @@ -2524,7 +2524,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };
         const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };
 @@ -2532,15 +2532,15 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
         const rhs_ty = self.typeOf(extra.rhs);
         const tuple_ty = self.typeOfIndex(inst);
-        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(pt)));
+        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(zcu)));
-        const tuple_align = tuple_ty.abiAlignment(pt);
+        const tuple_align = tuple_ty.abiAlignment(zcu);
-        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, pt)));
+        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, zcu)));
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement add_with_overflow/sub_with_overflow for vectors", .{}),
             .Int => {
-                assert(lhs_ty.eql(rhs_ty, mod));
+                assert(lhs_ty.eql(rhs_ty, zcu));
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 switch (int_info.bits) {
                     1...31, 33...63 => {
                         const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
 @@ -2652,8 +2652,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
-    const mod = pt.zcu;
     const result: MCValue = result: {
         const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };
         const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };
 @@ -2661,15 +2660,15 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
         const rhs_ty = self.typeOf(extra.rhs);
         const tuple_ty = self.typeOfIndex(inst);
-        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(pt)));
+        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(zcu)));
-        const tuple_align = tuple_ty.abiAlignment(pt);
+        const tuple_align = tuple_ty.abiAlignment(zcu);
-        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, pt)));
+        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, zcu)));
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
             .Int => {
-                assert(lhs_ty.eql(rhs_ty, mod));
+                assert(lhs_ty.eql(rhs_ty, zcu));
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 if (int_info.bits <= 32) {
                     const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
 @@ -2878,7 +2877,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = result: {
         const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };
         const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };
 @@ -2886,14 +2885,14 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
         const rhs_ty = self.typeOf(extra.rhs);
         const tuple_ty = self.typeOfIndex(inst);
-        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(pt)));
+        const tuple_size = @as(u32, @intCast(tuple_ty.abiSize(zcu)));
-        const tuple_align = tuple_ty.abiAlignment(pt);
+        const tuple_align = tuple_ty.abiAlignment(zcu);
-        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, pt)));
+        const overflow_bit_offset = @as(u32, @intCast(tuple_ty.structFieldOffset(1, zcu)));
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement shl_with_overflow for vectors", .{}),
             .Int => {
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 if (int_info.bits <= 64) {
                     const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
 @@ -3027,10 +3026,10 @@ fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
 fn optionalPayload(self: *Self, inst: Air.Inst.Index, mcv: MCValue, optional_ty: Type) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const payload_ty = optional_ty.optionalChild(mod);
+    const payload_ty = optional_ty.optionalChild(zcu);
-    if (!payload_ty.hasRuntimeBits(pt)) return MCValue.none;
+    if (!payload_ty.hasRuntimeBits(zcu)) return MCValue.none;
-    if (optional_ty.isPtrLikeOptional(mod)) {
+    if (optional_ty.isPtrLikeOptional(zcu)) {
         // TODO should we reuse the operand here?
         const raw_reg = try self.register_manager.allocReg(inst, gp);
         const reg = self.registerAlias(raw_reg, payload_ty);
 @@ -3072,17 +3071,17 @@ fn errUnionErr(
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const err_ty = error_union_ty.errorUnionSet(mod);
+    const err_ty = error_union_ty.errorUnionSet(zcu);
-    const payload_ty = error_union_ty.errorUnionPayload(mod);
+    const payload_ty = error_union_ty.errorUnionPayload(zcu);
-    if (err_ty.errorSetIsEmpty(mod)) {
+    if (err_ty.errorSetIsEmpty(zcu)) {
         return MCValue{ .immediate = 0 };
     }
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return try error_union_bind.resolveToMcv(self);
     }
-    const err_offset: u32 = @intCast(errUnionErrorOffset(payload_ty, pt));
+    const err_offset: u32 = @intCast(errUnionErrorOffset(payload_ty, zcu));
     switch (try error_union_bind.resolveToMcv(self)) {
         .register => {
             var operand_reg: Register = undefined;
 @@ -3104,7 +3103,7 @@ fn errUnionErr(
             );
             const err_bit_offset = err_offset * 8;
-            const err_bit_size = @as(u32, @intCast(err_ty.abiSize(pt))) * 8;
+            const err_bit_size = @as(u32, @intCast(err_ty.abiSize(zcu))) * 8;
             _ = try self.addInst(.{
                 .tag = .ubfx, // errors are unsigned integers
 @@ -3153,17 +3152,17 @@ fn errUnionPayload(
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const err_ty = error_union_ty.errorUnionSet(mod);
+    const err_ty = error_union_ty.errorUnionSet(zcu);
-    const payload_ty = error_union_ty.errorUnionPayload(mod);
+    const payload_ty = error_union_ty.errorUnionPayload(zcu);
-    if (err_ty.errorSetIsEmpty(mod)) {
+    if (err_ty.errorSetIsEmpty(zcu)) {
         return try error_union_bind.resolveToMcv(self);
     }
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return MCValue.none;
     }
-    const payload_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, pt)));
+    const payload_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, zcu)));
     switch (try error_union_bind.resolveToMcv(self)) {
         .register => {
             var operand_reg: Register = undefined;
 @@ -3185,10 +3184,10 @@ fn errUnionPayload(
             );
             const payload_bit_offset = payload_offset * 8;
-            const payload_bit_size = @as(u32, @intCast(payload_ty.abiSize(pt))) * 8;
+            const payload_bit_size = @as(u32, @intCast(payload_ty.abiSize(zcu))) * 8;
             _ = try self.addInst(.{
-                .tag = if (payload_ty.isSignedInt(mod)) Mir.Inst.Tag.sbfx else .ubfx,
+                .tag = if (payload_ty.isSignedInt(zcu)) Mir.Inst.Tag.sbfx else .ubfx,
                 .data = .{
                     .rr_lsb_width = .{
                         // Set both registers to the X variant to get the full width
 @@ -3266,7 +3265,7 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
 fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     if (self.liveness.isUnused(inst)) {
 @@ -3275,7 +3274,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
     const result: MCValue = result: {
         const payload_ty = self.typeOf(ty_op.operand);
-        if (!payload_ty.hasRuntimeBits(pt)) {
+        if (!payload_ty.hasRuntimeBits(zcu)) {
             break :result MCValue{ .immediate = 1 };
         }
 @@ -3287,7 +3286,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
         };
         defer if (operand_lock) |lock| self.register_manager.unlockReg(lock);
-        if (optional_ty.isPtrLikeOptional(mod)) {
+        if (optional_ty.isPtrLikeOptional(zcu)) {
             // TODO should we check if we can reuse the operand?
             const raw_reg = try self.register_manager.allocReg(inst, gp);
             const reg = self.registerAlias(raw_reg, payload_ty);
 @@ -3295,9 +3294,9 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
             break :result MCValue{ .register = reg };
         }
-        const optional_abi_size: u32 = @intCast(optional_ty.abiSize(pt));
+        const optional_abi_size: u32 = @intCast(optional_ty.abiSize(zcu));
-        const optional_abi_align = optional_ty.abiAlignment(pt);
+        const optional_abi_align = optional_ty.abiAlignment(zcu);
-        const offset: u32 = @intCast(payload_ty.abiSize(pt));
+        const offset: u32 = @intCast(payload_ty.abiSize(zcu));
         const stack_offset = try self.allocMem(optional_abi_size, optional_abi_align, inst);
         try self.genSetStack(payload_ty, stack_offset, operand);
 @@ -3312,20 +3311,20 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
 /// T to E!T
 fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const error_union_ty = ty_op.ty.toType();
-        const error_ty = error_union_ty.errorUnionSet(mod);
+        const error_ty = error_union_ty.errorUnionSet(zcu);
-        const payload_ty = error_union_ty.errorUnionPayload(mod);
+        const payload_ty = error_union_ty.errorUnionPayload(zcu);
         const operand = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result operand;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result operand;
-        const abi_size = @as(u32, @intCast(error_union_ty.abiSize(pt)));
+        const abi_size = @as(u32, @intCast(error_union_ty.abiSize(zcu)));
-        const abi_align = error_union_ty.abiAlignment(pt);
+        const abi_align = error_union_ty.abiAlignment(zcu);
         const stack_offset = try self.allocMem(abi_size, abi_align, inst);
-        const payload_off = errUnionPayloadOffset(payload_ty, pt);
+        const payload_off = errUnionPayloadOffset(payload_ty, zcu);
-        const err_off = errUnionErrorOffset(payload_ty, pt);
+        const err_off = errUnionErrorOffset(payload_ty, zcu);
         try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), operand);
         try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), .{ .immediate = 0 });
 @@ -3339,18 +3338,18 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const error_union_ty = ty_op.ty.toType();
-        const error_ty = error_union_ty.errorUnionSet(mod);
+        const error_ty = error_union_ty.errorUnionSet(zcu);
-        const payload_ty = error_union_ty.errorUnionPayload(mod);
+        const payload_ty = error_union_ty.errorUnionPayload(zcu);
         const operand = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result operand;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result operand;
-        const abi_size = @as(u32, @intCast(error_union_ty.abiSize(pt)));
+        const abi_size = @as(u32, @intCast(error_union_ty.abiSize(zcu)));
-        const abi_align = error_union_ty.abiAlignment(pt);
+        const abi_align = error_union_ty.abiAlignment(zcu);
         const stack_offset = try self.allocMem(abi_size, abi_align, inst);
-        const payload_off = errUnionPayloadOffset(payload_ty, pt);
+        const payload_off = errUnionPayloadOffset(payload_ty, zcu);
-        const err_off = errUnionErrorOffset(payload_ty, pt);
+        const err_off = errUnionErrorOffset(payload_ty, zcu);
         try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), operand);
         try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), .undef);
 @@ -3443,11 +3442,11 @@ fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const slice_ty = self.typeOf(bin_op.lhs);
-    const result: MCValue = if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
+    const result: MCValue = if (!slice_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) .dead else result: {
-        const ptr_ty = slice_ty.slicePtrFieldType(mod);
+        const ptr_ty = slice_ty.slicePtrFieldType(zcu);
         const slice_mcv = try self.resolveInst(bin_op.lhs);
         const base_mcv = slicePtr(slice_mcv);
 @@ -3468,9 +3467,9 @@ fn ptrElemVal(
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
-    const elem_size = @as(u32, @intCast(elem_ty.abiSize(pt)));
+    const elem_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));
     // TODO optimize for elem_sizes of 1, 2, 4, 8
     switch (elem_size) {
 @@ -3511,10 +3510,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr_ty = self.typeOf(bin_op.lhs);
-    const result: MCValue = if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {
+    const result: MCValue = if (!ptr_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) .dead else result: {
         const base_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };
         const index_bind: ReadArg.Bind = .{ .inst = bin_op.rhs };
 @@ -3635,9 +3634,9 @@ fn reuseOperand(
 fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     switch (ptr) {
         .none => unreachable,
 @@ -3884,16 +3883,16 @@ fn genInlineMemsetCode(
 fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const elem_ty = self.typeOfIndex(inst);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     const result: MCValue = result: {
-        if (!elem_ty.hasRuntimeBits(pt))
+        if (!elem_ty.hasRuntimeBits(zcu))
             break :result MCValue.none;
         const ptr = try self.resolveInst(ty_op.operand);
-        const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(mod);
+        const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(zcu);
         if (self.liveness.isUnused(inst) and !is_volatile)
             break :result MCValue.dead;
 @@ -3916,12 +3915,12 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
 fn genLdrRegister(self: *Self, value_reg: Register, addr_reg: Register, ty: Type) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(zcu);
     const tag: Mir.Inst.Tag = switch (abi_size) {
-        1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb_immediate else .ldrb_immediate,
+        1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb_immediate else .ldrb_immediate,
-        2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh_immediate else .ldrh_immediate,
+        2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh_immediate else .ldrh_immediate,
         4 => .ldr_immediate,
         8 => .ldr_immediate,
         3, 5, 6, 7 => return self.fail("TODO: genLdrRegister for more abi_sizes", .{}),
 @@ -3940,7 +3939,7 @@ fn genLdrRegister(self: *Self, value_reg: Register, addr_reg: Register, ty: Type
 fn genStrRegister(self: *Self, value_reg: Register, addr_reg: Register, ty: Type) !void {
     const pt = self.pt;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(pt.zcu);
     const tag: Mir.Inst.Tag = switch (abi_size) {
         1 => .strb_immediate,
 @@ -3963,7 +3962,7 @@ fn genStrRegister(self: *Self, value_reg: Register, addr_reg: Register, ty: Type
 fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {
     const pt = self.pt;
     log.debug("store: storing {} to {}", .{ value, ptr });
-    const abi_size = value_ty.abiSize(pt);
+    const abi_size = value_ty.abiSize(pt.zcu);
     switch (ptr) {
         .none => unreachable,
 @@ -4116,11 +4115,11 @@ fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
 fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {
     return if (self.liveness.isUnused(inst)) .dead else result: {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const mcv = try self.resolveInst(operand);
         const ptr_ty = self.typeOf(operand);
-        const struct_ty = ptr_ty.childType(mod);
+        const struct_ty = ptr_ty.childType(zcu);
-        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, pt)));
+        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, zcu)));
         switch (mcv) {
             .ptr_stack_offset => |off| {
                 break :result MCValue{ .ptr_stack_offset = off - struct_field_offset };
 @@ -4142,11 +4141,11 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
     const index = extra.field_index;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const mcv = try self.resolveInst(operand);
         const struct_ty = self.typeOf(operand);
-        const struct_field_ty = struct_ty.structFieldType(index, mod);
+        const struct_field_ty = struct_ty.fieldType(index, zcu);
-        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, pt)));
+        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, zcu)));
         switch (mcv) {
             .dead, .unreach => unreachable,
 @@ -4193,13 +4192,13 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const field_ptr = try self.resolveInst(extra.field_ptr);
-        const struct_ty = ty_pl.ty.toType().childType(mod);
+        const struct_ty = ty_pl.ty.toType().childType(zcu);
-        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(extra.field_index, pt)));
+        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(extra.field_index, zcu)));
         switch (field_ptr) {
             .ptr_stack_offset => |off| {
                 break :result MCValue{ .ptr_stack_offset = off + struct_field_offset };
 @@ -4274,12 +4273,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]));
     const ty = self.typeOf(callee);
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_ty = switch (ty.zigTypeTag(mod)) {
+    const fn_ty = switch (ty.zigTypeTag(zcu)) {
         .Fn => ty,
-        .Pointer => ty.childType(mod),
+        .Pointer => ty.childType(zcu),
         else => unreachable,
     };
 @@ -4298,9 +4297,9 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     if (info.return_value == .stack_offset) {
         log.debug("airCall: return by reference", .{});
-        const ret_ty = fn_ty.fnReturnType(mod);
+        const ret_ty = fn_ty.fnReturnType(zcu);
-        const ret_abi_size: u32 = @intCast(ret_ty.abiSize(pt));
+        const ret_abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
-        const ret_abi_align = ret_ty.abiAlignment(pt);
+        const ret_abi_align = ret_ty.abiAlignment(zcu);
         const stack_offset = try self.allocMem(ret_abi_size, ret_abi_align, inst);
         const ret_ptr_reg = self.registerAlias(.x0, Type.usize);
 @@ -4387,7 +4386,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
         },
         else => return self.fail("TODO implement calling bitcasted functions", .{}),
     } else {
-        assert(ty.zigTypeTag(mod) == .Pointer);
+        assert(ty.zigTypeTag(zcu) == .Pointer);
         const mcv = try self.resolveInst(callee);
         try self.genSetReg(ty, .x30, mcv);
 @@ -4426,15 +4425,15 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
 fn airRet(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try self.resolveInst(un_op);
-    const ret_ty = self.fn_type.fnReturnType(mod);
+    const ret_ty = self.fn_type.fnReturnType(zcu);
     switch (self.ret_mcv) {
         .none => {},
         .immediate => {
-            assert(ret_ty.isError(mod));
+            assert(ret_ty.isError(zcu));
         },
         .register => |reg| {
             // Return result by value
 @@ -4459,11 +4458,11 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
 fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const ptr = try self.resolveInst(un_op);
     const ptr_ty = self.typeOf(un_op);
-    const ret_ty = self.fn_type.fnReturnType(mod);
+    const ret_ty = self.fn_type.fnReturnType(zcu);
     switch (self.ret_mcv) {
         .none => {},
 @@ -4483,8 +4482,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
             // location.
             const op_inst = un_op.toIndex().?;
             if (self.air.instructions.items(.tag)[@intFromEnum(op_inst)] != .ret_ptr) {
-                const abi_size = @as(u32, @intCast(ret_ty.abiSize(pt)));
+                const abi_size = @as(u32, @intCast(ret_ty.abiSize(zcu)));
-                const abi_align = ret_ty.abiAlignment(pt);
+                const abi_align = ret_ty.abiAlignment(zcu);
                 const offset = try self.allocMem(abi_size, abi_align, null);
 @@ -4520,20 +4519,20 @@ fn cmp(
     op: math.CompareOperator,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const int_ty = switch (lhs_ty.zigTypeTag(mod)) {
+    const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
         .Optional => blk: {
-            const payload_ty = lhs_ty.optionalChild(mod);
+            const payload_ty = lhs_ty.optionalChild(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 break :blk Type.u1;
-            } else if (lhs_ty.isPtrLikeOptional(mod)) {
+            } else if (lhs_ty.isPtrLikeOptional(zcu)) {
                 break :blk Type.usize;
             } else {
                 return self.fail("TODO ARM cmp non-pointer optionals", .{});
             }
         },
         .Float => return self.fail("TODO ARM cmp floats", .{}),
-        .Enum => lhs_ty.intTagType(mod),
+        .Enum => lhs_ty.intTagType(zcu),
         .Int => lhs_ty,
         .Bool => Type.u1,
         .Pointer => Type.usize,
 @@ -4541,7 +4540,7 @@ fn cmp(
         else => unreachable,
     };
-    const int_info = int_ty.intInfo(mod);
+    const int_info = int_ty.intInfo(zcu);
     if (int_info.bits <= 64) {
         try self.spillCompareFlagsIfOccupied();
 @@ -4628,10 +4627,10 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
 fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
-    const func = mod.funcInfo(extra.data.func);
+    const func = zcu.funcInfo(extra.data.func);
     // TODO emit debug info for function change
     _ = func;
     try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
 @@ -4834,13 +4833,13 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
 fn isNull(self: *Self, operand_bind: ReadArg.Bind, operand_ty: Type) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const sentinel: struct { ty: Type, bind: ReadArg.Bind } = if (!operand_ty.isPtrLikeOptional(mod)) blk: {
+    const sentinel: struct { ty: Type, bind: ReadArg.Bind } = if (!operand_ty.isPtrLikeOptional(zcu)) blk: {
-        const payload_ty = operand_ty.optionalChild(mod);
+        const payload_ty = operand_ty.optionalChild(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt))
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
             break :blk .{ .ty = operand_ty, .bind = operand_bind };
-        const offset = @as(u32, @intCast(payload_ty.abiSize(pt)));
+        const offset = @as(u32, @intCast(payload_ty.abiSize(zcu)));
         const operand_mcv = try operand_bind.resolveToMcv(self);
         const new_mcv: MCValue = switch (operand_mcv) {
             .register => |source_reg| new: {
 @@ -4853,7 +4852,7 @@ fn isNull(self: *Self, operand_bind: ReadArg.Bind, operand_ty: Type) !MCValue {
                     try self.genSetReg(payload_ty, dest_reg, operand_mcv);
                 } else {
                     _ = try self.addInst(.{
-                        .tag = if (payload_ty.isSignedInt(mod))
+                        .tag = if (payload_ty.isSignedInt(zcu))
                             Mir.Inst.Tag.asr_immediate
                         else
                             Mir.Inst.Tag.lsr_immediate,
 @@ -4891,10 +4890,10 @@ fn isErr(
     error_union_ty: Type,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const error_type = error_union_ty.errorUnionSet(mod);
+    const error_type = error_union_ty.errorUnionSet(zcu);
-    if (error_type.errorSetIsEmpty(mod)) {
+    if (error_type.errorSetIsEmpty(zcu)) {
         return MCValue{ .immediate = 0 }; // always false
     }
 @@ -4934,12 +4933,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
 fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand_ptr = try self.resolveInst(un_op);
         const ptr_ty = self.typeOf(un_op);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4962,12 +4961,12 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
 fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand_ptr = try self.resolveInst(un_op);
         const ptr_ty = self.typeOf(un_op);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4990,12 +4989,12 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
 fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand_ptr = try self.resolveInst(un_op);
         const ptr_ty = self.typeOf(un_op);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -5018,12 +5017,12 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
 fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand_ptr = try self.resolveInst(un_op);
         const ptr_ty = self.typeOf(un_op);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -5240,9 +5239,10 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
 fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
     const pt = self.pt;
+    const zcu = pt.zcu;
     const block_data = self.blocks.getPtr(block).?;
-    if (self.typeOf(operand).hasRuntimeBits(pt)) {
+    if (self.typeOf(operand).hasRuntimeBits(zcu)) {
         const operand_mcv = try self.resolveInst(operand);
         const block_mcv = block_data.mcv;
         if (block_mcv == .none) {
 @@ -5417,8 +5417,8 @@ fn setRegOrMem(self: *Self, ty: Type, loc: MCValue, val: MCValue) !void {
 fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = @as(u32, @intCast(ty.abiSize(pt)));
+    const abi_size = @as(u32, @intCast(ty.abiSize(zcu)));
     switch (mcv) {
         .dead => unreachable,
         .unreach, .none => return, // Nothing to do.
 @@ -5473,11 +5473,11 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
             const reg_lock = self.register_manager.lockReg(rwo.reg);
             defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
-            const wrapped_ty = ty.structFieldType(0, mod);
+            const wrapped_ty = ty.fieldType(0, zcu);
             try self.genSetStack(wrapped_ty, stack_offset, .{ .register = rwo.reg });
-            const overflow_bit_ty = ty.structFieldType(1, mod);
+            const overflow_bit_ty = ty.fieldType(1, zcu);
-            const overflow_bit_offset = @as(u32, @intCast(ty.structFieldOffset(1, pt)));
+            const overflow_bit_offset = @as(u32, @intCast(ty.structFieldOffset(1, zcu)));
             const raw_cond_reg = try self.register_manager.allocReg(null, gp);
             const cond_reg = self.registerAlias(raw_cond_reg, overflow_bit_ty);
 @@ -5589,7 +5589,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
 fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     switch (mcv) {
         .dead => unreachable,
         .unreach, .none => return, // Nothing to do.
 @@ -5701,13 +5701,13 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
             try self.genLdrRegister(reg, reg.toX(), ty);
         },
         .stack_offset => |off| {
-            const abi_size = ty.abiSize(pt);
+            const abi_size = ty.abiSize(zcu);
             switch (abi_size) {
                 1, 2, 4, 8 => {
                     const tag: Mir.Inst.Tag = switch (abi_size) {
-                        1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb_stack else .ldrb_stack,
+                        1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb_stack else .ldrb_stack,
-                        2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh_stack else .ldrh_stack,
+                        2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh_stack else .ldrh_stack,
                         4, 8 => .ldr_stack,
                         else => unreachable, // unexpected abi size
                     };
 @@ -5725,13 +5725,13 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
             }
         },
         .stack_argument_offset => |off| {
-            const abi_size = ty.abiSize(pt);
+            const abi_size = ty.abiSize(zcu);
             switch (abi_size) {
                 1, 2, 4, 8 => {
                     const tag: Mir.Inst.Tag = switch (abi_size) {
-                        1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb_stack_argument else .ldrb_stack_argument,
+                        1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb_stack_argument else .ldrb_stack_argument,
-                        2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh_stack_argument else .ldrh_stack_argument,
+                        2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh_stack_argument else .ldrh_stack_argument,
                         4, 8 => .ldr_stack_argument,
                         else => unreachable, // unexpected abi size
                     };
 @@ -5753,7 +5753,8 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
 fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const abi_size = @as(u32, @intCast(ty.abiSize(pt)));
+    const zcu = pt.zcu;
+    const abi_size = @as(u32, @intCast(ty.abiSize(zcu)));
     switch (mcv) {
         .dead => unreachable,
         .none, .unreach => return,
 @@ -5761,7 +5762,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
             if (!self.wantSafety())
                 return; // The already existing value will do just fine.
             // TODO Upgrade this to a memset call when we have that available.
-            switch (ty.abiSize(pt)) {
+            switch (ty.abiSize(pt.zcu)) {
                 1 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaa }),
                 2 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaa }),
                 4 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
 @@ -5953,13 +5954,13 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
 fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const ptr_ty = self.typeOf(ty_op.operand);
         const ptr = try self.resolveInst(ty_op.operand);
-        const array_ty = ptr_ty.childType(mod);
+        const array_ty = ptr_ty.childType(zcu);
-        const array_len = @as(u32, @intCast(array_ty.arrayLen(mod)));
+        const array_len = @as(u32, @intCast(array_ty.arrayLen(zcu)));
         const ptr_bytes = 8;
         const stack_offset = try self.allocMem(ptr_bytes * 2, .@"8", inst);
         try self.genSetStack(ptr_ty, stack_offset, ptr);
 @@ -6074,9 +6075,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const vector_ty = self.typeOfIndex(inst);
-    const len = vector_ty.vectorLen(mod);
+    const len = vector_ty.vectorLen(zcu);
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
     const result: MCValue = res: {
 @@ -6125,8 +6126,8 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
     const result: MCValue = result: {
         const error_union_bind: ReadArg.Bind = .{ .inst = pl_op.operand };
         const error_union_ty = self.typeOf(pl_op.operand);
-        const error_union_size = @as(u32, @intCast(error_union_ty.abiSize(pt)));
+        const error_union_size = @as(u32, @intCast(error_union_ty.abiSize(pt.zcu)));
-        const error_union_align = error_union_ty.abiAlignment(pt);
+        const error_union_align = error_union_ty.abiAlignment(pt.zcu);
         // The error union will die in the body. However, we need the
         // error union after the body in order to extract the payload
 @@ -6156,11 +6157,11 @@ fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // If the type has no codegen bits, no need to store it.
     const inst_ty = self.typeOf(inst);
-    if (!inst_ty.hasRuntimeBitsIgnoreComptime(pt) and !inst_ty.isError(mod))
+    if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu) and !inst_ty.isError(zcu))
         return MCValue{ .none = {} };
     const inst_index = inst.toIndex() orelse return self.genTypedValue((try self.air.value(inst, pt)).?);
 @@ -6220,9 +6221,9 @@ const CallMCValues = struct {
 /// Caller must call `CallMCValues.deinit`.
 fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_info = mod.typeToFunc(fn_ty).?;
+    const fn_info = zcu.typeToFunc(fn_ty).?;
     const cc = fn_info.cc;
     var result: CallMCValues = .{
         .args = try self.gpa.alloc(MCValue, fn_info.param_types.len),
 @@ -6233,7 +6234,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
     };
     errdefer self.gpa.free(result.args);
-    const ret_ty = fn_ty.fnReturnType(mod);
+    const ret_ty = fn_ty.fnReturnType(zcu);
     switch (cc) {
         .Naked => {
 @@ -6248,14 +6249,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             var ncrn: usize = 0; // Next Core Register Number
             var nsaa: u32 = 0; // Next stacked argument address
-            if (ret_ty.zigTypeTag(mod) == .NoReturn) {
+            if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = .{ .unreach = {} };
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt) and !ret_ty.isError(mod)) {
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
                 result.return_value = .{ .none = {} };
             } else {
-                const ret_ty_size: u32 = @intCast(ret_ty.abiSize(pt));
+                const ret_ty_size: u32 = @intCast(ret_ty.abiSize(zcu));
                 if (ret_ty_size == 0) {
-                    assert(ret_ty.isError(mod));
+                    assert(ret_ty.isError(zcu));
                     result.return_value = .{ .immediate = 0 };
                 } else if (ret_ty_size <= 8) {
                     result.return_value = .{ .register = self.registerAlias(c_abi_int_return_regs[0], ret_ty) };
 @@ -6265,7 +6266,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             }
             for (fn_info.param_types.get(ip), result.args) |ty, *result_arg| {
-                const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(pt)));
+                const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(zcu)));
                 if (param_size == 0) {
                     result_arg.* = .{ .none = {} };
                     continue;
 @@ -6273,7 +6274,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                 // We round up NCRN only for non-Apple platforms which allow the 16-byte aligned
                 // values to spread across odd-numbered registers.
-                if (Type.fromInterned(ty).abiAlignment(pt) == .@"16" and !self.target.isDarwin()) {
+                if (Type.fromInterned(ty).abiAlignment(zcu) == .@"16" and !self.target.isDarwin()) {
                     // Round up NCRN to the next even number
                     ncrn += ncrn % 2;
                 }
 @@ -6291,7 +6292,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                     ncrn = 8;
                     // TODO Apple allows the arguments on the stack to be non-8-byte aligned provided
                     // that the entire stack space consumed by the arguments is 8-byte aligned.
-                    if (Type.fromInterned(ty).abiAlignment(pt) == .@"8") {
+                    if (Type.fromInterned(ty).abiAlignment(zcu) == .@"8") {
                         if (nsaa % 8 != 0) {
                             nsaa += 8 - (nsaa % 8);
                         }
 @@ -6306,14 +6307,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             result.stack_align = 16;
         },
         .Unspecified => {
-            if (ret_ty.zigTypeTag(mod) == .NoReturn) {
+            if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = .{ .unreach = {} };
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt) and !ret_ty.isError(mod)) {
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
                 result.return_value = .{ .none = {} };
             } else {
-                const ret_ty_size = @as(u32, @intCast(ret_ty.abiSize(pt)));
+                const ret_ty_size = @as(u32, @intCast(ret_ty.abiSize(zcu)));
                 if (ret_ty_size == 0) {
-                    assert(ret_ty.isError(mod));
+                    assert(ret_ty.isError(zcu));
                     result.return_value = .{ .immediate = 0 };
                 } else if (ret_ty_size <= 8) {
                     result.return_value = .{ .register = self.registerAlias(.x0, ret_ty) };
 @@ -6330,9 +6331,9 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             var stack_offset: u32 = 0;
             for (fn_info.param_types.get(ip), result.args) |ty, *result_arg| {
-                if (Type.fromInterned(ty).abiSize(pt) > 0) {
+                if (Type.fromInterned(ty).abiSize(zcu) > 0) {
-                    const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(pt));
+                    const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(zcu));
-                    const param_alignment = Type.fromInterned(ty).abiAlignment(pt);
+                    const param_alignment = Type.fromInterned(ty).abiAlignment(zcu);
                     stack_offset = @intCast(param_alignment.forward(stack_offset));
                     result_arg.* = .{ .stack_argument_offset = stack_offset };
 @@ -6383,7 +6384,7 @@ fn parseRegName(name: []const u8) ?Register {
 }
 fn registerAlias(self: *Self, reg: Register, ty: Type) Register {
-    const abi_size = ty.abiSize(self.pt);
+    const abi_size = ty.abiSize(self.pt.zcu);
     switch (reg.class()) {
         .general_purpose => {

src/arch/aarch64/abi.zig+14-14

...	@@ -15,44 +15,44 @@ pub const Class = union(enum) {	...	@@ -15,44 +15,44 @@ pub const Class = union(enum) {
15	};	15	};
16		16
17	/// For `float_array` the second element will be the amount of floats.	17	/// For `float_array` the second element will be the amount of floats.
18	pub fn classifyType(ty: Type, pt: Zcu.PerThread) Class {	18	pub fn classifyType(ty: Type, zcu: *Zcu) Class {
19	std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(pt));	19	std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
20		20
21	var maybe_float_bits: ?u16 = null;	21	var maybe_float_bits: ?u16 = null;
22	switch (ty.zigTypeTag(pt.zcu)) {	22	switch (ty.zigTypeTag(zcu)) {
23	.Struct => {	23	.Struct => {
24	if (ty.containerLayout(pt.zcu) == .@"packed") return .byval;	24	if (ty.containerLayout(zcu) == .@"packed") return .byval;
25	const float_count = countFloats(ty, pt.zcu, &maybe_float_bits);	25	const float_count = countFloats(ty, zcu, &maybe_float_bits);
26	if (float_count <= sret_float_count) return .{ .float_array = float_count };	26	if (float_count <= sret_float_count) return .{ .float_array = float_count };
27		27
28	const bit_size = ty.bitSize(pt);	28	const bit_size = ty.bitSize(zcu);
29	if (bit_size > 128) return .memory;	29	if (bit_size > 128) return .memory;
30	if (bit_size > 64) return .double_integer;	30	if (bit_size > 64) return .double_integer;
31	return .integer;	31	return .integer;
32	},	32	},
33	.Union => {	33	.Union => {
34	if (ty.containerLayout(pt.zcu) == .@"packed") return .byval;	34	if (ty.containerLayout(zcu) == .@"packed") return .byval;
35	const float_count = countFloats(ty, pt.zcu, &maybe_float_bits);	35	const float_count = countFloats(ty, zcu, &maybe_float_bits);
36	if (float_count <= sret_float_count) return .{ .float_array = float_count };	36	if (float_count <= sret_float_count) return .{ .float_array = float_count };
37		37
38	const bit_size = ty.bitSize(pt);	38	const bit_size = ty.bitSize(zcu);
39	if (bit_size > 128) return .memory;	39	if (bit_size > 128) return .memory;
40	if (bit_size > 64) return .double_integer;	40	if (bit_size > 64) return .double_integer;
41	return .integer;	41	return .integer;
42	},	42	},
43	.Int, .Enum, .ErrorSet, .Float, .Bool => return .byval,	43	.Int, .Enum, .ErrorSet, .Float, .Bool => return .byval,
44	.Vector => {	44	.Vector => {
45	const bit_size = ty.bitSize(pt);	45	const bit_size = ty.bitSize(zcu);
46	// TODO is this controlled by a cpu feature?	46	// TODO is this controlled by a cpu feature?
47	if (bit_size > 128) return .memory;	47	if (bit_size > 128) return .memory;
48	return .byval;	48	return .byval;
49	},	49	},
50	.Optional => {	50	.Optional => {
51	std.debug.assert(ty.isPtrLikeOptional(pt.zcu));	51	std.debug.assert(ty.isPtrLikeOptional(zcu));
52	return .byval;	52	return .byval;
53	},	53	},
54	.Pointer => {	54	.Pointer => {
55	std.debug.assert(!ty.isSlice(pt.zcu));	55	std.debug.assert(!ty.isSlice(zcu));
56	return .byval;	56	return .byval;
57	},	57	},
58	.ErrorUnion,	58	.ErrorUnion,
...	@@ -95,7 +95,7 @@ fn countFloats(ty: Type, zcu: Zcu, maybe_float_bits: ?u16) u8 {	...	@@ -95,7 +95,7 @@ fn countFloats(ty: Type, zcu: Zcu, maybe_float_bits: ?u16) u8 {
95	var count: u8 = 0;	95	var count: u8 = 0;
96	var i: u32 = 0;	96	var i: u32 = 0;
97	while (i < fields_len) : (i += 1) {	97	while (i < fields_len) : (i += 1) {
98	const field_ty = ty.structFieldType(i, zcu);	98	const field_ty = ty.fieldType(i, zcu);
99	const field_count = countFloats(field_ty, zcu, maybe_float_bits);	99	const field_count = countFloats(field_ty, zcu, maybe_float_bits);
100	if (field_count == invalid) return invalid;	100	if (field_count == invalid) return invalid;
101	count += field_count;	101	count += field_count;
...	@@ -130,7 +130,7 @@ pub fn getFloatArrayType(ty: Type, zcu: *Zcu) ?Type {	...	@@ -130,7 +130,7 @@ pub fn getFloatArrayType(ty: Type, zcu: *Zcu) ?Type {
130	const fields_len = ty.structFieldCount(zcu);	130	const fields_len = ty.structFieldCount(zcu);
131	var i: u32 = 0;	131	var i: u32 = 0;
132	while (i < fields_len) : (i += 1) {	132	while (i < fields_len) : (i += 1) {
133	const field_ty = ty.structFieldType(i, zcu);	133	const field_ty = ty.fieldType(i, zcu);
134	if (getFloatArrayType(field_ty, zcu)) \|some\| return some;	134	if (getFloatArrayType(field_ty, zcu)) \|some\| return some;
135	}	135	}
136	return null;	136	return null;

src/arch/arm/CodeGen.zig+252-252

...	@@ -474,8 +474,8 @@ pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {	...	@@ -474,8 +474,8 @@ pub fn addExtraAssumeCapacity(self: *Self, extra: anytype) u32 {
474		474
475	fn gen(self: *Self) !void {	475	fn gen(self: *Self) !void {
476	const pt = self.pt;	476	const pt = self.pt;
477	const mod = pt.zcu;	477	const zcu = pt.zcu;
478	const cc = self.fn_type.fnCallingConvention(mod);	478	const cc = self.fn_type.fnCallingConvention(zcu);
479	if (cc != .Naked) {	479	if (cc != .Naked) {
480	// push {fp, lr}	480	// push {fp, lr}
481	const push_reloc = try self.addNop();	481	const push_reloc = try self.addNop();
...	@@ -518,8 +518,8 @@ fn gen(self: *Self) !void {	...	@@ -518,8 +518,8 @@ fn gen(self: *Self) !void {
518		518
519	const ty = self.typeOfIndex(inst);	519	const ty = self.typeOfIndex(inst);
520		520
521	const abi_size: u32 = @intCast(ty.abiSize(pt));	521	const abi_size: u32 = @intCast(ty.abiSize(zcu));
522	const abi_align = ty.abiAlignment(pt);	522	const abi_align = ty.abiAlignment(zcu);
523	const stack_offset = try self.allocMem(abi_size, abi_align, inst);	523	const stack_offset = try self.allocMem(abi_size, abi_align, inst);
524	try self.genSetStack(ty, stack_offset, MCValue{ .register = reg });	524	try self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
525		525
...	@@ -635,8 +635,8 @@ fn gen(self: *Self) !void {	...	@@ -635,8 +635,8 @@ fn gen(self: *Self) !void {
635		635
636	fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {	636	fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
637	const pt = self.pt;	637	const pt = self.pt;
638	const mod = pt.zcu;	638	const zcu = pt.zcu;
639	const ip = &mod.intern_pool;	639	const ip = &zcu.intern_pool;
640	const air_tags = self.air.instructions.items(.tag);	640	const air_tags = self.air.instructions.items(.tag);
641		641
642	for (body) \|inst\| {	642	for (body) \|inst\| {
...	@@ -999,10 +999,10 @@ fn allocMem(	...	@@ -999,10 +999,10 @@ fn allocMem(
999	/// Use a pointer instruction as the basis for allocating stack memory.	999	/// Use a pointer instruction as the basis for allocating stack memory.
1000	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {	1000	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
1001	const pt = self.pt;	1001	const pt = self.pt;
1002	const mod = pt.zcu;	1002	const zcu = pt.zcu;
1003	const elem_ty = self.typeOfIndex(inst).childType(mod);	1003	const elem_ty = self.typeOfIndex(inst).childType(zcu);
1004		1004
1005	if (!elem_ty.hasRuntimeBits(pt)) {	1005	if (!elem_ty.hasRuntimeBits(zcu)) {
1006	// As this stack item will never be dereferenced at runtime,	1006	// As this stack item will never be dereferenced at runtime,
1007	// return the stack offset 0. Stack offset 0 will be where all	1007	// return the stack offset 0. Stack offset 0 will be where all
1008	// zero-sized stack allocations live as non-zero-sized	1008	// zero-sized stack allocations live as non-zero-sized
...	@@ -1010,21 +1010,21 @@ fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {	...	@@ -1010,21 +1010,21 @@ fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
1010	return 0;	1010	return 0;
1011	}	1011	}
1012		1012
1013	const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {	1013	const abi_size = math.cast(u32, elem_ty.abiSize(zcu)) orelse {
1014	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});	1014	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
1015	};	1015	};
1016	// TODO swap this for inst.ty.ptrAlign	1016	// TODO swap this for inst.ty.ptrAlign
1017	const abi_align = elem_ty.abiAlignment(pt);	1017	const abi_align = elem_ty.abiAlignment(zcu);
1018		1018
1019	return self.allocMem(abi_size, abi_align, inst);	1019	return self.allocMem(abi_size, abi_align, inst);
1020	}	1020	}
1021		1021
1022	fn allocRegOrMem(self: *Self, elem_ty: Type, reg_ok: bool, maybe_inst: ?Air.Inst.Index) !MCValue {	1022	fn allocRegOrMem(self: *Self, elem_ty: Type, reg_ok: bool, maybe_inst: ?Air.Inst.Index) !MCValue {
1023	const pt = self.pt;	1023	const pt = self.pt;
1024	const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {	1024	const abi_size = math.cast(u32, elem_ty.abiSize(pt.zcu)) orelse {
1025	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});	1025	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
1026	};	1026	};
1027	const abi_align = elem_ty.abiAlignment(pt);	1027	const abi_align = elem_ty.abiAlignment(pt.zcu);
1028		1028
1029	if (reg_ok) {	1029	if (reg_ok) {
1030	// Make sure the type can fit in a register before we try to allocate one.	1030	// Make sure the type can fit in a register before we try to allocate one.
...	@@ -1108,13 +1108,13 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1108,13 +1108,13 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
1108		1108
1109	fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {	1109	fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
1110	const pt = self.pt;	1110	const pt = self.pt;
1111	const mod = pt.zcu;	1111	const zcu = pt.zcu;
1112	const result: MCValue = switch (self.ret_mcv) {	1112	const result: MCValue = switch (self.ret_mcv) {
1113	.none, .register => .{ .ptr_stack_offset = try self.allocMemPtr(inst) },	1113	.none, .register => .{ .ptr_stack_offset = try self.allocMemPtr(inst) },
1114	.stack_offset => blk: {	1114	.stack_offset => blk: {
1115	// self.ret_mcv is an address to where this function	1115	// self.ret_mcv is an address to where this function
1116	// should store its result into	1116	// should store its result into
1117	const ret_ty = self.fn_type.fnReturnType(mod);	1117	const ret_ty = self.fn_type.fnReturnType(zcu);
1118	const ptr_ty = try pt.singleMutPtrType(ret_ty);	1118	const ptr_ty = try pt.singleMutPtrType(ret_ty);
1119		1119
1120	// addr_reg will contain the address of where to store the	1120	// addr_reg will contain the address of where to store the
...	@@ -1142,7 +1142,7 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1142,7 +1142,7 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
1142		1142
1143	fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {	1143	fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
1144	const pt = self.pt;	1144	const pt = self.pt;
1145	const mod = pt.zcu;	1145	const zcu = pt.zcu;
1146	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1146	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1147	if (self.liveness.isUnused(inst))	1147	if (self.liveness.isUnused(inst))
1148	return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });	1148	return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
...	@@ -1151,10 +1151,10 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1151,10 +1151,10 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
1151	const operand_ty = self.typeOf(ty_op.operand);	1151	const operand_ty = self.typeOf(ty_op.operand);
1152	const dest_ty = self.typeOfIndex(inst);	1152	const dest_ty = self.typeOfIndex(inst);
1153		1153
1154	const operand_abi_size = operand_ty.abiSize(pt);	1154	const operand_abi_size = operand_ty.abiSize(zcu);
1155	const dest_abi_size = dest_ty.abiSize(pt);	1155	const dest_abi_size = dest_ty.abiSize(zcu);
1156	const info_a = operand_ty.intInfo(mod);	1156	const info_a = operand_ty.intInfo(zcu);
1157	const info_b = dest_ty.intInfo(mod);	1157	const info_b = dest_ty.intInfo(zcu);
1158		1158
1159	const dst_mcv: MCValue = blk: {	1159	const dst_mcv: MCValue = blk: {
1160	if (info_a.bits == info_b.bits) {	1160	if (info_a.bits == info_b.bits) {
...	@@ -1209,9 +1209,9 @@ fn trunc(	...	@@ -1209,9 +1209,9 @@ fn trunc(
1209	dest_ty: Type,	1209	dest_ty: Type,
1210	) !MCValue {	1210	) !MCValue {
1211	const pt = self.pt;	1211	const pt = self.pt;
1212	const mod = pt.zcu;	1212	const zcu = pt.zcu;
1213	const info_a = operand_ty.intInfo(mod);	1213	const info_a = operand_ty.intInfo(zcu);
1214	const info_b = dest_ty.intInfo(mod);	1214	const info_b = dest_ty.intInfo(zcu);
1215		1215
1216	if (info_b.bits <= 32) {	1216	if (info_b.bits <= 32) {
1217	if (info_a.bits > 32) {	1217	if (info_a.bits > 32) {
...	@@ -1274,7 +1274,7 @@ fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1274,7 +1274,7 @@ fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
1274	fn airNot(self: *Self, inst: Air.Inst.Index) !void {	1274	fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1275	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	1275	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
1276	const pt = self.pt;	1276	const pt = self.pt;
1277	const mod = pt.zcu;	1277	const zcu = pt.zcu;
1278	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	1278	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1279	const operand_bind: ReadArg.Bind = .{ .inst = ty_op.operand };	1279	const operand_bind: ReadArg.Bind = .{ .inst = ty_op.operand };
1280	const operand_ty = self.typeOf(ty_op.operand);	1280	const operand_ty = self.typeOf(ty_op.operand);
...	@@ -1283,7 +1283,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1283,7 +1283,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1283	.unreach => unreachable,	1283	.unreach => unreachable,
1284	.cpsr_flags => \|cond\| break :result MCValue{ .cpsr_flags = cond.negate() },	1284	.cpsr_flags => \|cond\| break :result MCValue{ .cpsr_flags = cond.negate() },
1285	else => {	1285	else => {
1286	switch (operand_ty.zigTypeTag(mod)) {	1286	switch (operand_ty.zigTypeTag(zcu)) {
1287	.Bool => {	1287	.Bool => {
1288	var op_reg: Register = undefined;	1288	var op_reg: Register = undefined;
1289	var dest_reg: Register = undefined;	1289	var dest_reg: Register = undefined;
...	@@ -1316,7 +1316,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1316,7 +1316,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
1316	},	1316	},
1317	.Vector => return self.fail("TODO bitwise not for vectors", .{}),	1317	.Vector => return self.fail("TODO bitwise not for vectors", .{}),
1318	.Int => {	1318	.Int => {
1319	const int_info = operand_ty.intInfo(mod);	1319	const int_info = operand_ty.intInfo(zcu);
1320	if (int_info.bits <= 32) {	1320	if (int_info.bits <= 32) {
1321	var op_reg: Register = undefined;	1321	var op_reg: Register = undefined;
1322	var dest_reg: Register = undefined;	1322	var dest_reg: Register = undefined;
...	@@ -1371,13 +1371,13 @@ fn minMax(	...	@@ -1371,13 +1371,13 @@ fn minMax(
1371	maybe_inst: ?Air.Inst.Index,	1371	maybe_inst: ?Air.Inst.Index,
1372	) !MCValue {	1372	) !MCValue {
1373	const pt = self.pt;	1373	const pt = self.pt;
1374	const mod = pt.zcu;	1374	const zcu = pt.zcu;
1375	switch (lhs_ty.zigTypeTag(mod)) {	1375	switch (lhs_ty.zigTypeTag(zcu)) {
1376	.Float => return self.fail("TODO ARM min/max on floats", .{}),	1376	.Float => return self.fail("TODO ARM min/max on floats", .{}),
1377	.Vector => return self.fail("TODO ARM min/max on vectors", .{}),	1377	.Vector => return self.fail("TODO ARM min/max on vectors", .{}),
1378	.Int => {	1378	.Int => {
1379	assert(lhs_ty.eql(rhs_ty, mod));	1379	assert(lhs_ty.eql(rhs_ty, zcu));
1380	const int_info = lhs_ty.intInfo(mod);	1380	const int_info = lhs_ty.intInfo(zcu);
1381	if (int_info.bits <= 32) {	1381	if (int_info.bits <= 32) {
1382	var lhs_reg: Register = undefined;	1382	var lhs_reg: Register = undefined;
1383	var rhs_reg: Register = undefined;	1383	var rhs_reg: Register = undefined;
...	@@ -1581,7 +1581,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1581,7 +1581,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
1581	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	1581	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
1582	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;	1582	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1583	const pt = self.pt;	1583	const pt = self.pt;
1584	const mod = pt.zcu;	1584	const zcu = pt.zcu;
1585	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	1585	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1586	const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };	1586	const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };
1587	const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };	1587	const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };
...	@@ -1589,15 +1589,15 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1589,15 +1589,15 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
1589	const rhs_ty = self.typeOf(extra.rhs);	1589	const rhs_ty = self.typeOf(extra.rhs);
1590		1590
1591	const tuple_ty = self.typeOfIndex(inst);	1591	const tuple_ty = self.typeOfIndex(inst);
1592	const tuple_size: u32 = @intCast(tuple_ty.abiSize(pt));	1592	const tuple_size: u32 = @intCast(tuple_ty.abiSize(zcu));
1593	const tuple_align = tuple_ty.abiAlignment(pt);	1593	const tuple_align = tuple_ty.abiAlignment(zcu);
1594	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, pt));	1594	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, zcu));
1595		1595
1596	switch (lhs_ty.zigTypeTag(mod)) {	1596	switch (lhs_ty.zigTypeTag(zcu)) {
1597	.Vector => return self.fail("TODO implement add_with_overflow/sub_with_overflow for vectors", .{}),	1597	.Vector => return self.fail("TODO implement add_with_overflow/sub_with_overflow for vectors", .{}),
1598	.Int => {	1598	.Int => {
1599	assert(lhs_ty.eql(rhs_ty, mod));	1599	assert(lhs_ty.eql(rhs_ty, zcu));
1600	const int_info = lhs_ty.intInfo(mod);	1600	const int_info = lhs_ty.intInfo(zcu);
1601	if (int_info.bits < 32) {	1601	if (int_info.bits < 32) {
1602	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);	1602	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
1603		1603
...	@@ -1695,7 +1695,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1695,7 +1695,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1695	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;	1695	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1696	if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });	1696	if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
1697	const pt = self.pt;	1697	const pt = self.pt;
1698	const mod = pt.zcu;	1698	const zcu = pt.zcu;
1699	const result: MCValue = result: {	1699	const result: MCValue = result: {
1700	const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };	1700	const lhs_bind: ReadArg.Bind = .{ .inst = extra.lhs };
1701	const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };	1701	const rhs_bind: ReadArg.Bind = .{ .inst = extra.rhs };
...	@@ -1703,15 +1703,15 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1703,15 +1703,15 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1703	const rhs_ty = self.typeOf(extra.rhs);	1703	const rhs_ty = self.typeOf(extra.rhs);
1704		1704
1705	const tuple_ty = self.typeOfIndex(inst);	1705	const tuple_ty = self.typeOfIndex(inst);
1706	const tuple_size: u32 = @intCast(tuple_ty.abiSize(pt));	1706	const tuple_size: u32 = @intCast(tuple_ty.abiSize(zcu));
1707	const tuple_align = tuple_ty.abiAlignment(pt);	1707	const tuple_align = tuple_ty.abiAlignment(zcu);
1708	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, pt));	1708	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, zcu));
1709		1709
1710	switch (lhs_ty.zigTypeTag(mod)) {	1710	switch (lhs_ty.zigTypeTag(zcu)) {
1711	.Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),	1711	.Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
1712	.Int => {	1712	.Int => {
1713	assert(lhs_ty.eql(rhs_ty, mod));	1713	assert(lhs_ty.eql(rhs_ty, zcu));
1714	const int_info = lhs_ty.intInfo(mod);	1714	const int_info = lhs_ty.intInfo(zcu);
1715	if (int_info.bits <= 16) {	1715	if (int_info.bits <= 16) {
1716	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);	1716	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
1717		1717
...	@@ -1860,20 +1860,20 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -1860,20 +1860,20 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
1860	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;	1860	const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1861	if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });	1861	if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ extra.lhs, extra.rhs, .none });
1862	const pt = self.pt;	1862	const pt = self.pt;
1863	const mod = pt.zcu;	1863	const zcu = pt.zcu;
1864	const result: MCValue = result: {	1864	const result: MCValue = result: {
1865	const lhs_ty = self.typeOf(extra.lhs);	1865	const lhs_ty = self.typeOf(extra.lhs);
1866	const rhs_ty = self.typeOf(extra.rhs);	1866	const rhs_ty = self.typeOf(extra.rhs);
1867		1867
1868	const tuple_ty = self.typeOfIndex(inst);	1868	const tuple_ty = self.typeOfIndex(inst);
1869	const tuple_size: u32 = @intCast(tuple_ty.abiSize(pt));	1869	const tuple_size: u32 = @intCast(tuple_ty.abiSize(zcu));
1870	const tuple_align = tuple_ty.abiAlignment(pt);	1870	const tuple_align = tuple_ty.abiAlignment(zcu);
1871	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, pt));	1871	const overflow_bit_offset: u32 = @intCast(tuple_ty.structFieldOffset(1, zcu));
1872		1872
1873	switch (lhs_ty.zigTypeTag(mod)) {	1873	switch (lhs_ty.zigTypeTag(zcu)) {
1874	.Vector => return self.fail("TODO implement shl_with_overflow for vectors", .{}),	1874	.Vector => return self.fail("TODO implement shl_with_overflow for vectors", .{}),
1875	.Int => {	1875	.Int => {
1876	const int_info = lhs_ty.intInfo(mod);	1876	const int_info = lhs_ty.intInfo(zcu);
1877	if (int_info.bits <= 32) {	1877	if (int_info.bits <= 32) {
1878	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);	1878	const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
1879		1879
...	@@ -2020,7 +2020,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2020,7 +2020,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
2020	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2020	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2021	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	2021	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2022	const optional_ty = self.typeOfIndex(inst);	2022	const optional_ty = self.typeOfIndex(inst);
2023	const abi_size: u32 = @intCast(optional_ty.abiSize(pt));	2023	const abi_size: u32 = @intCast(optional_ty.abiSize(pt.zcu));
2024		2024
2025	// Optional with a zero-bit payload type is just a boolean true	2025	// Optional with a zero-bit payload type is just a boolean true
2026	if (abi_size == 1) {	2026	if (abi_size == 1) {
...	@@ -2040,17 +2040,17 @@ fn errUnionErr(	...	@@ -2040,17 +2040,17 @@ fn errUnionErr(
2040	maybe_inst: ?Air.Inst.Index,	2040	maybe_inst: ?Air.Inst.Index,
2041	) !MCValue {	2041	) !MCValue {
2042	const pt = self.pt;	2042	const pt = self.pt;
2043	const mod = pt.zcu;	2043	const zcu = pt.zcu;
2044	const err_ty = error_union_ty.errorUnionSet(mod);	2044	const err_ty = error_union_ty.errorUnionSet(zcu);
2045	const payload_ty = error_union_ty.errorUnionPayload(mod);	2045	const payload_ty = error_union_ty.errorUnionPayload(zcu);
2046	if (err_ty.errorSetIsEmpty(mod)) {	2046	if (err_ty.errorSetIsEmpty(zcu)) {
2047	return MCValue{ .immediate = 0 };	2047	return MCValue{ .immediate = 0 };
2048	}	2048	}
2049	if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {	2049	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
2050	return try error_union_bind.resolveToMcv(self);	2050	return try error_union_bind.resolveToMcv(self);
2051	}	2051	}
2052		2052
2053	const err_offset: u32 = @intCast(errUnionErrorOffset(payload_ty, pt));	2053	const err_offset: u32 = @intCast(errUnionErrorOffset(payload_ty, zcu));
2054	switch (try error_union_bind.resolveToMcv(self)) {	2054	switch (try error_union_bind.resolveToMcv(self)) {
2055	.register => {	2055	.register => {
2056	var operand_reg: Register = undefined;	2056	var operand_reg: Register = undefined;
...	@@ -2072,7 +2072,7 @@ fn errUnionErr(	...	@@ -2072,7 +2072,7 @@ fn errUnionErr(
2072	);	2072	);
2073		2073
2074	const err_bit_offset = err_offset * 8;	2074	const err_bit_offset = err_offset * 8;
2075	const err_bit_size: u32 = @intCast(err_ty.abiSize(pt) * 8);	2075	const err_bit_size: u32 = @intCast(err_ty.abiSize(zcu) * 8);
2076		2076
2077	_ = try self.addInst(.{	2077	_ = try self.addInst(.{
2078	.tag = .ubfx, // errors are unsigned integers	2078	.tag = .ubfx, // errors are unsigned integers
...	@@ -2118,17 +2118,17 @@ fn errUnionPayload(	...	@@ -2118,17 +2118,17 @@ fn errUnionPayload(
2118	maybe_inst: ?Air.Inst.Index,	2118	maybe_inst: ?Air.Inst.Index,
2119	) !MCValue {	2119	) !MCValue {
2120	const pt = self.pt;	2120	const pt = self.pt;
2121	const mod = pt.zcu;	2121	const zcu = pt.zcu;
2122	const err_ty = error_union_ty.errorUnionSet(mod);	2122	const err_ty = error_union_ty.errorUnionSet(zcu);
2123	const payload_ty = error_union_ty.errorUnionPayload(mod);	2123	const payload_ty = error_union_ty.errorUnionPayload(zcu);
2124	if (err_ty.errorSetIsEmpty(mod)) {	2124	if (err_ty.errorSetIsEmpty(zcu)) {
2125	return try error_union_bind.resolveToMcv(self);	2125	return try error_union_bind.resolveToMcv(self);
2126	}	2126	}
2127	if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {	2127	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
2128	return MCValue.none;	2128	return MCValue.none;
2129	}	2129	}
2130		2130
2131	const payload_offset: u32 = @intCast(errUnionPayloadOffset(payload_ty, pt));	2131	const payload_offset: u32 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
2132	switch (try error_union_bind.resolveToMcv(self)) {	2132	switch (try error_union_bind.resolveToMcv(self)) {
2133	.register => {	2133	.register => {
2134	var operand_reg: Register = undefined;	2134	var operand_reg: Register = undefined;
...	@@ -2150,10 +2150,10 @@ fn errUnionPayload(	...	@@ -2150,10 +2150,10 @@ fn errUnionPayload(
2150	);	2150	);
2151		2151
2152	const payload_bit_offset = payload_offset * 8;	2152	const payload_bit_offset = payload_offset * 8;
2153	const payload_bit_size: u32 = @intCast(payload_ty.abiSize(pt) * 8);	2153	const payload_bit_size: u32 = @intCast(payload_ty.abiSize(zcu) * 8);
2154		2154
2155	_ = try self.addInst(.{	2155	_ = try self.addInst(.{
2156	.tag = if (payload_ty.isSignedInt(mod)) Mir.Inst.Tag.sbfx else .ubfx,	2156	.tag = if (payload_ty.isSignedInt(zcu)) Mir.Inst.Tag.sbfx else .ubfx,
2157	.data = .{ .rr_lsb_width = .{	2157	.data = .{ .rr_lsb_width = .{
2158	.rd = dest_reg,	2158	.rd = dest_reg,
2159	.rn = operand_reg,	2159	.rn = operand_reg,
...	@@ -2229,20 +2229,20 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2229,20 +2229,20 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
2229	/// T to E!T	2229	/// T to E!T
2230	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {	2230	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
2231	const pt = self.pt;	2231	const pt = self.pt;
2232	const mod = pt.zcu;	2232	const zcu = pt.zcu;
2233	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2233	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2234	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	2234	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2235	const error_union_ty = ty_op.ty.toType();	2235	const error_union_ty = ty_op.ty.toType();
2236	const error_ty = error_union_ty.errorUnionSet(mod);	2236	const error_ty = error_union_ty.errorUnionSet(zcu);
2237	const payload_ty = error_union_ty.errorUnionPayload(mod);	2237	const payload_ty = error_union_ty.errorUnionPayload(zcu);
2238	const operand = try self.resolveInst(ty_op.operand);	2238	const operand = try self.resolveInst(ty_op.operand);
2239	if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result operand;	2239	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result operand;
2240		2240
2241	const abi_size: u32 = @intCast(error_union_ty.abiSize(pt));	2241	const abi_size: u32 = @intCast(error_union_ty.abiSize(zcu));
2242	const abi_align = error_union_ty.abiAlignment(pt);	2242	const abi_align = error_union_ty.abiAlignment(zcu);
2243	const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));	2243	const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));
2244	const payload_off = errUnionPayloadOffset(payload_ty, pt);	2244	const payload_off = errUnionPayloadOffset(payload_ty, zcu);
2245	const err_off = errUnionErrorOffset(payload_ty, pt);	2245	const err_off = errUnionErrorOffset(payload_ty, zcu);
2246	try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), operand);	2246	try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), operand);
2247	try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), .{ .immediate = 0 });	2247	try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), .{ .immediate = 0 });
2248		2248
...	@@ -2254,20 +2254,20 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2254,20 +2254,20 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
2254	/// E to E!T	2254	/// E to E!T
2255	fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {	2255	fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
2256	const pt = self.pt;	2256	const pt = self.pt;
2257	const mod = pt.zcu;	2257	const zcu = pt.zcu;
2258	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2258	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2259	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	2259	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2260	const error_union_ty = ty_op.ty.toType();	2260	const error_union_ty = ty_op.ty.toType();
2261	const error_ty = error_union_ty.errorUnionSet(mod);	2261	const error_ty = error_union_ty.errorUnionSet(zcu);
2262	const payload_ty = error_union_ty.errorUnionPayload(mod);	2262	const payload_ty = error_union_ty.errorUnionPayload(zcu);
2263	const operand = try self.resolveInst(ty_op.operand);	2263	const operand = try self.resolveInst(ty_op.operand);
2264	if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result operand;	2264	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result operand;
2265		2265
2266	const abi_size: u32 = @intCast(error_union_ty.abiSize(pt));	2266	const abi_size: u32 = @intCast(error_union_ty.abiSize(zcu));
2267	const abi_align = error_union_ty.abiAlignment(pt);	2267	const abi_align = error_union_ty.abiAlignment(zcu);
2268	const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));	2268	const stack_offset: u32 = @intCast(try self.allocMem(abi_size, abi_align, inst));
2269	const payload_off = errUnionPayloadOffset(payload_ty, pt);	2269	const payload_off = errUnionPayloadOffset(payload_ty, zcu);
2270	const err_off = errUnionErrorOffset(payload_ty, pt);	2270	const err_off = errUnionErrorOffset(payload_ty, zcu);
2271	try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), operand);	2271	try self.genSetStack(error_ty, stack_offset - @as(u32, @intCast(err_off)), operand);
2272	try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), .undef);	2272	try self.genSetStack(payload_ty, stack_offset - @as(u32, @intCast(payload_off)), .undef);
2273		2273
...	@@ -2372,9 +2372,9 @@ fn ptrElemVal(	...	@@ -2372,9 +2372,9 @@ fn ptrElemVal(
2372	maybe_inst: ?Air.Inst.Index,	2372	maybe_inst: ?Air.Inst.Index,
2373	) !MCValue {	2373	) !MCValue {
2374	const pt = self.pt;	2374	const pt = self.pt;
2375	const mod = pt.zcu;	2375	const zcu = pt.zcu;
2376	const elem_ty = ptr_ty.childType(mod);	2376	const elem_ty = ptr_ty.childType(zcu);
2377	const elem_size: u32 = @intCast(elem_ty.abiSize(pt));	2377	const elem_size: u32 = @intCast(elem_ty.abiSize(zcu));
2378		2378
2379	switch (elem_size) {	2379	switch (elem_size) {
2380	1, 4 => {	2380	1, 4 => {
...	@@ -2432,11 +2432,11 @@ fn ptrElemVal(	...	@@ -2432,11 +2432,11 @@ fn ptrElemVal(
2432		2432
2433	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {	2433	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
2434	const pt = self.pt;	2434	const pt = self.pt;
2435	const mod = pt.zcu;	2435	const zcu = pt.zcu;
2436	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2436	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2437	const slice_ty = self.typeOf(bin_op.lhs);	2437	const slice_ty = self.typeOf(bin_op.lhs);
2438	const result: MCValue = if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {	2438	const result: MCValue = if (!slice_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) .dead else result: {
2439	const ptr_ty = slice_ty.slicePtrFieldType(mod);	2439	const ptr_ty = slice_ty.slicePtrFieldType(zcu);
2440		2440
2441	const slice_mcv = try self.resolveInst(bin_op.lhs);	2441	const slice_mcv = try self.resolveInst(bin_op.lhs);
2442	const base_mcv = slicePtr(slice_mcv);	2442	const base_mcv = slicePtr(slice_mcv);
...	@@ -2476,8 +2476,8 @@ fn arrayElemVal(	...	@@ -2476,8 +2476,8 @@ fn arrayElemVal(
2476	maybe_inst: ?Air.Inst.Index,	2476	maybe_inst: ?Air.Inst.Index,
2477	) InnerError!MCValue {	2477	) InnerError!MCValue {
2478	const pt = self.pt;	2478	const pt = self.pt;
2479	const mod = pt.zcu;	2479	const zcu = pt.zcu;
2480	const elem_ty = array_ty.childType(mod);	2480	const elem_ty = array_ty.childType(zcu);
2481		2481
2482	const mcv = try array_bind.resolveToMcv(self);	2482	const mcv = try array_bind.resolveToMcv(self);
2483	switch (mcv) {	2483	switch (mcv) {
...	@@ -2533,10 +2533,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2533,10 +2533,10 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
2533		2533
2534	fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {	2534	fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
2535	const pt = self.pt;	2535	const pt = self.pt;
2536	const mod = pt.zcu;	2536	const zcu = pt.zcu;
2537	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;	2537	const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
2538	const ptr_ty = self.typeOf(bin_op.lhs);	2538	const ptr_ty = self.typeOf(bin_op.lhs);
2539	const result: MCValue = if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) .dead else result: {	2539	const result: MCValue = if (!ptr_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) .dead else result: {
2540	const base_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };	2540	const base_bind: ReadArg.Bind = .{ .inst = bin_op.lhs };
2541	const index_bind: ReadArg.Bind = .{ .inst = bin_op.rhs };	2541	const index_bind: ReadArg.Bind = .{ .inst = bin_op.rhs };
2542		2542
...	@@ -2668,9 +2668,9 @@ fn reuseOperand(	...	@@ -2668,9 +2668,9 @@ fn reuseOperand(
2668		2668
2669	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {	2669	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
2670	const pt = self.pt;	2670	const pt = self.pt;
2671	const mod = pt.zcu;	2671	const zcu = pt.zcu;
2672	const elem_ty = ptr_ty.childType(mod);	2672	const elem_ty = ptr_ty.childType(zcu);
2673	const elem_size: u32 = @intCast(elem_ty.abiSize(pt));	2673	const elem_size: u32 = @intCast(elem_ty.abiSize(zcu));
2674		2674
2675	switch (ptr) {	2675	switch (ptr) {
2676	.none => unreachable,	2676	.none => unreachable,
...	@@ -2746,20 +2746,20 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo	...	@@ -2746,20 +2746,20 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
2746		2746
2747	fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	2747	fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
2748	const pt = self.pt;	2748	const pt = self.pt;
2749	const mod = pt.zcu;	2749	const zcu = pt.zcu;
2750	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	2750	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
2751	const elem_ty = self.typeOfIndex(inst);	2751	const elem_ty = self.typeOfIndex(inst);
2752	const result: MCValue = result: {	2752	const result: MCValue = result: {
2753	if (!elem_ty.hasRuntimeBits(pt))	2753	if (!elem_ty.hasRuntimeBits(zcu))
2754	break :result MCValue.none;	2754	break :result MCValue.none;
2755		2755
2756	const ptr = try self.resolveInst(ty_op.operand);	2756	const ptr = try self.resolveInst(ty_op.operand);
2757	const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(mod);	2757	const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(zcu);
2758	if (self.liveness.isUnused(inst) and !is_volatile)	2758	if (self.liveness.isUnused(inst) and !is_volatile)
2759	break :result MCValue.dead;	2759	break :result MCValue.dead;
2760		2760
2761	const dest_mcv: MCValue = blk: {	2761	const dest_mcv: MCValue = blk: {
2762	const ptr_fits_dest = elem_ty.abiSize(pt) <= 4;	2762	const ptr_fits_dest = elem_ty.abiSize(zcu) <= 4;
2763	if (ptr_fits_dest and self.reuseOperand(inst, ty_op.operand, 0, ptr)) {	2763	if (ptr_fits_dest and self.reuseOperand(inst, ty_op.operand, 0, ptr)) {
2764	// The MCValue that holds the pointer can be re-used as the value.	2764	// The MCValue that holds the pointer can be re-used as the value.
2765	break :blk ptr;	2765	break :blk ptr;
...	@@ -2776,7 +2776,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2776,7 +2776,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
2776		2776
2777	fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {	2777	fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {
2778	const pt = self.pt;	2778	const pt = self.pt;
2779	const elem_size: u32 = @intCast(value_ty.abiSize(pt));	2779	const elem_size: u32 = @intCast(value_ty.abiSize(pt.zcu));
2780		2780
2781	switch (ptr) {	2781	switch (ptr) {
2782	.none => unreachable,	2782	.none => unreachable,
...	@@ -2896,11 +2896,11 @@ fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {	...	@@ -2896,11 +2896,11 @@ fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
2896	fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {	2896	fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {
2897	return if (self.liveness.isUnused(inst)) .dead else result: {	2897	return if (self.liveness.isUnused(inst)) .dead else result: {
2898	const pt = self.pt;	2898	const pt = self.pt;
2899	const mod = pt.zcu;	2899	const zcu = pt.zcu;
2900	const mcv = try self.resolveInst(operand);	2900	const mcv = try self.resolveInst(operand);
2901	const ptr_ty = self.typeOf(operand);	2901	const ptr_ty = self.typeOf(operand);
2902	const struct_ty = ptr_ty.childType(mod);	2902	const struct_ty = ptr_ty.childType(zcu);
2903	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, pt));	2903	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, zcu));
2904	switch (mcv) {	2904	switch (mcv) {
2905	.ptr_stack_offset => \|off\| {	2905	.ptr_stack_offset => \|off\| {
2906	break :result MCValue{ .ptr_stack_offset = off - struct_field_offset };	2906	break :result MCValue{ .ptr_stack_offset = off - struct_field_offset };
...	@@ -2921,12 +2921,12 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2921,12 +2921,12 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
2921	const operand = extra.struct_operand;	2921	const operand = extra.struct_operand;
2922	const index = extra.field_index;	2922	const index = extra.field_index;
2923	const pt = self.pt;	2923	const pt = self.pt;
2924	const mod = pt.zcu;	2924	const zcu = pt.zcu;
2925	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	2925	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
2926	const mcv = try self.resolveInst(operand);	2926	const mcv = try self.resolveInst(operand);
2927	const struct_ty = self.typeOf(operand);	2927	const struct_ty = self.typeOf(operand);
2928	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, pt));	2928	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(index, zcu));
2929	const struct_field_ty = struct_ty.structFieldType(index, mod);	2929	const struct_field_ty = struct_ty.fieldType(index, zcu);
2930		2930
2931	switch (mcv) {	2931	switch (mcv) {
2932	.dead, .unreach => unreachable,	2932	.dead, .unreach => unreachable,
...	@@ -2989,10 +2989,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2989,10 +2989,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
2989	);	2989	);
2990		2990
2991	const field_bit_offset = struct_field_offset * 8;	2991	const field_bit_offset = struct_field_offset * 8;
2992	const field_bit_size: u32 = @intCast(struct_field_ty.abiSize(pt) * 8);	2992	const field_bit_size: u32 = @intCast(struct_field_ty.abiSize(zcu) * 8);
2993		2993
2994	_ = try self.addInst(.{	2994	_ = try self.addInst(.{
2995	.tag = if (struct_field_ty.isSignedInt(mod)) Mir.Inst.Tag.sbfx else .ubfx,	2995	.tag = if (struct_field_ty.isSignedInt(zcu)) Mir.Inst.Tag.sbfx else .ubfx,
2996	.data = .{ .rr_lsb_width = .{	2996	.data = .{ .rr_lsb_width = .{
2997	.rd = dest_reg,	2997	.rd = dest_reg,
2998	.rn = operand_reg,	2998	.rn = operand_reg,
...	@@ -3012,18 +3012,18 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3012,18 +3012,18 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
3012		3012
3013	fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {	3013	fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
3014	const pt = self.pt;	3014	const pt = self.pt;
3015	const mod = pt.zcu;	3015	const zcu = pt.zcu;
3016	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	3016	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
3017	const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;	3017	const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
3018	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	3018	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
3019	const field_ptr = try self.resolveInst(extra.field_ptr);	3019	const field_ptr = try self.resolveInst(extra.field_ptr);
3020	const struct_ty = ty_pl.ty.toType().childType(mod);	3020	const struct_ty = ty_pl.ty.toType().childType(zcu);
3021		3021
3022	if (struct_ty.zigTypeTag(mod) == .Union) {	3022	if (struct_ty.zigTypeTag(zcu) == .Union) {
3023	return self.fail("TODO implement @fieldParentPtr codegen for unions", .{});	3023	return self.fail("TODO implement @fieldParentPtr codegen for unions", .{});
3024	}	3024	}
3025		3025
3026	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(extra.field_index, pt));	3026	const struct_field_offset: u32 = @intCast(struct_ty.structFieldOffset(extra.field_index, zcu));
3027	switch (field_ptr) {	3027	switch (field_ptr) {
3028	.ptr_stack_offset => \|off\| {	3028	.ptr_stack_offset => \|off\| {
3029	break :result MCValue{ .ptr_stack_offset = off + struct_field_offset };	3029	break :result MCValue{ .ptr_stack_offset = off + struct_field_offset };
...	@@ -3407,13 +3407,13 @@ fn addSub(	...	@@ -3407,13 +3407,13 @@ fn addSub(
3407	maybe_inst: ?Air.Inst.Index,	3407	maybe_inst: ?Air.Inst.Index,
3408	) InnerError!MCValue {	3408	) InnerError!MCValue {
3409	const pt = self.pt;	3409	const pt = self.pt;
3410	const mod = pt.zcu;	3410	const zcu = pt.zcu;
3411	switch (lhs_ty.zigTypeTag(mod)) {	3411	switch (lhs_ty.zigTypeTag(zcu)) {
3412	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3412	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3413	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3413	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3414	.Int => {	3414	.Int => {
3415	assert(lhs_ty.eql(rhs_ty, mod));	3415	assert(lhs_ty.eql(rhs_ty, zcu));
3416	const int_info = lhs_ty.intInfo(mod);	3416	const int_info = lhs_ty.intInfo(zcu);
3417	if (int_info.bits <= 32) {	3417	if (int_info.bits <= 32) {
3418	const lhs_immediate = try lhs_bind.resolveToImmediate(self);	3418	const lhs_immediate = try lhs_bind.resolveToImmediate(self);
3419	const rhs_immediate = try rhs_bind.resolveToImmediate(self);	3419	const rhs_immediate = try rhs_bind.resolveToImmediate(self);
...	@@ -3464,13 +3464,13 @@ fn mul(	...	@@ -3464,13 +3464,13 @@ fn mul(
3464	maybe_inst: ?Air.Inst.Index,	3464	maybe_inst: ?Air.Inst.Index,
3465	) InnerError!MCValue {	3465	) InnerError!MCValue {
3466	const pt = self.pt;	3466	const pt = self.pt;
3467	const mod = pt.zcu;	3467	const zcu = pt.zcu;
3468	switch (lhs_ty.zigTypeTag(mod)) {	3468	switch (lhs_ty.zigTypeTag(zcu)) {
3469	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3469	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3470	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3470	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3471	.Int => {	3471	.Int => {
3472	assert(lhs_ty.eql(rhs_ty, mod));	3472	assert(lhs_ty.eql(rhs_ty, zcu));
3473	const int_info = lhs_ty.intInfo(mod);	3473	const int_info = lhs_ty.intInfo(zcu);
3474	if (int_info.bits <= 32) {	3474	if (int_info.bits <= 32) {
3475	// TODO add optimisations for multiplication	3475	// TODO add optimisations for multiplication
3476	// with immediates, for example a * 2 can be	3476	// with immediates, for example a * 2 can be
...	@@ -3498,8 +3498,8 @@ fn divFloat(	...	@@ -3498,8 +3498,8 @@ fn divFloat(
3498	_ = maybe_inst;	3498	_ = maybe_inst;
3499		3499
3500	const pt = self.pt;	3500	const pt = self.pt;
3501	const mod = pt.zcu;	3501	const zcu = pt.zcu;
3502	switch (lhs_ty.zigTypeTag(mod)) {	3502	switch (lhs_ty.zigTypeTag(zcu)) {
3503	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3503	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3504	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3504	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3505	else => unreachable,	3505	else => unreachable,
...	@@ -3515,13 +3515,13 @@ fn divTrunc(	...	@@ -3515,13 +3515,13 @@ fn divTrunc(
3515	maybe_inst: ?Air.Inst.Index,	3515	maybe_inst: ?Air.Inst.Index,
3516	) InnerError!MCValue {	3516	) InnerError!MCValue {
3517	const pt = self.pt;	3517	const pt = self.pt;
3518	const mod = pt.zcu;	3518	const zcu = pt.zcu;
3519	switch (lhs_ty.zigTypeTag(mod)) {	3519	switch (lhs_ty.zigTypeTag(zcu)) {
3520	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3520	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3521	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3521	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3522	.Int => {	3522	.Int => {
3523	assert(lhs_ty.eql(rhs_ty, mod));	3523	assert(lhs_ty.eql(rhs_ty, zcu));
3524	const int_info = lhs_ty.intInfo(mod);	3524	const int_info = lhs_ty.intInfo(zcu);
3525	if (int_info.bits <= 32) {	3525	if (int_info.bits <= 32) {
3526	switch (int_info.signedness) {	3526	switch (int_info.signedness) {
3527	.signed => {	3527	.signed => {
...	@@ -3559,13 +3559,13 @@ fn divFloor(	...	@@ -3559,13 +3559,13 @@ fn divFloor(
3559	maybe_inst: ?Air.Inst.Index,	3559	maybe_inst: ?Air.Inst.Index,
3560	) InnerError!MCValue {	3560	) InnerError!MCValue {
3561	const pt = self.pt;	3561	const pt = self.pt;
3562	const mod = pt.zcu;	3562	const zcu = pt.zcu;
3563	switch (lhs_ty.zigTypeTag(mod)) {	3563	switch (lhs_ty.zigTypeTag(zcu)) {
3564	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3564	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3565	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3565	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3566	.Int => {	3566	.Int => {
3567	assert(lhs_ty.eql(rhs_ty, mod));	3567	assert(lhs_ty.eql(rhs_ty, zcu));
3568	const int_info = lhs_ty.intInfo(mod);	3568	const int_info = lhs_ty.intInfo(zcu);
3569	if (int_info.bits <= 32) {	3569	if (int_info.bits <= 32) {
3570	switch (int_info.signedness) {	3570	switch (int_info.signedness) {
3571	.signed => {	3571	.signed => {
...	@@ -3608,8 +3608,8 @@ fn divExact(	...	@@ -3608,8 +3608,8 @@ fn divExact(
3608	_ = maybe_inst;	3608	_ = maybe_inst;
3609		3609
3610	const pt = self.pt;	3610	const pt = self.pt;
3611	const mod = pt.zcu;	3611	const zcu = pt.zcu;
3612	switch (lhs_ty.zigTypeTag(mod)) {	3612	switch (lhs_ty.zigTypeTag(zcu)) {
3613	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3613	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3614	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3614	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3615	.Int => return self.fail("TODO ARM div_exact", .{}),	3615	.Int => return self.fail("TODO ARM div_exact", .{}),
...	@@ -3626,17 +3626,17 @@ fn rem(	...	@@ -3626,17 +3626,17 @@ fn rem(
3626	maybe_inst: ?Air.Inst.Index,	3626	maybe_inst: ?Air.Inst.Index,
3627	) InnerError!MCValue {	3627	) InnerError!MCValue {
3628	const pt = self.pt;	3628	const pt = self.pt;
3629	const mod = pt.zcu;	3629	const zcu = pt.zcu;
3630	switch (lhs_ty.zigTypeTag(mod)) {	3630	switch (lhs_ty.zigTypeTag(zcu)) {
3631	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3631	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3632	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3632	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3633	.Int => {	3633	.Int => {
3634	assert(lhs_ty.eql(rhs_ty, mod));	3634	assert(lhs_ty.eql(rhs_ty, zcu));
3635	const int_info = lhs_ty.intInfo(mod);	3635	const int_info = lhs_ty.intInfo(zcu);
3636	if (int_info.bits <= 32) {	3636	if (int_info.bits <= 32) {
3637	switch (int_info.signedness) {	3637	switch (int_info.signedness) {
3638	.signed => {	3638	.signed => {
3639	return self.fail("TODO ARM signed integer mod", .{});	3639	return self.fail("TODO ARM signed integer zcu", .{});
3640	},	3640	},
3641	.unsigned => {	3641	.unsigned => {
3642	const rhs_immediate = try rhs_bind.resolveToImmediate(self);	3642	const rhs_immediate = try rhs_bind.resolveToImmediate(self);
...	@@ -3667,10 +3667,10 @@ fn rem(	...	@@ -3667,10 +3667,10 @@ fn rem(
3667		3667
3668	return MCValue{ .register = dest_reg };	3668	return MCValue{ .register = dest_reg };
3669	} else {	3669	} else {
3670	return self.fail("TODO ARM integer mod by constants", .{});	3670	return self.fail("TODO ARM integer zcu by constants", .{});
3671	}	3671	}
3672	} else {	3672	} else {
3673	return self.fail("TODO ARM integer mod", .{});	3673	return self.fail("TODO ARM integer zcu", .{});
3674	}	3674	}
3675	},	3675	},
3676	}	3676	}
...	@@ -3696,11 +3696,11 @@ fn modulo(	...	@@ -3696,11 +3696,11 @@ fn modulo(
3696	_ = maybe_inst;	3696	_ = maybe_inst;
3697		3697
3698	const pt = self.pt;	3698	const pt = self.pt;
3699	const mod = pt.zcu;	3699	const zcu = pt.zcu;
3700	switch (lhs_ty.zigTypeTag(mod)) {	3700	switch (lhs_ty.zigTypeTag(zcu)) {
3701	.Float => return self.fail("TODO ARM binary operations on floats", .{}),	3701	.Float => return self.fail("TODO ARM binary operations on floats", .{}),
3702	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3702	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3703	.Int => return self.fail("TODO ARM mod", .{}),	3703	.Int => return self.fail("TODO ARM zcu", .{}),
3704	else => unreachable,	3704	else => unreachable,
3705	}	3705	}
3706	}	3706	}
...	@@ -3715,11 +3715,11 @@ fn wrappingArithmetic(	...	@@ -3715,11 +3715,11 @@ fn wrappingArithmetic(
3715	maybe_inst: ?Air.Inst.Index,	3715	maybe_inst: ?Air.Inst.Index,
3716	) InnerError!MCValue {	3716	) InnerError!MCValue {
3717	const pt = self.pt;	3717	const pt = self.pt;
3718	const mod = pt.zcu;	3718	const zcu = pt.zcu;
3719	switch (lhs_ty.zigTypeTag(mod)) {	3719	switch (lhs_ty.zigTypeTag(zcu)) {
3720	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3720	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3721	.Int => {	3721	.Int => {
3722	const int_info = lhs_ty.intInfo(mod);	3722	const int_info = lhs_ty.intInfo(zcu);
3723	if (int_info.bits <= 32) {	3723	if (int_info.bits <= 32) {
3724	// Generate an add/sub/mul	3724	// Generate an add/sub/mul
3725	const result: MCValue = switch (tag) {	3725	const result: MCValue = switch (tag) {
...	@@ -3754,12 +3754,12 @@ fn bitwise(	...	@@ -3754,12 +3754,12 @@ fn bitwise(
3754	maybe_inst: ?Air.Inst.Index,	3754	maybe_inst: ?Air.Inst.Index,
3755	) InnerError!MCValue {	3755	) InnerError!MCValue {
3756	const pt = self.pt;	3756	const pt = self.pt;
3757	const mod = pt.zcu;	3757	const zcu = pt.zcu;
3758	switch (lhs_ty.zigTypeTag(mod)) {	3758	switch (lhs_ty.zigTypeTag(zcu)) {
3759	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3759	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3760	.Int => {	3760	.Int => {
3761	assert(lhs_ty.eql(rhs_ty, mod));	3761	assert(lhs_ty.eql(rhs_ty, zcu));
3762	const int_info = lhs_ty.intInfo(mod);	3762	const int_info = lhs_ty.intInfo(zcu);
3763	if (int_info.bits <= 32) {	3763	if (int_info.bits <= 32) {
3764	const lhs_immediate = try lhs_bind.resolveToImmediate(self);	3764	const lhs_immediate = try lhs_bind.resolveToImmediate(self);
3765	const rhs_immediate = try rhs_bind.resolveToImmediate(self);	3765	const rhs_immediate = try rhs_bind.resolveToImmediate(self);
...	@@ -3800,17 +3800,17 @@ fn shiftExact(	...	@@ -3800,17 +3800,17 @@ fn shiftExact(
3800	maybe_inst: ?Air.Inst.Index,	3800	maybe_inst: ?Air.Inst.Index,
3801	) InnerError!MCValue {	3801	) InnerError!MCValue {
3802	const pt = self.pt;	3802	const pt = self.pt;
3803	const mod = pt.zcu;	3803	const zcu = pt.zcu;
3804	switch (lhs_ty.zigTypeTag(mod)) {	3804	switch (lhs_ty.zigTypeTag(zcu)) {
3805	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3805	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3806	.Int => {	3806	.Int => {
3807	const int_info = lhs_ty.intInfo(mod);	3807	const int_info = lhs_ty.intInfo(zcu);
3808	if (int_info.bits <= 32) {	3808	if (int_info.bits <= 32) {
3809	const rhs_immediate = try rhs_bind.resolveToImmediate(self);	3809	const rhs_immediate = try rhs_bind.resolveToImmediate(self);
3810		3810
3811	const mir_tag: Mir.Inst.Tag = switch (tag) {	3811	const mir_tag: Mir.Inst.Tag = switch (tag) {
3812	.shl_exact => .lsl,	3812	.shl_exact => .lsl,
3813	.shr_exact => switch (lhs_ty.intInfo(mod).signedness) {	3813	.shr_exact => switch (lhs_ty.intInfo(zcu).signedness) {
3814	.signed => Mir.Inst.Tag.asr,	3814	.signed => Mir.Inst.Tag.asr,
3815	.unsigned => Mir.Inst.Tag.lsr,	3815	.unsigned => Mir.Inst.Tag.lsr,
3816	},	3816	},
...	@@ -3840,11 +3840,11 @@ fn shiftNormal(	...	@@ -3840,11 +3840,11 @@ fn shiftNormal(
3840	maybe_inst: ?Air.Inst.Index,	3840	maybe_inst: ?Air.Inst.Index,
3841	) InnerError!MCValue {	3841	) InnerError!MCValue {
3842	const pt = self.pt;	3842	const pt = self.pt;
3843	const mod = pt.zcu;	3843	const zcu = pt.zcu;
3844	switch (lhs_ty.zigTypeTag(mod)) {	3844	switch (lhs_ty.zigTypeTag(zcu)) {
3845	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),	3845	.Vector => return self.fail("TODO ARM binary operations on vectors", .{}),
3846	.Int => {	3846	.Int => {
3847	const int_info = lhs_ty.intInfo(mod);	3847	const int_info = lhs_ty.intInfo(zcu);
3848	if (int_info.bits <= 32) {	3848	if (int_info.bits <= 32) {
3849	// Generate a shl_exact/shr_exact	3849	// Generate a shl_exact/shr_exact
3850	const result: MCValue = switch (tag) {	3850	const result: MCValue = switch (tag) {
...	@@ -3884,8 +3884,8 @@ fn booleanOp(	...	@@ -3884,8 +3884,8 @@ fn booleanOp(
3884	maybe_inst: ?Air.Inst.Index,	3884	maybe_inst: ?Air.Inst.Index,
3885	) InnerError!MCValue {	3885	) InnerError!MCValue {
3886	const pt = self.pt;	3886	const pt = self.pt;
3887	const mod = pt.zcu;	3887	const zcu = pt.zcu;
3888	switch (lhs_ty.zigTypeTag(mod)) {	3888	switch (lhs_ty.zigTypeTag(zcu)) {
3889	.Bool => {	3889	.Bool => {
3890	const lhs_immediate = try lhs_bind.resolveToImmediate(self);	3890	const lhs_immediate = try lhs_bind.resolveToImmediate(self);
3891	const rhs_immediate = try rhs_bind.resolveToImmediate(self);	3891	const rhs_immediate = try rhs_bind.resolveToImmediate(self);
...	@@ -3919,17 +3919,17 @@ fn ptrArithmetic(	...	@@ -3919,17 +3919,17 @@ fn ptrArithmetic(
3919	maybe_inst: ?Air.Inst.Index,	3919	maybe_inst: ?Air.Inst.Index,
3920	) InnerError!MCValue {	3920	) InnerError!MCValue {
3921	const pt = self.pt;	3921	const pt = self.pt;
3922	const mod = pt.zcu;	3922	const zcu = pt.zcu;
3923	switch (lhs_ty.zigTypeTag(mod)) {	3923	switch (lhs_ty.zigTypeTag(zcu)) {
3924	.Pointer => {	3924	.Pointer => {
3925	assert(rhs_ty.eql(Type.usize, mod));	3925	assert(rhs_ty.eql(Type.usize, zcu));
3926		3926
3927	const ptr_ty = lhs_ty;	3927	const ptr_ty = lhs_ty;
3928	const elem_ty = switch (ptr_ty.ptrSize(mod)) {	3928	const elem_ty = switch (ptr_ty.ptrSize(zcu)) {
3929	.One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type	3929	.One => ptr_ty.childType(zcu).childType(zcu), // ptr to array, so get array element type
3930	else => ptr_ty.childType(mod),	3930	else => ptr_ty.childType(zcu),
3931	};	3931	};
3932	const elem_size: u32 = @intCast(elem_ty.abiSize(pt));	3932	const elem_size: u32 = @intCast(elem_ty.abiSize(zcu));
3933		3933
3934	const base_tag: Air.Inst.Tag = switch (tag) {	3934	const base_tag: Air.Inst.Tag = switch (tag) {
3935	.ptr_add => .add,	3935	.ptr_add => .add,
...	@@ -3957,12 +3957,12 @@ fn ptrArithmetic(	...	@@ -3957,12 +3957,12 @@ fn ptrArithmetic(
3957		3957
3958	fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type) !void {	3958	fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type) !void {
3959	const pt = self.pt;	3959	const pt = self.pt;
3960	const mod = pt.zcu;	3960	const zcu = pt.zcu;
3961	const abi_size = ty.abiSize(pt);	3961	const abi_size = ty.abiSize(zcu);
3962		3962
3963	const tag: Mir.Inst.Tag = switch (abi_size) {	3963	const tag: Mir.Inst.Tag = switch (abi_size) {
3964	1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb else .ldrb,	3964	1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb else .ldrb,
3965	2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh else .ldrh,	3965	2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh else .ldrh,
3966	3, 4 => .ldr,	3966	3, 4 => .ldr,
3967	else => unreachable,	3967	else => unreachable,
3968	};	3968	};
...	@@ -3979,7 +3979,7 @@ fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type)	...	@@ -3979,7 +3979,7 @@ fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type)
3979	} };	3979	} };
3980		3980
3981	const data: Mir.Inst.Data = switch (abi_size) {	3981	const data: Mir.Inst.Data = switch (abi_size) {
3982	1 => if (ty.isSignedInt(mod)) rr_extra_offset else rr_offset,	3982	1 => if (ty.isSignedInt(zcu)) rr_extra_offset else rr_offset,
3983	2 => rr_extra_offset,	3983	2 => rr_extra_offset,
3984	3, 4 => rr_offset,	3984	3, 4 => rr_offset,
3985	else => unreachable,	3985	else => unreachable,
...	@@ -3993,7 +3993,7 @@ fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type)	...	@@ -3993,7 +3993,7 @@ fn genLdrRegister(self: *Self, dest_reg: Register, addr_reg: Register, ty: Type)
3993		3993
3994	fn genStrRegister(self: *Self, source_reg: Register, addr_reg: Register, ty: Type) !void {	3994	fn genStrRegister(self: *Self, source_reg: Register, addr_reg: Register, ty: Type) !void {
3995	const pt = self.pt;	3995	const pt = self.pt;
3996	const abi_size = ty.abiSize(pt);	3996	const abi_size = ty.abiSize(pt.zcu);
3997		3997
3998	const tag: Mir.Inst.Tag = switch (abi_size) {	3998	const tag: Mir.Inst.Tag = switch (abi_size) {
3999	1 => .strb,	3999	1 => .strb,
...	@@ -4253,12 +4253,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -4253,12 +4253,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4253	const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);	4253	const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
4254	const ty = self.typeOf(callee);	4254	const ty = self.typeOf(callee);
4255	const pt = self.pt;	4255	const pt = self.pt;
4256	const mod = pt.zcu;	4256	const zcu = pt.zcu;
4257	const ip = &mod.intern_pool;	4257	const ip = &zcu.intern_pool;
4258		4258
4259	const fn_ty = switch (ty.zigTypeTag(mod)) {	4259	const fn_ty = switch (ty.zigTypeTag(zcu)) {
4260	.Fn => ty,	4260	.Fn => ty,
4261	.Pointer => ty.childType(mod),	4261	.Pointer => ty.childType(zcu),
4262	else => unreachable,	4262	else => unreachable,
4263	};	4263	};
4264		4264
...	@@ -4283,9 +4283,9 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -4283,9 +4283,9 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4283	// untouched by the parameter passing code	4283	// untouched by the parameter passing code
4284	const r0_lock: ?RegisterLock = if (info.return_value == .stack_offset) blk: {	4284	const r0_lock: ?RegisterLock = if (info.return_value == .stack_offset) blk: {
4285	log.debug("airCall: return by reference", .{});	4285	log.debug("airCall: return by reference", .{});
4286	const ret_ty = fn_ty.fnReturnType(mod);	4286	const ret_ty = fn_ty.fnReturnType(zcu);
4287	const ret_abi_size: u32 = @intCast(ret_ty.abiSize(pt));	4287	const ret_abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
4288	const ret_abi_align = ret_ty.abiAlignment(pt);	4288	const ret_abi_align = ret_ty.abiAlignment(zcu);
4289	const stack_offset = try self.allocMem(ret_abi_size, ret_abi_align, inst);	4289	const stack_offset = try self.allocMem(ret_abi_size, ret_abi_align, inst);
4290		4290
4291	const ptr_ty = try pt.singleMutPtrType(ret_ty);	4291	const ptr_ty = try pt.singleMutPtrType(ret_ty);
...	@@ -4335,7 +4335,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -4335,7 +4335,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4335	return self.fail("TODO implement calling bitcasted functions", .{});	4335	return self.fail("TODO implement calling bitcasted functions", .{});
4336	},	4336	},
4337	} else {	4337	} else {
4338	assert(ty.zigTypeTag(mod) == .Pointer);	4338	assert(ty.zigTypeTag(zcu) == .Pointer);
4339	const mcv = try self.resolveInst(callee);	4339	const mcv = try self.resolveInst(callee);
4340		4340
4341	try self.genSetReg(Type.usize, .lr, mcv);	4341	try self.genSetReg(Type.usize, .lr, mcv);
...	@@ -4370,7 +4370,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -4370,7 +4370,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4370	if (RegisterManager.indexOfRegIntoTracked(reg) == null) {	4370	if (RegisterManager.indexOfRegIntoTracked(reg) == null) {
4371	// Save function return value into a tracked register	4371	// Save function return value into a tracked register
4372	log.debug("airCall: copying {} as it is not tracked", .{reg});	4372	log.debug("airCall: copying {} as it is not tracked", .{reg});
4373	const new_reg = try self.copyToTmpRegister(fn_ty.fnReturnType(mod), info.return_value);	4373	const new_reg = try self.copyToTmpRegister(fn_ty.fnReturnType(zcu), info.return_value);
4374	break :result MCValue{ .register = new_reg };	4374	break :result MCValue{ .register = new_reg };
4375	}	4375	}
4376	},	4376	},
...	@@ -4395,15 +4395,15 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -4395,15 +4395,15 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4395		4395
4396	fn airRet(self: *Self, inst: Air.Inst.Index) !void {	4396	fn airRet(self: *Self, inst: Air.Inst.Index) !void {
4397	const pt = self.pt;	4397	const pt = self.pt;
4398	const mod = pt.zcu;	4398	const zcu = pt.zcu;
4399	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4399	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4400	const operand = try self.resolveInst(un_op);	4400	const operand = try self.resolveInst(un_op);
4401	const ret_ty = self.fn_type.fnReturnType(mod);	4401	const ret_ty = self.fn_type.fnReturnType(zcu);
4402		4402
4403	switch (self.ret_mcv) {	4403	switch (self.ret_mcv) {
4404	.none => {},	4404	.none => {},
4405	.immediate => {	4405	.immediate => {
4406	assert(ret_ty.isError(mod));	4406	assert(ret_ty.isError(zcu));
4407	},	4407	},
4408	.register => \|reg\| {	4408	.register => \|reg\| {
4409	// Return result by value	4409	// Return result by value
...	@@ -4428,11 +4428,11 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4428,11 +4428,11 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
4428		4428
4429	fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {	4429	fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
4430	const pt = self.pt;	4430	const pt = self.pt;
4431	const mod = pt.zcu;	4431	const zcu = pt.zcu;
4432	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4432	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4433	const ptr = try self.resolveInst(un_op);	4433	const ptr = try self.resolveInst(un_op);
4434	const ptr_ty = self.typeOf(un_op);	4434	const ptr_ty = self.typeOf(un_op);
4435	const ret_ty = self.fn_type.fnReturnType(mod);	4435	const ret_ty = self.fn_type.fnReturnType(zcu);
4436		4436
4437	switch (self.ret_mcv) {	4437	switch (self.ret_mcv) {
4438	.none => {},	4438	.none => {},
...	@@ -4452,8 +4452,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4452,8 +4452,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
4452	// location.	4452	// location.
4453	const op_inst = un_op.toIndex().?;	4453	const op_inst = un_op.toIndex().?;
4454	if (self.air.instructions.items(.tag)[@intFromEnum(op_inst)] != .ret_ptr) {	4454	if (self.air.instructions.items(.tag)[@intFromEnum(op_inst)] != .ret_ptr) {
4455	const abi_size: u32 = @intCast(ret_ty.abiSize(pt));	4455	const abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
4456	const abi_align = ret_ty.abiAlignment(pt);	4456	const abi_align = ret_ty.abiAlignment(zcu);
4457		4457
4458	const offset = try self.allocMem(abi_size, abi_align, null);	4458	const offset = try self.allocMem(abi_size, abi_align, null);
4459		4459
...	@@ -4490,20 +4490,20 @@ fn cmp(	...	@@ -4490,20 +4490,20 @@ fn cmp(
4490	op: math.CompareOperator,	4490	op: math.CompareOperator,
4491	) !MCValue {	4491	) !MCValue {
4492	const pt = self.pt;	4492	const pt = self.pt;
4493	const mod = pt.zcu;	4493	const zcu = pt.zcu;
4494	const int_ty = switch (lhs_ty.zigTypeTag(mod)) {	4494	const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
4495	.Optional => blk: {	4495	.Optional => blk: {
4496	const payload_ty = lhs_ty.optionalChild(mod);	4496	const payload_ty = lhs_ty.optionalChild(zcu);
4497	if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {	4497	if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
4498	break :blk Type.u1;	4498	break :blk Type.u1;
4499	} else if (lhs_ty.isPtrLikeOptional(mod)) {	4499	} else if (lhs_ty.isPtrLikeOptional(zcu)) {
4500	break :blk Type.usize;	4500	break :blk Type.usize;
4501	} else {	4501	} else {
4502	return self.fail("TODO ARM cmp non-pointer optionals", .{});	4502	return self.fail("TODO ARM cmp non-pointer optionals", .{});
4503	}	4503	}
4504	},	4504	},
4505	.Float => return self.fail("TODO ARM cmp floats", .{}),	4505	.Float => return self.fail("TODO ARM cmp floats", .{}),
4506	.Enum => lhs_ty.intTagType(mod),	4506	.Enum => lhs_ty.intTagType(zcu),
4507	.Int => lhs_ty,	4507	.Int => lhs_ty,
4508	.Bool => Type.u1,	4508	.Bool => Type.u1,
4509	.Pointer => Type.usize,	4509	.Pointer => Type.usize,
...	@@ -4511,7 +4511,7 @@ fn cmp(	...	@@ -4511,7 +4511,7 @@ fn cmp(
4511	else => unreachable,	4511	else => unreachable,
4512	};	4512	};
4513		4513
4514	const int_info = int_ty.intInfo(mod);	4514	const int_info = int_ty.intInfo(zcu);
4515	if (int_info.bits <= 32) {	4515	if (int_info.bits <= 32) {
4516	try self.spillCompareFlagsIfOccupied();	4516	try self.spillCompareFlagsIfOccupied();
4517		4517
...	@@ -4597,10 +4597,10 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4597,10 +4597,10 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void {
4597		4597
4598	fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {	4598	fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {
4599	const pt = self.pt;	4599	const pt = self.pt;
4600	const mod = pt.zcu;	4600	const zcu = pt.zcu;
4601	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	4601	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
4602	const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);	4602	const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
4603	const func = mod.funcInfo(extra.data.func);	4603	const func = zcu.funcInfo(extra.data.func);
4604	// TODO emit debug info for function change	4604	// TODO emit debug info for function change
4605	_ = func;	4605	_ = func;
4606	try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));	4606	try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
...	@@ -4810,9 +4810,9 @@ fn isNull(	...	@@ -4810,9 +4810,9 @@ fn isNull(
4810	operand_ty: Type,	4810	operand_ty: Type,
4811	) !MCValue {	4811	) !MCValue {
4812	const pt = self.pt;	4812	const pt = self.pt;
4813	const mod = pt.zcu;	4813	const zcu = pt.zcu;
4814	if (operand_ty.isPtrLikeOptional(mod)) {	4814	if (operand_ty.isPtrLikeOptional(zcu)) {
4815	assert(operand_ty.abiSize(pt) == 4);	4815	assert(operand_ty.abiSize(zcu) == 4);
4816		4816
4817	const imm_bind: ReadArg.Bind = .{ .mcv = .{ .immediate = 0 } };	4817	const imm_bind: ReadArg.Bind = .{ .mcv = .{ .immediate = 0 } };
4818	return self.cmp(operand_bind, imm_bind, Type.usize, .eq);	4818	return self.cmp(operand_bind, imm_bind, Type.usize, .eq);
...	@@ -4845,12 +4845,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4845,12 +4845,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
4845		4845
4846	fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {	4846	fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
4847	const pt = self.pt;	4847	const pt = self.pt;
4848	const mod = pt.zcu;	4848	const zcu = pt.zcu;
4849	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4849	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4850	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4850	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
4851	const operand_ptr = try self.resolveInst(un_op);	4851	const operand_ptr = try self.resolveInst(un_op);
4852	const ptr_ty = self.typeOf(un_op);	4852	const ptr_ty = self.typeOf(un_op);
4853	const elem_ty = ptr_ty.childType(mod);	4853	const elem_ty = ptr_ty.childType(zcu);
4854		4854
4855	const operand = try self.allocRegOrMem(elem_ty, true, null);	4855	const operand = try self.allocRegOrMem(elem_ty, true, null);
4856	try self.load(operand, operand_ptr, ptr_ty);	4856	try self.load(operand, operand_ptr, ptr_ty);
...	@@ -4873,12 +4873,12 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4873,12 +4873,12 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
4873		4873
4874	fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {	4874	fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
4875	const pt = self.pt;	4875	const pt = self.pt;
4876	const mod = pt.zcu;	4876	const zcu = pt.zcu;
4877	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4877	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4878	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4878	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
4879	const operand_ptr = try self.resolveInst(un_op);	4879	const operand_ptr = try self.resolveInst(un_op);
4880	const ptr_ty = self.typeOf(un_op);	4880	const ptr_ty = self.typeOf(un_op);
4881	const elem_ty = ptr_ty.childType(mod);	4881	const elem_ty = ptr_ty.childType(zcu);
4882		4882
4883	const operand = try self.allocRegOrMem(elem_ty, true, null);	4883	const operand = try self.allocRegOrMem(elem_ty, true, null);
4884	try self.load(operand, operand_ptr, ptr_ty);	4884	try self.load(operand, operand_ptr, ptr_ty);
...	@@ -4894,10 +4894,10 @@ fn isErr(	...	@@ -4894,10 +4894,10 @@ fn isErr(
4894	error_union_ty: Type,	4894	error_union_ty: Type,
4895	) !MCValue {	4895	) !MCValue {
4896	const pt = self.pt;	4896	const pt = self.pt;
4897	const mod = pt.zcu;	4897	const zcu = pt.zcu;
4898	const error_type = error_union_ty.errorUnionSet(mod);	4898	const error_type = error_union_ty.errorUnionSet(zcu);
4899		4899
4900	if (error_type.errorSetIsEmpty(mod)) {	4900	if (error_type.errorSetIsEmpty(zcu)) {
4901	return MCValue{ .immediate = 0 }; // always false	4901	return MCValue{ .immediate = 0 }; // always false
4902	}	4902	}
4903		4903
...	@@ -4937,12 +4937,12 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4937,12 +4937,12 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
4937		4937
4938	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {	4938	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
4939	const pt = self.pt;	4939	const pt = self.pt;
4940	const mod = pt.zcu;	4940	const zcu = pt.zcu;
4941	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4941	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4942	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4942	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
4943	const operand_ptr = try self.resolveInst(un_op);	4943	const operand_ptr = try self.resolveInst(un_op);
4944	const ptr_ty = self.typeOf(un_op);	4944	const ptr_ty = self.typeOf(un_op);
4945	const elem_ty = ptr_ty.childType(mod);	4945	const elem_ty = ptr_ty.childType(zcu);
4946		4946
4947	const operand = try self.allocRegOrMem(elem_ty, true, null);	4947	const operand = try self.allocRegOrMem(elem_ty, true, null);
4948	try self.load(operand, operand_ptr, ptr_ty);	4948	try self.load(operand, operand_ptr, ptr_ty);
...	@@ -4965,12 +4965,12 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4965,12 +4965,12 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
4965		4965
4966	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {	4966	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
4967	const pt = self.pt;	4967	const pt = self.pt;
4968	const mod = pt.zcu;	4968	const zcu = pt.zcu;
4969	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;	4969	const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
4970	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	4970	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
4971	const operand_ptr = try self.resolveInst(un_op);	4971	const operand_ptr = try self.resolveInst(un_op);
4972	const ptr_ty = self.typeOf(un_op);	4972	const ptr_ty = self.typeOf(un_op);
4973	const elem_ty = ptr_ty.childType(mod);	4973	const elem_ty = ptr_ty.childType(zcu);
4974		4974
4975	const operand = try self.allocRegOrMem(elem_ty, true, null);	4975	const operand = try self.allocRegOrMem(elem_ty, true, null);
4976	try self.load(operand, operand_ptr, ptr_ty);	4976	try self.load(operand, operand_ptr, ptr_ty);
...	@@ -5184,10 +5184,10 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5184,10 +5184,10 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
5184	}	5184	}
5185		5185
5186	fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {	5186	fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
5187	const pt = self.pt;	5187	const zcu = self.pt.zcu;
5188	const block_data = self.blocks.getPtr(block).?;	5188	const block_data = self.blocks.getPtr(block).?;
5189		5189
5190	if (self.typeOf(operand).hasRuntimeBits(pt)) {	5190	if (self.typeOf(operand).hasRuntimeBits(zcu)) {
5191	const operand_mcv = try self.resolveInst(operand);	5191	const operand_mcv = try self.resolveInst(operand);
5192	const block_mcv = block_data.mcv;	5192	const block_mcv = block_data.mcv;
5193	if (block_mcv == .none) {	5193	if (block_mcv == .none) {
...	@@ -5356,8 +5356,8 @@ fn setRegOrMem(self: *Self, ty: Type, loc: MCValue, val: MCValue) !void {	...	@@ -5356,8 +5356,8 @@ fn setRegOrMem(self: *Self, ty: Type, loc: MCValue, val: MCValue) !void {
5356		5356
5357	fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {	5357	fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
5358	const pt = self.pt;	5358	const pt = self.pt;
5359	const mod = pt.zcu;	5359	const zcu = pt.zcu;
5360	const abi_size: u32 = @intCast(ty.abiSize(pt));	5360	const abi_size: u32 = @intCast(ty.abiSize(zcu));
5361	switch (mcv) {	5361	switch (mcv) {
5362	.dead => unreachable,	5362	.dead => unreachable,
5363	.unreach, .none => return, // Nothing to do.	5363	.unreach, .none => return, // Nothing to do.
...	@@ -5434,11 +5434,11 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro	...	@@ -5434,11 +5434,11 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
5434	const reg_lock = self.register_manager.lockReg(reg);	5434	const reg_lock = self.register_manager.lockReg(reg);
5435	defer if (reg_lock) \|locked_reg\| self.register_manager.unlockReg(locked_reg);	5435	defer if (reg_lock) \|locked_reg\| self.register_manager.unlockReg(locked_reg);
5436		5436
5437	const wrapped_ty = ty.structFieldType(0, mod);	5437	const wrapped_ty = ty.fieldType(0, zcu);
5438	try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg });	5438	try self.genSetStack(wrapped_ty, stack_offset, .{ .register = reg });
5439		5439
5440	const overflow_bit_ty = ty.structFieldType(1, mod);	5440	const overflow_bit_ty = ty.fieldType(1, zcu);
5441	const overflow_bit_offset: u32 = @intCast(ty.structFieldOffset(1, pt));	5441	const overflow_bit_offset: u32 = @intCast(ty.structFieldOffset(1, zcu));
5442	const cond_reg = try self.register_manager.allocReg(null, gp);	5442	const cond_reg = try self.register_manager.allocReg(null, gp);
5443		5443
5444	// C flag: movcs reg, #1	5444	// C flag: movcs reg, #1
...	@@ -5519,7 +5519,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro	...	@@ -5519,7 +5519,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
5519		5519
5520	fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {	5520	fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
5521	const pt = self.pt;	5521	const pt = self.pt;
5522	const mod = pt.zcu;	5522	const zcu = pt.zcu;
5523	switch (mcv) {	5523	switch (mcv) {
5524	.dead => unreachable,	5524	.dead => unreachable,
5525	.unreach, .none => return, // Nothing to do.	5525	.unreach, .none => return, // Nothing to do.
...	@@ -5694,17 +5694,17 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -5694,17 +5694,17 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
5694	},	5694	},
5695	.stack_offset => \|off\| {	5695	.stack_offset => \|off\| {
5696	// TODO: maybe addressing from sp instead of fp	5696	// TODO: maybe addressing from sp instead of fp
5697	const abi_size: u32 = @intCast(ty.abiSize(pt));	5697	const abi_size: u32 = @intCast(ty.abiSize(zcu));
5698		5698
5699	const tag: Mir.Inst.Tag = switch (abi_size) {	5699	const tag: Mir.Inst.Tag = switch (abi_size) {
5700	1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb else .ldrb,	5700	1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb else .ldrb,
5701	2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh else .ldrh,	5701	2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh else .ldrh,
5702	3, 4 => .ldr,	5702	3, 4 => .ldr,
5703	else => unreachable,	5703	else => unreachable,
5704	};	5704	};
5705		5705
5706	const extra_offset = switch (abi_size) {	5706	const extra_offset = switch (abi_size) {
5707	1 => ty.isSignedInt(mod),	5707	1 => ty.isSignedInt(zcu),
5708	2 => true,	5708	2 => true,
5709	3, 4 => false,	5709	3, 4 => false,
5710	else => unreachable,	5710	else => unreachable,
...	@@ -5745,11 +5745,11 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -5745,11 +5745,11 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
5745	}	5745	}
5746	},	5746	},
5747	.stack_argument_offset => \|off\| {	5747	.stack_argument_offset => \|off\| {
5748	const abi_size = ty.abiSize(pt);	5748	const abi_size = ty.abiSize(zcu);
5749		5749
5750	const tag: Mir.Inst.Tag = switch (abi_size) {	5750	const tag: Mir.Inst.Tag = switch (abi_size) {
5751	1 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsb_stack_argument else .ldrb_stack_argument,	5751	1 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsb_stack_argument else .ldrb_stack_argument,
5752	2 => if (ty.isSignedInt(mod)) Mir.Inst.Tag.ldrsh_stack_argument else .ldrh_stack_argument,	5752	2 => if (ty.isSignedInt(zcu)) Mir.Inst.Tag.ldrsh_stack_argument else .ldrh_stack_argument,
5753	3, 4 => .ldr_stack_argument,	5753	3, 4 => .ldr_stack_argument,
5754	else => unreachable,	5754	else => unreachable,
5755	};	5755	};
...	@@ -5767,7 +5767,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void	...	@@ -5767,7 +5767,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
5767		5767
5768	fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {	5768	fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
5769	const pt = self.pt;	5769	const pt = self.pt;
5770	const abi_size: u32 = @intCast(ty.abiSize(pt));	5770	const abi_size: u32 = @intCast(ty.abiSize(pt.zcu));
5771	switch (mcv) {	5771	switch (mcv) {
5772	.dead => unreachable,	5772	.dead => unreachable,
5773	.none, .unreach => return,	5773	.none, .unreach => return,
...	@@ -5923,13 +5923,13 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5923,13 +5923,13 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
5923		5923
5924	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {	5924	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
5925	const pt = self.pt;	5925	const pt = self.pt;
5926	const mod = pt.zcu;	5926	const zcu = pt.zcu;
5927	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;	5927	const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
5928	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	5928	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
5929	const ptr_ty = self.typeOf(ty_op.operand);	5929	const ptr_ty = self.typeOf(ty_op.operand);
5930	const ptr = try self.resolveInst(ty_op.operand);	5930	const ptr = try self.resolveInst(ty_op.operand);
5931	const array_ty = ptr_ty.childType(mod);	5931	const array_ty = ptr_ty.childType(zcu);
5932	const array_len: u32 = @intCast(array_ty.arrayLen(mod));	5932	const array_len: u32 = @intCast(array_ty.arrayLen(zcu));
5933		5933
5934	const stack_offset = try self.allocMem(8, .@"8", inst);	5934	const stack_offset = try self.allocMem(8, .@"8", inst);
5935	try self.genSetStack(ptr_ty, stack_offset, ptr);	5935	try self.genSetStack(ptr_ty, stack_offset, ptr);
...	@@ -6043,9 +6043,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -6043,9 +6043,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
6043		6043
6044	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	6044	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
6045	const pt = self.pt;	6045	const pt = self.pt;
6046	const mod = pt.zcu;	6046	const zcu = pt.zcu;
6047	const vector_ty = self.typeOfIndex(inst);	6047	const vector_ty = self.typeOfIndex(inst);
6048	const len = vector_ty.vectorLen(mod);	6048	const len = vector_ty.vectorLen(zcu);
6049	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	6049	const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
6050	const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);	6050	const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
6051	const result: MCValue = res: {	6051	const result: MCValue = res: {
...	@@ -6095,8 +6095,8 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -6095,8 +6095,8 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
6095	const result: MCValue = result: {	6095	const result: MCValue = result: {
6096	const error_union_bind: ReadArg.Bind = .{ .inst = pl_op.operand };	6096	const error_union_bind: ReadArg.Bind = .{ .inst = pl_op.operand };
6097	const error_union_ty = self.typeOf(pl_op.operand);	6097	const error_union_ty = self.typeOf(pl_op.operand);
6098	const error_union_size: u32 = @intCast(error_union_ty.abiSize(pt));	6098	const error_union_size: u32 = @intCast(error_union_ty.abiSize(pt.zcu));
6099	const error_union_align = error_union_ty.abiAlignment(pt);	6099	const error_union_align = error_union_ty.abiAlignment(pt.zcu);
6100		6100
6101	// The error union will die in the body. However, we need the	6101	// The error union will die in the body. However, we need the
6102	// error union after the body in order to extract the payload	6102	// error union after the body in order to extract the payload
...	@@ -6126,11 +6126,11 @@ fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -6126,11 +6126,11 @@ fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
6126		6126
6127	fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {	6127	fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
6128	const pt = self.pt;	6128	const pt = self.pt;
6129	const mod = pt.zcu;	6129	const zcu = pt.zcu;
6130		6130
6131	// If the type has no codegen bits, no need to store it.	6131	// If the type has no codegen bits, no need to store it.
6132	const inst_ty = self.typeOf(inst);	6132	const inst_ty = self.typeOf(inst);
6133	if (!inst_ty.hasRuntimeBitsIgnoreComptime(pt) and !inst_ty.isError(mod))	6133	if (!inst_ty.hasRuntimeBitsIgnoreComptime(zcu) and !inst_ty.isError(zcu))
6134	return MCValue{ .none = {} };	6134	return MCValue{ .none = {} };
6135		6135
6136	const inst_index = inst.toIndex() orelse return self.genTypedValue((try self.air.value(inst, pt)).?);	6136	const inst_index = inst.toIndex() orelse return self.genTypedValue((try self.air.value(inst, pt)).?);
...	@@ -6189,9 +6189,9 @@ const CallMCValues = struct {	...	@@ -6189,9 +6189,9 @@ const CallMCValues = struct {
6189	/// Caller must call `CallMCValues.deinit`.	6189	/// Caller must call `CallMCValues.deinit`.
6190	fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	6190	fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6191	const pt = self.pt;	6191	const pt = self.pt;
6192	const mod = pt.zcu;	6192	const zcu = pt.zcu;
6193	const ip = &mod.intern_pool;	6193	const ip = &zcu.intern_pool;
6194	const fn_info = mod.typeToFunc(fn_ty).?;	6194	const fn_info = zcu.typeToFunc(fn_ty).?;
6195	const cc = fn_info.cc;	6195	const cc = fn_info.cc;
6196	var result: CallMCValues = .{	6196	var result: CallMCValues = .{
6197	.args = try self.gpa.alloc(MCValue, fn_info.param_types.len),	6197	.args = try self.gpa.alloc(MCValue, fn_info.param_types.len),
...	@@ -6202,7 +6202,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6202,7 +6202,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6202	};	6202	};
6203	errdefer self.gpa.free(result.args);	6203	errdefer self.gpa.free(result.args);
6204		6204
6205	const ret_ty = fn_ty.fnReturnType(mod);	6205	const ret_ty = fn_ty.fnReturnType(zcu);
6206		6206
6207	switch (cc) {	6207	switch (cc) {
6208	.Naked => {	6208	.Naked => {
...	@@ -6217,12 +6217,12 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6217,12 +6217,12 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6217	var ncrn: usize = 0; // Next Core Register Number	6217	var ncrn: usize = 0; // Next Core Register Number
6218	var nsaa: u32 = 0; // Next stacked argument address	6218	var nsaa: u32 = 0; // Next stacked argument address
6219		6219
6220	if (ret_ty.zigTypeTag(mod) == .NoReturn) {	6220	if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
6221	result.return_value = .{ .unreach = {} };	6221	result.return_value = .{ .unreach = {} };
6222	} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {	6222	} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
6223	result.return_value = .{ .none = {} };	6223	result.return_value = .{ .none = {} };
6224	} else {	6224	} else {
6225	const ret_ty_size: u32 = @intCast(ret_ty.abiSize(pt));	6225	const ret_ty_size: u32 = @intCast(ret_ty.abiSize(zcu));
6226	// TODO handle cases where multiple registers are used	6226	// TODO handle cases where multiple registers are used
6227	if (ret_ty_size <= 4) {	6227	if (ret_ty_size <= 4) {
6228	result.return_value = .{ .register = c_abi_int_return_regs[0] };	6228	result.return_value = .{ .register = c_abi_int_return_regs[0] };
...	@@ -6237,10 +6237,10 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6237,10 +6237,10 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6237	}	6237	}
6238		6238
6239	for (fn_info.param_types.get(ip), result.args) \|ty, *result_arg\| {	6239	for (fn_info.param_types.get(ip), result.args) \|ty, *result_arg\| {
6240	if (Type.fromInterned(ty).abiAlignment(pt) == .@"8")	6240	if (Type.fromInterned(ty).abiAlignment(zcu) == .@"8")
6241	ncrn = std.mem.alignForward(usize, ncrn, 2);	6241	ncrn = std.mem.alignForward(usize, ncrn, 2);
6242		6242
6243	const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(pt));	6243	const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(zcu));
6244	if (std.math.divCeil(u32, param_size, 4) catch unreachable <= 4 - ncrn) {	6244	if (std.math.divCeil(u32, param_size, 4) catch unreachable <= 4 - ncrn) {
6245	if (param_size <= 4) {	6245	if (param_size <= 4) {
6246	result_arg.* = .{ .register = c_abi_int_param_regs[ncrn] };	6246	result_arg.* = .{ .register = c_abi_int_param_regs[ncrn] };
...	@@ -6252,7 +6252,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6252,7 +6252,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6252	return self.fail("TODO MCValues split between registers and stack", .{});	6252	return self.fail("TODO MCValues split between registers and stack", .{});
6253	} else {	6253	} else {
6254	ncrn = 4;	6254	ncrn = 4;
6255	if (Type.fromInterned(ty).abiAlignment(pt) == .@"8")	6255	if (Type.fromInterned(ty).abiAlignment(zcu) == .@"8")
6256	nsaa = std.mem.alignForward(u32, nsaa, 8);	6256	nsaa = std.mem.alignForward(u32, nsaa, 8);
6257		6257
6258	result_arg.* = .{ .stack_argument_offset = nsaa };	6258	result_arg.* = .{ .stack_argument_offset = nsaa };
...	@@ -6264,14 +6264,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6264,14 +6264,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6264	result.stack_align = 8;	6264	result.stack_align = 8;
6265	},	6265	},
6266	.Unspecified => {	6266	.Unspecified => {
6267	if (ret_ty.zigTypeTag(mod) == .NoReturn) {	6267	if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
6268	result.return_value = .{ .unreach = {} };	6268	result.return_value = .{ .unreach = {} };
6269	} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt) and !ret_ty.isError(mod)) {	6269	} else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
6270	result.return_value = .{ .none = {} };	6270	result.return_value = .{ .none = {} };
6271	} else {	6271	} else {
6272	const ret_ty_size: u32 = @intCast(ret_ty.abiSize(pt));	6272	const ret_ty_size: u32 = @intCast(ret_ty.abiSize(zcu));
6273	if (ret_ty_size == 0) {	6273	if (ret_ty_size == 0) {
6274	assert(ret_ty.isError(mod));	6274	assert(ret_ty.isError(zcu));
6275	result.return_value = .{ .immediate = 0 };	6275	result.return_value = .{ .immediate = 0 };
6276	} else if (ret_ty_size <= 4) {	6276	} else if (ret_ty_size <= 4) {
6277	result.return_value = .{ .register = .r0 };	6277	result.return_value = .{ .register = .r0 };
...	@@ -6287,9 +6287,9 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {	...	@@ -6287,9 +6287,9 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
6287	var stack_offset: u32 = 0;	6287	var stack_offset: u32 = 0;
6288		6288
6289	for (fn_info.param_types.get(ip), result.args) \|ty, *result_arg\| {	6289	for (fn_info.param_types.get(ip), result.args) \|ty, *result_arg\| {
6290	if (Type.fromInterned(ty).abiSize(pt) > 0) {	6290	if (Type.fromInterned(ty).abiSize(zcu) > 0) {
6291	const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(pt));	6291	const param_size: u32 = @intCast(Type.fromInterned(ty).abiSize(zcu));
6292	const param_alignment = Type.fromInterned(ty).abiAlignment(pt);	6292	const param_alignment = Type.fromInterned(ty).abiAlignment(zcu);
6293		6293
6294	stack_offset = @intCast(param_alignment.forward(stack_offset));	6294	stack_offset = @intCast(param_alignment.forward(stack_offset));
6295	result_arg.* = .{ .stack_argument_offset = stack_offset };	6295	result_arg.* = .{ .stack_argument_offset = stack_offset };

src/arch/arm/abi.zig+22-22

...	@@ -24,29 +24,29 @@ pub const Class = union(enum) {	...	@@ -24,29 +24,29 @@ pub const Class = union(enum) {
24		24
25	pub const Context = enum { ret, arg };	25	pub const Context = enum { ret, arg };
26		26
27	pub fn classifyType(ty: Type, pt: Zcu.PerThread, ctx: Context) Class {	27	pub fn classifyType(ty: Type, zcu: *Zcu, ctx: Context) Class {
28	assert(ty.hasRuntimeBitsIgnoreComptime(pt));	28	assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
29		29
30	var maybe_float_bits: ?u16 = null;	30	var maybe_float_bits: ?u16 = null;
31	const max_byval_size = 512;	31	const max_byval_size = 512;
32	const ip = &pt.zcu.intern_pool;	32	const ip = &zcu.intern_pool;
33	switch (ty.zigTypeTag(pt.zcu)) {	33	switch (ty.zigTypeTag(zcu)) {
34	.Struct => {	34	.Struct => {
35	const bit_size = ty.bitSize(pt);	35	const bit_size = ty.bitSize(zcu);
36	if (ty.containerLayout(pt.zcu) == .@"packed") {	36	if (ty.containerLayout(zcu) == .@"packed") {
37	if (bit_size > 64) return .memory;	37	if (bit_size > 64) return .memory;
38	return .byval;	38	return .byval;
39	}	39	}
40	if (bit_size > max_byval_size) return .memory;	40	if (bit_size > max_byval_size) return .memory;
41	const float_count = countFloats(ty, pt.zcu, &maybe_float_bits);	41	const float_count = countFloats(ty, zcu, &maybe_float_bits);
42	if (float_count <= byval_float_count) return .byval;	42	if (float_count <= byval_float_count) return .byval;
43		43
44	const fields = ty.structFieldCount(pt.zcu);	44	const fields = ty.structFieldCount(zcu);
45	var i: u32 = 0;	45	var i: u32 = 0;
46	while (i < fields) : (i += 1) {	46	while (i < fields) : (i += 1) {
47	const field_ty = ty.structFieldType(i, pt.zcu);	47	const field_ty = ty.fieldType(i, zcu);
48	const field_alignment = ty.structFieldAlign(i, pt);	48	const field_alignment = ty.fieldAlignment(i, zcu);
49	const field_size = field_ty.bitSize(pt);	49	const field_size = field_ty.bitSize(zcu);
50	if (field_size > 32 or field_alignment.compare(.gt, .@"32")) {	50	if (field_size > 32 or field_alignment.compare(.gt, .@"32")) {
51	return Class.arrSize(bit_size, 64);	51	return Class.arrSize(bit_size, 64);
52	}	52	}
...	@@ -54,19 +54,19 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread, ctx: Context) Class {	...	@@ -54,19 +54,19 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread, ctx: Context) Class {
54	return Class.arrSize(bit_size, 32);	54	return Class.arrSize(bit_size, 32);
55	},	55	},
56	.Union => {	56	.Union => {
57	const bit_size = ty.bitSize(pt);	57	const bit_size = ty.bitSize(zcu);
58	const union_obj = pt.zcu.typeToUnion(ty).?;	58	const union_obj = zcu.typeToUnion(ty).?;
59	if (union_obj.flagsUnordered(ip).layout == .@"packed") {	59	if (union_obj.flagsUnordered(ip).layout == .@"packed") {
60	if (bit_size > 64) return .memory;	60	if (bit_size > 64) return .memory;
61	return .byval;	61	return .byval;
62	}	62	}
63	if (bit_size > max_byval_size) return .memory;	63	if (bit_size > max_byval_size) return .memory;
64	const float_count = countFloats(ty, pt.zcu, &maybe_float_bits);	64	const float_count = countFloats(ty, zcu, &maybe_float_bits);
65	if (float_count <= byval_float_count) return .byval;	65	if (float_count <= byval_float_count) return .byval;
66		66
67	for (union_obj.field_types.get(ip), 0..) \|field_ty, field_index\| {	67	for (union_obj.field_types.get(ip), 0..) \|field_ty, field_index\| {
68	if (Type.fromInterned(field_ty).bitSize(pt) > 32 or	68	if (Type.fromInterned(field_ty).bitSize(zcu) > 32 or
69	pt.unionFieldNormalAlignment(union_obj, @intCast(field_index)).compare(.gt, .@"32"))	69	ty.fieldAlignment(field_index, zcu).compare(.gt, .@"32"))
70	{	70	{
71	return Class.arrSize(bit_size, 64);	71	return Class.arrSize(bit_size, 64);
72	}	72	}
...	@@ -77,28 +77,28 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread, ctx: Context) Class {	...	@@ -77,28 +77,28 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread, ctx: Context) Class {
77	.Int => {	77	.Int => {
78	// TODO this is incorrect for _BitInt(128) but implementing	78	// TODO this is incorrect for _BitInt(128) but implementing
79	// this correctly makes implementing compiler-rt impossible.	79	// this correctly makes implementing compiler-rt impossible.
80	// const bit_size = ty.bitSize(pt);	80	// const bit_size = ty.bitSize(zcu);
81	// if (bit_size > 64) return .memory;	81	// if (bit_size > 64) return .memory;
82	return .byval;	82	return .byval;
83	},	83	},
84	.Enum, .ErrorSet => {	84	.Enum, .ErrorSet => {
85	const bit_size = ty.bitSize(pt);	85	const bit_size = ty.bitSize(zcu);
86	if (bit_size > 64) return .memory;	86	if (bit_size > 64) return .memory;
87	return .byval;	87	return .byval;
88	},	88	},
89	.Vector => {	89	.Vector => {
90	const bit_size = ty.bitSize(pt);	90	const bit_size = ty.bitSize(zcu);
91	// TODO is this controlled by a cpu feature?	91	// TODO is this controlled by a cpu feature?
92	if (ctx == .ret and bit_size > 128) return .memory;	92	if (ctx == .ret and bit_size > 128) return .memory;
93	if (bit_size > 512) return .memory;	93	if (bit_size > 512) return .memory;
94	return .byval;	94	return .byval;
95	},	95	},
96	.Optional => {	96	.Optional => {
97	assert(ty.isPtrLikeOptional(pt.zcu));	97	assert(ty.isPtrLikeOptional(zcu));
98	return .byval;	98	return .byval;
99	},	99	},
100	.Pointer => {	100	.Pointer => {
101	assert(!ty.isSlice(pt.zcu));	101	assert(!ty.isSlice(zcu));
102	return .byval;	102	return .byval;
103	},	103	},
104	.ErrorUnion,	104	.ErrorUnion,
...	@@ -141,7 +141,7 @@ fn countFloats(ty: Type, zcu: Zcu, maybe_float_bits: ?u16) u32 {	...	@@ -141,7 +141,7 @@ fn countFloats(ty: Type, zcu: Zcu, maybe_float_bits: ?u16) u32 {
141	var count: u32 = 0;	141	var count: u32 = 0;
142	var i: u32 = 0;	142	var i: u32 = 0;
143	while (i < fields_len) : (i += 1) {	143	while (i < fields_len) : (i += 1) {
144	const field_ty = ty.structFieldType(i, zcu);	144	const field_ty = ty.fieldType(i, zcu);
145	const field_count = countFloats(field_ty, zcu, maybe_float_bits);	145	const field_count = countFloats(field_ty, zcu, maybe_float_bits);
146	if (field_count == invalid) return invalid;	146	if (field_count == invalid) return invalid;
147	count += field_count;	147	count += field_count;

src/arch/riscv64/CodeGen.zig+168-161

 @@ -591,14 +591,14 @@ const FrameAlloc = struct {
             .ref_count = 0,
         };
     }
-    fn initType(ty: Type, pt: Zcu.PerThread) FrameAlloc {
+    fn initType(ty: Type, zcu: *Zcu) FrameAlloc {
         return init(.{
-            .size = ty.abiSize(pt),
+            .size = ty.abiSize(zcu),
-            .alignment = ty.abiAlignment(pt),
+            .alignment = ty.abiAlignment(zcu),
         });
     }
-    fn initSpill(ty: Type, pt: Zcu.PerThread) FrameAlloc {
+    fn initSpill(ty: Type, zcu: *Zcu) FrameAlloc {
-        const abi_size = ty.abiSize(pt);
+        const abi_size = ty.abiSize(zcu);
         const spill_size = if (abi_size < 8)
             math.ceilPowerOfTwoAssert(u64, abi_size)
         else
 @@ -606,7 +606,7 @@ const FrameAlloc = struct {
         return init(.{
             .size = spill_size,
             .pad = @intCast(spill_size - abi_size),
-            .alignment = ty.abiAlignment(pt).maxStrict(
+            .alignment = ty.abiAlignment(zcu).maxStrict(
                 Alignment.fromNonzeroByteUnits(@min(spill_size, 8)),
             ),
         });
 @@ -835,11 +835,11 @@ pub fn generate(
     function.args = call_info.args;
     function.ret_mcv = call_info.return_value;
     function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), FrameAlloc.init(.{
-        .size = Type.u64.abiSize(pt),
+        .size = Type.u64.abiSize(zcu),
-        .alignment = Type.u64.abiAlignment(pt).min(call_info.stack_align),
+        .alignment = Type.u64.abiAlignment(zcu).min(call_info.stack_align),
     }));
     function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), FrameAlloc.init(.{
-        .size = Type.u64.abiSize(pt),
+        .size = Type.u64.abiSize(zcu),
         .alignment = Alignment.min(
             call_info.stack_align,
             Alignment.fromNonzeroByteUnits(function.target.stackAlignment()),
 @@ -851,7 +851,7 @@ pub fn generate(
     }));
     function.frame_allocs.set(@intFromEnum(FrameIndex.spill_frame), FrameAlloc.init(.{
         .size = 0,
-        .alignment = Type.u64.abiAlignment(pt),
+        .alignment = Type.u64.abiAlignment(zcu),
     }));
     function.gen() catch |err| switch (err) {
 @@ -1245,7 +1245,7 @@ fn gen(func: *Func) !void {
                 // The address where to store the return value for the caller is in a
                 // register which the callee is free to clobber. Therefore, we purposely
                 // spill it to stack immediately.
-                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(Type.u64, pt));
+                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(Type.u64, zcu));
                 try func.genSetMem(
                     .{ .frame = frame_index },
                     0,
 @@ -1379,9 +1379,9 @@ fn gen(func: *Func) !void {
 fn genLazy(func: *Func, lazy_sym: link.File.LazySymbol) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (Type.fromInterned(lazy_sym.ty).zigTypeTag(mod)) {
+    switch (Type.fromInterned(lazy_sym.ty).zigTypeTag(zcu)) {
         .Enum => {
             const enum_ty = Type.fromInterned(lazy_sym.ty);
             wip_mir_log.debug("{}.@tagName:", .{enum_ty.fmt(pt)});
 @@ -1390,7 +1390,7 @@ fn genLazy(func: *Func, lazy_sym: link.File.LazySymbol) InnerError!void {
             const ret_reg = param_regs[0];
             const enum_mcv: MCValue = .{ .register = param_regs[1] };
-            const exitlude_jump_relocs = try func.gpa.alloc(Mir.Inst.Index, enum_ty.enumFieldCount(mod));
+            const exitlude_jump_relocs = try func.gpa.alloc(Mir.Inst.Index, enum_ty.enumFieldCount(zcu));
             defer func.gpa.free(exitlude_jump_relocs);
             const data_reg, const data_lock = try func.allocReg(.int);
 @@ -1410,7 +1410,7 @@ fn genLazy(func: *Func, lazy_sym: link.File.LazySymbol) InnerError!void {
             defer func.register_manager.unlockReg(cmp_lock);
             var data_off: i32 = 0;
-            const tag_names = enum_ty.enumFields(mod);
+            const tag_names = enum_ty.enumFields(zcu);
             for (exitlude_jump_relocs, 0..) |*exitlude_jump_reloc, tag_index| {
                 const tag_name_len = tag_names.get(ip)[tag_index].length(ip);
                 const tag_val = try pt.enumValueFieldIndex(enum_ty, @intCast(tag_index));
 @@ -1944,32 +1944,32 @@ fn memSize(func: *Func, ty: Type) Memory.Size {
     const zcu = pt.zcu;
     return switch (ty.zigTypeTag(zcu)) {
         .Float => Memory.Size.fromBitSize(ty.floatBits(func.target.*)),
-        else => Memory.Size.fromByteSize(ty.abiSize(pt)),
+        else => Memory.Size.fromByteSize(ty.abiSize(zcu)),
     };
 }
 fn splitType(func: *Func, ty: Type) ![2]Type {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
-    const classes = mem.sliceTo(&abi.classifySystem(ty, pt), .none);
+    const classes = mem.sliceTo(&abi.classifySystem(ty, zcu), .none);
     var parts: [2]Type = undefined;
     if (classes.len == 2) for (&parts, classes, 0..) |*part, class, part_i| {
         part.* = switch (class) {
             .integer => switch (part_i) {
                 0 => Type.u64,
                 1 => part: {
-                    const elem_size = ty.abiAlignment(pt).minStrict(.@"8").toByteUnits().?;
+                    const elem_size = ty.abiAlignment(zcu).minStrict(.@"8").toByteUnits().?;
-                    const elem_ty = try pt.intType(.unsigned, @intCast(elem_size * 8));
+                    const elem_ty = try func.pt.intType(.unsigned, @intCast(elem_size * 8));
-                    break :part switch (@divExact(ty.abiSize(pt) - 8, elem_size)) {
+                    break :part switch (@divExact(ty.abiSize(zcu) - 8, elem_size)) {
                         1 => elem_ty,
-                        else => |len| try pt.arrayType(.{ .len = len, .child = elem_ty.toIntern() }),
+                        else => |len| try func.pt.arrayType(.{ .len = len, .child = elem_ty.toIntern() }),
                     };
                 },
                 else => unreachable,
             },
             else => return func.fail("TODO: splitType class {}", .{class}),
         };
-    } else if (parts[0].abiSize(pt) + parts[1].abiSize(pt) == ty.abiSize(pt)) return parts;
+    } else if (parts[0].abiSize(zcu) + parts[1].abiSize(zcu) == ty.abiSize(zcu)) return parts;
-    return func.fail("TODO implement splitType for {}", .{ty.fmt(pt)});
+    return func.fail("TODO implement splitType for {}", .{ty.fmt(func.pt)});
 }
 /// Truncates the value in the register in place.
 @@ -1979,7 +1979,7 @@ fn truncateRegister(func: *Func, ty: Type, reg: Register) !void {
     const zcu = pt.zcu;
     const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.builtin.Type.Int{
         .signedness = .unsigned,
-        .bits = @intCast(ty.bitSize(pt)),
+        .bits = @intCast(ty.bitSize(zcu)),
     };
     assert(reg.class() == .int);
 @@ -2081,10 +2081,10 @@ fn allocMemPtr(func: *Func, inst: Air.Inst.Index) !FrameIndex {
     const ptr_ty = func.typeOfIndex(inst);
     const val_ty = ptr_ty.childType(zcu);
     return func.allocFrameIndex(FrameAlloc.init(.{
-        .size = math.cast(u32, val_ty.abiSize(pt)) orelse {
+        .size = math.cast(u32, val_ty.abiSize(zcu)) orelse {
             return func.fail("type '{}' too big to fit into stack frame", .{val_ty.fmt(pt)});
         },
-        .alignment = ptr_ty.ptrAlignment(pt).max(.@"1"),
+        .alignment = ptr_ty.ptrAlignment(zcu).max(.@"1"),
     }));
 }
 @@ -2118,7 +2118,7 @@ fn allocRegOrMem(func: *Func, elem_ty: Type, inst: ?Air.Inst.Index, reg_ok: bool
     const pt = func.pt;
     const zcu = pt.zcu;
-    const bit_size = elem_ty.bitSize(pt);
+    const bit_size = elem_ty.bitSize(zcu);
     const min_size: u64 = switch (elem_ty.zigTypeTag(zcu)) {
         .Float => if (func.hasFeature(.d)) 64 else 32,
         .Vector => 256, // TODO: calculate it from avl * vsew
 @@ -2133,7 +2133,7 @@ fn allocRegOrMem(func: *Func, elem_ty: Type, inst: ?Air.Inst.Index, reg_ok: bool
         return func.fail("did you forget to extend vector registers before allocating", .{});
     }
-    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(elem_ty, pt));
+    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(elem_ty, zcu));
     return .{ .load_frame = .{ .index = frame_index } };
 }
 @@ -2368,7 +2368,7 @@ fn airNot(func: *Func, inst: Air.Inst.Index) !void {
                 });
             },
             .Int => {
-                const size = ty.bitSize(pt);
+                const size = ty.bitSize(zcu);
                 if (!math.isPowerOfTwo(size))
                     return func.fail("TODO: airNot non-pow 2 int size", .{});
 @@ -2399,11 +2399,12 @@ fn airNot(func: *Func, inst: Air.Inst.Index) !void {
 fn airSlice(func: *Func, inst: Air.Inst.Index) !void {
     const pt = func.pt;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
     const slice_ty = func.typeOfIndex(inst);
-    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(slice_ty, pt));
+    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(slice_ty, zcu));
     const ptr_ty = func.typeOf(bin_op.lhs);
     try func.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, .{ .air_ref = bin_op.lhs });
 @@ -2411,7 +2412,7 @@ fn airSlice(func: *Func, inst: Air.Inst.Index) !void {
     const len_ty = func.typeOf(bin_op.rhs);
     try func.genSetMem(
         .{ .frame = frame_index },
-        @intCast(ptr_ty.abiSize(pt)),
+        @intCast(ptr_ty.abiSize(zcu)),
         len_ty,
         .{ .air_ref = bin_op.rhs },
     );
 @@ -2428,8 +2429,8 @@ fn airBinOp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
     const dst_ty = func.typeOfIndex(inst);
     if (dst_ty.isAbiInt(zcu)) {
-        const abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+        const abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-        const bit_size: u32 = @intCast(dst_ty.bitSize(pt));
+        const bit_size: u32 = @intCast(dst_ty.bitSize(zcu));
         if (abi_size * 8 > bit_size) {
             const dst_lock = switch (dst_mcv) {
                 .register => |dst_reg| func.register_manager.lockRegAssumeUnused(dst_reg),
 @@ -2443,7 +2444,7 @@ fn airBinOp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
                 const tmp_reg, const tmp_lock = try func.allocReg(.int);
                 defer func.register_manager.unlockReg(tmp_lock);
-                const hi_ty = try pt.intType(.unsigned, @intCast((dst_ty.bitSize(pt) - 1) % 64 + 1));
+                const hi_ty = try pt.intType(.unsigned, @intCast((dst_ty.bitSize(zcu) - 1) % 64 + 1));
                 const hi_mcv = dst_mcv.address().offset(@intCast(bit_size / 64 * 8)).deref();
                 try func.genSetReg(hi_ty, tmp_reg, hi_mcv);
                 try func.truncateRegister(dst_ty, tmp_reg);
 @@ -2464,6 +2465,7 @@ fn binOp(
 ) !MCValue {
     _ = maybe_inst;
     const pt = func.pt;
+    const zcu = pt.zcu;
     const lhs_ty = func.typeOf(lhs_air);
     const rhs_ty = func.typeOf(rhs_air);
 @@ -2480,9 +2482,9 @@ fn binOp(
     }
     // don't have support for certain sizes of addition
-    switch (lhs_ty.zigTypeTag(pt.zcu)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Vector => {}, // works differently and fails in a different place
-        else => if (lhs_ty.bitSize(pt) > 64) return func.fail("TODO: binOp >= 64 bits", .{}),
+        else => if (lhs_ty.bitSize(zcu) > 64) return func.fail("TODO: binOp >= 64 bits", .{}),
     }
     const lhs_mcv = try func.resolveInst(lhs_air);
 @@ -2533,7 +2535,7 @@ fn genBinOp(
 ) !void {
     const pt = func.pt;
     const zcu = pt.zcu;
-    const bit_size = lhs_ty.bitSize(pt);
+    const bit_size = lhs_ty.bitSize(zcu);
     const is_unsigned = lhs_ty.isUnsignedInt(zcu);
 @@ -2646,7 +2648,7 @@ fn genBinOp(
                 },
                 .Vector => {
                     const num_elem = lhs_ty.vectorLen(zcu);
-                    const elem_size = lhs_ty.childType(zcu).bitSize(pt);
+                    const elem_size = lhs_ty.childType(zcu).bitSize(zcu);
                     const child_ty = lhs_ty.childType(zcu);
 @@ -2753,7 +2755,7 @@ fn genBinOp(
             defer func.register_manager.unlockReg(tmp_lock);
             // RISC-V has no immediate mul, so we copy the size to a temporary register
-            const elem_size = lhs_ty.elemType2(zcu).abiSize(pt);
+            const elem_size = lhs_ty.elemType2(zcu).abiSize(zcu);
             const elem_size_reg = try func.copyToTmpRegister(Type.u64, .{ .immediate = elem_size });
             try func.genBinOp(
 @@ -2990,7 +2992,7 @@ fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                     try func.genSetMem(
                         .{ .frame = offset.index },
-                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, pt))),
+                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
                         lhs_ty,
                         add_result,
                     );
 @@ -3016,7 +3018,7 @@ fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                     try func.genSetMem(
                         .{ .frame = offset.index },
-                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, pt))),
+                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
                         Type.u1,
                         .{ .register = overflow_reg },
                     );
 @@ -3053,7 +3055,7 @@ fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                     try func.genSetMem(
                         .{ .frame = offset.index },
-                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, pt))),
+                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
                         lhs_ty,
                         add_result,
                     );
 @@ -3079,7 +3081,7 @@ fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                     try func.genSetMem(
                         .{ .frame = offset.index },
-                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, pt))),
+                        offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
                         Type.u1,
                         .{ .register = overflow_reg },
                     );
 @@ -3126,7 +3128,7 @@ fn airSubWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
         try func.genSetMem(
             .{ .frame = offset.index },
-            offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, pt))),
+            offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
             lhs_ty,
             .{ .register = dest_reg },
         );
 @@ -3155,7 +3157,7 @@ fn airSubWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                 try func.genSetMem(
                     .{ .frame = offset.index },
-                    offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, pt))),
+                    offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
                     Type.u1,
                     .{ .register = overflow_reg },
                 );
 @@ -3203,7 +3205,7 @@ fn airSubWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
                         try func.genSetMem(
                             .{ .frame = offset.index },
-                            offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, pt))),
+                            offset.off + @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
                             Type.u1,
                             .{ .register = overflow_reg },
                         );
 @@ -3236,8 +3238,8 @@ fn airMulWithOverflow(func: *Func, inst: Air.Inst.Index) !void {
         // genSetReg needs to support register_offset src_mcv for this to be true.
         const result_mcv = try func.allocRegOrMem(tuple_ty, inst, false);
-        const result_off: i32 = @intCast(tuple_ty.structFieldOffset(0, pt));
+        const result_off: i32 = @intCast(tuple_ty.structFieldOffset(0, zcu));
-        const overflow_off: i32 = @intCast(tuple_ty.structFieldOffset(1, pt));
+        const overflow_off: i32 = @intCast(tuple_ty.structFieldOffset(1, zcu));
         const dest_reg, const dest_lock = try func.allocReg(.int);
         defer func.register_manager.unlockReg(dest_lock);
 @@ -3320,11 +3322,11 @@ fn airShlSat(func: *Func, inst: Air.Inst.Index) !void {
 }
 fn airOptionalPayload(func: *Func, inst: Air.Inst.Index) !void {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const pl_ty = func.typeOfIndex(inst);
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const opt_mcv = try func.resolveInst(ty_op.operand);
         if (func.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) {
 @@ -3368,11 +3370,11 @@ fn airUnwrapErrErr(func: *Func, inst: Air.Inst.Index) !void {
             break :result .{ .immediate = 0 };
         }
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result operand;
         }
-        const err_off: u32 = @intCast(errUnionErrorOffset(payload_ty, pt));
+        const err_off: u32 = @intCast(errUnionErrorOffset(payload_ty, zcu));
         switch (operand) {
             .register => |reg| {
 @@ -3421,9 +3423,9 @@ fn genUnwrapErrUnionPayloadMir(
     const payload_ty = err_union_ty.errorUnionPayload(zcu);
     const result: MCValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
-        const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, pt));
+        const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
         switch (err_union) {
             .load_frame => |frame_addr| break :result .{ .load_frame = .{
                 .index = frame_addr.index,
 @@ -3497,7 +3499,7 @@ fn airWrapOptional(func: *Func, inst: Air.Inst.Index) !void {
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const pl_ty = func.typeOf(ty_op.operand);
-        if (!pl_ty.hasRuntimeBits(pt)) break :result .{ .immediate = 1 };
+        if (!pl_ty.hasRuntimeBits(zcu)) break :result .{ .immediate = 1 };
         const opt_ty = func.typeOfIndex(inst);
         const pl_mcv = try func.resolveInst(ty_op.operand);
 @@ -3514,7 +3516,7 @@ fn airWrapOptional(func: *Func, inst: Air.Inst.Index) !void {
         try func.genCopy(pl_ty, opt_mcv, pl_mcv);
         if (!same_repr) {
-            const pl_abi_size: i32 = @intCast(pl_ty.abiSize(pt));
+            const pl_abi_size: i32 = @intCast(pl_ty.abiSize(zcu));
             switch (opt_mcv) {
                 .load_frame => |frame_addr| {
                     try func.genCopy(pl_ty, opt_mcv, pl_mcv);
 @@ -3545,11 +3547,11 @@ fn airWrapErrUnionPayload(func: *Func, inst: Air.Inst.Index) !void {
     const operand = try func.resolveInst(ty_op.operand);
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .{ .immediate = 0 };
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .{ .immediate = 0 };
-        const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, pt));
+        const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
-        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
-        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
         try func.genSetMem(.{ .frame = frame_index }, pl_off, pl_ty, operand);
         try func.genSetMem(.{ .frame = frame_index }, err_off, err_ty, .{ .immediate = 0 });
         break :result .{ .load_frame = .{ .index = frame_index } };
 @@ -3569,11 +3571,11 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void {
     const err_ty = eu_ty.errorUnionSet(zcu);
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result try func.resolveInst(ty_op.operand);
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result try func.resolveInst(ty_op.operand);
-        const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, pt));
+        const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
-        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
-        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
         try func.genSetMem(.{ .frame = frame_index }, pl_off, pl_ty, .{ .undef = null });
         const operand = try func.resolveInst(ty_op.operand);
         try func.genSetMem(.{ .frame = frame_index }, err_off, err_ty, operand);
 @@ -3717,7 +3719,7 @@ fn airSliceElemVal(func: *Func, inst: Air.Inst.Index) !void {
     const result: MCValue = result: {
         const elem_ty = func.typeOfIndex(inst);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const slice_ty = func.typeOf(bin_op.lhs);
         const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
 @@ -3748,7 +3750,7 @@ fn genSliceElemPtr(func: *Func, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
     defer if (slice_mcv_lock) |lock| func.register_manager.unlockReg(lock);
     const elem_ty = slice_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     const index_ty = func.typeOf(rhs);
     const index_mcv = try func.resolveInst(rhs);
 @@ -3792,14 +3794,14 @@ fn airArrayElemVal(func: *Func, inst: Air.Inst.Index) !void {
         const index_ty = func.typeOf(bin_op.rhs);
         const elem_ty = array_ty.childType(zcu);
-        const elem_abi_size = elem_ty.abiSize(pt);
+        const elem_abi_size = elem_ty.abiSize(zcu);
         const addr_reg, const addr_reg_lock = try func.allocReg(.int);
         defer func.register_manager.unlockReg(addr_reg_lock);
         switch (array_mcv) {
             .register => {
-                const frame_index = try func.allocFrameIndex(FrameAlloc.initType(array_ty, pt));
+                const frame_index = try func.allocFrameIndex(FrameAlloc.initType(array_ty, zcu));
                 try func.genSetMem(.{ .frame = frame_index }, 0, array_ty, array_mcv);
                 try func.genSetReg(Type.u64, addr_reg, .{ .lea_frame = .{ .index = frame_index } });
             },
 @@ -3870,7 +3872,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void {
     const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: {
         const elem_ty = base_ptr_ty.elemType2(zcu);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const base_ptr_mcv = try func.resolveInst(bin_op.lhs);
         const base_ptr_lock: ?RegisterLock = switch (base_ptr_mcv) {
 @@ -3970,11 +3972,12 @@ fn airSetUnionTag(func: *Func, inst: Air.Inst.Index) !void {
 fn airGetUnionTag(func: *Func, inst: Air.Inst.Index) !void {
     const pt = func.pt;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const tag_ty = func.typeOfIndex(inst);
     const union_ty = func.typeOf(ty_op.operand);
-    const layout = union_ty.unionGetLayout(pt);
+    const layout = union_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) {
         return func.finishAir(inst, .none, .{ ty_op.operand, .none, .none });
 @@ -3985,7 +3988,7 @@ fn airGetUnionTag(func: *Func, inst: Air.Inst.Index) !void {
     const frame_mcv = try func.allocRegOrMem(union_ty, null, false);
     try func.genCopy(union_ty, frame_mcv, operand);
-    const tag_abi_size = tag_ty.abiSize(pt);
+    const tag_abi_size = tag_ty.abiSize(zcu);
     const result_reg, const result_lock = try func.allocReg(.int);
     defer func.register_manager.unlockReg(result_lock);
 @@ -4034,7 +4037,7 @@ fn airClz(func: *Func, inst: Air.Inst.Index) !void {
         else
             (try func.allocRegOrMem(func.typeOfIndex(inst), inst, true)).register;
-        const bit_size = ty.bitSize(func.pt);
+        const bit_size = ty.bitSize(func.pt.zcu);
         if (!math.isPowerOfTwo(bit_size)) try func.truncateRegister(ty, src_reg);
         if (bit_size > 64) {
 @@ -4081,6 +4084,7 @@ fn airPopcount(func: *Func, inst: Air.Inst.Index) !void {
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: {
         const pt = func.pt;
+        const zcu = pt.zcu;
         const operand = try func.resolveInst(ty_op.operand);
         const src_ty = func.typeOf(ty_op.operand);
 @@ -4090,7 +4094,7 @@ fn airPopcount(func: *Func, inst: Air.Inst.Index) !void {
         const dst_reg, const dst_lock = try func.allocReg(.int);
         defer func.register_manager.unlockReg(dst_lock);
-        const bit_size = src_ty.bitSize(pt);
+        const bit_size = src_ty.bitSize(zcu);
         switch (bit_size) {
             32, 64 => {},
             1...31, 33...63 => try func.truncateRegister(src_ty, operand_reg),
 @@ -4283,12 +4287,13 @@ fn airBitReverse(func: *Func, inst: Air.Inst.Index) !void {
 fn airUnaryMath(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
     const pt = func.pt;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: {
         const ty = func.typeOf(un_op);
         const operand = try func.resolveInst(un_op);
-        const operand_bit_size = ty.bitSize(pt);
+        const operand_bit_size = ty.bitSize(zcu);
         if (!math.isPowerOfTwo(operand_bit_size))
             return func.fail("TODO: airUnaryMath non-pow 2", .{});
 @@ -4300,7 +4305,7 @@ fn airUnaryMath(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
         const dst_reg, const dst_lock = try func.allocReg(dst_class);
         defer func.register_manager.unlockReg(dst_lock);
-        switch (ty.zigTypeTag(pt.zcu)) {
+        switch (ty.zigTypeTag(zcu)) {
             .Float => {
                 assert(dst_class == .float);
 @@ -4397,7 +4402,7 @@ fn airLoad(func: *Func, inst: Air.Inst.Index) !void {
     const elem_ty = func.typeOfIndex(inst);
     const result: MCValue = result: {
-        if (!elem_ty.hasRuntimeBits(pt))
+        if (!elem_ty.hasRuntimeBits(zcu))
             break :result .none;
         const ptr = try func.resolveInst(ty_op.operand);
 @@ -4405,7 +4410,7 @@ fn airLoad(func: *Func, inst: Air.Inst.Index) !void {
         if (func.liveness.isUnused(inst) and !is_volatile)
             break :result .unreach;
-        const elem_size = elem_ty.abiSize(pt);
+        const elem_size = elem_ty.abiSize(zcu);
         const dst_mcv: MCValue = blk: {
             // The MCValue that holds the pointer can be re-used as the value.
 @@ -4544,7 +4549,7 @@ fn structFieldPtr(func: *Func, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
     const container_ty = ptr_container_ty.childType(zcu);
     const field_offset: i32 = switch (container_ty.containerLayout(zcu)) {
-        .auto, .@"extern" => @intCast(container_ty.structFieldOffset(index, pt)),
+        .auto, .@"extern" => @intCast(container_ty.structFieldOffset(index, zcu)),
         .@"packed" => @divExact(@as(i32, ptr_container_ty.ptrInfo(zcu).packed_offset.bit_offset) +
             (if (zcu.typeToStruct(container_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, index) else 0) -
             ptr_field_ty.ptrInfo(zcu).packed_offset.bit_offset, 8),
 @@ -4571,11 +4576,11 @@ fn airStructFieldVal(func: *Func, inst: Air.Inst.Index) !void {
     const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: {
         const src_mcv = try func.resolveInst(operand);
         const struct_ty = func.typeOf(operand);
-        const field_ty = struct_ty.structFieldType(index, zcu);
+        const field_ty = struct_ty.fieldType(index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const field_off: u32 = switch (struct_ty.containerLayout(zcu)) {
-            .auto, .@"extern" => @intCast(struct_ty.structFieldOffset(index, pt) * 8),
+            .auto, .@"extern" => @intCast(struct_ty.structFieldOffset(index, zcu) * 8),
             .@"packed" => if (zcu.typeToStruct(struct_ty)) |struct_type|
                 pt.structPackedFieldBitOffset(struct_type, index)
             else
 @@ -4615,11 +4620,11 @@ fn airStructFieldVal(func: *Func, inst: Air.Inst.Index) !void {
                 break :result if (field_off == 0) dst_mcv else try func.copyToNewRegister(inst, dst_mcv);
             },
             .load_frame => {
-                const field_abi_size: u32 = @intCast(field_ty.abiSize(pt));
+                const field_abi_size: u32 = @intCast(field_ty.abiSize(zcu));
                 if (field_off % 8 == 0) {
                     const field_byte_off = @divExact(field_off, 8);
                     const off_mcv = src_mcv.address().offset(@intCast(field_byte_off)).deref();
-                    const field_bit_size = field_ty.bitSize(pt);
+                    const field_bit_size = field_ty.bitSize(zcu);
                     if (field_abi_size <= 8) {
                         const int_ty = try pt.intType(
 @@ -4635,7 +4640,7 @@ fn airStructFieldVal(func: *Func, inst: Air.Inst.Index) !void {
                         break :result try func.copyToNewRegister(inst, dst_mcv);
                     }
-                    const container_abi_size: u32 = @intCast(struct_ty.abiSize(pt));
+                    const container_abi_size: u32 = @intCast(struct_ty.abiSize(zcu));
                     const dst_mcv = if (field_byte_off + field_abi_size <= container_abi_size and
                         func.reuseOperand(inst, operand, 0, src_mcv))
                         off_mcv
 @@ -4880,7 +4885,7 @@ fn genCall(
                 try reg_locks.appendSlice(&func.register_manager.lockRegs(2, regs));
             },
             .indirect => |reg_off| {
-                frame_index.* = try func.allocFrameIndex(FrameAlloc.initType(arg_ty, pt));
+                frame_index.* = try func.allocFrameIndex(FrameAlloc.initType(arg_ty, zcu));
                 try func.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg);
                 try func.register_manager.getReg(reg_off.reg, null);
                 try reg_locks.append(func.register_manager.lockReg(reg_off.reg));
 @@ -4893,7 +4898,7 @@ fn genCall(
         .none, .unreach => {},
         .indirect => |reg_off| {
             const ret_ty = Type.fromInterned(fn_info.return_type);
-            const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(ret_ty, pt));
+            const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(ret_ty, zcu));
             try func.genSetReg(Type.u64, reg_off.reg, .{
                 .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
             });
 @@ -5013,7 +5018,7 @@ fn airRet(func: *Func, inst: Air.Inst.Index, safety: bool) !void {
         .register_pair,
         => {
             if (ret_ty.isVector(zcu)) {
-                const bit_size = ret_ty.totalVectorBits(pt);
+                const bit_size = ret_ty.totalVectorBits(zcu);
                 // set the vtype to hold the entire vector's contents in a single element
                 try func.setVl(.zero, 0, .{
 @@ -5113,7 +5118,7 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
                     .ErrorSet => Type.anyerror,
                     .Optional => blk: {
                         const payload_ty = lhs_ty.optionalChild(zcu);
-                        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                             break :blk Type.u1;
                         } else if (lhs_ty.isPtrLikeOptional(zcu)) {
                             break :blk Type.u64;
 @@ -5289,7 +5294,7 @@ fn isNull(func: *Func, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
     const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu))
         .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty }
     else
-        .{ .off = @intCast(pl_ty.abiSize(pt)), .ty = Type.bool };
+        .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = Type.bool };
     const return_mcv = try func.allocRegOrMem(func.typeOfIndex(inst), inst, true);
     assert(return_mcv == .register); // should not be larger 8 bytes
 @@ -5472,11 +5477,10 @@ fn airIsErrPtr(func: *Func, inst: Air.Inst.Index) !void {
 /// Result is in the return register.
 fn isErr(func: *Func, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
     _ = maybe_inst;
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
-    const zcu = pt.zcu;
     const err_ty = eu_ty.errorUnionSet(zcu);
     if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false
-    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), pt));
+    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
     const return_reg, const return_lock = try func.allocReg(.int);
     defer func.register_manager.unlockReg(return_lock);
 @@ -5769,12 +5773,12 @@ fn performReloc(func: *Func, inst: Mir.Inst.Index) void {
 }
 fn airBr(func: *Func, inst: Air.Inst.Index) !void {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
     const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br;
     const block_ty = func.typeOfIndex(br.block_inst);
     const block_unused =
-        !block_ty.hasRuntimeBitsIgnoreComptime(pt) or func.liveness.isUnused(br.block_inst);
+        !block_ty.hasRuntimeBitsIgnoreComptime(zcu) or func.liveness.isUnused(br.block_inst);
     const block_tracking = func.inst_tracking.getPtr(br.block_inst).?;
     const block_data = func.blocks.getPtr(br.block_inst).?;
     const first_br = block_data.relocs.items.len == 0;
 @@ -6354,6 +6358,8 @@ fn genCopy(func: *Func, ty: Type, dst_mcv: MCValue, src_mcv: MCValue) !void {
         return std.debug.panic("tried to genCopy immutable: {s}", .{@tagName(dst_mcv)});
     }
+    const zcu = func.pt.zcu;
     switch (dst_mcv) {
         .register => |reg| return func.genSetReg(ty, reg, src_mcv),
         .register_offset => |dst_reg_off| try func.genSetReg(ty, dst_reg_off.reg, switch (src_mcv) {
 @@ -6425,7 +6431,7 @@ fn genCopy(func: *Func, ty: Type, dst_mcv: MCValue, src_mcv: MCValue) !void {
                     } },
                     else => unreachable,
                 });
-                part_disp += @intCast(dst_ty.abiSize(func.pt));
+                part_disp += @intCast(dst_ty.abiSize(zcu));
             }
         },
         else => return std.debug.panic("TODO: genCopy to {s} from {s}", .{ @tagName(dst_mcv), @tagName(src_mcv) }),
 @@ -6622,7 +6628,7 @@ fn genInlineMemset(
 fn genSetReg(func: *Func, ty: Type, reg: Register, src_mcv: MCValue) InnerError!void {
     const pt = func.pt;
     const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const max_size: u32 = switch (reg.class()) {
         .int => 64,
 @@ -6729,7 +6735,7 @@ fn genSetReg(func: *Func, ty: Type, reg: Register, src_mcv: MCValue) InnerError!
             // size to the total size of the vector, and vmv.x.s will work then
             if (src_reg.class() == .vector) {
                 try func.setVl(.zero, 0, .{
-                    .vsew = switch (ty.totalVectorBits(pt)) {
+                    .vsew = switch (ty.totalVectorBits(zcu)) {
                         8 => .@"8",
                         16 => .@"16",
                         32 => .@"32",
 @@ -6848,7 +6854,7 @@ fn genSetReg(func: *Func, ty: Type, reg: Register, src_mcv: MCValue) InnerError!
                     // and load from it.
                     const len = ty.vectorLen(zcu);
                     const elem_ty = ty.childType(zcu);
-                    const elem_size = elem_ty.abiSize(pt);
+                    const elem_size = elem_ty.abiSize(zcu);
                     try func.setVl(.zero, len, .{
                         .vsew = switch (elem_size) {
 @@ -6945,7 +6951,7 @@ fn genSetMem(
     const pt = func.pt;
     const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const dst_ptr_mcv: MCValue = switch (base) {
         .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } },
         .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } },
 @@ -6995,7 +7001,7 @@ fn genSetMem(
                 const addr_reg = try func.copyToTmpRegister(Type.u64, dst_ptr_mcv);
                 const num_elem = ty.vectorLen(zcu);
-                const elem_size = ty.childType(zcu).bitSize(pt);
+                const elem_size = ty.childType(zcu).bitSize(zcu);
                 try func.setVl(.zero, num_elem, .{
                     .vsew = switch (elem_size) {
 @@ -7083,7 +7089,7 @@ fn genSetMem(
             var part_disp: i32 = disp;
             for (try func.splitType(ty), src_regs) |src_ty, src_reg| {
                 try func.genSetMem(base, part_disp, src_ty, .{ .register = src_reg });
-                part_disp += @intCast(src_ty.abiSize(pt));
+                part_disp += @intCast(src_ty.abiSize(zcu));
             }
         },
         .immediate => {
 @@ -7128,10 +7134,10 @@ fn airBitCast(func: *Func, inst: Air.Inst.Index) !void {
         const src_lock = if (src_mcv.getReg()) |reg| func.register_manager.lockReg(reg) else null;
         defer if (src_lock) |lock| func.register_manager.unlockReg(lock);
-        const dst_mcv = if (dst_ty.abiSize(pt) <= src_ty.abiSize(pt) and src_mcv != .register_pair and
+        const dst_mcv = if (dst_ty.abiSize(zcu) <= src_ty.abiSize(zcu) and src_mcv != .register_pair and
             func.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
             const dst_mcv = try func.allocRegOrMem(dst_ty, inst, true);
-            try func.genCopy(switch (math.order(dst_ty.abiSize(pt), src_ty.abiSize(pt))) {
+            try func.genCopy(switch (math.order(dst_ty.abiSize(zcu), src_ty.abiSize(zcu))) {
                 .lt => dst_ty,
                 .eq => if (!dst_mcv.isMemory() or src_mcv.isMemory()) dst_ty else src_ty,
                 .gt => src_ty,
 @@ -7142,8 +7148,8 @@ fn airBitCast(func: *Func, inst: Air.Inst.Index) !void {
         if (dst_ty.isAbiInt(zcu) and src_ty.isAbiInt(zcu) and
             dst_ty.intInfo(zcu).signedness == src_ty.intInfo(zcu).signedness) break :result dst_mcv;
-        const abi_size = dst_ty.abiSize(pt);
+        const abi_size = dst_ty.abiSize(zcu);
-        const bit_size = dst_ty.bitSize(pt);
+        const bit_size = dst_ty.bitSize(zcu);
         if (abi_size * 8 <= bit_size) break :result dst_mcv;
         return func.fail("TODO: airBitCast {} to {}", .{ src_ty.fmt(pt), dst_ty.fmt(pt) });
 @@ -7162,11 +7168,11 @@ fn airArrayToSlice(func: *Func, inst: Air.Inst.Index) !void {
     const array_ty = ptr_ty.childType(zcu);
     const array_len = array_ty.arrayLen(zcu);
-    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(slice_ty, pt));
+    const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(slice_ty, zcu));
     try func.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, ptr);
     try func.genSetMem(
         .{ .frame = frame_index },
-        @intCast(ptr_ty.abiSize(pt)),
+        @intCast(ptr_ty.abiSize(zcu)),
         Type.u64,
         .{ .immediate = array_len },
     );
 @@ -7190,21 +7196,21 @@ fn airFloatFromInt(func: *Func, inst: Air.Inst.Index) !void {
         defer if (src_lock) |lock| func.register_manager.unlockReg(lock);
         const is_unsigned = dst_ty.isUnsignedInt(zcu);
-        const src_bits = src_ty.bitSize(pt);
+        const src_bits = src_ty.bitSize(zcu);
-        const dst_bits = dst_ty.bitSize(pt);
+        const dst_bits = dst_ty.bitSize(zcu);
         switch (src_bits) {
             32, 64 => {},
             else => try func.truncateRegister(src_ty, src_reg),
         }
-        const int_mod: Mir.FcvtOp = switch (src_bits) {
+        const int_zcu: Mir.FcvtOp = switch (src_bits) {
             8, 16, 32 => if (is_unsigned) .wu else .w,
             64 => if (is_unsigned) .lu else .l,
             else => return func.fail("TODO: airFloatFromInt src size: {d}", .{src_bits}),
         };
-        const float_mod: enum { s, d } = switch (dst_bits) {
+        const float_zcu: enum { s, d } = switch (dst_bits) {
             32 => .s,
             64 => .d,
             else => return func.fail("TODO: airFloatFromInt dst size {d}", .{dst_bits}),
 @@ -7214,14 +7220,14 @@ fn airFloatFromInt(func: *Func, inst: Air.Inst.Index) !void {
         defer func.register_manager.unlockReg(dst_lock);
         _ = try func.addInst(.{
-            .tag = switch (float_mod) {
+            .tag = switch (float_zcu) {
-                .s => switch (int_mod) {
+                .s => switch (int_zcu) {
                     .l => .fcvtsl,
                     .lu => .fcvtslu,
                     .w => .fcvtsw,
                     .wu => .fcvtswu,
                 },
-                .d => switch (int_mod) {
+                .d => switch (int_zcu) {
                     .l => .fcvtdl,
                     .lu => .fcvtdlu,
                     .w => .fcvtdw,
 @@ -7250,16 +7256,16 @@ fn airIntFromFloat(func: *Func, inst: Air.Inst.Index) !void {
         const dst_ty = ty_op.ty.toType();
         const is_unsigned = dst_ty.isUnsignedInt(zcu);
-        const src_bits = src_ty.bitSize(pt);
+        const src_bits = src_ty.bitSize(zcu);
-        const dst_bits = dst_ty.bitSize(pt);
+        const dst_bits = dst_ty.bitSize(zcu);
-        const float_mod: enum { s, d } = switch (src_bits) {
+        const float_zcu: enum { s, d } = switch (src_bits) {
             32 => .s,
             64 => .d,
             else => return func.fail("TODO: airIntFromFloat src size {d}", .{src_bits}),
         };
-        const int_mod: Mir.FcvtOp = switch (dst_bits) {
+        const int_zcu: Mir.FcvtOp = switch (dst_bits) {
             32 => if (is_unsigned) .wu else .w,
             8, 16, 64 => if (is_unsigned) .lu else .l,
             else => return func.fail("TODO: airIntFromFloat dst size: {d}", .{dst_bits}),
 @@ -7272,14 +7278,14 @@ fn airIntFromFloat(func: *Func, inst: Air.Inst.Index) !void {
         defer func.register_manager.unlockReg(dst_lock);
         _ = try func.addInst(.{
-            .tag = switch (float_mod) {
+            .tag = switch (float_zcu) {
-                .s => switch (int_mod) {
+                .s => switch (int_zcu) {
                     .l => .fcvtls,
                     .lu => .fcvtlus,
                     .w => .fcvtws,
                     .wu => .fcvtwus,
                 },
-                .d => switch (int_mod) {
+                .d => switch (int_zcu) {
                     .l => .fcvtld,
                     .lu => .fcvtlud,
                     .w => .fcvtwd,
 @@ -7301,12 +7307,13 @@ fn airCmpxchg(func: *Func, inst: Air.Inst.Index, strength: enum { weak, strong }
     _ = strength; // TODO: do something with this
     const pt = func.pt;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
     const ptr_ty = func.typeOf(extra.ptr);
     const val_ty = func.typeOf(extra.expected_value);
-    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt));
+    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt.zcu));
     switch (val_abi_size) {
         1, 2, 4, 8 => {},
 @@ -7364,7 +7371,7 @@ fn airCmpxchg(func: *Func, inst: Air.Inst.Index, strength: enum { weak, strong }
     defer func.register_manager.unlockReg(fallthrough_lock);
     const jump_back = try func.addInst(.{
-        .tag = if (val_ty.bitSize(pt) <= 32) .lrw else .lrd,
+        .tag = if (val_ty.bitSize(zcu) <= 32) .lrw else .lrd,
         .data = .{ .amo = .{
             .aq = lr_order.aq,
             .rl = lr_order.rl,
 @@ -7385,7 +7392,7 @@ fn airCmpxchg(func: *Func, inst: Air.Inst.Index, strength: enum { weak, strong }
     });
     _ = try func.addInst(.{
-        .tag = if (val_ty.bitSize(pt) <= 32) .scw else .scd,
+        .tag = if (val_ty.bitSize(zcu) <= 32) .scw else .scd,
         .data = .{ .amo = .{
             .aq = sc_order.aq,
             .rl = sc_order.rl,
 @@ -7449,7 +7456,7 @@ fn airAtomicRmw(func: *Func, inst: Air.Inst.Index) !void {
         const ptr_mcv = try func.resolveInst(pl_op.operand);
         const val_ty = func.typeOf(extra.operand);
-        const val_size = val_ty.abiSize(pt);
+        const val_size = val_ty.abiSize(zcu);
         const val_mcv = try func.resolveInst(extra.operand);
         if (!math.isPowerOfTwo(val_size))
 @@ -7488,7 +7495,7 @@ fn airAtomicRmw(func: *Func, inst: Air.Inst.Index) !void {
         switch (method) {
             .amo => {
-                const is_d = val_ty.abiSize(pt) == 8;
+                const is_d = val_ty.abiSize(zcu) == 8;
                 const is_un = val_ty.isUnsignedInt(zcu);
                 const mnem: Mnemonic = switch (op) {
 @@ -7587,7 +7594,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void {
     const elem_ty = ptr_ty.childType(zcu);
     const ptr_mcv = try func.resolveInst(atomic_load.ptr);
-    const bit_size = elem_ty.bitSize(pt);
+    const bit_size = elem_ty.bitSize(zcu);
     if (bit_size > 64) return func.fail("TODO: airAtomicStore > 64 bits", .{});
     const result_mcv = try func.allocRegOrMem(elem_ty, inst, true);
 @@ -7634,7 +7641,7 @@ fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.builtin.AtomicOr
     const val_ty = func.typeOf(bin_op.rhs);
     const val_mcv = try func.resolveInst(bin_op.rhs);
-    const bit_size = val_ty.bitSize(func.pt);
+    const bit_size = val_ty.bitSize(func.pt.zcu);
     if (bit_size > 64) return func.fail("TODO: airAtomicStore > 64 bits", .{});
     switch (order) {
 @@ -7679,7 +7686,7 @@ fn airMemset(func: *Func, inst: Air.Inst.Index, safety: bool) !void {
         };
         defer if (src_val_lock) |lock| func.register_manager.unlockReg(lock);
-        const elem_abi_size: u31 = @intCast(elem_ty.abiSize(pt));
+        const elem_abi_size: u31 = @intCast(elem_ty.abiSize(zcu));
         if (elem_abi_size == 1) {
             const ptr: MCValue = switch (dst_ptr_ty.ptrSize(zcu)) {
 @@ -7751,7 +7758,7 @@ fn airMemcpy(func: *Func, inst: Air.Inst.Index) !void {
             const len_reg, const len_lock = try func.allocReg(.int);
             defer func.register_manager.unlockReg(len_lock);
-            const elem_size = dst_ty.childType(zcu).abiSize(pt);
+            const elem_size = dst_ty.childType(zcu).abiSize(zcu);
             try func.genBinOp(
                 .mul,
                 .{ .immediate = elem_size },
 @@ -7764,7 +7771,7 @@ fn airMemcpy(func: *Func, inst: Air.Inst.Index) !void {
         },
         .One => len: {
             const array_ty = dst_ty.childType(zcu);
-            break :len .{ .immediate = array_ty.arrayLen(zcu) * array_ty.childType(zcu).abiSize(pt) };
+            break :len .{ .immediate = array_ty.arrayLen(zcu) * array_ty.childType(zcu).abiSize(zcu) };
         },
         else => |size| return func.fail("TODO: airMemcpy size {s}", .{@tagName(size)}),
     };
 @@ -7862,21 +7869,21 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void {
     const result: MCValue = result: {
         switch (result_ty.zigTypeTag(zcu)) {
             .Struct => {
-                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(result_ty, pt));
+                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
                 if (result_ty.containerLayout(zcu) == .@"packed") {
                     const struct_obj = zcu.typeToStruct(result_ty).?;
                     try func.genInlineMemset(
                         .{ .lea_frame = .{ .index = frame_index } },
                         .{ .immediate = 0 },
-                        .{ .immediate = result_ty.abiSize(pt) },
+                        .{ .immediate = result_ty.abiSize(zcu) },
                     );
                     for (elements, 0..) |elem, elem_i_usize| {
                         const elem_i: u32 = @intCast(elem_i_usize);
                         if ((try result_ty.structFieldValueComptime(pt, elem_i)) != null) continue;
-                        const elem_ty = result_ty.structFieldType(elem_i, zcu);
+                        const elem_ty = result_ty.fieldType(elem_i, zcu);
-                        const elem_bit_size: u32 = @intCast(elem_ty.bitSize(pt));
+                        const elem_bit_size: u32 = @intCast(elem_ty.bitSize(zcu));
                         if (elem_bit_size > 64) {
                             return func.fail(
                                 "TODO airAggregateInit implement packed structs with large fields",
 @@ -7884,7 +7891,7 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void {
                             );
                         }
-                        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(pt));
+                        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
                         const elem_abi_bits = elem_abi_size * 8;
                         const elem_off = pt.structPackedFieldBitOffset(struct_obj, elem_i);
                         const elem_byte_off: i32 = @intCast(elem_off / elem_abi_bits * elem_abi_size);
 @@ -7909,8 +7916,8 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void {
                 } else for (elements, 0..) |elem, elem_i| {
                     if ((try result_ty.structFieldValueComptime(pt, elem_i)) != null) continue;
-                    const elem_ty = result_ty.structFieldType(elem_i, zcu);
+                    const elem_ty = result_ty.fieldType(elem_i, zcu);
-                    const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, pt));
+                    const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, zcu));
                     const elem_mcv = try func.resolveInst(elem);
                     try func.genSetMem(.{ .frame = frame_index }, elem_off, elem_ty, elem_mcv);
                 }
 @@ -7918,8 +7925,8 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void {
             },
             .Array => {
                 const elem_ty = result_ty.childType(zcu);
-                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(result_ty, pt));
+                const frame_index = try func.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
-                const elem_size: u32 = @intCast(elem_ty.abiSize(pt));
+                const elem_size: u32 = @intCast(elem_ty.abiSize(zcu));
                 for (elements, 0..) |elem, elem_i| {
                     const elem_mcv = try func.resolveInst(elem);
 @@ -7979,10 +7986,11 @@ fn airMulAdd(func: *Func, inst: Air.Inst.Index) !void {
 fn resolveInst(func: *Func, ref: Air.Inst.Ref) InnerError!MCValue {
     const pt = func.pt;
+    const zcu = pt.zcu;
     // If the type has no codegen bits, no need to store it.
     const inst_ty = func.typeOf(ref);
-    if (!inst_ty.hasRuntimeBits(pt))
+    if (!inst_ty.hasRuntimeBits(zcu))
         return .none;
     const mcv = if (ref.toIndex()) |inst| mcv: {
 @@ -8100,14 +8108,14 @@ fn resolveCallingConventionValues(
             // Return values
             if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = InstTracking.init(.unreach);
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 result.return_value = InstTracking.init(.none);
             } else {
                 var ret_tracking: [2]InstTracking = undefined;
                 var ret_tracking_i: usize = 0;
                 var ret_float_reg_i: usize = 0;
-                const classes = mem.sliceTo(&abi.classifySystem(ret_ty, pt), .none);
+                const classes = mem.sliceTo(&abi.classifySystem(ret_ty, zcu), .none);
                 for (classes) |class| switch (class) {
                     .integer => {
 @@ -8151,7 +8159,7 @@ fn resolveCallingConventionValues(
             var param_float_reg_i: usize = 0;
             for (param_types, result.args) |ty, *arg| {
-                if (!ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     assert(cc == .Unspecified);
                     arg.* = .none;
                     continue;
 @@ -8160,7 +8168,7 @@ fn resolveCallingConventionValues(
                 var arg_mcv: [2]MCValue = undefined;
                 var arg_mcv_i: usize = 0;
-                const classes = mem.sliceTo(&abi.classifySystem(ty, pt), .none);
+                const classes = mem.sliceTo(&abi.classifySystem(ty, zcu), .none);
                 for (classes) |class| switch (class) {
                     .integer => {
 @@ -8244,8 +8252,7 @@ fn typeOf(func: *Func, inst: Air.Inst.Ref) Type {
 }
 fn typeOfIndex(func: *Func, inst: Air.Inst.Index) Type {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
-    const zcu = pt.zcu;
     return func.air.typeOfIndex(inst, &zcu.intern_pool);
 }
 @@ -8253,23 +8260,23 @@ fn hasFeature(func: *Func, feature: Target.riscv.Feature) bool {
     return Target.riscv.featureSetHas(func.target.cpu.features, feature);
 }
-pub fn errUnionPayloadOffset(payload_ty: Type, pt: Zcu.PerThread) u64 {
+pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0;
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
-    const payload_align = payload_ty.abiAlignment(pt);
+    const payload_align = payload_ty.abiAlignment(zcu);
-    const error_align = Type.anyerror.abiAlignment(pt);
+    const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return 0;
     } else {
-        return payload_align.forward(Type.anyerror.abiSize(pt));
+        return payload_align.forward(Type.anyerror.abiSize(zcu));
     }
 }
-pub fn errUnionErrorOffset(payload_ty: Type, pt: Zcu.PerThread) u64 {
+pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0;
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
-    const payload_align = payload_ty.abiAlignment(pt);
+    const payload_align = payload_ty.abiAlignment(zcu);
-    const error_align = Type.anyerror.abiAlignment(pt);
+    const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        return error_align.forward(payload_ty.abiSize(pt));
+        return error_align.forward(payload_ty.abiSize(zcu));
     } else {
         return 0;
     }

src/arch/riscv64/Lower.zig+4-3

 @@ -49,6 +49,7 @@ pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index, options: struct {
     relocs: []const Reloc,
 } {
     const pt = lower.pt;
+    const zcu = pt.zcu;
     lower.result_insts = undefined;
     lower.result_relocs = undefined;
 @@ -308,11 +309,11 @@ pub fn lowerMir(lower: *Lower, index: Mir.Inst.Index, options: struct {
             const class = rs1.class();
             const ty = compare.ty;
-            const size = std.math.ceilPowerOfTwo(u64, ty.bitSize(pt)) catch {
+            const size = std.math.ceilPowerOfTwo(u64, ty.bitSize(zcu)) catch {
-                return lower.fail("pseudo_compare size {}", .{ty.bitSize(pt)});
+                return lower.fail("pseudo_compare size {}", .{ty.bitSize(zcu)});
             };
-            const is_unsigned = ty.isUnsignedInt(pt.zcu);
+            const is_unsigned = ty.isUnsignedInt(zcu);
             const less_than: Mnemonic = if (is_unsigned) .sltu else .slt;
             switch (class) {

src/arch/riscv64/abi.zig+27-28

 @@ -9,15 +9,15 @@ const assert = std.debug.assert;
 pub const Class = enum { memory, byval, integer, double_integer, fields };
-pub fn classifyType(ty: Type, pt: Zcu.PerThread) Class {
+pub fn classifyType(ty: Type, zcu: *Zcu) Class {
-    const target = pt.zcu.getTarget();
+    const target = zcu.getTarget();
-    std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(pt));
+    std.debug.assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
     const max_byval_size = target.ptrBitWidth() * 2;
-    switch (ty.zigTypeTag(pt.zcu)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Struct => {
-            const bit_size = ty.bitSize(pt);
+            const bit_size = ty.bitSize(zcu);
-            if (ty.containerLayout(pt.zcu) == .@"packed") {
+            if (ty.containerLayout(zcu) == .@"packed") {
                 if (bit_size > max_byval_size) return .memory;
                 return .byval;
             }
 @@ -25,12 +25,12 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) Class {
             if (std.Target.riscv.featureSetHas(target.cpu.features, .d)) fields: {
                 var any_fp = false;
                 var field_count: usize = 0;
-                for (0..ty.structFieldCount(pt.zcu)) |field_index| {
+                for (0..ty.structFieldCount(zcu)) |field_index| {
-                    const field_ty = ty.structFieldType(field_index, pt.zcu);
+                    const field_ty = ty.fieldType(field_index, zcu);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
                     if (field_ty.isRuntimeFloat())
                         any_fp = true
-                    else if (!field_ty.isAbiInt(pt.zcu))
+                    else if (!field_ty.isAbiInt(zcu))
                         break :fields;
                     field_count += 1;
                     if (field_count > 2) break :fields;
 @@ -45,8 +45,8 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) Class {
             return .integer;
         },
         .Union => {
-            const bit_size = ty.bitSize(pt);
+            const bit_size = ty.bitSize(zcu);
-            if (ty.containerLayout(pt.zcu) == .@"packed") {
+            if (ty.containerLayout(zcu) == .@"packed") {
                 if (bit_size > max_byval_size) return .memory;
                 return .byval;
             }
 @@ -58,21 +58,21 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) Class {
         .Bool => return .integer,
         .Float => return .byval,
         .Int, .Enum, .ErrorSet => {
-            const bit_size = ty.bitSize(pt);
+            const bit_size = ty.bitSize(zcu);
             if (bit_size > max_byval_size) return .memory;
             return .byval;
         },
         .Vector => {
-            const bit_size = ty.bitSize(pt);
+            const bit_size = ty.bitSize(zcu);
             if (bit_size > max_byval_size) return .memory;
             return .integer;
         },
         .Optional => {
-            std.debug.assert(ty.isPtrLikeOptional(pt.zcu));
+            std.debug.assert(ty.isPtrLikeOptional(zcu));
             return .byval;
         },
         .Pointer => {
-            std.debug.assert(!ty.isSlice(pt.zcu));
+            std.debug.assert(!ty.isSlice(zcu));
             return .byval;
         },
         .ErrorUnion,
 @@ -97,19 +97,18 @@ pub const SystemClass = enum { integer, float, memory, none };
 /// There are a maximum of 8 possible return slots. Returned values are in
 /// the beginning of the array; unused slots are filled with .none.
-pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
+pub fn classifySystem(ty: Type, zcu: *Zcu) [8]SystemClass {
-    const zcu = pt.zcu;
     var result = [1]SystemClass{.none} ** 8;
     const memory_class = [_]SystemClass{
         .memory, .none, .none, .none,
         .none,   .none, .none, .none,
     };
-    switch (ty.zigTypeTag(pt.zcu)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Bool, .Void, .NoReturn => {
             result[0] = .integer;
             return result;
         },
-        .Pointer => switch (ty.ptrSize(pt.zcu)) {
+        .Pointer => switch (ty.ptrSize(zcu)) {
             .Slice => {
                 result[0] = .integer;
                 result[1] = .integer;
 @@ -121,14 +120,14 @@ pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
             },
         },
         .Optional => {
-            if (ty.isPtrLikeOptional(pt.zcu)) {
+            if (ty.isPtrLikeOptional(zcu)) {
                 result[0] = .integer;
                 return result;
             }
             return memory_class;
         },
         .Int, .Enum, .ErrorSet => {
-            const int_bits = ty.intInfo(pt.zcu).bits;
+            const int_bits = ty.intInfo(zcu).bits;
             if (int_bits <= 64) {
                 result[0] = .integer;
                 return result;
 @@ -153,8 +152,8 @@ pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
             unreachable; // support split float args
         },
         .ErrorUnion => {
-            const payload_ty = ty.errorUnionPayload(pt.zcu);
+            const payload_ty = ty.errorUnionPayload(zcu);
-            const payload_bits = payload_ty.bitSize(pt);
+            const payload_bits = payload_ty.bitSize(zcu);
             // the error union itself
             result[0] = .integer;
 @@ -165,8 +164,8 @@ pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
             return memory_class;
         },
         .Struct, .Union => {
-            const layout = ty.containerLayout(pt.zcu);
+            const layout = ty.containerLayout(zcu);
-            const ty_size = ty.abiSize(pt);
+            const ty_size = ty.abiSize(zcu);
             if (layout == .@"packed") {
                 assert(ty_size <= 16);
 @@ -178,7 +177,7 @@ pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
             return memory_class;
         },
         .Array => {
-            const ty_size = ty.abiSize(pt);
+            const ty_size = ty.abiSize(zcu);
             if (ty_size <= 8) {
                 result[0] = .integer;
                 return result;
 @@ -192,7 +191,7 @@ pub fn classifySystem(ty: Type, pt: Zcu.PerThread) [8]SystemClass {
         },
         .Vector => {
             // we pass vectors through integer registers if they are small enough to fit.
-            const vec_bits = ty.totalVectorBits(pt);
+            const vec_bits = ty.totalVectorBits(zcu);
             if (vec_bits <= 64) {
                 result[0] = .integer;
                 return result;

src/arch/sparc64/CodeGen.zig+139-140

 @@ -365,8 +365,8 @@ pub fn generate(
 fn gen(self: *Self) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const cc = self.fn_type.fnCallingConvention(mod);
+    const cc = self.fn_type.fnCallingConvention(zcu);
     if (cc != .Naked) {
         // TODO Finish function prologue and epilogue for sparc64.
 @@ -494,8 +494,8 @@ fn gen(self: *Self) !void {
 fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const air_tags = self.air.instructions.items(.tag);
     for (body) |inst| {
 @@ -760,18 +760,18 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const lhs = try self.resolveInst(extra.lhs);
         const rhs = try self.resolveInst(extra.rhs);
         const lhs_ty = self.typeOf(extra.lhs);
         const rhs_ty = self.typeOf(extra.rhs);
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement add_with_overflow/sub_with_overflow for vectors", .{}),
             .Int => {
-                assert(lhs_ty.eql(rhs_ty, mod));
+                assert(lhs_ty.eql(rhs_ty, zcu));
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 switch (int_info.bits) {
                     32, 64 => {
                         // Only say yes if the operation is
 @@ -839,9 +839,9 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const vector_ty = self.typeOfIndex(inst);
-    const len = vector_ty.vectorLen(mod);
+    const len = vector_ty.vectorLen(zcu);
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[ty_pl.payload..][0..len]));
     const result: MCValue = res: {
 @@ -874,13 +874,13 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const ptr_ty = self.typeOf(ty_op.operand);
         const ptr = try self.resolveInst(ty_op.operand);
-        const array_ty = ptr_ty.childType(mod);
+        const array_ty = ptr_ty.childType(zcu);
-        const array_len = @as(u32, @intCast(array_ty.arrayLen(mod)));
+        const array_len = @as(u32, @intCast(array_ty.arrayLen(zcu)));
         const ptr_bytes = 8;
         const stack_offset = try self.allocMem(inst, ptr_bytes * 2, .@"8");
         try self.genSetStack(ptr_ty, stack_offset, ptr);
 @@ -1012,6 +1012,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
 fn airArg(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
+    const zcu = pt.zcu;
     const arg_index = self.arg_index;
     self.arg_index += 1;
 @@ -1021,7 +1022,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
     const mcv = blk: {
         switch (arg) {
             .stack_offset => |off| {
-                const abi_size = math.cast(u32, ty.abiSize(pt)) orelse {
+                const abi_size = math.cast(u32, ty.abiSize(zcu)) orelse {
                     return self.fail("type '{}' too big to fit into stack frame", .{ty.fmt(pt)});
                 };
                 const offset = off + abi_size;
 @@ -1211,7 +1212,7 @@ fn airBreakpoint(self: *Self) !void {
 fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     // We have hardware byteswapper in SPARCv9, don't let mainstream compilers mislead you.
 @@ -1227,14 +1228,14 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        switch (operand_ty.zigTypeTag(mod)) {
+        switch (operand_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO byteswap for vectors", .{}),
             .Int => {
-                const int_info = operand_ty.intInfo(mod);
+                const int_info = operand_ty.intInfo(zcu);
                 if (int_info.bits == 8) break :result operand;
                 const abi_size = int_info.bits >> 3;
-                const abi_align = operand_ty.abiAlignment(pt);
+                const abi_align = operand_ty.abiAlignment(zcu);
                 const opposite_endian_asi = switch (self.target.cpu.arch.endian()) {
                     Endian.big => ASI.asi_primary_little,
                     Endian.little => ASI.asi_primary,
 @@ -1304,11 +1305,11 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     const args = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra[extra.end .. extra.end + extra.data.args_len]));
     const ty = self.typeOf(callee);
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_ty = switch (ty.zigTypeTag(mod)) {
+    const fn_ty = switch (ty.zigTypeTag(zcu)) {
         .Fn => ty,
-        .Pointer => ty.childType(mod),
+        .Pointer => ty.childType(zcu),
         else => unreachable,
     };
 @@ -1360,7 +1361,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
             return self.fail("TODO implement calling bitcasted functions", .{});
         },
     } else {
-        assert(ty.zigTypeTag(mod) == .Pointer);
+        assert(ty.zigTypeTag(zcu) == .Pointer);
         const mcv = try self.resolveInst(callee);
         try self.genSetReg(ty, .o7, mcv);
 @@ -1409,24 +1410,24 @@ fn airClz(self: *Self, inst: Air.Inst.Index) !void {
 fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const lhs_ty = self.typeOf(bin_op.lhs);
-        const int_ty = switch (lhs_ty.zigTypeTag(mod)) {
+        const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => unreachable, // Handled by cmp_vector.
-            .Enum => lhs_ty.intTagType(mod),
+            .Enum => lhs_ty.intTagType(zcu),
             .Int => lhs_ty,
             .Bool => Type.u1,
             .Pointer => Type.usize,
             .ErrorSet => Type.u16,
             .Optional => blk: {
-                const payload_ty = lhs_ty.optionalChild(mod);
+                const payload_ty = lhs_ty.optionalChild(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     break :blk Type.u1;
-                } else if (lhs_ty.isPtrLikeOptional(mod)) {
+                } else if (lhs_ty.isPtrLikeOptional(zcu)) {
                     break :blk Type.usize;
                 } else {
                     return self.fail("TODO SPARCv9 cmp non-pointer optionals", .{});
 @@ -1436,7 +1437,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
             else => unreachable,
         };
-        const int_info = int_ty.intInfo(mod);
+        const int_info = int_ty.intInfo(zcu);
         if (int_info.bits <= 64) {
             _ = try self.binOp(.cmp_eq, lhs, rhs, int_ty, int_ty, BinOpMetadata{
                 .lhs = bin_op.lhs,
 @@ -1635,13 +1636,9 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
-    const mod = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
-    const func = mod.funcInfo(extra.data.func);
     // TODO emit debug info for function change
-    _ = func;
     try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
 }
 @@ -1735,11 +1732,11 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
         return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const operand_ty = self.typeOf(ty_op.operand);
     const operand = try self.resolveInst(ty_op.operand);
-    const info_a = operand_ty.intInfo(mod);
+    const info_a = operand_ty.intInfo(zcu);
-    const info_b = self.typeOfIndex(inst).intInfo(mod);
+    const info_b = self.typeOfIndex(inst).intInfo(zcu);
     if (info_a.signedness != info_b.signedness)
         return self.fail("TODO gen intcast sign safety in semantic analysis", .{});
 @@ -1797,16 +1794,16 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
 fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const elem_ty = self.typeOfIndex(inst);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     const result: MCValue = result: {
-        if (!elem_ty.hasRuntimeBits(pt))
+        if (!elem_ty.hasRuntimeBits(zcu))
             break :result MCValue.none;
         const ptr = try self.resolveInst(ty_op.operand);
-        const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(mod);
+        const is_volatile = self.typeOf(ty_op.operand).isVolatilePtr(zcu);
         if (self.liveness.isUnused(inst) and !is_volatile)
             break :result MCValue.dead;
 @@ -2024,18 +2021,18 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const lhs = try self.resolveInst(extra.lhs);
         const rhs = try self.resolveInst(extra.rhs);
         const lhs_ty = self.typeOf(extra.lhs);
         const rhs_ty = self.typeOf(extra.rhs);
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
             .Int => {
-                assert(lhs_ty.eql(rhs_ty, mod));
+                assert(lhs_ty.eql(rhs_ty, zcu));
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 switch (int_info.bits) {
                     1...32 => {
                         try self.spillConditionFlagsIfOccupied();
 @@ -2089,7 +2086,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
 fn airNot(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
 @@ -2105,7 +2102,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
                 };
             },
             else => {
-                switch (operand_ty.zigTypeTag(mod)) {
+                switch (operand_ty.zigTypeTag(zcu)) {
                     .Bool => {
                         const op_reg = switch (operand) {
                             .register => |r| r,
 @@ -2139,7 +2136,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
                     },
                     .Vector => return self.fail("TODO bitwise not for vectors", .{}),
                     .Int => {
-                        const int_info = operand_ty.intInfo(mod);
+                        const int_info = operand_ty.intInfo(zcu);
                         if (int_info.bits <= 64) {
                             const op_reg = switch (operand) {
                                 .register => |r| r,
 @@ -2322,17 +2319,17 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const lhs = try self.resolveInst(extra.lhs);
         const rhs = try self.resolveInst(extra.rhs);
         const lhs_ty = self.typeOf(extra.lhs);
         const rhs_ty = self.typeOf(extra.rhs);
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement mul_with_overflow for vectors", .{}),
             .Int => {
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 if (int_info.bits <= 64) {
                     try self.spillConditionFlagsIfOccupied();
 @@ -2428,7 +2425,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
 fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const is_volatile = false; // TODO
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 @@ -2438,10 +2435,10 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
         const index_mcv = try self.resolveInst(bin_op.rhs);
         const slice_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = slice_ty.childType(mod);
+        const elem_ty = slice_ty.childType(zcu);
-        const elem_size = elem_ty.abiSize(pt);
+        const elem_size = elem_ty.abiSize(zcu);
-        const slice_ptr_field_type = slice_ty.slicePtrFieldType(mod);
+        const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
         const index_lock: ?RegisterLock = if (index_mcv == .register)
             self.register_manager.lockRegAssumeUnused(index_mcv.register)
 @@ -2553,10 +2550,10 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
     const operand = extra.struct_operand;
     const index = extra.field_index;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
-        const pt = self.pt;
+        const zcu = self.pt.zcu;
         const mcv = try self.resolveInst(operand);
         const struct_ty = self.typeOf(operand);
-        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, pt)));
+        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, zcu)));
         switch (mcv) {
             .dead, .unreach => unreachable,
 @@ -2687,13 +2684,13 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
 fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const error_union_ty = self.typeOf(ty_op.operand);
-        const payload_ty = error_union_ty.errorUnionPayload(mod);
+        const payload_ty = error_union_ty.errorUnionPayload(zcu);
         const mcv = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBits(pt)) break :result mcv;
+        if (!payload_ty.hasRuntimeBits(zcu)) break :result mcv;
         return self.fail("TODO implement unwrap error union error for non-empty payloads", .{});
     };
 @@ -2702,12 +2699,12 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
 fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const error_union_ty = self.typeOf(ty_op.operand);
-        const payload_ty = error_union_ty.errorUnionPayload(mod);
+        const payload_ty = error_union_ty.errorUnionPayload(zcu);
-        if (!payload_ty.hasRuntimeBits(pt)) break :result MCValue.none;
+        if (!payload_ty.hasRuntimeBits(zcu)) break :result MCValue.none;
         return self.fail("TODO implement unwrap error union payload for non-empty payloads", .{});
     };
 @@ -2717,13 +2714,13 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
 /// E to E!T
 fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const error_union_ty = ty_op.ty.toType();
-        const payload_ty = error_union_ty.errorUnionPayload(mod);
+        const payload_ty = error_union_ty.errorUnionPayload(zcu);
         const mcv = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBits(pt)) break :result mcv;
+        if (!payload_ty.hasRuntimeBits(zcu)) break :result mcv;
         return self.fail("TODO implement wrap errunion error for non-empty payloads", .{});
     };
 @@ -2744,7 +2741,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
         const optional_ty = self.typeOfIndex(inst);
         // Optional with a zero-bit payload type is just a boolean true
-        if (optional_ty.abiSize(pt) == 1)
+        if (optional_ty.abiSize(pt.zcu) == 1)
             break :result MCValue{ .immediate = 1 };
         return self.fail("TODO implement wrap optional for {}", .{self.target.cpu.arch});
 @@ -2779,10 +2776,10 @@ fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: Alignme
 /// Use a pointer instruction as the basis for allocating stack memory.
 fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const elem_ty = self.typeOfIndex(inst).childType(mod);
+    const elem_ty = self.typeOfIndex(inst).childType(zcu);
-    if (!elem_ty.hasRuntimeBits(pt)) {
+    if (!elem_ty.hasRuntimeBits(zcu)) {
         // As this stack item will never be dereferenced at runtime,
         // return the stack offset 0. Stack offset 0 will be where all
         // zero-sized stack allocations live as non-zero-sized
 @@ -2790,21 +2787,22 @@ fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
         return @as(u32, 0);
     }
-    const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {
+    const abi_size = math.cast(u32, elem_ty.abiSize(zcu)) orelse {
         return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
     };
     // TODO swap this for inst.ty.ptrAlign
-    const abi_align = elem_ty.abiAlignment(pt);
+    const abi_align = elem_ty.abiAlignment(zcu);
     return self.allocMem(inst, abi_size, abi_align);
 }
 fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
     const pt = self.pt;
+    const zcu = pt.zcu;
     const elem_ty = self.typeOfIndex(inst);
-    const abi_size = math.cast(u32, elem_ty.abiSize(pt)) orelse {
+    const abi_size = math.cast(u32, elem_ty.abiSize(zcu)) orelse {
         return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(pt)});
     };
-    const abi_align = elem_ty.abiAlignment(pt);
+    const abi_align = elem_ty.abiAlignment(zcu);
     self.stack_align = self.stack_align.max(abi_align);
     if (reg_ok) {
 @@ -2847,7 +2845,7 @@ fn binOp(
     metadata: ?BinOpMetadata,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     switch (tag) {
         .add,
         .sub,
 @@ -2857,12 +2855,12 @@ fn binOp(
         .xor,
         .cmp_eq,
         => {
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Float => return self.fail("TODO binary operations on floats", .{}),
                 .Vector => return self.fail("TODO binary operations on vectors", .{}),
                 .Int => {
-                    assert(lhs_ty.eql(rhs_ty, mod));
+                    assert(lhs_ty.eql(rhs_ty, zcu));
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     if (int_info.bits <= 64) {
                         // Only say yes if the operation is
                         // commutative, i.e. we can swap both of the
 @@ -2931,10 +2929,10 @@ fn binOp(
             const result = try self.binOp(base_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
             // Truncate if necessary
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Vector => return self.fail("TODO binary operations on vectors", .{}),
                 .Int => {
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     if (int_info.bits <= 64) {
                         const result_reg = result.register;
                         try self.truncRegister(result_reg, result_reg, int_info.signedness, int_info.bits);
 @@ -2948,11 +2946,11 @@ fn binOp(
         },
         .div_trunc => {
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Vector => return self.fail("TODO binary operations on vectors", .{}),
                 .Int => {
-                    assert(lhs_ty.eql(rhs_ty, mod));
+                    assert(lhs_ty.eql(rhs_ty, zcu));
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     if (int_info.bits <= 64) {
                         const rhs_immediate_ok = switch (tag) {
                             .div_trunc => rhs == .immediate and rhs.immediate <= std.math.maxInt(u12),
 @@ -2981,14 +2979,14 @@ fn binOp(
         },
         .ptr_add => {
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Pointer => {
                     const ptr_ty = lhs_ty;
-                    const elem_ty = switch (ptr_ty.ptrSize(mod)) {
+                    const elem_ty = switch (ptr_ty.ptrSize(zcu)) {
-                        .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
+                        .One => ptr_ty.childType(zcu).childType(zcu), // ptr to array, so get array element type
-                        else => ptr_ty.childType(mod),
+                        else => ptr_ty.childType(zcu),
                     };
-                    const elem_size = elem_ty.abiSize(pt);
+                    const elem_size = elem_ty.abiSize(zcu);
                     if (elem_size == 1) {
                         const base_tag: Mir.Inst.Tag = switch (tag) {
 @@ -3013,7 +3011,7 @@ fn binOp(
         .bool_and,
         .bool_or,
         => {
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Bool => {
                     assert(lhs != .immediate); // should have been handled by Sema
                     assert(rhs != .immediate); // should have been handled by Sema
 @@ -3043,10 +3041,10 @@ fn binOp(
             const result = try self.binOp(base_tag, lhs, rhs, lhs_ty, rhs_ty, metadata);
             // Truncate if necessary
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Vector => return self.fail("TODO binary operations on vectors", .{}),
                 .Int => {
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     if (int_info.bits <= 64) {
                         // 32 and 64 bit operands doesn't need truncating
                         if (int_info.bits == 32 or int_info.bits == 64) return result;
 @@ -3065,10 +3063,10 @@ fn binOp(
         .shl_exact,
         .shr_exact,
         => {
-            switch (lhs_ty.zigTypeTag(mod)) {
+            switch (lhs_ty.zigTypeTag(zcu)) {
                 .Vector => return self.fail("TODO binary operations on vectors", .{}),
                 .Int => {
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     if (int_info.bits <= 64) {
                         const rhs_immediate_ok = rhs == .immediate;
 @@ -3388,8 +3386,8 @@ fn binOpRegister(
 fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
     const block_data = self.blocks.getPtr(block).?;
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
-    if (self.typeOf(operand).hasRuntimeBits(pt)) {
+    if (self.typeOf(operand).hasRuntimeBits(zcu)) {
         const operand_mcv = try self.resolveInst(operand);
         const block_mcv = block_data.mcv;
         if (block_mcv == .none) {
 @@ -3509,17 +3507,17 @@ fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {
 /// Given an error union, returns the payload
 fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const err_ty = error_union_ty.errorUnionSet(mod);
+    const err_ty = error_union_ty.errorUnionSet(zcu);
-    const payload_ty = error_union_ty.errorUnionPayload(mod);
+    const payload_ty = error_union_ty.errorUnionPayload(zcu);
-    if (err_ty.errorSetIsEmpty(mod)) {
+    if (err_ty.errorSetIsEmpty(zcu)) {
         return error_union_mcv;
     }
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return MCValue.none;
     }
-    const payload_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, pt)));
+    const payload_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, zcu)));
     switch (error_union_mcv) {
         .register => return self.fail("TODO errUnionPayload for registers", .{}),
         .stack_offset => |off| {
 @@ -3731,6 +3729,7 @@ fn genLoadASI(self: *Self, value_reg: Register, addr_reg: Register, off_reg: Reg
 fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
     const pt = self.pt;
+    const zcu = pt.zcu;
     switch (mcv) {
         .dead => unreachable,
         .unreach, .none => return, // Nothing to do.
 @@ -3929,21 +3928,21 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
             // The value is in memory at a hard-coded address.
             // If the type is a pointer, it means the pointer address is at this memory location.
             try self.genSetReg(ty, reg, .{ .immediate = addr });
-            try self.genLoad(reg, reg, i13, 0, ty.abiSize(pt));
+            try self.genLoad(reg, reg, i13, 0, ty.abiSize(zcu));
         },
         .stack_offset => |off| {
             const real_offset = realStackOffset(off);
             const simm13 = math.cast(i13, real_offset) orelse
                 return self.fail("TODO larger stack offsets: {}", .{real_offset});
-            try self.genLoad(reg, .sp, i13, simm13, ty.abiSize(pt));
+            try self.genLoad(reg, .sp, i13, simm13, ty.abiSize(zcu));
         },
     }
 }
 fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(zcu);
     switch (mcv) {
         .dead => unreachable,
         .unreach, .none => return, // Nothing to do.
 @@ -3951,7 +3950,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
             if (!self.wantSafety())
                 return; // The already existing value will do just fine.
             // TODO Upgrade this to a memset call when we have that available.
-            switch (ty.abiSize(pt)) {
+            switch (ty.abiSize(zcu)) {
                 1 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaa }),
                 2 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaa }),
                 4 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
 @@ -3977,11 +3976,11 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
             const reg_lock = self.register_manager.lockReg(rwo.reg);
             defer if (reg_lock) |locked_reg| self.register_manager.unlockReg(locked_reg);
-            const wrapped_ty = ty.structFieldType(0, mod);
+            const wrapped_ty = ty.fieldType(0, zcu);
             try self.genSetStack(wrapped_ty, stack_offset, .{ .register = rwo.reg });
-            const overflow_bit_ty = ty.structFieldType(1, mod);
+            const overflow_bit_ty = ty.fieldType(1, zcu);
-            const overflow_bit_offset = @as(u32, @intCast(ty.structFieldOffset(1, pt)));
+            const overflow_bit_offset = @as(u32, @intCast(ty.structFieldOffset(1, zcu)));
             const cond_reg = try self.register_manager.allocReg(null, gp);
             // TODO handle floating point CCRs
 @@ -4154,14 +4153,14 @@ fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) MCValue {
 fn isErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const error_type = ty.errorUnionSet(mod);
+    const error_type = ty.errorUnionSet(zcu);
-    const payload_type = ty.errorUnionPayload(mod);
+    const payload_type = ty.errorUnionPayload(zcu);
-    if (!error_type.hasRuntimeBits(pt)) {
+    if (!error_type.hasRuntimeBits(zcu)) {
         return MCValue{ .immediate = 0 }; // always false
-    } else if (!payload_type.hasRuntimeBits(pt)) {
+    } else if (!payload_type.hasRuntimeBits(zcu)) {
-        if (error_type.abiSize(pt) <= 8) {
+        if (error_type.abiSize(zcu) <= 8) {
             const reg_mcv: MCValue = switch (operand) {
                 .register => operand,
                 else => .{ .register = try self.copyToTmpRegister(error_type, operand) },
 @@ -4253,9 +4252,9 @@ fn jump(self: *Self, inst: Mir.Inst.Index) !void {
 fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     switch (ptr) {
         .none => unreachable,
 @@ -4325,13 +4324,13 @@ fn minMax(
     rhs_ty: Type,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    assert(lhs_ty.eql(rhs_ty, mod));
+    assert(lhs_ty.eql(rhs_ty, zcu));
-    switch (lhs_ty.zigTypeTag(mod)) {
+    switch (lhs_ty.zigTypeTag(zcu)) {
         .Float => return self.fail("TODO min/max on floats", .{}),
         .Vector => return self.fail("TODO min/max on vectors", .{}),
         .Int => {
-            const int_info = lhs_ty.intInfo(mod);
+            const int_info = lhs_ty.intInfo(zcu);
             if (int_info.bits <= 64) {
                 // TODO skip register setting when one of the operands
                 // is a small (fits in i13) immediate.
 @@ -4446,9 +4445,9 @@ fn realStackOffset(off: u32) u32 {
 /// Caller must call `CallMCValues.deinit`.
 fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView) !CallMCValues {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_info = mod.typeToFunc(fn_ty).?;
+    const fn_info = zcu.typeToFunc(fn_ty).?;
     const cc = fn_info.cc;
     var result: CallMCValues = .{
         .args = try self.gpa.alloc(MCValue, fn_info.param_types.len),
 @@ -4459,7 +4458,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView)
     };
     errdefer self.gpa.free(result.args);
-    const ret_ty = fn_ty.fnReturnType(mod);
+    const ret_ty = fn_ty.fnReturnType(zcu);
     switch (cc) {
         .Naked => {
 @@ -4487,7 +4486,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView)
             };
             for (fn_info.param_types.get(ip), result.args) |ty, *result_arg| {
-                const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(pt)));
+                const param_size = @as(u32, @intCast(Type.fromInterned(ty).abiSize(zcu)));
                 if (param_size <= 8) {
                     if (next_register < argument_registers.len) {
                         result_arg.* = .{ .register = argument_registers[next_register] };
 @@ -4514,12 +4513,12 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView)
             result.stack_byte_count = next_stack_offset;
             result.stack_align = .@"16";
-            if (ret_ty.zigTypeTag(mod) == .NoReturn) {
+            if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = .{ .unreach = {} };
-            } else if (!ret_ty.hasRuntimeBits(pt)) {
+            } else if (!ret_ty.hasRuntimeBits(zcu)) {
                 result.return_value = .{ .none = {} };
             } else {
-                const ret_ty_size: u32 = @intCast(ret_ty.abiSize(pt));
+                const ret_ty_size: u32 = @intCast(ret_ty.abiSize(zcu));
                 // The callee puts the return values in %i0-%i3, which becomes %o0-%o3 inside the caller.
                 if (ret_ty_size <= 8) {
                     result.return_value = switch (role) {
 @@ -4542,7 +4541,7 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
     const ty = self.typeOf(ref);
     // If the type has no codegen bits, no need to store it.
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+    if (!ty.hasRuntimeBitsIgnoreComptime(pt.zcu)) return .none;
     if (ref.toIndex()) |inst| {
         return self.getResolvedInstValue(inst);
 @@ -4553,8 +4552,8 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
 fn ret(self: *Self, mcv: MCValue) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ret_ty = self.fn_type.fnReturnType(mod);
+    const ret_ty = self.fn_type.fnReturnType(zcu);
     try self.setRegOrMem(ret_ty, self.ret_mcv, mcv);
     // Just add space for a branch instruction, patch this later
 @@ -4656,7 +4655,7 @@ pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void
 fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {
     const pt = self.pt;
-    const abi_size = value_ty.abiSize(pt);
+    const abi_size = value_ty.abiSize(pt.zcu);
     switch (ptr) {
         .none => unreachable,
 @@ -4698,11 +4697,11 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
 fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {
     return if (self.liveness.isUnused(inst)) .dead else result: {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const mcv = try self.resolveInst(operand);
         const ptr_ty = self.typeOf(operand);
-        const struct_ty = ptr_ty.childType(mod);
+        const struct_ty = ptr_ty.childType(zcu);
-        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, pt)));
+        const struct_field_offset = @as(u32, @intCast(struct_ty.structFieldOffset(index, zcu)));
         switch (mcv) {
             .ptr_stack_offset => |off| {
                 break :result MCValue{ .ptr_stack_offset = off - struct_field_offset };
 @@ -4741,9 +4740,9 @@ fn trunc(
     dest_ty: Type,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const info_a = operand_ty.intInfo(mod);
+    const info_a = operand_ty.intInfo(zcu);
-    const info_b = dest_ty.intInfo(mod);
+    const info_b = dest_ty.intInfo(zcu);
     if (info_b.bits <= 64) {
         const operand_reg = switch (operand) {

src/arch/wasm/CodeGen.zig+542-539

 @@ -788,10 +788,10 @@ fn resolveInst(func: *CodeGen, ref: Air.Inst.Ref) InnerError!WValue {
     assert(!gop.found_existing);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const val = (try func.air.value(ref, pt)).?;
     const ty = func.typeOf(ref);
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt) and !ty.isInt(mod) and !ty.isError(mod)) {
+    if (!ty.hasRuntimeBitsIgnoreComptime(zcu) and !ty.isInt(zcu) and !ty.isError(zcu)) {
         gop.value_ptr.* = .none;
         return gop.value_ptr.*;
     }
 @@ -1001,9 +1001,9 @@ fn addExtraAssumeCapacity(func: *CodeGen, extra: anytype) error{OutOfMemory}!u32
 /// Using a given `Type`, returns the corresponding valtype for .auto callconv
 fn typeToValtype(ty: Type, pt: Zcu.PerThread, target: std.Target) wasm.Valtype {
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .Float => switch (ty.floatBits(target)) {
             16 => .i32, // stored/loaded as u16
             32 => .f32,
 @@ -1011,26 +1011,26 @@ fn typeToValtype(ty: Type, pt: Zcu.PerThread, target: std.Target) wasm.Valtype {
             80, 128 => .i32,
             else => unreachable,
         },
-        .Int, .Enum => switch (ty.intInfo(pt.zcu).bits) {
+        .Int, .Enum => switch (ty.intInfo(zcu).bits) {
             0...32 => .i32,
             33...64 => .i64,
             else => .i32,
         },
         .Struct => blk: {
-            if (pt.zcu.typeToPackedStruct(ty)) |packed_struct| {
+            if (zcu.typeToPackedStruct(ty)) |packed_struct| {
                 const backing_int_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
                 break :blk typeToValtype(backing_int_ty, pt, target);
             } else {
                 break :blk .i32;
             }
         },
-        .Vector => switch (determineSimdStoreStrategy(ty, pt, target)) {
+        .Vector => switch (determineSimdStoreStrategy(ty, zcu, target)) {
             .direct => .v128,
             .unrolled => .i32,
         },
-        .Union => switch (ty.containerLayout(pt.zcu)) {
+        .Union => switch (ty.containerLayout(zcu)) {
             .@"packed" => blk: {
-                const int_ty = pt.intType(.unsigned, @as(u16, @intCast(ty.bitSize(pt)))) catch @panic("out of memory");
+                const int_ty = pt.intType(.unsigned, @as(u16, @intCast(ty.bitSize(zcu)))) catch @panic("out of memory");
                 break :blk typeToValtype(int_ty, pt, target);
             },
             else => .i32,
 @@ -1148,7 +1148,7 @@ fn genFunctype(
     pt: Zcu.PerThread,
     target: std.Target,
 ) !wasm.Type {
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     var temp_params = std.ArrayList(wasm.Valtype).init(gpa);
     defer temp_params.deinit();
     var returns = std.ArrayList(wasm.Valtype).init(gpa);
 @@ -1156,30 +1156,30 @@ fn genFunctype(
     if (firstParamSRet(cc, return_type, pt, target)) {
         try temp_params.append(.i32); // memory address is always a 32-bit handle
-    } else if (return_type.hasRuntimeBitsIgnoreComptime(pt)) {
+    } else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
         if (cc == .C) {
-            const res_classes = abi.classifyType(return_type, pt);
+            const res_classes = abi.classifyType(return_type, zcu);
             assert(res_classes[0] == .direct and res_classes[1] == .none);
-            const scalar_type = abi.scalarType(return_type, pt);
+            const scalar_type = abi.scalarType(return_type, zcu);
             try returns.append(typeToValtype(scalar_type, pt, target));
         } else {
             try returns.append(typeToValtype(return_type, pt, target));
         }
-    } else if (return_type.isError(mod)) {
+    } else if (return_type.isError(zcu)) {
         try returns.append(.i32);
     }
     // param types
     for (params) |param_type_ip| {
         const param_type = Type.fromInterned(param_type_ip);
-        if (!param_type.hasRuntimeBitsIgnoreComptime(pt)) continue;
+        if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
         switch (cc) {
             .C => {
-                const param_classes = abi.classifyType(param_type, pt);
+                const param_classes = abi.classifyType(param_type, zcu);
                 if (param_classes[1] == .none) {
                     if (param_classes[0] == .direct) {
-                        const scalar_type = abi.scalarType(param_type, pt);
+                        const scalar_type = abi.scalarType(param_type, zcu);
                         try temp_params.append(typeToValtype(scalar_type, pt, target));
                     } else {
                         try temp_params.append(typeToValtype(param_type, pt, target));
 @@ -1242,10 +1242,10 @@ pub fn generate(
 fn genFunc(func: *CodeGen) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_ty = mod.navValue(func.owner_nav).typeOf(mod);
+    const fn_ty = zcu.navValue(func.owner_nav).typeOf(zcu);
-    const fn_info = mod.typeToFunc(fn_ty).?;
+    const fn_info = zcu.typeToFunc(fn_ty).?;
     var func_type = try genFunctype(func.gpa, fn_info.cc, fn_info.param_types.get(ip), Type.fromInterned(fn_info.return_type), pt, func.target.*);
     defer func_type.deinit(func.gpa);
     _ = try func.bin_file.storeNavType(func.owner_nav, func_type);
 @@ -1273,7 +1273,7 @@ fn genFunc(func: *CodeGen) InnerError!void {
     if (func_type.returns.len != 0 and func.air.instructions.len > 0) {
         const inst: Air.Inst.Index = @enumFromInt(func.air.instructions.len - 1);
         const last_inst_ty = func.typeOfIndex(inst);
-        if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(pt) or last_inst_ty.isNoReturn(mod)) {
+        if (!last_inst_ty.hasRuntimeBitsIgnoreComptime(zcu) or last_inst_ty.isNoReturn(zcu)) {
             try func.addTag(.@"unreachable");
         }
     }
 @@ -1356,9 +1356,9 @@ const CallWValues = struct {
 fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWValues {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_info = mod.typeToFunc(fn_ty).?;
+    const fn_info = zcu.typeToFunc(fn_ty).?;
     const cc = fn_info.cc;
     var result: CallWValues = .{
         .args = &.{},
 @@ -1381,7 +1381,7 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
     switch (cc) {
         .Unspecified => {
             for (fn_info.param_types.get(ip)) |ty| {
-                if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
                     continue;
                 }
 @@ -1391,7 +1391,7 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
         },
         .C => {
             for (fn_info.param_types.get(ip)) |ty| {
-                const ty_classes = abi.classifyType(Type.fromInterned(ty), pt);
+                const ty_classes = abi.classifyType(Type.fromInterned(ty), zcu);
                 for (ty_classes) |class| {
                     if (class == .none) continue;
                     try args.append(.{ .local = .{ .value = func.local_index, .references = 1 } });
 @@ -1409,7 +1409,7 @@ fn firstParamSRet(cc: std.builtin.CallingConvention, return_type: Type, pt: Zcu.
     switch (cc) {
         .Unspecified, .Inline => return isByRef(return_type, pt, target),
         .C => {
-            const ty_classes = abi.classifyType(return_type, pt);
+            const ty_classes = abi.classifyType(return_type, pt.zcu);
             if (ty_classes[0] == .indirect) return true;
             if (ty_classes[0] == .direct and ty_classes[1] == .direct) return true;
             return false;
 @@ -1426,16 +1426,16 @@ fn lowerArg(func: *CodeGen, cc: std.builtin.CallingConvention, ty: Type, value:
     }
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ty_classes = abi.classifyType(ty, pt);
+    const ty_classes = abi.classifyType(ty, zcu);
     assert(ty_classes[0] != .none);
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Struct, .Union => {
             if (ty_classes[0] == .indirect) {
                 return func.lowerToStack(value);
             }
             assert(ty_classes[0] == .direct);
-            const scalar_type = abi.scalarType(ty, pt);
+            const scalar_type = abi.scalarType(ty, zcu);
             switch (value) {
                 .memory,
                 .memory_offset,
 @@ -1450,7 +1450,7 @@ fn lowerArg(func: *CodeGen, cc: std.builtin.CallingConvention, ty: Type, value:
                 return func.lowerToStack(value);
             }
             assert(ty_classes[0] == .direct and ty_classes[1] == .direct);
-            assert(ty.abiSize(pt) == 16);
+            assert(ty.abiSize(zcu) == 16);
             // in this case we have an integer or float that must be lowered as 2 i64's.
             try func.emitWValue(value);
             try func.addMemArg(.i64_load, .{ .offset = value.offset(), .alignment = 8 });
 @@ -1517,18 +1517,18 @@ fn restoreStackPointer(func: *CodeGen) !void {
 ///
 /// Asserts Type has codegenbits
 fn allocStack(func: *CodeGen, ty: Type) !WValue {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
-    assert(ty.hasRuntimeBitsIgnoreComptime(pt));
+    assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
     if (func.initial_stack_value == .none) {
         try func.initializeStack();
     }
-    const abi_size = std.math.cast(u32, ty.abiSize(pt)) orelse {
+    const abi_size = std.math.cast(u32, ty.abiSize(zcu)) orelse {
         return func.fail("Type {} with ABI size of {d} exceeds stack frame size", .{
-            ty.fmt(pt), ty.abiSize(pt),
+            ty.fmt(func.pt), ty.abiSize(zcu),
         });
     };
-    const abi_align = ty.abiAlignment(pt);
+    const abi_align = ty.abiAlignment(zcu);
     func.stack_alignment = func.stack_alignment.max(abi_align);
 @@ -1544,22 +1544,22 @@ fn allocStack(func: *CodeGen, ty: Type) !WValue {
 /// if it is set, to ensure the stack alignment will be set correctly.
 fn allocStackPtr(func: *CodeGen, inst: Air.Inst.Index) !WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = func.typeOfIndex(inst);
-    const pointee_ty = ptr_ty.childType(mod);
+    const pointee_ty = ptr_ty.childType(zcu);
     if (func.initial_stack_value == .none) {
         try func.initializeStack();
     }
-    if (!pointee_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!pointee_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return func.allocStack(Type.usize); // create a value containing just the stack pointer.
     }
-    const abi_alignment = ptr_ty.ptrAlignment(pt);
+    const abi_alignment = ptr_ty.ptrAlignment(zcu);
-    const abi_size = std.math.cast(u32, pointee_ty.abiSize(pt)) orelse {
+    const abi_size = std.math.cast(u32, pointee_ty.abiSize(zcu)) orelse {
         return func.fail("Type {} with ABI size of {d} exceeds stack frame size", .{
-            pointee_ty.fmt(pt), pointee_ty.abiSize(pt),
+            pointee_ty.fmt(pt), pointee_ty.abiSize(zcu),
         });
     };
     func.stack_alignment = func.stack_alignment.max(abi_alignment);
 @@ -1716,9 +1716,9 @@ fn arch(func: *const CodeGen) std.Target.Cpu.Arch {
 /// For a given `Type`, will return true when the type will be passed
 /// by reference, rather than by value
 fn isByRef(ty: Type, pt: Zcu.PerThread, target: std.Target) bool {
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Type,
         .ComptimeInt,
         .ComptimeFloat,
 @@ -1738,41 +1738,41 @@ fn isByRef(ty: Type, pt: Zcu.PerThread, target: std.Target) bool {
         .Array,
         .Frame,
-        => return ty.hasRuntimeBitsIgnoreComptime(pt),
+        => return ty.hasRuntimeBitsIgnoreComptime(zcu),
         .Union => {
-            if (mod.typeToUnion(ty)) |union_obj| {
+            if (zcu.typeToUnion(ty)) |union_obj| {
                 if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-                    return ty.abiSize(pt) > 8;
+                    return ty.abiSize(zcu) > 8;
                 }
             }
-            return ty.hasRuntimeBitsIgnoreComptime(pt);
+            return ty.hasRuntimeBitsIgnoreComptime(zcu);
         },
         .Struct => {
-            if (mod.typeToPackedStruct(ty)) |packed_struct| {
+            if (zcu.typeToPackedStruct(ty)) |packed_struct| {
                 return isByRef(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), pt, target);
             }
-            return ty.hasRuntimeBitsIgnoreComptime(pt);
+            return ty.hasRuntimeBitsIgnoreComptime(zcu);
         },
-        .Vector => return determineSimdStoreStrategy(ty, pt, target) == .unrolled,
+        .Vector => return determineSimdStoreStrategy(ty, zcu, target) == .unrolled,
-        .Int => return ty.intInfo(mod).bits > 64,
+        .Int => return ty.intInfo(zcu).bits > 64,
-        .Enum => return ty.intInfo(mod).bits > 64,
+        .Enum => return ty.intInfo(zcu).bits > 64,
         .Float => return ty.floatBits(target) > 64,
         .ErrorUnion => {
-            const pl_ty = ty.errorUnionPayload(mod);
+            const pl_ty = ty.errorUnionPayload(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 return false;
             }
             return true;
         },
         .Optional => {
-            if (ty.isPtrLikeOptional(mod)) return false;
+            if (ty.isPtrLikeOptional(zcu)) return false;
-            const pl_type = ty.optionalChild(mod);
+            const pl_type = ty.optionalChild(zcu);
-            if (pl_type.zigTypeTag(mod) == .ErrorSet) return false;
+            if (pl_type.zigTypeTag(zcu) == .ErrorSet) return false;
-            return pl_type.hasRuntimeBitsIgnoreComptime(pt);
+            return pl_type.hasRuntimeBitsIgnoreComptime(zcu);
         },
         .Pointer => {
             // Slices act like struct and will be passed by reference
-            if (ty.isSlice(mod)) return true;
+            if (ty.isSlice(zcu)) return true;
             return false;
         },
     }
 @@ -1787,9 +1787,9 @@ const SimdStoreStrategy = enum {
 /// This means when a given type is 128 bits and either the simd128 or relaxed-simd
 /// features are enabled, the function will return `.direct`. This would allow to store
 /// it using a instruction, rather than an unrolled version.
-fn determineSimdStoreStrategy(ty: Type, pt: Zcu.PerThread, target: std.Target) SimdStoreStrategy {
+fn determineSimdStoreStrategy(ty: Type, zcu: *Zcu, target: std.Target) SimdStoreStrategy {
-    std.debug.assert(ty.zigTypeTag(pt.zcu) == .Vector);
+    std.debug.assert(ty.zigTypeTag(zcu) == .Vector);
-    if (ty.bitSize(pt) != 128) return .unrolled;
+    if (ty.bitSize(zcu) != 128) return .unrolled;
     const hasFeature = std.Target.wasm.featureSetHas;
     const features = target.cpu.features;
     if (hasFeature(features, .relaxed_simd) or hasFeature(features, .simd128)) {
 @@ -2069,8 +2069,8 @@ fn genInst(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn genBody(func: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     for (body) |inst| {
         if (func.liveness.isUnused(inst) and !func.air.mustLower(inst, ip)) {
 @@ -2091,37 +2091,37 @@ fn genBody(func: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
 fn airRet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
-    const fn_info = mod.typeToFunc(mod.navValue(func.owner_nav).typeOf(mod)).?;
+    const fn_info = zcu.typeToFunc(zcu.navValue(func.owner_nav).typeOf(zcu)).?;
     const ret_ty = Type.fromInterned(fn_info.return_type);
     // result must be stored in the stack and we return a pointer
     // to the stack instead
     if (func.return_value != .none) {
         try func.store(func.return_value, operand, ret_ty, 0);
-    } else if (fn_info.cc == .C and ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    } else if (fn_info.cc == .C and ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        switch (ret_ty.zigTypeTag(mod)) {
+        switch (ret_ty.zigTypeTag(zcu)) {
             // Aggregate types can be lowered as a singular value
             .Struct, .Union => {
-                const scalar_type = abi.scalarType(ret_ty, pt);
+                const scalar_type = abi.scalarType(ret_ty, zcu);
                 try func.emitWValue(operand);
                 const opcode = buildOpcode(.{
                     .op = .load,
-                    .width = @as(u8, @intCast(scalar_type.abiSize(pt) * 8)),
+                    .width = @as(u8, @intCast(scalar_type.abiSize(zcu) * 8)),
-                    .signedness = if (scalar_type.isSignedInt(mod)) .signed else .unsigned,
+                    .signedness = if (scalar_type.isSignedInt(zcu)) .signed else .unsigned,
                     .valtype1 = typeToValtype(scalar_type, pt, func.target.*),
                 });
                 try func.addMemArg(Mir.Inst.Tag.fromOpcode(opcode), .{
                     .offset = operand.offset(),
-                    .alignment = @intCast(scalar_type.abiAlignment(pt).toByteUnits().?),
+                    .alignment = @intCast(scalar_type.abiAlignment(zcu).toByteUnits().?),
                 });
             },
             else => try func.emitWValue(operand),
         }
     } else {
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt) and ret_ty.isError(mod)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and ret_ty.isError(zcu)) {
             try func.addImm32(0);
         } else {
             try func.emitWValue(operand);
 @@ -2135,15 +2135,15 @@ fn airRet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airRetPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const child_type = func.typeOfIndex(inst).childType(mod);
+    const child_type = func.typeOfIndex(inst).childType(zcu);
     const result = result: {
-        if (!child_type.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+        if (!child_type.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
             break :result try func.allocStack(Type.usize); // create pointer to void
         }
-        const fn_info = mod.typeToFunc(mod.navValue(func.owner_nav).typeOf(mod)).?;
+        const fn_info = zcu.typeToFunc(zcu.navValue(func.owner_nav).typeOf(zcu)).?;
         if (firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, func.target.*)) {
             break :result func.return_value;
         }
 @@ -2156,14 +2156,14 @@ fn airRetPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airRetLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
-    const ret_ty = func.typeOf(un_op).childType(mod);
+    const ret_ty = func.typeOf(un_op).childType(zcu);
-    const fn_info = mod.typeToFunc(mod.navValue(func.owner_nav).typeOf(mod)).?;
+    const fn_info = zcu.typeToFunc(zcu.navValue(func.owner_nav).typeOf(zcu)).?;
-    if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        if (ret_ty.isError(mod)) {
+        if (ret_ty.isError(zcu)) {
             try func.addImm32(0);
         }
     } else if (!firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, func.target.*)) {
 @@ -2184,15 +2184,15 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     const ty = func.typeOf(pl_op.operand);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const fn_ty = switch (ty.zigTypeTag(mod)) {
+    const fn_ty = switch (ty.zigTypeTag(zcu)) {
         .Fn => ty,
-        .Pointer => ty.childType(mod),
+        .Pointer => ty.childType(zcu),
         else => unreachable,
     };
-    const ret_ty = fn_ty.fnReturnType(mod);
+    const ret_ty = fn_ty.fnReturnType(zcu);
-    const fn_info = mod.typeToFunc(fn_ty).?;
+    const fn_info = zcu.typeToFunc(fn_ty).?;
     const first_param_sret = firstParamSRet(fn_info.cc, Type.fromInterned(fn_info.return_type), pt, func.target.*);
     const callee: ?InternPool.Nav.Index = blk: {
 @@ -2205,7 +2205,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
             },
             .@"extern" => |@"extern"| {
                 const ext_nav = ip.getNav(@"extern".owner_nav);
-                const ext_info = mod.typeToFunc(Type.fromInterned(@"extern".ty)).?;
+                const ext_info = zcu.typeToFunc(Type.fromInterned(@"extern".ty)).?;
                 var func_type = try genFunctype(
                     func.gpa,
                     ext_info.cc,
 @@ -2248,9 +2248,9 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
         const arg_val = try func.resolveInst(arg);
         const arg_ty = func.typeOf(arg);
-        if (!arg_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+        if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-        try func.lowerArg(mod.typeToFunc(fn_ty).?.cc, arg_ty, arg_val);
+        try func.lowerArg(zcu.typeToFunc(fn_ty).?.cc, arg_ty, arg_val);
     }
     if (callee) |direct| {
 @@ -2259,7 +2259,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     } else {
         // in this case we call a function pointer
         // so load its value onto the stack
-        std.debug.assert(ty.zigTypeTag(mod) == .Pointer);
+        std.debug.assert(ty.zigTypeTag(zcu) == .Pointer);
         const operand = try func.resolveInst(pl_op.operand);
         try func.emitWValue(operand);
 @@ -2271,18 +2271,18 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     }
     const result_value = result_value: {
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt) and !ret_ty.isError(mod)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
             break :result_value .none;
-        } else if (ret_ty.isNoReturn(mod)) {
+        } else if (ret_ty.isNoReturn(zcu)) {
             try func.addTag(.@"unreachable");
             break :result_value .none;
         } else if (first_param_sret) {
             break :result_value sret;
             // TODO: Make this less fragile and optimize
-        } else if (mod.typeToFunc(fn_ty).?.cc == .C and ret_ty.zigTypeTag(mod) == .Struct or ret_ty.zigTypeTag(mod) == .Union) {
+        } else if (zcu.typeToFunc(fn_ty).?.cc == .C and ret_ty.zigTypeTag(zcu) == .Struct or ret_ty.zigTypeTag(zcu) == .Union) {
             const result_local = try func.allocLocal(ret_ty);
             try func.addLabel(.local_set, result_local.local.value);
-            const scalar_type = abi.scalarType(ret_ty, pt);
+            const scalar_type = abi.scalarType(ret_ty, zcu);
             const result = try func.allocStack(scalar_type);
             try func.store(result, result_local, scalar_type, 0);
             break :result_value result;
 @@ -2306,7 +2306,7 @@ fn airAlloc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (safety) {
         // TODO if the value is undef, write 0xaa bytes to dest
     } else {
 @@ -2317,8 +2317,8 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
     const ptr_ty = func.typeOf(bin_op.lhs);
-    const ptr_info = ptr_ty.ptrInfo(mod);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
-    const ty = ptr_ty.childType(mod);
+    const ty = ptr_ty.childType(zcu);
     if (ptr_info.packed_offset.host_size == 0) {
         try func.store(lhs, rhs, ty, 0);
 @@ -2331,7 +2331,7 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
             return func.fail("TODO: airStore for pointers to bitfields with backing type larger than 64bits", .{});
         }
-        var mask = @as(u64, @intCast((@as(u65, 1) << @as(u7, @intCast(ty.bitSize(pt)))) - 1));
+        var mask = @as(u64, @intCast((@as(u65, 1) << @as(u7, @intCast(ty.bitSize(zcu)))) - 1));
         mask <<= @as(u6, @intCast(ptr_info.packed_offset.bit_offset));
         mask ^= ~@as(u64, 0);
         const shift_val: WValue = if (ptr_info.packed_offset.host_size <= 4)
 @@ -2343,9 +2343,9 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
         else
             .{ .imm64 = mask };
         const wrap_mask_val: WValue = if (ptr_info.packed_offset.host_size <= 4)
-            .{ .imm32 = @truncate(~@as(u64, 0) >> @intCast(64 - ty.bitSize(pt))) }
+            .{ .imm32 = @truncate(~@as(u64, 0) >> @intCast(64 - ty.bitSize(zcu))) }
         else
-            .{ .imm64 = ~@as(u64, 0) >> @intCast(64 - ty.bitSize(pt)) };
+            .{ .imm64 = ~@as(u64, 0) >> @intCast(64 - ty.bitSize(zcu)) };
         try func.emitWValue(lhs);
         const loaded = try func.load(lhs, int_elem_ty, 0);
 @@ -2366,12 +2366,12 @@ fn airStore(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
 fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerError!void {
     assert(!(lhs != .stack and rhs == .stack));
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(zcu);
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .ErrorUnion => {
-            const pl_ty = ty.errorUnionPayload(mod);
+            const pl_ty = ty.errorUnionPayload(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 return func.store(lhs, rhs, Type.anyerror, 0);
             }
 @@ -2379,14 +2379,14 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
             return func.memcpy(lhs, rhs, .{ .imm32 = len });
         },
         .Optional => {
-            if (ty.isPtrLikeOptional(mod)) {
+            if (ty.isPtrLikeOptional(zcu)) {
                 return func.store(lhs, rhs, Type.usize, 0);
             }
-            const pl_ty = ty.optionalChild(mod);
+            const pl_ty = ty.optionalChild(zcu);
-            if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 return func.store(lhs, rhs, Type.u8, 0);
             }
-            if (pl_ty.zigTypeTag(mod) == .ErrorSet) {
+            if (pl_ty.zigTypeTag(zcu) == .ErrorSet) {
                 return func.store(lhs, rhs, Type.anyerror, 0);
             }
 @@ -2397,7 +2397,7 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
             const len = @as(u32, @intCast(abi_size));
             return func.memcpy(lhs, rhs, .{ .imm32 = len });
         },
-        .Vector => switch (determineSimdStoreStrategy(ty, pt, func.target.*)) {
+        .Vector => switch (determineSimdStoreStrategy(ty, zcu, func.target.*)) {
             .unrolled => {
                 const len: u32 = @intCast(abi_size);
                 return func.memcpy(lhs, rhs, .{ .imm32 = len });
 @@ -2411,13 +2411,13 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
                 try func.mir_extra.appendSlice(func.gpa, &[_]u32{
                     std.wasm.simdOpcode(.v128_store),
                     offset + lhs.offset(),
-                    @intCast(ty.abiAlignment(pt).toByteUnits() orelse 0),
+                    @intCast(ty.abiAlignment(zcu).toByteUnits() orelse 0),
                 });
                 return func.addInst(.{ .tag = .simd_prefix, .data = .{ .payload = extra_index } });
             },
         },
         .Pointer => {
-            if (ty.isSlice(mod)) {
+            if (ty.isSlice(zcu)) {
                 // store pointer first
                 // lower it to the stack so we do not have to store rhs into a local first
                 try func.emitWValue(lhs);
 @@ -2441,7 +2441,7 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
             try func.store(.stack, msb, Type.u64, 8 + lhs.offset());
             return;
         } else if (abi_size > 16) {
-            try func.memcpy(lhs, rhs, .{ .imm32 = @as(u32, @intCast(ty.abiSize(pt))) });
+            try func.memcpy(lhs, rhs, .{ .imm32 = @as(u32, @intCast(ty.abiSize(zcu))) });
         },
         else => if (abi_size > 8) {
             return func.fail("TODO: `store` for type `{}` with abisize `{d}`", .{
 @@ -2467,21 +2467,21 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
         Mir.Inst.Tag.fromOpcode(opcode),
         .{
             .offset = offset + lhs.offset(),
-            .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
         },
     );
 }
 fn airLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const ty = ty_op.ty.toType();
     const ptr_ty = func.typeOf(ty_op.operand);
-    const ptr_info = ptr_ty.ptrInfo(mod);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt)) return func.finishAir(inst, .none, &.{ty_op.operand});
+    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return func.finishAir(inst, .none, &.{ty_op.operand});
     const result = result: {
         if (isByRef(ty, pt, func.target.*)) {
 @@ -2515,36 +2515,36 @@ fn airLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 /// NOTE: Leaves the value on the stack.
 fn load(func: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // load local's value from memory by its stack position
     try func.emitWValue(operand);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         // TODO: Add helper functions for simd opcodes
         const extra_index = @as(u32, @intCast(func.mir_extra.items.len));
         // stores as := opcode, offset, alignment (opcode::memarg)
         try func.mir_extra.appendSlice(func.gpa, &[_]u32{
             std.wasm.simdOpcode(.v128_load),
             offset + operand.offset(),
-            @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            @intCast(ty.abiAlignment(zcu).toByteUnits().?),
         });
         try func.addInst(.{ .tag = .simd_prefix, .data = .{ .payload = extra_index } });
         return .stack;
     }
-    const abi_size: u8 = @intCast(ty.abiSize(pt));
+    const abi_size: u8 = @intCast(ty.abiSize(zcu));
     const opcode = buildOpcode(.{
         .valtype1 = typeToValtype(ty, pt, func.target.*),
         .width = abi_size * 8,
         .op = .load,
-        .signedness = if (ty.isSignedInt(mod)) .signed else .unsigned,
+        .signedness = if (ty.isSignedInt(zcu)) .signed else .unsigned,
     });
     try func.addMemArg(
         Mir.Inst.Tag.fromOpcode(opcode),
         .{
             .offset = offset + operand.offset(),
-            .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
         },
     );
 @@ -2553,13 +2553,13 @@ fn load(func: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValu
 fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const arg_index = func.arg_index;
     const arg = func.args[arg_index];
-    const cc = mod.typeToFunc(mod.navValue(func.owner_nav).typeOf(mod)).?.cc;
+    const cc = zcu.typeToFunc(zcu.navValue(func.owner_nav).typeOf(zcu)).?.cc;
     const arg_ty = func.typeOfIndex(inst);
     if (cc == .C) {
-        const arg_classes = abi.classifyType(arg_ty, pt);
+        const arg_classes = abi.classifyType(arg_ty, zcu);
         for (arg_classes) |class| {
             if (class != .none) {
                 func.arg_index += 1;
 @@ -2569,7 +2569,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         // When we have an argument that's passed using more than a single parameter,
         // we combine them into a single stack value
         if (arg_classes[0] == .direct and arg_classes[1] == .direct) {
-            if (arg_ty.zigTypeTag(mod) != .Int and arg_ty.zigTypeTag(mod) != .Float) {
+            if (arg_ty.zigTypeTag(zcu) != .Int and arg_ty.zigTypeTag(zcu) != .Float) {
                 return func.fail(
                     "TODO: Implement C-ABI argument for type '{}'",
                     .{arg_ty.fmt(pt)},
 @@ -2602,6 +2602,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     const pt = func.pt;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
 @@ -2615,10 +2616,10 @@ fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     // For big integers we can ignore this as we will call into compiler-rt which handles this.
     const result = switch (op) {
         .shr, .shl => result: {
-            const lhs_wasm_bits = toWasmBits(@intCast(lhs_ty.bitSize(pt))) orelse {
+            const lhs_wasm_bits = toWasmBits(@intCast(lhs_ty.bitSize(zcu))) orelse {
                 return func.fail("TODO: implement '{s}' for types larger than 128 bits", .{@tagName(op)});
             };
-            const rhs_wasm_bits = toWasmBits(@intCast(rhs_ty.bitSize(pt))).?;
+            const rhs_wasm_bits = toWasmBits(@intCast(rhs_ty.bitSize(zcu))).?;
             const new_rhs = if (lhs_wasm_bits != rhs_wasm_bits and lhs_wasm_bits != 128)
                 try (try func.intcast(rhs, rhs_ty, lhs_ty)).toLocal(func, lhs_ty)
             else
 @@ -2635,7 +2636,7 @@ fn airBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
 /// NOTE: THis leaves the value on top of the stack.
 fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     assert(!(lhs != .stack and rhs == .stack));
     if (ty.isAnyFloat()) {
 @@ -2644,7 +2645,7 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
     }
     if (isByRef(ty, pt, func.target.*)) {
-        if (ty.zigTypeTag(mod) == .Int) {
+        if (ty.zigTypeTag(zcu) == .Int) {
             return func.binOpBigInt(lhs, rhs, ty, op);
         } else {
             return func.fail(
 @@ -2657,7 +2658,7 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
     const opcode: wasm.Opcode = buildOpcode(.{
         .op = op,
         .valtype1 = typeToValtype(ty, pt, func.target.*),
-        .signedness = if (ty.isSignedInt(mod)) .signed else .unsigned,
+        .signedness = if (ty.isSignedInt(zcu)) .signed else .unsigned,
     });
     try func.emitWValue(lhs);
     try func.emitWValue(rhs);
 @@ -2669,8 +2670,8 @@ fn binOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!
 fn binOpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     if (int_info.bits > 128) {
         return func.fail("TODO: Implement binary operation for big integers larger than 128 bits", .{});
     }
 @@ -2812,17 +2813,17 @@ const FloatOp = enum {
 fn airAbs(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const ty = func.typeOf(ty_op.operand);
-    const scalar_ty = ty.scalarType(mod);
+    const scalar_ty = ty.scalarType(zcu);
-    switch (scalar_ty.zigTypeTag(mod)) {
+    switch (scalar_ty.zigTypeTag(zcu)) {
-        .Int => if (ty.zigTypeTag(mod) == .Vector) {
+        .Int => if (ty.zigTypeTag(zcu) == .Vector) {
             return func.fail("TODO implement airAbs for {}", .{ty.fmt(pt)});
         } else {
-            const int_bits = ty.intInfo(mod).bits;
+            const int_bits = ty.intInfo(zcu).bits;
             const wasm_bits = toWasmBits(int_bits) orelse {
                 return func.fail("TODO: airAbs for signed integers larger than '{d}' bits", .{int_bits});
             };
 @@ -2903,8 +2904,8 @@ fn airUnaryFloatOp(func: *CodeGen, inst: Air.Inst.Index, op: FloatOp) InnerError
 fn floatOp(func: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement floatOps for vectors", .{});
     }
 @@ -3010,7 +3011,7 @@ fn floatNeg(func: *CodeGen, ty: Type, arg: WValue) InnerError!WValue {
 fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const lhs = try func.resolveInst(bin_op.lhs);
 @@ -3018,7 +3019,7 @@ fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     const lhs_ty = func.typeOf(bin_op.lhs);
     const rhs_ty = func.typeOf(bin_op.rhs);
-    if (lhs_ty.zigTypeTag(mod) == .Vector or rhs_ty.zigTypeTag(mod) == .Vector) {
+    if (lhs_ty.zigTypeTag(zcu) == .Vector or rhs_ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement wrapping arithmetic for vectors", .{});
     }
 @@ -3029,10 +3030,10 @@ fn airWrapBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     // For big integers we can ignore this as we will call into compiler-rt which handles this.
     const result = switch (op) {
         .shr, .shl => result: {
-            const lhs_wasm_bits = toWasmBits(@intCast(lhs_ty.bitSize(pt))) orelse {
+            const lhs_wasm_bits = toWasmBits(@intCast(lhs_ty.bitSize(zcu))) orelse {
                 return func.fail("TODO: implement '{s}' for types larger than 128 bits", .{@tagName(op)});
             };
-            const rhs_wasm_bits = toWasmBits(@intCast(rhs_ty.bitSize(pt))).?;
+            const rhs_wasm_bits = toWasmBits(@intCast(rhs_ty.bitSize(zcu))).?;
             const new_rhs = if (lhs_wasm_bits != rhs_wasm_bits and lhs_wasm_bits != 128)
                 try (try func.intcast(rhs, rhs_ty, lhs_ty)).toLocal(func, lhs_ty)
             else
 @@ -3058,9 +3059,9 @@ fn wrapBinOp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerEr
 /// NOTE: When the Type is <= 64 bits, leaves the value on top of the stack, if wrapping was needed.
 fn wrapOperand(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    assert(ty.abiSize(pt) <= 16);
+    assert(ty.abiSize(zcu) <= 16);
-    const int_bits: u16 = @intCast(ty.bitSize(pt)); // TODO use ty.intInfo(mod).bits
+    const int_bits: u16 = @intCast(ty.bitSize(zcu)); // TODO use ty.intInfo(zcu).bits
     const wasm_bits = toWasmBits(int_bits) orelse {
         return func.fail("TODO: Implement wrapOperand for bitsize '{d}'", .{int_bits});
     };
 @@ -3070,7 +3071,7 @@ fn wrapOperand(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
     switch (wasm_bits) {
         32 => {
             try func.emitWValue(operand);
-            if (ty.isSignedInt(mod)) {
+            if (ty.isSignedInt(zcu)) {
                 try func.addImm32(32 - int_bits);
                 try func.addTag(.i32_shl);
                 try func.addImm32(32 - int_bits);
 @@ -3083,7 +3084,7 @@ fn wrapOperand(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
         },
         64 => {
             try func.emitWValue(operand);
-            if (ty.isSignedInt(mod)) {
+            if (ty.isSignedInt(zcu)) {
                 try func.addImm64(64 - int_bits);
                 try func.addTag(.i64_shl);
                 try func.addImm64(64 - int_bits);
 @@ -3104,7 +3105,7 @@ fn wrapOperand(func: *CodeGen, operand: WValue, ty: Type) InnerError!WValue {
             try func.emitWValue(result);
             _ = try func.load(operand, Type.u64, 8);
-            if (ty.isSignedInt(mod)) {
+            if (ty.isSignedInt(zcu)) {
                 try func.addImm64(128 - int_bits);
                 try func.addTag(.i64_shl);
                 try func.addImm64(128 - int_bits);
 @@ -3145,13 +3146,13 @@ fn lowerPtr(func: *CodeGen, ptr_val: InternPool.Index, prev_offset: u64) InnerEr
                     };
                 },
                 .Struct => switch (base_ty.containerLayout(zcu)) {
-                    .auto => base_ty.structFieldOffset(@intCast(field.index), pt),
+                    .auto => base_ty.structFieldOffset(@intCast(field.index), zcu),
                     .@"extern", .@"packed" => unreachable,
                 },
                 .Union => switch (base_ty.containerLayout(zcu)) {
                     .auto => off: {
                         // Keep in sync with the `un` case of `generateSymbol`.
-                        const layout = base_ty.unionGetLayout(pt);
+                        const layout = base_ty.unionGetLayout(zcu);
                         if (layout.payload_size == 0) break :off 0;
                         if (layout.tag_size == 0) break :off 0;
                         if (layout.tag_align.compare(.gte, layout.payload_align)) {
 @@ -3178,15 +3179,15 @@ fn lowerUavRef(
     offset: u32,
 ) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ty = Type.fromInterned(mod.intern_pool.typeOf(uav.val));
+    const ty = Type.fromInterned(zcu.intern_pool.typeOf(uav.val));
-    const is_fn_body = ty.zigTypeTag(mod) == .Fn;
+    const is_fn_body = ty.zigTypeTag(zcu) == .Fn;
-    if (!is_fn_body and !ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!is_fn_body and !ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return .{ .imm32 = 0xaaaaaaaa };
     }
-    const decl_align = mod.intern_pool.indexToKey(uav.orig_ty).ptr_type.flags.alignment;
+    const decl_align = zcu.intern_pool.indexToKey(uav.orig_ty).ptr_type.flags.alignment;
     const res = try func.bin_file.lowerUav(pt, uav.val, decl_align, func.src_loc);
     const target_sym_index = switch (res) {
         .mcv => |mcv| mcv.load_symbol,
 @@ -3204,19 +3205,19 @@ fn lowerUavRef(
 fn lowerNavRef(func: *CodeGen, nav_index: InternPool.Nav.Index, offset: u32) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     // check if decl is an alias to a function, in which case we
     // want to lower the actual decl, rather than the alias itself.
-    const owner_nav = switch (ip.indexToKey(mod.navValue(nav_index).toIntern())) {
+    const owner_nav = switch (ip.indexToKey(zcu.navValue(nav_index).toIntern())) {
         .func => |function| function.owner_nav,
         .variable => |variable| variable.owner_nav,
         .@"extern" => |@"extern"| @"extern".owner_nav,
         else => nav_index,
     };
     const nav_ty = ip.getNav(owner_nav).typeOf(ip);
-    if (!ip.isFunctionType(nav_ty) and !Type.fromInterned(nav_ty).hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!ip.isFunctionType(nav_ty) and !Type.fromInterned(nav_ty).hasRuntimeBitsIgnoreComptime(zcu)) {
         return .{ .imm32 = 0xaaaaaaaa };
     }
 @@ -3234,10 +3235,10 @@ fn lowerNavRef(func: *CodeGen, nav_index: InternPool.Nav.Index, offset: u32) Inn
 /// Asserts that `isByRef` returns `false` for `ty`.
 fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     assert(!isByRef(ty, pt, func.target.*));
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    if (val.isUndefDeep(mod)) return func.emitUndefined(ty);
+    if (val.isUndefDeep(zcu)) return func.emitUndefined(ty);
     switch (ip.indexToKey(val.ip_index)) {
         .int_type,
 @@ -3280,16 +3281,16 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
         .empty_enum_value,
         => unreachable, // non-runtime values
         .int => {
-            const int_info = ty.intInfo(mod);
+            const int_info = ty.intInfo(zcu);
             switch (int_info.signedness) {
                 .signed => switch (int_info.bits) {
-                    0...32 => return .{ .imm32 = @bitCast(@as(i32, @intCast(val.toSignedInt(pt)))) },
+                    0...32 => return .{ .imm32 = @bitCast(@as(i32, @intCast(val.toSignedInt(zcu)))) },
-                    33...64 => return .{ .imm64 = @bitCast(val.toSignedInt(pt)) },
+                    33...64 => return .{ .imm64 = @bitCast(val.toSignedInt(zcu)) },
                     else => unreachable,
                 },
                 .unsigned => switch (int_info.bits) {
-                    0...32 => return .{ .imm32 = @intCast(val.toUnsignedInt(pt)) },
+                    0...32 => return .{ .imm32 = @intCast(val.toUnsignedInt(zcu)) },
-                    33...64 => return .{ .imm64 = val.toUnsignedInt(pt) },
+                    33...64 => return .{ .imm64 = val.toUnsignedInt(zcu) },
                     else => unreachable,
                 },
             }
 @@ -3302,9 +3303,9 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             const err_int_ty = try pt.errorIntType();
             const err_ty, const err_val = switch (error_union.val) {
                 .err_name => |err_name| .{
-                    ty.errorUnionSet(mod),
+                    ty.errorUnionSet(zcu),
                     Value.fromInterned(try pt.intern(.{ .err = .{
-                        .ty = ty.errorUnionSet(mod).toIntern(),
+                        .ty = ty.errorUnionSet(zcu).toIntern(),
                         .name = err_name,
                     } })),
                 },
 @@ -3313,8 +3314,8 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
                     try pt.intValue(err_int_ty, 0),
                 },
             };
-            const payload_type = ty.errorUnionPayload(mod);
+            const payload_type = ty.errorUnionPayload(zcu);
-            if (!payload_type.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
                 // We use the error type directly as the type.
                 return func.lowerConstant(err_val, err_ty);
             }
 @@ -3339,20 +3340,20 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             },
         },
         .ptr => return func.lowerPtr(val.toIntern(), 0),
-        .opt => if (ty.optionalReprIsPayload(mod)) {
+        .opt => if (ty.optionalReprIsPayload(zcu)) {
-            const pl_ty = ty.optionalChild(mod);
+            const pl_ty = ty.optionalChild(zcu);
-            if (val.optionalValue(mod)) |payload| {
+            if (val.optionalValue(zcu)) |payload| {
                 return func.lowerConstant(payload, pl_ty);
             } else {
                 return .{ .imm32 = 0 };
             }
         } else {
-            return .{ .imm32 = @intFromBool(!val.isNull(mod)) };
+            return .{ .imm32 = @intFromBool(!val.isNull(zcu)) };
         },
         .aggregate => switch (ip.indexToKey(ty.ip_index)) {
             .array_type => return func.fail("Wasm TODO: LowerConstant for {}", .{ty.fmt(pt)}),
             .vector_type => {
-                assert(determineSimdStoreStrategy(ty, pt, func.target.*) == .direct);
+                assert(determineSimdStoreStrategy(ty, zcu, func.target.*) == .direct);
                 var buf: [16]u8 = undefined;
                 val.writeToMemory(ty, pt, &buf) catch unreachable;
                 return func.storeSimdImmd(buf);
 @@ -3378,8 +3379,8 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             const constant_ty = if (un.tag == .none)
                 try ty.unionBackingType(pt)
             else field_ty: {
-                const union_obj = mod.typeToUnion(ty).?;
+                const union_obj = zcu.typeToUnion(ty).?;
-                const field_index = mod.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
+                const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
                 break :field_ty Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
             };
             return func.lowerConstant(Value.fromInterned(un.val), constant_ty);
 @@ -3398,11 +3399,11 @@ fn storeSimdImmd(func: *CodeGen, value: [16]u8) !WValue {
 fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(mod)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Bool, .ErrorSet => return .{ .imm32 = 0xaaaaaaaa },
-        .Int, .Enum => switch (ty.intInfo(mod).bits) {
+        .Int, .Enum => switch (ty.intInfo(zcu).bits) {
             0...32 => return .{ .imm32 = 0xaaaaaaaa },
             33...64 => return .{ .imm64 = 0xaaaaaaaaaaaaaaaa },
             else => unreachable,
 @@ -3419,8 +3420,8 @@ fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
             else => unreachable,
         },
         .Optional => {
-            const pl_ty = ty.optionalChild(mod);
+            const pl_ty = ty.optionalChild(zcu);
-            if (ty.optionalReprIsPayload(mod)) {
+            if (ty.optionalReprIsPayload(zcu)) {
                 return func.emitUndefined(pl_ty);
             }
             return .{ .imm32 = 0xaaaaaaaa };
 @@ -3429,10 +3430,10 @@ fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
             return .{ .imm32 = 0xaaaaaaaa };
         },
         .Struct => {
-            const packed_struct = mod.typeToPackedStruct(ty).?;
+            const packed_struct = zcu.typeToPackedStruct(ty).?;
             return func.emitUndefined(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)));
         },
-        else => return func.fail("Wasm TODO: emitUndefined for type: {}\n", .{ty.zigTypeTag(mod)}),
+        else => return func.fail("Wasm TODO: emitUndefined for type: {}\n", .{ty.zigTypeTag(zcu)}),
     }
 }
 @@ -3441,8 +3442,8 @@ fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
 /// as an integer value.
 fn valueAsI32(func: *const CodeGen, val: Value) i32 {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     switch (val.toIntern()) {
         .bool_true => return 1,
 @@ -3465,12 +3466,13 @@ fn intIndexAsI32(ip: *const InternPool, int: InternPool.Index, pt: Zcu.PerThread
 }
 fn intStorageAsI32(storage: InternPool.Key.Int.Storage, pt: Zcu.PerThread) i32 {
+    const zcu = pt.zcu;
     return switch (storage) {
         .i64 => |x| @as(i32, @intCast(x)),
         .u64 => |x| @as(i32, @bitCast(@as(u32, @intCast(x)))),
         .big_int => unreachable,
-        .lazy_align => |ty| @as(i32, @bitCast(@as(u32, @intCast(Type.fromInterned(ty).abiAlignment(pt).toByteUnits() orelse 0)))),
+        .lazy_align => |ty| @as(i32, @bitCast(@as(u32, @intCast(Type.fromInterned(ty).abiAlignment(zcu).toByteUnits() orelse 0)))),
-        .lazy_size => |ty| @as(i32, @bitCast(@as(u32, @intCast(Type.fromInterned(ty).abiSize(pt))))),
+        .lazy_size => |ty| @as(i32, @bitCast(@as(u32, @intCast(Type.fromInterned(ty).abiSize(zcu))))),
     };
 }
 @@ -3599,10 +3601,10 @@ fn airCmp(func: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) In
 fn cmp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOperator) InnerError!WValue {
     assert(!(lhs != .stack and rhs == .stack));
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Optional and !ty.optionalReprIsPayload(mod)) {
+    if (ty.zigTypeTag(zcu) == .Optional and !ty.optionalReprIsPayload(zcu)) {
-        const payload_ty = ty.optionalChild(mod);
+        const payload_ty = ty.optionalChild(zcu);
-        if (payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             // When we hit this case, we must check the value of optionals
             // that are not pointers. This means first checking against non-null for
             // both lhs and rhs, as well as checking the payload are matching of lhs and rhs
 @@ -3616,10 +3618,10 @@ fn cmp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareO
     const signedness: std.builtin.Signedness = blk: {
         // by default we tell the operand type is unsigned (i.e. bools and enum values)
-        if (ty.zigTypeTag(mod) != .Int) break :blk .unsigned;
+        if (ty.zigTypeTag(zcu) != .Int) break :blk .unsigned;
         // incase of an actual integer, we emit the correct signedness
-        break :blk ty.intInfo(mod).signedness;
+        break :blk ty.intInfo(zcu).signedness;
     };
     // ensure that when we compare pointers, we emit
 @@ -3708,12 +3710,12 @@ fn airCmpLtErrorsLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
     const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br;
     const block = func.blocks.get(br.block_inst).?;
     // if operand has codegen bits we should break with a value
-    if (func.typeOf(br.operand).hasRuntimeBitsIgnoreComptime(pt)) {
+    if (func.typeOf(br.operand).hasRuntimeBitsIgnoreComptime(zcu)) {
         const operand = try func.resolveInst(br.operand);
         try func.lowerToStack(operand);
 @@ -3736,17 +3738,17 @@ fn airNot(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const operand = try func.resolveInst(ty_op.operand);
     const operand_ty = func.typeOf(ty_op.operand);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result = result: {
-        if (operand_ty.zigTypeTag(mod) == .Bool) {
+        if (operand_ty.zigTypeTag(zcu) == .Bool) {
             try func.emitWValue(operand);
             try func.addTag(.i32_eqz);
             const not_tmp = try func.allocLocal(operand_ty);
             try func.addLabel(.local_set, not_tmp.local.value);
             break :result not_tmp;
         } else {
-            const int_info = operand_ty.intInfo(mod);
+            const int_info = operand_ty.intInfo(zcu);
             const wasm_bits = toWasmBits(int_info.bits) orelse {
                 return func.fail("TODO: Implement binary NOT for {}", .{operand_ty.fmt(pt)});
             };
 @@ -3816,14 +3818,14 @@ fn airUnreachable(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airBitcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const wanted_ty = func.typeOfIndex(inst);
     const given_ty = func.typeOf(ty_op.operand);
-    const bit_size = given_ty.bitSize(pt);
+    const bit_size = given_ty.bitSize(zcu);
-    const needs_wrapping = (given_ty.isSignedInt(mod) != wanted_ty.isSignedInt(mod)) and
+    const needs_wrapping = (given_ty.isSignedInt(zcu) != wanted_ty.isSignedInt(zcu)) and
         bit_size != 32 and bit_size != 64 and bit_size != 128;
     const result = result: {
 @@ -3860,12 +3862,12 @@ fn airBitcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // if we bitcast a float to or from an integer we must use the 'reinterpret' instruction
     if (!(wanted_ty.isAnyFloat() or given_ty.isAnyFloat())) return operand;
     if (wanted_ty.ip_index == .f16_type or given_ty.ip_index == .f16_type) return operand;
-    if (wanted_ty.bitSize(pt) > 64) return operand;
+    if (wanted_ty.bitSize(zcu) > 64) return operand;
-    assert((wanted_ty.isInt(mod) and given_ty.isAnyFloat()) or (wanted_ty.isAnyFloat() and given_ty.isInt(mod)));
+    assert((wanted_ty.isInt(zcu) and given_ty.isAnyFloat()) or (wanted_ty.isAnyFloat() and given_ty.isInt(zcu)));
     const opcode = buildOpcode(.{
         .op = .reinterpret,
 @@ -3879,24 +3881,24 @@ fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) Inn
 fn airStructFieldPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.StructField, ty_pl.payload);
     const struct_ptr = try func.resolveInst(extra.data.struct_operand);
     const struct_ptr_ty = func.typeOf(extra.data.struct_operand);
-    const struct_ty = struct_ptr_ty.childType(mod);
+    const struct_ty = struct_ptr_ty.childType(zcu);
     const result = try func.structFieldPtr(inst, extra.data.struct_operand, struct_ptr, struct_ptr_ty, struct_ty, extra.data.field_index);
     return func.finishAir(inst, result, &.{extra.data.struct_operand});
 }
 fn airStructFieldPtrIndex(func: *CodeGen, inst: Air.Inst.Index, index: u32) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const struct_ptr = try func.resolveInst(ty_op.operand);
     const struct_ptr_ty = func.typeOf(ty_op.operand);
-    const struct_ty = struct_ptr_ty.childType(mod);
+    const struct_ty = struct_ptr_ty.childType(zcu);
     const result = try func.structFieldPtr(inst, ty_op.operand, struct_ptr, struct_ptr_ty, struct_ty, index);
     return func.finishAir(inst, result, &.{ty_op.operand});
 @@ -3912,23 +3914,23 @@ fn structFieldPtr(
     index: u32,
 ) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result_ty = func.typeOfIndex(inst);
-    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(mod);
+    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
-    const offset = switch (struct_ty.containerLayout(mod)) {
+    const offset = switch (struct_ty.containerLayout(zcu)) {
-        .@"packed" => switch (struct_ty.zigTypeTag(mod)) {
+        .@"packed" => switch (struct_ty.zigTypeTag(zcu)) {
             .Struct => offset: {
-                if (result_ty.ptrInfo(mod).packed_offset.host_size != 0) {
+                if (result_ty.ptrInfo(zcu).packed_offset.host_size != 0) {
                     break :offset @as(u32, 0);
                 }
-                const struct_type = mod.typeToStruct(struct_ty).?;
+                const struct_type = zcu.typeToStruct(struct_ty).?;
                 break :offset @divExact(pt.structPackedFieldBitOffset(struct_type, index) + struct_ptr_ty_info.packed_offset.bit_offset, 8);
             },
             .Union => 0,
             else => unreachable,
         },
-        else => struct_ty.structFieldOffset(index, pt),
+        else => struct_ty.structFieldOffset(index, zcu),
     };
     // save a load and store when we can simply reuse the operand
     if (offset == 0) {
 @@ -3944,24 +3946,24 @@ fn structFieldPtr(
 fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const struct_field = func.air.extraData(Air.StructField, ty_pl.payload).data;
     const struct_ty = func.typeOf(struct_field.struct_operand);
     const operand = try func.resolveInst(struct_field.struct_operand);
     const field_index = struct_field.field_index;
-    const field_ty = struct_ty.structFieldType(field_index, mod);
+    const field_ty = struct_ty.fieldType(field_index, zcu);
-    if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) return func.finishAir(inst, .none, &.{struct_field.struct_operand});
+    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return func.finishAir(inst, .none, &.{struct_field.struct_operand});
-    const result: WValue = switch (struct_ty.containerLayout(mod)) {
+    const result: WValue = switch (struct_ty.containerLayout(zcu)) {
-        .@"packed" => switch (struct_ty.zigTypeTag(mod)) {
+        .@"packed" => switch (struct_ty.zigTypeTag(zcu)) {
             .Struct => result: {
-                const packed_struct = mod.typeToPackedStruct(struct_ty).?;
+                const packed_struct = zcu.typeToPackedStruct(struct_ty).?;
                 const offset = pt.structPackedFieldBitOffset(packed_struct, field_index);
                 const backing_ty = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
-                const wasm_bits = toWasmBits(backing_ty.intInfo(mod).bits) orelse {
+                const wasm_bits = toWasmBits(backing_ty.intInfo(zcu).bits) orelse {
                     return func.fail("TODO: airStructFieldVal for packed structs larger than 128 bits", .{});
                 };
                 const const_wvalue: WValue = if (wasm_bits == 32)
 @@ -3977,16 +3979,16 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 else
                     try func.binOp(operand, const_wvalue, backing_ty, .shr);
-                if (field_ty.zigTypeTag(mod) == .Float) {
+                if (field_ty.zigTypeTag(zcu) == .Float) {
-                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(pt))));
+                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(zcu))));
                     const truncated = try func.trunc(shifted_value, int_type, backing_ty);
                     break :result try func.bitcast(field_ty, int_type, truncated);
-                } else if (field_ty.isPtrAtRuntime(mod) and packed_struct.field_types.len == 1) {
+                } else if (field_ty.isPtrAtRuntime(zcu) and packed_struct.field_types.len == 1) {
                     // In this case we do not have to perform any transformations,
                     // we can simply reuse the operand.
                     break :result func.reuseOperand(struct_field.struct_operand, operand);
-                } else if (field_ty.isPtrAtRuntime(mod)) {
+                } else if (field_ty.isPtrAtRuntime(zcu)) {
-                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(pt))));
+                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(zcu))));
                     break :result try func.trunc(shifted_value, int_type, backing_ty);
                 }
                 break :result try func.trunc(shifted_value, field_ty, backing_ty);
 @@ -4002,13 +4004,13 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     }
                 }
-                const union_int_type = try pt.intType(.unsigned, @as(u16, @intCast(struct_ty.bitSize(pt))));
+                const union_int_type = try pt.intType(.unsigned, @as(u16, @intCast(struct_ty.bitSize(zcu))));
-                if (field_ty.zigTypeTag(mod) == .Float) {
+                if (field_ty.zigTypeTag(zcu) == .Float) {
-                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(pt))));
+                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(zcu))));
                     const truncated = try func.trunc(operand, int_type, union_int_type);
                     break :result try func.bitcast(field_ty, int_type, truncated);
-                } else if (field_ty.isPtrAtRuntime(mod)) {
+                } else if (field_ty.isPtrAtRuntime(zcu)) {
-                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(pt))));
+                    const int_type = try pt.intType(.unsigned, @as(u16, @intCast(field_ty.bitSize(zcu))));
                     break :result try func.trunc(operand, int_type, union_int_type);
                 }
                 break :result try func.trunc(operand, field_ty, union_int_type);
 @@ -4016,7 +4018,7 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             else => unreachable,
         },
         else => result: {
-            const offset = std.math.cast(u32, struct_ty.structFieldOffset(field_index, pt)) orelse {
+            const offset = std.math.cast(u32, struct_ty.structFieldOffset(field_index, zcu)) orelse {
                 return func.fail("Field type '{}' too big to fit into stack frame", .{field_ty.fmt(pt)});
             };
             if (isByRef(field_ty, pt, func.target.*)) {
 @@ -4036,7 +4038,7 @@ fn airStructFieldVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     // result type is always 'noreturn'
     const blocktype = wasm.block_empty;
     const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
 @@ -4093,7 +4095,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     // When the target is an integer size larger than u32, we have no way to use the value
     // as an index, therefore we also use an if/else-chain for those cases.
     // TODO: Benchmark this to find a proper value, LLVM seems to draw the line at '40~45'.
-    const is_sparse = highest - lowest > 50 or target_ty.bitSize(pt) > 32;
+    const is_sparse = highest - lowest > 50 or target_ty.bitSize(zcu) > 32;
     const else_body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra_index..][0..switch_br.data.else_body_len]);
     const has_else_body = else_body.len != 0;
 @@ -4138,7 +4140,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 // for errors that are not present in any branch. This is fine as this default
                 // case will never be hit for those cases but we do save runtime cost and size
                 // by using a jump table for this instead of if-else chains.
-                break :blk if (has_else_body or target_ty.zigTypeTag(mod) == .ErrorSet) case_i else unreachable;
+                break :blk if (has_else_body or target_ty.zigTypeTag(zcu) == .ErrorSet) case_i else unreachable;
             };
             func.mir_extra.appendAssumeCapacity(idx);
         } else if (has_else_body) {
 @@ -4149,10 +4151,10 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const signedness: std.builtin.Signedness = blk: {
         // by default we tell the operand type is unsigned (i.e. bools and enum values)
-        if (target_ty.zigTypeTag(mod) != .Int) break :blk .unsigned;
+        if (target_ty.zigTypeTag(zcu) != .Int) break :blk .unsigned;
         // incase of an actual integer, we emit the correct signedness
-        break :blk target_ty.intInfo(mod).signedness;
+        break :blk target_ty.intInfo(zcu).signedness;
     };
     try func.branches.ensureUnusedCapacity(func.gpa, case_list.items.len + @intFromBool(has_else_body));
 @@ -4217,14 +4219,14 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airIsErr(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
     const err_union_ty = func.typeOf(un_op);
-    const pl_ty = err_union_ty.errorUnionPayload(mod);
+    const pl_ty = err_union_ty.errorUnionPayload(zcu);
     const result: WValue = result: {
-        if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             switch (opcode) {
                 .i32_ne => break :result .{ .imm32 = 0 },
                 .i32_eq => break :result .{ .imm32 = 1 },
 @@ -4233,10 +4235,10 @@ fn airIsErr(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerErro
         }
         try func.emitWValue(operand);
-        if (pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             try func.addMemArg(.i32_load16_u, .{
-                .offset = operand.offset() + @as(u32, @intCast(errUnionErrorOffset(pl_ty, pt))),
+                .offset = operand.offset() + @as(u32, @intCast(errUnionErrorOffset(pl_ty, zcu))),
-                .alignment = @intCast(Type.anyerror.abiAlignment(pt).toByteUnits().?),
+                .alignment = @intCast(Type.anyerror.abiAlignment(zcu).toByteUnits().?),
             });
         }
 @@ -4250,23 +4252,23 @@ fn airIsErr(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode) InnerErro
 fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const op_ty = func.typeOf(ty_op.operand);
-    const err_ty = if (op_is_ptr) op_ty.childType(mod) else op_ty;
+    const err_ty = if (op_is_ptr) op_ty.childType(zcu) else op_ty;
-    const payload_ty = err_ty.errorUnionPayload(mod);
+    const payload_ty = err_ty.errorUnionPayload(zcu);
     const result: WValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             if (op_is_ptr) {
                 break :result func.reuseOperand(ty_op.operand, operand);
             }
             break :result .none;
         }
-        const pl_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, pt)));
+        const pl_offset = @as(u32, @intCast(errUnionPayloadOffset(payload_ty, zcu)));
         if (op_is_ptr or isByRef(payload_ty, pt, func.target.*)) {
             break :result try func.buildPointerOffset(operand, pl_offset, .new);
         }
 @@ -4278,30 +4280,30 @@ fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: boo
 fn airUnwrapErrUnionError(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const op_ty = func.typeOf(ty_op.operand);
-    const err_ty = if (op_is_ptr) op_ty.childType(mod) else op_ty;
+    const err_ty = if (op_is_ptr) op_ty.childType(zcu) else op_ty;
-    const payload_ty = err_ty.errorUnionPayload(mod);
+    const payload_ty = err_ty.errorUnionPayload(zcu);
     const result: WValue = result: {
-        if (err_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             break :result .{ .imm32 = 0 };
         }
-        if (op_is_ptr or !payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (op_is_ptr or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
-        break :result try func.load(operand, Type.anyerror, @intCast(errUnionErrorOffset(payload_ty, pt)));
+        break :result try func.load(operand, Type.anyerror, @intCast(errUnionErrorOffset(payload_ty, zcu)));
     };
     return func.finishAir(inst, result, &.{ty_op.operand});
 }
 fn airWrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
 @@ -4309,18 +4311,18 @@ fn airWrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void
     const pl_ty = func.typeOf(ty_op.operand);
     const result = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
         const err_union = try func.allocStack(err_ty);
-        const payload_ptr = try func.buildPointerOffset(err_union, @as(u32, @intCast(errUnionPayloadOffset(pl_ty, pt))), .new);
+        const payload_ptr = try func.buildPointerOffset(err_union, @as(u32, @intCast(errUnionPayloadOffset(pl_ty, zcu))), .new);
         try func.store(payload_ptr, operand, pl_ty, 0);
         // ensure we also write '0' to the error part, so any present stack value gets overwritten by it.
         try func.emitWValue(err_union);
         try func.addImm32(0);
-        const err_val_offset: u32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_val_offset: u32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
         try func.addMemArg(.i32_store16, .{
             .offset = err_union.offset() + err_val_offset,
             .alignment = 2,
 @@ -4332,25 +4334,25 @@ fn airWrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void
 fn airWrapErrUnionErr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const err_ty = ty_op.ty.toType();
-    const pl_ty = err_ty.errorUnionPayload(mod);
+    const pl_ty = err_ty.errorUnionPayload(zcu);
     const result = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
         const err_union = try func.allocStack(err_ty);
         // store error value
-        try func.store(err_union, operand, Type.anyerror, @intCast(errUnionErrorOffset(pl_ty, pt)));
+        try func.store(err_union, operand, Type.anyerror, @intCast(errUnionErrorOffset(pl_ty, zcu)));
         // write 'undefined' to the payload
-        const payload_ptr = try func.buildPointerOffset(err_union, @as(u32, @intCast(errUnionPayloadOffset(pl_ty, pt))), .new);
+        const payload_ptr = try func.buildPointerOffset(err_union, @as(u32, @intCast(errUnionPayloadOffset(pl_ty, zcu))), .new);
-        const len = @as(u32, @intCast(err_ty.errorUnionPayload(mod).abiSize(pt)));
+        const len = @as(u32, @intCast(err_ty.errorUnionPayload(zcu).abiSize(zcu)));
         try func.memset(Type.u8, payload_ptr, .{ .imm32 = len }, .{ .imm32 = 0xaa });
         break :result err_union;
 @@ -4365,16 +4367,16 @@ fn airIntcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const operand = try func.resolveInst(ty_op.operand);
     const operand_ty = func.typeOf(ty_op.operand);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector or operand_ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector or operand_ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("todo Wasm intcast for vectors", .{});
     }
-    if (ty.abiSize(pt) > 16 or operand_ty.abiSize(pt) > 16) {
+    if (ty.abiSize(zcu) > 16 or operand_ty.abiSize(zcu) > 16) {
         return func.fail("todo Wasm intcast for bitsize > 128", .{});
     }
-    const op_bits = toWasmBits(@intCast(operand_ty.bitSize(pt))).?;
+    const op_bits = toWasmBits(@intCast(operand_ty.bitSize(zcu))).?;
-    const wanted_bits = toWasmBits(@intCast(ty.bitSize(pt))).?;
+    const wanted_bits = toWasmBits(@intCast(ty.bitSize(zcu))).?;
     const result = if (op_bits == wanted_bits)
         func.reuseOperand(ty_op.operand, operand)
     else
 @@ -4389,9 +4391,9 @@ fn airIntcast(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 /// NOTE: May leave the result on the top of the stack.
 fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const given_bitsize = @as(u16, @intCast(given.bitSize(pt)));
+    const given_bitsize = @as(u16, @intCast(given.bitSize(zcu)));
-    const wanted_bitsize = @as(u16, @intCast(wanted.bitSize(pt)));
+    const wanted_bitsize = @as(u16, @intCast(wanted.bitSize(zcu)));
     assert(given_bitsize <= 128);
     assert(wanted_bitsize <= 128);
 @@ -4407,7 +4409,7 @@ fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
         return .stack;
     } else if (op_bits == 32 and wanted_bits == 64) {
         try func.emitWValue(operand);
-        try func.addTag(if (wanted.isSignedInt(mod)) .i64_extend_i32_s else .i64_extend_i32_u);
+        try func.addTag(if (wanted.isSignedInt(zcu)) .i64_extend_i32_s else .i64_extend_i32_u);
         return .stack;
     } else if (wanted_bits == 128) {
         // for 128bit integers we store the integer in the virtual stack, rather than a local
 @@ -4417,7 +4419,7 @@ fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
         // for 32 bit integers, we first coerce the value into a 64 bit integer before storing it
         // meaning less store operations are required.
         const lhs = if (op_bits == 32) blk: {
-            const sign_ty = if (wanted.isSignedInt(mod)) Type.i64 else Type.u64;
+            const sign_ty = if (wanted.isSignedInt(zcu)) Type.i64 else Type.u64;
             break :blk try (try func.intcast(operand, given, sign_ty)).toLocal(func, sign_ty);
         } else operand;
 @@ -4425,7 +4427,7 @@ fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
         try func.store(.stack, lhs, Type.u64, 0 + stack_ptr.offset());
         // For signed integers we shift lsb by 63 (64bit integer - 1 sign bit) and store remaining value
-        if (wanted.isSignedInt(mod)) {
+        if (wanted.isSignedInt(zcu)) {
             try func.emitWValue(stack_ptr);
             const shr = try func.binOp(lhs, .{ .imm64 = 63 }, Type.i64, .shr);
             try func.store(.stack, shr, Type.u64, 8 + stack_ptr.offset());
 @@ -4439,12 +4441,12 @@ fn intcast(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
 fn airIsNull(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind: enum { value, ptr }) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
     const op_ty = func.typeOf(un_op);
-    const optional_ty = if (op_kind == .ptr) op_ty.childType(mod) else op_ty;
+    const optional_ty = if (op_kind == .ptr) op_ty.childType(zcu) else op_ty;
     const result = try func.isNull(operand, optional_ty, opcode);
     return func.finishAir(inst, result, &.{un_op});
 }
 @@ -4453,19 +4455,19 @@ fn airIsNull(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind:
 /// NOTE: Leaves the result on the stack
 fn isNull(func: *CodeGen, operand: WValue, optional_ty: Type, opcode: wasm.Opcode) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     try func.emitWValue(operand);
-    const payload_ty = optional_ty.optionalChild(mod);
+    const payload_ty = optional_ty.optionalChild(zcu);
-    if (!optional_ty.optionalReprIsPayload(mod)) {
+    if (!optional_ty.optionalReprIsPayload(zcu)) {
         // When payload is zero-bits, we can treat operand as a value, rather than
         // a pointer to the stack value
-        if (payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            const offset = std.math.cast(u32, payload_ty.abiSize(pt)) orelse {
+            const offset = std.math.cast(u32, payload_ty.abiSize(zcu)) orelse {
                 return func.fail("Optional type {} too big to fit into stack frame", .{optional_ty.fmt(pt)});
             };
             try func.addMemArg(.i32_load8_u, .{ .offset = operand.offset() + offset, .alignment = 1 });
         }
-    } else if (payload_ty.isSlice(mod)) {
+    } else if (payload_ty.isSlice(zcu)) {
         switch (func.arch()) {
             .wasm32 => try func.addMemArg(.i32_load, .{ .offset = operand.offset(), .alignment = 4 }),
             .wasm64 => try func.addMemArg(.i64_load, .{ .offset = operand.offset(), .alignment = 8 }),
 @@ -4482,17 +4484,17 @@ fn isNull(func: *CodeGen, operand: WValue, optional_ty: Type, opcode: wasm.Opcod
 fn airOptionalPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const opt_ty = func.typeOf(ty_op.operand);
     const payload_ty = func.typeOfIndex(inst);
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return func.finishAir(inst, .none, &.{ty_op.operand});
     }
     const result = result: {
         const operand = try func.resolveInst(ty_op.operand);
-        if (opt_ty.optionalReprIsPayload(mod)) break :result func.reuseOperand(ty_op.operand, operand);
+        if (opt_ty.optionalReprIsPayload(zcu)) break :result func.reuseOperand(ty_op.operand, operand);
         if (isByRef(payload_ty, pt, func.target.*)) {
             break :result try func.buildPointerOffset(operand, 0, .new);
 @@ -4505,14 +4507,14 @@ fn airOptionalPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airOptionalPayloadPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const opt_ty = func.typeOf(ty_op.operand).childType(mod);
+    const opt_ty = func.typeOf(ty_op.operand).childType(zcu);
     const result = result: {
-        const payload_ty = opt_ty.optionalChild(mod);
+        const payload_ty = opt_ty.optionalChild(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt) or opt_ty.optionalReprIsPayload(mod)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu) or opt_ty.optionalReprIsPayload(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
 @@ -4523,20 +4525,20 @@ fn airOptionalPayloadPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airOptionalPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const opt_ty = func.typeOf(ty_op.operand).childType(mod);
+    const opt_ty = func.typeOf(ty_op.operand).childType(zcu);
-    const payload_ty = opt_ty.optionalChild(mod);
+    const payload_ty = opt_ty.optionalChild(zcu);
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return func.fail("TODO: Implement OptionalPayloadPtrSet for optional with zero-sized type {}", .{payload_ty.fmtDebug()});
     }
-    if (opt_ty.optionalReprIsPayload(mod)) {
+    if (opt_ty.optionalReprIsPayload(zcu)) {
         return func.finishAir(inst, operand, &.{ty_op.operand});
     }
-    const offset = std.math.cast(u32, payload_ty.abiSize(pt)) orelse {
+    const offset = std.math.cast(u32, payload_ty.abiSize(zcu)) orelse {
         return func.fail("Optional type {} too big to fit into stack frame", .{opt_ty.fmt(pt)});
     };
 @@ -4552,10 +4554,10 @@ fn airWrapOptional(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const payload_ty = func.typeOf(ty_op.operand);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             const non_null_bit = try func.allocStack(Type.u1);
             try func.emitWValue(non_null_bit);
             try func.addImm32(1);
 @@ -4565,10 +4567,10 @@ fn airWrapOptional(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         const operand = try func.resolveInst(ty_op.operand);
         const op_ty = func.typeOfIndex(inst);
-        if (op_ty.optionalReprIsPayload(mod)) {
+        if (op_ty.optionalReprIsPayload(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
-        const offset = std.math.cast(u32, payload_ty.abiSize(pt)) orelse {
+        const offset = std.math.cast(u32, payload_ty.abiSize(zcu)) orelse {
             return func.fail("Optional type {} too big to fit into stack frame", .{op_ty.fmt(pt)});
         };
 @@ -4610,14 +4612,14 @@ fn airSliceLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const slice_ty = func.typeOf(bin_op.lhs);
     const slice = try func.resolveInst(bin_op.lhs);
     const index = try func.resolveInst(bin_op.rhs);
-    const elem_ty = slice_ty.childType(mod);
+    const elem_ty = slice_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     // load pointer onto stack
     _ = try func.load(slice, Type.usize, 0);
 @@ -4638,12 +4640,12 @@ fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airSliceElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
-    const elem_ty = ty_pl.ty.toType().childType(mod);
+    const elem_ty = ty_pl.ty.toType().childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     const slice = try func.resolveInst(bin_op.lhs);
     const index = try func.resolveInst(bin_op.rhs);
 @@ -4682,13 +4684,13 @@ fn airTrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const wanted_ty: Type = ty_op.ty.toType();
     const op_ty = func.typeOf(ty_op.operand);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (wanted_ty.zigTypeTag(mod) == .Vector or op_ty.zigTypeTag(mod) == .Vector) {
+    if (wanted_ty.zigTypeTag(zcu) == .Vector or op_ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: trunc for vectors", .{});
     }
-    const result = if (op_ty.bitSize(pt) == wanted_ty.bitSize(pt))
+    const result = if (op_ty.bitSize(zcu) == wanted_ty.bitSize(zcu))
         func.reuseOperand(ty_op.operand, operand)
     else
         try func.trunc(operand, wanted_ty, op_ty);
 @@ -4700,13 +4702,14 @@ fn airTrunc(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 /// NOTE: Resulting value is left on the stack.
 fn trunc(func: *CodeGen, operand: WValue, wanted_ty: Type, given_ty: Type) InnerError!WValue {
     const pt = func.pt;
-    const given_bits = @as(u16, @intCast(given_ty.bitSize(pt)));
+    const zcu = pt.zcu;
+    const given_bits = @as(u16, @intCast(given_ty.bitSize(zcu)));
     if (toWasmBits(given_bits) == null) {
         return func.fail("TODO: Implement wasm integer truncation for integer bitsize: {d}", .{given_bits});
     }
     var result = try func.intcast(operand, given_ty, wanted_ty);
-    const wanted_bits = @as(u16, @intCast(wanted_ty.bitSize(pt)));
+    const wanted_bits = @as(u16, @intCast(wanted_ty.bitSize(zcu)));
     const wasm_bits = toWasmBits(wanted_bits).?;
     if (wasm_bits != wanted_bits) {
         result = try func.wrapOperand(result, wanted_ty);
 @@ -4724,23 +4727,23 @@ fn airIntFromBool(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const array_ty = func.typeOf(ty_op.operand).childType(mod);
+    const array_ty = func.typeOf(ty_op.operand).childType(zcu);
     const slice_ty = ty_op.ty.toType();
     // create a slice on the stack
     const slice_local = try func.allocStack(slice_ty);
     // store the array ptr in the slice
-    if (array_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (array_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         try func.store(slice_local, operand, Type.usize, 0);
     }
     // store the length of the array in the slice
-    const array_len: u32 = @intCast(array_ty.arrayLen(mod));
+    const array_len: u32 = @intCast(array_ty.arrayLen(zcu));
     try func.store(slice_local, .{ .imm32 = array_len }, Type.usize, func.ptrSize());
     return func.finishAir(inst, slice_local, &.{ty_op.operand});
 @@ -4748,11 +4751,11 @@ fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airIntFromPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
     const ptr_ty = func.typeOf(un_op);
-    const result = if (ptr_ty.isSlice(mod))
+    const result = if (ptr_ty.isSlice(zcu))
         try func.slicePtr(operand)
     else switch (operand) {
         // for stack offset, return a pointer to this offset.
 @@ -4764,17 +4767,17 @@ fn airIntFromPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr_ty = func.typeOf(bin_op.lhs);
     const ptr = try func.resolveInst(bin_op.lhs);
     const index = try func.resolveInst(bin_op.rhs);
-    const elem_ty = ptr_ty.childType(mod);
+    const elem_ty = ptr_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     // load pointer onto the stack
-    if (ptr_ty.isSlice(mod)) {
+    if (ptr_ty.isSlice(zcu)) {
         _ = try func.load(ptr, Type.usize, 0);
     } else {
         try func.lowerToStack(ptr);
 @@ -4796,19 +4799,19 @@ fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airPtrElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
     const ptr_ty = func.typeOf(bin_op.lhs);
-    const elem_ty = ty_pl.ty.toType().childType(mod);
+    const elem_ty = ty_pl.ty.toType().childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     const ptr = try func.resolveInst(bin_op.lhs);
     const index = try func.resolveInst(bin_op.rhs);
     // load pointer onto the stack
-    if (ptr_ty.isSlice(mod)) {
+    if (ptr_ty.isSlice(zcu)) {
         _ = try func.load(ptr, Type.usize, 0);
     } else {
         try func.lowerToStack(ptr);
 @@ -4825,16 +4828,16 @@ fn airPtrElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airPtrBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
     const ptr = try func.resolveInst(bin_op.lhs);
     const offset = try func.resolveInst(bin_op.rhs);
     const ptr_ty = func.typeOf(bin_op.lhs);
-    const pointee_ty = switch (ptr_ty.ptrSize(mod)) {
+    const pointee_ty = switch (ptr_ty.ptrSize(zcu)) {
-        .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
+        .One => ptr_ty.childType(zcu).childType(zcu), // ptr to array, so get array element type
-        else => ptr_ty.childType(mod),
+        else => ptr_ty.childType(zcu),
     };
     const valtype = typeToValtype(Type.usize, pt, func.target.*);
 @@ -4843,7 +4846,7 @@ fn airPtrBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     try func.lowerToStack(ptr);
     try func.emitWValue(offset);
-    try func.addImm32(@intCast(pointee_ty.abiSize(pt)));
+    try func.addImm32(@intCast(pointee_ty.abiSize(zcu)));
     try func.addTag(Mir.Inst.Tag.fromOpcode(mul_opcode));
     try func.addTag(Mir.Inst.Tag.fromOpcode(bin_opcode));
 @@ -4852,7 +4855,7 @@ fn airPtrBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
 fn airMemset(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (safety) {
         // TODO if the value is undef, write 0xaa bytes to dest
     } else {
 @@ -4863,16 +4866,16 @@ fn airMemset(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
     const ptr = try func.resolveInst(bin_op.lhs);
     const ptr_ty = func.typeOf(bin_op.lhs);
     const value = try func.resolveInst(bin_op.rhs);
-    const len = switch (ptr_ty.ptrSize(mod)) {
+    const len = switch (ptr_ty.ptrSize(zcu)) {
         .Slice => try func.sliceLen(ptr),
-        .One => @as(WValue, .{ .imm32 = @as(u32, @intCast(ptr_ty.childType(mod).arrayLen(mod))) }),
+        .One => @as(WValue, .{ .imm32 = @as(u32, @intCast(ptr_ty.childType(zcu).arrayLen(zcu))) }),
         .C, .Many => unreachable,
     };
-    const elem_ty = if (ptr_ty.ptrSize(mod) == .One)
+    const elem_ty = if (ptr_ty.ptrSize(zcu) == .One)
-        ptr_ty.childType(mod).childType(mod)
+        ptr_ty.childType(zcu).childType(zcu)
     else
-        ptr_ty.childType(mod);
+        ptr_ty.childType(zcu);
     const dst_ptr = try func.sliceOrArrayPtr(ptr, ptr_ty);
     try func.memset(elem_ty, dst_ptr, len, value);
 @@ -4886,7 +4889,7 @@ fn airMemset(func: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void
 /// we implement it manually.
 fn memset(func: *CodeGen, elem_ty: Type, ptr: WValue, len: WValue, value: WValue) InnerError!void {
     const pt = func.pt;
-    const abi_size = @as(u32, @intCast(elem_ty.abiSize(pt)));
+    const abi_size = @as(u32, @intCast(elem_ty.abiSize(pt.zcu)));
     // When bulk_memory is enabled, we lower it to wasm's memset instruction.
     // If not, we lower it ourselves.
 @@ -4975,14 +4978,14 @@ fn memset(func: *CodeGen, elem_ty: Type, ptr: WValue, len: WValue, value: WValue
 fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const array_ty = func.typeOf(bin_op.lhs);
     const array = try func.resolveInst(bin_op.lhs);
     const index = try func.resolveInst(bin_op.rhs);
-    const elem_ty = array_ty.childType(mod);
+    const elem_ty = array_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
     if (isByRef(array_ty, pt, func.target.*)) {
         try func.lowerToStack(array);
 @@ -4991,15 +4994,15 @@ fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.addTag(.i32_mul);
         try func.addTag(.i32_add);
     } else {
-        std.debug.assert(array_ty.zigTypeTag(mod) == .Vector);
+        std.debug.assert(array_ty.zigTypeTag(zcu) == .Vector);
         switch (index) {
             inline .imm32, .imm64 => |lane| {
-                const opcode: wasm.SimdOpcode = switch (elem_ty.bitSize(pt)) {
+                const opcode: wasm.SimdOpcode = switch (elem_ty.bitSize(zcu)) {
-                    8 => if (elem_ty.isSignedInt(mod)) .i8x16_extract_lane_s else .i8x16_extract_lane_u,
+                    8 => if (elem_ty.isSignedInt(zcu)) .i8x16_extract_lane_s else .i8x16_extract_lane_u,
-                    16 => if (elem_ty.isSignedInt(mod)) .i16x8_extract_lane_s else .i16x8_extract_lane_u,
+                    16 => if (elem_ty.isSignedInt(zcu)) .i16x8_extract_lane_s else .i16x8_extract_lane_u,
-                    32 => if (elem_ty.isInt(mod)) .i32x4_extract_lane else .f32x4_extract_lane,
+                    32 => if (elem_ty.isInt(zcu)) .i32x4_extract_lane else .f32x4_extract_lane,
-                    64 => if (elem_ty.isInt(mod)) .i64x2_extract_lane else .f64x2_extract_lane,
+                    64 => if (elem_ty.isInt(zcu)) .i64x2_extract_lane else .f64x2_extract_lane,
                     else => unreachable,
                 };
 @@ -5037,7 +5040,7 @@ fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
 @@ -5045,7 +5048,7 @@ fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const op_bits = op_ty.floatBits(func.target.*);
     const dest_ty = func.typeOfIndex(inst);
-    const dest_info = dest_ty.intInfo(mod);
+    const dest_info = dest_ty.intInfo(zcu);
     if (dest_info.bits > 128) {
         return func.fail("TODO: intFromFloat for integers/floats with bitsize {}", .{dest_info.bits});
 @@ -5082,12 +5085,12 @@ fn airIntFromFloat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const op_ty = func.typeOf(ty_op.operand);
-    const op_info = op_ty.intInfo(mod);
+    const op_info = op_ty.intInfo(zcu);
     const dest_ty = func.typeOfIndex(inst);
     const dest_bits = dest_ty.floatBits(func.target.*);
 @@ -5127,19 +5130,19 @@ fn airFloatFromInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const ty = func.typeOfIndex(inst);
-    const elem_ty = ty.childType(mod);
+    const elem_ty = ty.childType(zcu);
-    if (determineSimdStoreStrategy(ty, pt, func.target.*) == .direct) blk: {
+    if (determineSimdStoreStrategy(ty, zcu, func.target.*) == .direct) blk: {
         switch (operand) {
             // when the operand lives in the linear memory section, we can directly
             // load and splat the value at once. Meaning we do not first have to load
             // the scalar value onto the stack.
             .stack_offset, .memory, .memory_offset => {
-                const opcode = switch (elem_ty.bitSize(pt)) {
+                const opcode = switch (elem_ty.bitSize(zcu)) {
                     8 => std.wasm.simdOpcode(.v128_load8_splat),
                     16 => std.wasm.simdOpcode(.v128_load16_splat),
                     32 => std.wasm.simdOpcode(.v128_load32_splat),
 @@ -5153,17 +5156,17 @@ fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 try func.mir_extra.appendSlice(func.gpa, &[_]u32{
                     opcode,
                     operand.offset(),
-                    @intCast(elem_ty.abiAlignment(pt).toByteUnits().?),
+                    @intCast(elem_ty.abiAlignment(zcu).toByteUnits().?),
                 });
                 try func.addInst(.{ .tag = .simd_prefix, .data = .{ .payload = extra_index } });
                 return func.finishAir(inst, .stack, &.{ty_op.operand});
             },
             .local => {
-                const opcode = switch (elem_ty.bitSize(pt)) {
+                const opcode = switch (elem_ty.bitSize(zcu)) {
                     8 => std.wasm.simdOpcode(.i8x16_splat),
                     16 => std.wasm.simdOpcode(.i16x8_splat),
-                    32 => if (elem_ty.isInt(mod)) std.wasm.simdOpcode(.i32x4_splat) else std.wasm.simdOpcode(.f32x4_splat),
+                    32 => if (elem_ty.isInt(zcu)) std.wasm.simdOpcode(.i32x4_splat) else std.wasm.simdOpcode(.f32x4_splat),
-                    64 => if (elem_ty.isInt(mod)) std.wasm.simdOpcode(.i64x2_splat) else std.wasm.simdOpcode(.f64x2_splat),
+                    64 => if (elem_ty.isInt(zcu)) std.wasm.simdOpcode(.i64x2_splat) else std.wasm.simdOpcode(.f64x2_splat),
                     else => break :blk, // Cannot make use of simd-instructions
                 };
                 try func.emitWValue(operand);
 @@ -5175,14 +5178,14 @@ fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             else => unreachable,
         }
     }
-    const elem_size = elem_ty.bitSize(pt);
+    const elem_size = elem_ty.bitSize(zcu);
-    const vector_len = @as(usize, @intCast(ty.vectorLen(mod)));
+    const vector_len = @as(usize, @intCast(ty.vectorLen(zcu)));
     if ((!std.math.isPowerOfTwo(elem_size) or elem_size % 8 != 0) and vector_len > 1) {
         return func.fail("TODO: WebAssembly `@splat` for arbitrary element bitsize {d}", .{elem_size});
     }
     const result = try func.allocStack(ty);
-    const elem_byte_size = @as(u32, @intCast(elem_ty.abiSize(pt)));
+    const elem_byte_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));
     var index: usize = 0;
     var offset: u32 = 0;
     while (index < vector_len) : (index += 1) {
 @@ -5203,7 +5206,7 @@ fn airSelect(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const inst_ty = func.typeOfIndex(inst);
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.Shuffle, ty_pl.payload).data;
 @@ -5213,15 +5216,15 @@ fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mask = Value.fromInterned(extra.mask);
     const mask_len = extra.mask_len;
-    const child_ty = inst_ty.childType(mod);
+    const child_ty = inst_ty.childType(zcu);
-    const elem_size = child_ty.abiSize(pt);
+    const elem_size = child_ty.abiSize(zcu);
     // TODO: One of them could be by ref; handle in loop
     if (isByRef(func.typeOf(extra.a), pt, func.target.*) or isByRef(inst_ty, pt, func.target.*)) {
         const result = try func.allocStack(inst_ty);
         for (0..mask_len) |index| {
-            const value = (try mask.elemValue(pt, index)).toSignedInt(pt);
+            const value = (try mask.elemValue(pt, index)).toSignedInt(zcu);
             try func.emitWValue(result);
 @@ -5241,7 +5244,7 @@ fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         var lanes = mem.asBytes(operands[1..]);
         for (0..@as(usize, @intCast(mask_len))) |index| {
-            const mask_elem = (try mask.elemValue(pt, index)).toSignedInt(pt);
+            const mask_elem = (try mask.elemValue(pt, index)).toSignedInt(zcu);
             const base_index = if (mask_elem >= 0)
                 @as(u8, @intCast(@as(i64, @intCast(elem_size)) * mask_elem))
             else
 @@ -5273,20 +5276,20 @@ fn airReduce(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const result_ty = func.typeOfIndex(inst);
-    const len = @as(usize, @intCast(result_ty.arrayLen(mod)));
+    const len = @as(usize, @intCast(result_ty.arrayLen(zcu)));
     const elements = @as([]const Air.Inst.Ref, @ptrCast(func.air.extra[ty_pl.payload..][0..len]));
     const result: WValue = result_value: {
-        switch (result_ty.zigTypeTag(mod)) {
+        switch (result_ty.zigTypeTag(zcu)) {
             .Array => {
                 const result = try func.allocStack(result_ty);
-                const elem_ty = result_ty.childType(mod);
+                const elem_ty = result_ty.childType(zcu);
-                const elem_size = @as(u32, @intCast(elem_ty.abiSize(pt)));
+                const elem_size = @as(u32, @intCast(elem_ty.abiSize(zcu)));
-                const sentinel = if (result_ty.sentinel(mod)) |sent| blk: {
+                const sentinel = if (result_ty.sentinel(zcu)) |sent| blk: {
                     break :blk try func.lowerConstant(sent, elem_ty);
                 } else null;
 @@ -5321,18 +5324,18 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 }
                 break :result_value result;
             },
-            .Struct => switch (result_ty.containerLayout(mod)) {
+            .Struct => switch (result_ty.containerLayout(zcu)) {
                 .@"packed" => {
                     if (isByRef(result_ty, pt, func.target.*)) {
                         return func.fail("TODO: airAggregateInit for packed structs larger than 64 bits", .{});
                     }
-                    const packed_struct = mod.typeToPackedStruct(result_ty).?;
+                    const packed_struct = zcu.typeToPackedStruct(result_ty).?;
                     const field_types = packed_struct.field_types;
                     const backing_type = Type.fromInterned(packed_struct.backingIntTypeUnordered(ip));
                     // ensure the result is zero'd
                     const result = try func.allocLocal(backing_type);
-                    if (backing_type.bitSize(pt) <= 32)
+                    if (backing_type.bitSize(zcu) <= 32)
                         try func.addImm32(0)
                     else
                         try func.addImm64(0);
 @@ -5341,15 +5344,15 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     var current_bit: u16 = 0;
                     for (elements, 0..) |elem, elem_index| {
                         const field_ty = Type.fromInterned(field_types.get(ip)[elem_index]);
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                        const shift_val: WValue = if (backing_type.bitSize(pt) <= 32)
+                        const shift_val: WValue = if (backing_type.bitSize(zcu) <= 32)
                             .{ .imm32 = current_bit }
                         else
                             .{ .imm64 = current_bit };
                         const value = try func.resolveInst(elem);
-                        const value_bit_size: u16 = @intCast(field_ty.bitSize(pt));
+                        const value_bit_size: u16 = @intCast(field_ty.bitSize(zcu));
                         const int_ty = try pt.intType(.unsigned, value_bit_size);
                         // load our current result on stack so we can perform all transformations
 @@ -5375,8 +5378,8 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     for (elements, 0..) |elem, elem_index| {
                         if (try result_ty.structFieldValueComptime(pt, elem_index) != null) continue;
-                        const elem_ty = result_ty.structFieldType(elem_index, mod);
+                        const elem_ty = result_ty.fieldType(elem_index, zcu);
-                        const field_offset = result_ty.structFieldOffset(elem_index, pt);
+                        const field_offset = result_ty.structFieldOffset(elem_index, zcu);
                         _ = try func.buildPointerOffset(offset, @intCast(field_offset - prev_field_offset), .modify);
                         prev_field_offset = field_offset;
 @@ -5404,21 +5407,21 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.UnionInit, ty_pl.payload).data;
     const result = result: {
         const union_ty = func.typeOfIndex(inst);
-        const layout = union_ty.unionGetLayout(pt);
+        const layout = union_ty.unionGetLayout(zcu);
-        const union_obj = mod.typeToUnion(union_ty).?;
+        const union_obj = zcu.typeToUnion(union_ty).?;
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
         const field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
         const tag_int = blk: {
-            const tag_ty = union_ty.unionTagTypeHypothetical(mod);
+            const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
-            const enum_field_index = tag_ty.enumFieldIndex(field_name, mod).?;
+            const enum_field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
             const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
             break :blk try func.lowerConstant(tag_val, tag_ty);
         };
 @@ -5458,13 +5461,13 @@ fn airUnionInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             break :result result_ptr;
         } else {
             const operand = try func.resolveInst(extra.init);
-            const union_int_type = try pt.intType(.unsigned, @as(u16, @intCast(union_ty.bitSize(pt))));
+            const union_int_type = try pt.intType(.unsigned, @as(u16, @intCast(union_ty.bitSize(zcu))));
-            if (field_ty.zigTypeTag(mod) == .Float) {
+            if (field_ty.zigTypeTag(zcu) == .Float) {
-                const int_type = try pt.intType(.unsigned, @intCast(field_ty.bitSize(pt)));
+                const int_type = try pt.intType(.unsigned, @intCast(field_ty.bitSize(zcu)));
                 const bitcasted = try func.bitcast(field_ty, int_type, operand);
                 break :result try func.trunc(bitcasted, int_type, union_int_type);
-            } else if (field_ty.isPtrAtRuntime(mod)) {
+            } else if (field_ty.isPtrAtRuntime(zcu)) {
-                const int_type = try pt.intType(.unsigned, @intCast(field_ty.bitSize(pt)));
+                const int_type = try pt.intType(.unsigned, @intCast(field_ty.bitSize(zcu)));
                 break :result try func.intcast(operand, int_type, union_int_type);
             }
             break :result try func.intcast(operand, field_ty, union_int_type);
 @@ -5497,10 +5500,10 @@ fn airWasmMemoryGrow(func: *CodeGen, inst: Air.Inst.Index) !void {
 fn cmpOptionals(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    assert(operand_ty.hasRuntimeBitsIgnoreComptime(pt));
+    assert(operand_ty.hasRuntimeBitsIgnoreComptime(zcu));
     assert(op == .eq or op == .neq);
-    const payload_ty = operand_ty.optionalChild(mod);
+    const payload_ty = operand_ty.optionalChild(zcu);
     // We store the final result in here that will be validated
     // if the optional is truly equal.
 @@ -5534,11 +5537,11 @@ fn cmpOptionals(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op:
 /// TODO: Lower this to compiler_rt call when bitsize > 128
 fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    assert(operand_ty.abiSize(pt) >= 16);
+    assert(operand_ty.abiSize(zcu) >= 16);
     assert(!(lhs != .stack and rhs == .stack));
-    if (operand_ty.bitSize(pt) > 128) {
+    if (operand_ty.bitSize(zcu) > 128) {
-        return func.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.bitSize(pt)});
+        return func.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.bitSize(zcu)});
     }
     var lhs_msb = try (try func.load(lhs, Type.u64, 8)).toLocal(func, Type.u64);
 @@ -5561,7 +5564,7 @@ fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
             }
         },
         else => {
-            const ty = if (operand_ty.isSignedInt(mod)) Type.i64 else Type.u64;
+            const ty = if (operand_ty.isSignedInt(zcu)) Type.i64 else Type.u64;
             // leave those value on top of the stack for '.select'
             const lhs_lsb = try func.load(lhs, Type.u64, 0);
             const rhs_lsb = try func.load(rhs, Type.u64, 0);
 @@ -5577,11 +5580,11 @@ fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
 fn airSetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-    const un_ty = func.typeOf(bin_op.lhs).childType(mod);
+    const un_ty = func.typeOf(bin_op.lhs).childType(zcu);
     const tag_ty = func.typeOf(bin_op.rhs);
-    const layout = un_ty.unionGetLayout(pt);
+    const layout = un_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) return func.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
     const union_ptr = try func.resolveInst(bin_op.lhs);
 @@ -5601,12 +5604,12 @@ fn airSetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airGetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
-    const pt = func.pt;
+    const zcu = func.pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const un_ty = func.typeOf(ty_op.operand);
     const tag_ty = func.typeOfIndex(inst);
-    const layout = un_ty.unionGetLayout(pt);
+    const layout = un_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) return func.finishAir(inst, .none, &.{ty_op.operand});
     const operand = try func.resolveInst(ty_op.operand);
 @@ -5705,11 +5708,11 @@ fn fptrunc(func: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerErro
 fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
-    const err_set_ty = func.typeOf(ty_op.operand).childType(mod);
+    const err_set_ty = func.typeOf(ty_op.operand).childType(zcu);
-    const payload_ty = err_set_ty.errorUnionPayload(mod);
+    const payload_ty = err_set_ty.errorUnionPayload(zcu);
     const operand = try func.resolveInst(ty_op.operand);
     // set error-tag to '0' to annotate error union is non-error
 @@ -5717,28 +5720,28 @@ fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!voi
         operand,
         .{ .imm32 = 0 },
         Type.anyerror,
-        @intCast(errUnionErrorOffset(payload_ty, pt)),
+        @intCast(errUnionErrorOffset(payload_ty, zcu)),
     );
     const result = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
-        break :result try func.buildPointerOffset(operand, @as(u32, @intCast(errUnionPayloadOffset(payload_ty, pt))), .new);
+        break :result try func.buildPointerOffset(operand, @as(u32, @intCast(errUnionPayloadOffset(payload_ty, zcu))), .new);
     };
     return func.finishAir(inst, result, &.{ty_op.operand});
 }
 fn airFieldParentPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
     const field_ptr = try func.resolveInst(extra.field_ptr);
-    const parent_ty = ty_pl.ty.toType().childType(mod);
+    const parent_ty = ty_pl.ty.toType().childType(zcu);
-    const field_offset = parent_ty.structFieldOffset(extra.field_index, pt);
+    const field_offset = parent_ty.structFieldOffset(extra.field_index, zcu);
     const result = if (field_offset != 0) result: {
         const base = try func.buildPointerOffset(field_ptr, 0, .new);
 @@ -5754,8 +5757,8 @@ fn airFieldParentPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn sliceOrArrayPtr(func: *CodeGen, ptr: WValue, ptr_ty: Type) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ptr_ty.isSlice(mod)) {
+    if (ptr_ty.isSlice(zcu)) {
         return func.slicePtr(ptr);
     } else {
         return ptr;
 @@ -5764,26 +5767,26 @@ fn sliceOrArrayPtr(func: *CodeGen, ptr: WValue, ptr_ty: Type) InnerError!WValue
 fn airMemcpy(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const dst = try func.resolveInst(bin_op.lhs);
     const dst_ty = func.typeOf(bin_op.lhs);
-    const ptr_elem_ty = dst_ty.childType(mod);
+    const ptr_elem_ty = dst_ty.childType(zcu);
     const src = try func.resolveInst(bin_op.rhs);
     const src_ty = func.typeOf(bin_op.rhs);
-    const len = switch (dst_ty.ptrSize(mod)) {
+    const len = switch (dst_ty.ptrSize(zcu)) {
         .Slice => blk: {
             const slice_len = try func.sliceLen(dst);
-            if (ptr_elem_ty.abiSize(pt) != 1) {
+            if (ptr_elem_ty.abiSize(zcu) != 1) {
                 try func.emitWValue(slice_len);
-                try func.emitWValue(.{ .imm32 = @as(u32, @intCast(ptr_elem_ty.abiSize(pt))) });
+                try func.emitWValue(.{ .imm32 = @as(u32, @intCast(ptr_elem_ty.abiSize(zcu))) });
                 try func.addTag(.i32_mul);
                 try func.addLabel(.local_set, slice_len.local.value);
             }
             break :blk slice_len;
         },
         .One => @as(WValue, .{
-            .imm32 = @as(u32, @intCast(ptr_elem_ty.arrayLen(mod) * ptr_elem_ty.childType(mod).abiSize(pt))),
+            .imm32 = @as(u32, @intCast(ptr_elem_ty.arrayLen(zcu) * ptr_elem_ty.childType(zcu).abiSize(zcu))),
         }),
         .C, .Many => unreachable,
     };
 @@ -5805,17 +5808,17 @@ fn airRetAddr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const op_ty = func.typeOf(ty_op.operand);
-    if (op_ty.zigTypeTag(mod) == .Vector) {
+    if (op_ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement @popCount for vectors", .{});
     }
-    const int_info = op_ty.intInfo(mod);
+    const int_info = op_ty.intInfo(zcu);
     const bits = int_info.bits;
     const wasm_bits = toWasmBits(bits) orelse {
         return func.fail("TODO: Implement @popCount for integers with bitsize '{d}'", .{bits});
 @@ -5824,14 +5827,14 @@ fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     switch (wasm_bits) {
         32 => {
             try func.emitWValue(operand);
-            if (op_ty.isSignedInt(mod) and bits != wasm_bits) {
+            if (op_ty.isSignedInt(zcu) and bits != wasm_bits) {
                 _ = try func.wrapOperand(.stack, try pt.intType(.unsigned, bits));
             }
             try func.addTag(.i32_popcnt);
         },
         64 => {
             try func.emitWValue(operand);
-            if (op_ty.isSignedInt(mod) and bits != wasm_bits) {
+            if (op_ty.isSignedInt(zcu) and bits != wasm_bits) {
                 _ = try func.wrapOperand(.stack, try pt.intType(.unsigned, bits));
             }
             try func.addTag(.i64_popcnt);
 @@ -5842,7 +5845,7 @@ fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             _ = try func.load(operand, Type.u64, 0);
             try func.addTag(.i64_popcnt);
             _ = try func.load(operand, Type.u64, 8);
-            if (op_ty.isSignedInt(mod) and bits != wasm_bits) {
+            if (op_ty.isSignedInt(zcu) and bits != wasm_bits) {
                 _ = try func.wrapOperand(.stack, try pt.intType(.unsigned, bits - 64));
             }
             try func.addTag(.i64_popcnt);
 @@ -5857,17 +5860,17 @@ fn airPopcount(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airBitReverse(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const ty = func.typeOf(ty_op.operand);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement @bitReverse for vectors", .{});
     }
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const bits = int_info.bits;
     const wasm_bits = toWasmBits(bits) orelse {
         return func.fail("TODO: Implement @bitReverse for integers with bitsize '{d}'", .{bits});
 @@ -5933,7 +5936,7 @@ fn airBitReverse(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 defer tmp.free(func);
                 try func.addLabel(.local_tee, tmp.local.value);
                 try func.emitWValue(.{ .imm64 = 128 - bits });
-                if (ty.isSignedInt(mod)) {
+                if (ty.isSignedInt(zcu)) {
                     try func.addTag(.i64_shr_s);
                 } else {
                     try func.addTag(.i64_shr_u);
 @@ -5969,7 +5972,7 @@ fn airErrorName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
     const error_table_symbol = try func.bin_file.getErrorTableSymbol(pt);
     const name_ty = Type.slice_const_u8_sentinel_0;
-    const abi_size = name_ty.abiSize(pt);
+    const abi_size = name_ty.abiSize(pt.zcu);
     const error_name_value: WValue = .{ .memory = error_table_symbol }; // emitting this will create a relocation
     try func.emitWValue(error_name_value);
 @@ -6000,8 +6003,8 @@ fn airPtrSliceFieldPtr(func: *CodeGen, inst: Air.Inst.Index, offset: u32) InnerE
 /// NOTE: Allocates place for result on virtual stack, when integer size > 64 bits
 fn intZeroValue(func: *CodeGen, ty: Type) InnerError!WValue {
-    const mod = func.bin_file.base.comp.module.?;
+    const zcu = func.bin_file.base.comp.zcu.?;
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: Implement intZeroValue for integer bitsize: {d}", .{int_info.bits});
     };
 @@ -6027,13 +6030,13 @@ fn airAddSubWithOverflow(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerErro
     const rhs = try func.resolveInst(extra.rhs);
     const ty = func.typeOf(extra.lhs);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement overflow arithmetic for vectors", .{});
     }
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const is_signed = int_info.signedness == .signed;
     if (int_info.bits > 128) {
         return func.fail("TODO: Implement {{add/sub}}_with_overflow for integer bitsize: {d}", .{int_info.bits});
 @@ -6058,7 +6061,7 @@ fn airAddSubWithOverflow(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerErro
     defer bit_tmp.free(func);
     const result = try func.allocStack(func.typeOfIndex(inst));
-    const offset: u32 = @intCast(ty.abiSize(pt));
+    const offset: u32 = @intCast(ty.abiSize(zcu));
     try func.store(result, op_tmp, ty, 0);
     try func.store(result, bit_tmp, Type.u1, offset);
 @@ -6067,7 +6070,7 @@ fn airAddSubWithOverflow(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerErro
 fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.Bin, ty_pl.payload).data;
 @@ -6076,18 +6079,18 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty = func.typeOf(extra.lhs);
     const rhs_ty = func.typeOf(extra.rhs);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement overflow arithmetic for vectors", .{});
     }
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: Implement shl_with_overflow for integer bitsize: {d}", .{int_info.bits});
     };
     // Ensure rhs is coerced to lhs as they must have the same WebAssembly types
     // before we can perform any binary operation.
-    const rhs_wasm_bits = toWasmBits(rhs_ty.intInfo(mod).bits).?;
+    const rhs_wasm_bits = toWasmBits(rhs_ty.intInfo(zcu).bits).?;
     // If wasm_bits == 128, compiler-rt expects i32 for shift
     const rhs_final = if (wasm_bits != rhs_wasm_bits and wasm_bits == 64) blk: {
         const rhs_casted = try func.intcast(rhs, rhs_ty, ty);
 @@ -6105,7 +6108,7 @@ fn airShlWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     defer overflow_local.free(func);
     const result = try func.allocStack(func.typeOfIndex(inst));
-    const offset: u32 = @intCast(ty.abiSize(pt));
+    const offset: u32 = @intCast(ty.abiSize(zcu));
     try func.store(result, shl, ty, 0);
     try func.store(result, overflow_local, Type.u1, offset);
 @@ -6120,9 +6123,9 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const rhs = try func.resolveInst(extra.rhs);
     const ty = func.typeOf(extra.lhs);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: Implement overflow arithmetic for vectors", .{});
     }
 @@ -6131,7 +6134,7 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     var overflow_bit = try func.ensureAllocLocal(Type.u1);
     defer overflow_bit.free(func);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: Implement `@mulWithOverflow` for integer bitsize: {d}", .{int_info.bits});
     };
 @@ -6238,7 +6241,7 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     defer bin_op_local.free(func);
     const result = try func.allocStack(func.typeOfIndex(inst));
-    const offset: u32 = @intCast(ty.abiSize(pt));
+    const offset: u32 = @intCast(ty.abiSize(zcu));
     try func.store(result, bin_op_local, ty, 0);
     try func.store(result, overflow_bit, Type.u1, offset);
 @@ -6248,22 +6251,22 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     assert(op == .max or op == .min);
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ty = func.typeOfIndex(inst);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: `@maximum` and `@minimum` for vectors", .{});
     }
-    if (ty.abiSize(pt) > 16) {
+    if (ty.abiSize(zcu) > 16) {
         return func.fail("TODO: `@maximum` and `@minimum` for types larger than 16 bytes", .{});
     }
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
-    if (ty.zigTypeTag(mod) == .Float) {
+    if (ty.zigTypeTag(zcu) == .Float) {
         var fn_name_buf: [64]u8 = undefined;
         const float_bits = ty.floatBits(func.target.*);
         const fn_name = std.fmt.bufPrint(&fn_name_buf, "{s}f{s}{s}", .{
 @@ -6288,12 +6291,12 @@ fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
 fn airMulAdd(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const bin_op = func.air.extraData(Air.Bin, pl_op.payload).data;
     const ty = func.typeOfIndex(inst);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: `@mulAdd` for vectors", .{});
     }
 @@ -6323,16 +6326,16 @@ fn airMulAdd(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airClz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const ty = func.typeOf(ty_op.operand);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: `@clz` for vectors", .{});
     }
     const operand = try func.resolveInst(ty_op.operand);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: `@clz` for integers with bitsize '{d}'", .{int_info.bits});
     };
 @@ -6374,17 +6377,17 @@ fn airClz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airCtz(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const ty = func.typeOf(ty_op.operand);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: `@ctz` for vectors", .{});
     }
     const operand = try func.resolveInst(ty_op.operand);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: `@clz` for integers with bitsize '{d}'", .{int_info.bits});
     };
 @@ -6497,12 +6500,12 @@ fn airTry(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airTryPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.TryPtr, ty_pl.payload);
     const err_union_ptr = try func.resolveInst(extra.data.ptr);
     const body: []const Air.Inst.Index = @ptrCast(func.air.extra[extra.end..][0..extra.data.body_len]);
-    const err_union_ty = func.typeOf(extra.data.ptr).childType(mod);
+    const err_union_ty = func.typeOf(extra.data.ptr).childType(zcu);
     const result = try lowerTry(func, inst, err_union_ptr, body, err_union_ty, true);
     return func.finishAir(inst, result, &.{extra.data.ptr});
 }
 @@ -6516,25 +6519,25 @@ fn lowerTry(
     operand_is_ptr: bool,
 ) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (operand_is_ptr) {
         return func.fail("TODO: lowerTry for pointers", .{});
     }
-    const pl_ty = err_union_ty.errorUnionPayload(mod);
+    const pl_ty = err_union_ty.errorUnionPayload(zcu);
-    const pl_has_bits = pl_ty.hasRuntimeBitsIgnoreComptime(pt);
+    const pl_has_bits = pl_ty.hasRuntimeBitsIgnoreComptime(zcu);
-    if (!err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+    if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
         // Block we can jump out of when error is not set
         try func.startBlock(.block, wasm.block_empty);
         // check if the error tag is set for the error union.
         try func.emitWValue(err_union);
         if (pl_has_bits) {
-            const err_offset: u32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+            const err_offset: u32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
             try func.addMemArg(.i32_load16_u, .{
                 .offset = err_union.offset() + err_offset,
-                .alignment = @intCast(Type.anyerror.abiAlignment(pt).toByteUnits().?),
+                .alignment = @intCast(Type.anyerror.abiAlignment(zcu).toByteUnits().?),
             });
         }
         try func.addTag(.i32_eqz);
 @@ -6556,7 +6559,7 @@ fn lowerTry(
         return .none;
     }
-    const pl_offset: u32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+    const pl_offset: u32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
     if (isByRef(pl_ty, pt, func.target.*)) {
         return buildPointerOffset(func, err_union, pl_offset, .new);
     }
 @@ -6566,16 +6569,16 @@ fn lowerTry(
 fn airByteSwap(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const ty = func.typeOfIndex(inst);
     const operand = try func.resolveInst(ty_op.operand);
-    if (ty.zigTypeTag(mod) == .Vector) {
+    if (ty.zigTypeTag(zcu) == .Vector) {
         return func.fail("TODO: @byteSwap for vectors", .{});
     }
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return func.fail("TODO: @byteSwap for integers with bitsize {d}", .{int_info.bits});
     };
 @@ -6649,15 +6652,15 @@ fn airDivFloor(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty = func.typeOfIndex(inst);
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
-    if (ty.isUnsignedInt(mod)) {
+    if (ty.isUnsignedInt(zcu)) {
         _ = try func.binOp(lhs, rhs, ty, .div);
-    } else if (ty.isSignedInt(mod)) {
+    } else if (ty.isSignedInt(zcu)) {
-        const int_bits = ty.intInfo(mod).bits;
+        const int_bits = ty.intInfo(zcu).bits;
         const wasm_bits = toWasmBits(int_bits) orelse {
             return func.fail("TODO: `@divFloor` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
         };
 @@ -6767,19 +6770,19 @@ fn airMod(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty = func.typeOfIndex(inst);
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
-    if (ty.isUnsignedInt(mod)) {
+    if (ty.isUnsignedInt(zcu)) {
         _ = try func.binOp(lhs, rhs, ty, .rem);
-    } else if (ty.isSignedInt(mod)) {
+    } else if (ty.isSignedInt(zcu)) {
         // The wasm rem instruction gives the remainder after truncating division (rounding towards
         // 0), equivalent to @rem.
         // We make use of the fact that:
         // @mod(a, b) = @rem(@rem(a, b) + b, b)
-        const int_bits = ty.intInfo(mod).bits;
+        const int_bits = ty.intInfo(zcu).bits;
         const wasm_bits = toWasmBits(int_bits) orelse {
             return func.fail("TODO: `@mod` for signed integers larger than 64 bits ({d} bits requested)", .{int_bits});
         };
 @@ -6802,9 +6805,9 @@ fn airSatMul(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty = func.typeOfIndex(inst);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const is_signed = int_info.signedness == .signed;
     const lhs = try func.resolveInst(bin_op.lhs);
 @@ -6903,12 +6906,12 @@ fn airSatBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty = func.typeOfIndex(inst);
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const is_signed = int_info.signedness == .signed;
     if (int_info.bits > 64) {
 @@ -6950,8 +6953,8 @@ fn airSatBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
 fn signedSat(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const wasm_bits = toWasmBits(int_info.bits).?;
     const is_wasm_bits = wasm_bits == int_info.bits;
     const ext_ty = if (!is_wasm_bits) try pt.intType(int_info.signedness, wasm_bits) else ty;
 @@ -7009,9 +7012,9 @@ fn airShlSat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty = func.typeOfIndex(inst);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const is_signed = int_info.signedness == .signed;
     if (int_info.bits > 64) {
         return func.fail("TODO: Saturating shifting left for integers with bitsize '{d}'", .{int_info.bits});
 @@ -7130,7 +7133,7 @@ fn callIntrinsic(
     // Always pass over C-ABI
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     var func_type = try genFunctype(func.gpa, .C, param_types, return_type, pt, func.target.*);
     defer func_type.deinit(func.gpa);
     const func_type_index = try func.bin_file.zigObjectPtr().?.putOrGetFuncType(func.gpa, func_type);
 @@ -7148,16 +7151,16 @@ fn callIntrinsic(
     // Lower all arguments to the stack before we call our function
     for (args, 0..) |arg, arg_i| {
         assert(!(want_sret_param and arg == .stack));
-        assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBitsIgnoreComptime(pt));
+        assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBitsIgnoreComptime(zcu));
         try func.lowerArg(.C, Type.fromInterned(param_types[arg_i]), arg);
     }
     // Actually call our intrinsic
     try func.addLabel(.call, @intFromEnum(symbol_index));
-    if (!return_type.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
         return .none;
-    } else if (return_type.isNoReturn(mod)) {
+    } else if (return_type.isNoReturn(zcu)) {
         try func.addTag(.@"unreachable");
         return .none;
     } else if (want_sret_param) {
 @@ -7184,8 +7187,8 @@ fn airTagName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     var arena_allocator = std.heap.ArenaAllocator.init(func.gpa);
     defer arena_allocator.deinit();
 @@ -7198,9 +7201,9 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
         return @intFromEnum(loc.index);
     }
-    const int_tag_ty = enum_ty.intTagType(mod);
+    const int_tag_ty = enum_ty.intTagType(zcu);
-    if (int_tag_ty.bitSize(pt) > 64) {
+    if (int_tag_ty.bitSize(zcu) > 64) {
         return func.fail("TODO: Implement @tagName for enums with tag size larger than 64 bits", .{});
     }
 @@ -7220,7 +7223,7 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
     // TODO: Make switch implementation generic so we can use a jump table for this when the tags are not sparse.
     // generate an if-else chain for each tag value as well as constant.
-    const tag_names = enum_ty.enumFields(mod);
+    const tag_names = enum_ty.enumFields(zcu);
     for (0..tag_names.len) |tag_index| {
         const tag_name = tag_names.get(ip)[tag_index];
         const tag_name_len = tag_name.length(ip);
 @@ -7345,15 +7348,15 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
 fn airErrorSetHasValue(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const error_set_ty = ty_op.ty.toType();
     const result = try func.allocLocal(Type.bool);
-    const names = error_set_ty.errorSetNames(mod);
+    const names = error_set_ty.errorSetNames(zcu);
     var values = try std.ArrayList(u32).initCapacity(func.gpa, names.len);
     defer values.deinit();
 @@ -7432,12 +7435,12 @@ inline fn useAtomicFeature(func: *const CodeGen) bool {
 fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = func.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
     const ptr_ty = func.typeOf(extra.ptr);
-    const ty = ptr_ty.childType(mod);
+    const ty = ptr_ty.childType(zcu);
     const result_ty = func.typeOfIndex(inst);
     const ptr_operand = try func.resolveInst(extra.ptr);
 @@ -7451,7 +7454,7 @@ fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.emitWValue(ptr_operand);
         try func.lowerToStack(expected_val);
         try func.lowerToStack(new_val);
-        try func.addAtomicMemArg(switch (ty.abiSize(pt)) {
+        try func.addAtomicMemArg(switch (ty.abiSize(zcu)) {
             1 => .i32_atomic_rmw8_cmpxchg_u,
             2 => .i32_atomic_rmw16_cmpxchg_u,
             4 => .i32_atomic_rmw_cmpxchg,
 @@ -7459,14 +7462,14 @@ fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             else => |size| return func.fail("TODO: implement `@cmpxchg` for types with abi size '{d}'", .{size}),
         }, .{
             .offset = ptr_operand.offset(),
-            .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
         });
         try func.addLabel(.local_tee, val_local.local.value);
         _ = try func.cmp(.stack, expected_val, ty, .eq);
         try func.addLabel(.local_set, cmp_result.local.value);
         break :val val_local;
     } else val: {
-        if (ty.abiSize(pt) > 8) {
+        if (ty.abiSize(zcu) > 8) {
             return func.fail("TODO: Implement `@cmpxchg` for types larger than abi size of 8 bytes", .{});
         }
         const ptr_val = try WValue.toLocal(try func.load(ptr_operand, ty, 0), func, ty);
 @@ -7490,7 +7493,7 @@ fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.addTag(.i32_and);
         const and_result = try WValue.toLocal(.stack, func, Type.bool);
         const result_ptr = try func.allocStack(result_ty);
-        try func.store(result_ptr, and_result, Type.bool, @as(u32, @intCast(ty.abiSize(pt))));
+        try func.store(result_ptr, and_result, Type.bool, @as(u32, @intCast(ty.abiSize(zcu))));
         try func.store(result_ptr, ptr_val, ty, 0);
         break :val result_ptr;
     } else val: {
 @@ -7511,7 +7514,7 @@ fn airAtomicLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty = func.typeOfIndex(inst);
     if (func.useAtomicFeature()) {
-        const tag: wasm.AtomicsOpcode = switch (ty.abiSize(pt)) {
+        const tag: wasm.AtomicsOpcode = switch (ty.abiSize(pt.zcu)) {
             1 => .i32_atomic_load8_u,
             2 => .i32_atomic_load16_u,
             4 => .i32_atomic_load,
 @@ -7521,7 +7524,7 @@ fn airAtomicLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.emitWValue(ptr);
         try func.addAtomicMemArg(tag, .{
             .offset = ptr.offset(),
-            .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            .alignment = @intCast(ty.abiAlignment(pt.zcu).toByteUnits().?),
         });
     } else {
         _ = try func.load(ptr, ty, 0);
 @@ -7532,7 +7535,7 @@ fn airAtomicLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const extra = func.air.extraData(Air.AtomicRmw, pl_op.payload).data;
 @@ -7556,7 +7559,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 try func.emitWValue(ptr);
                 try func.emitWValue(value);
                 if (op == .Nand) {
-                    const wasm_bits = toWasmBits(@intCast(ty.bitSize(pt))).?;
+                    const wasm_bits = toWasmBits(@intCast(ty.bitSize(zcu))).?;
                     const and_res = try func.binOp(value, operand, ty, .@"and");
                     if (wasm_bits == 32)
 @@ -7573,7 +7576,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     try func.addTag(.select);
                 }
                 try func.addAtomicMemArg(
-                    switch (ty.abiSize(pt)) {
+                    switch (ty.abiSize(zcu)) {
                         1 => .i32_atomic_rmw8_cmpxchg_u,
                         2 => .i32_atomic_rmw16_cmpxchg_u,
                         4 => .i32_atomic_rmw_cmpxchg,
 @@ -7582,7 +7585,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     },
                     .{
                         .offset = ptr.offset(),
-                        .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+                        .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
                     },
                 );
                 const select_res = try func.allocLocal(ty);
 @@ -7601,7 +7604,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             else => {
                 try func.emitWValue(ptr);
                 try func.emitWValue(operand);
-                const tag: wasm.AtomicsOpcode = switch (ty.abiSize(pt)) {
+                const tag: wasm.AtomicsOpcode = switch (ty.abiSize(zcu)) {
                     1 => switch (op) {
                         .Xchg => .i32_atomic_rmw8_xchg_u,
                         .Add => .i32_atomic_rmw8_add_u,
 @@ -7642,7 +7645,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 };
                 try func.addAtomicMemArg(tag, .{
                     .offset = ptr.offset(),
-                    .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+                    .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
                 });
                 return func.finishAir(inst, .stack, &.{ pl_op.operand, extra.operand });
             },
 @@ -7670,7 +7673,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                     .Xor => .xor,
                     else => unreachable,
                 });
-                if (ty.isInt(mod) and (op == .Add or op == .Sub)) {
+                if (ty.isInt(zcu) and (op == .Add or op == .Sub)) {
                     _ = try func.wrapOperand(.stack, ty);
                 }
                 try func.store(.stack, .stack, ty, ptr.offset());
 @@ -7686,7 +7689,7 @@ fn airAtomicRmw(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
                 try func.store(.stack, .stack, ty, ptr.offset());
             },
             .Nand => {
-                const wasm_bits = toWasmBits(@intCast(ty.bitSize(pt))).?;
+                const wasm_bits = toWasmBits(@intCast(ty.bitSize(zcu))).?;
                 try func.emitWValue(ptr);
                 const and_res = try func.binOp(result, operand, ty, .@"and");
 @@ -7721,16 +7724,16 @@ fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airAtomicStore(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr = try func.resolveInst(bin_op.lhs);
     const operand = try func.resolveInst(bin_op.rhs);
     const ptr_ty = func.typeOf(bin_op.lhs);
-    const ty = ptr_ty.childType(mod);
+    const ty = ptr_ty.childType(zcu);
     if (func.useAtomicFeature()) {
-        const tag: wasm.AtomicsOpcode = switch (ty.abiSize(pt)) {
+        const tag: wasm.AtomicsOpcode = switch (ty.abiSize(zcu)) {
             1 => .i32_atomic_store8,
             2 => .i32_atomic_store16,
             4 => .i32_atomic_store,
 @@ -7741,7 +7744,7 @@ fn airAtomicStore(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.lowerToStack(operand);
         try func.addAtomicMemArg(tag, .{
             .offset = ptr.offset(),
-            .alignment = @intCast(ty.abiAlignment(pt).toByteUnits().?),
+            .alignment = @intCast(ty.abiAlignment(zcu).toByteUnits().?),
         });
     } else {
         try func.store(ptr, operand, ty, 0);
 @@ -7760,12 +7763,12 @@ fn airFrameAddress(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn typeOf(func: *CodeGen, inst: Air.Inst.Ref) Type {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return func.air.typeOf(inst, &mod.intern_pool);
+    return func.air.typeOf(inst, &zcu.intern_pool);
 }
 fn typeOfIndex(func: *CodeGen, inst: Air.Inst.Index) Type {
     const pt = func.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return func.air.typeOfIndex(inst, &mod.intern_pool);
+    return func.air.typeOfIndex(inst, &zcu.intern_pool);
 }

src/arch/wasm/Emit.zig+1-1

...	@@ -255,7 +255,7 @@ fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {	...	@@ -255,7 +255,7 @@ fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
255	@setCold(true);	255	@setCold(true);
256	std.debug.assert(emit.error_msg == null);	256	std.debug.assert(emit.error_msg == null);
257	const comp = emit.bin_file.base.comp;	257	const comp = emit.bin_file.base.comp;
258	const zcu = comp.module.?;	258	const zcu = comp.zcu.?;
259	const gpa = comp.gpa;	259	const gpa = comp.gpa;
260	emit.error_msg = try Zcu.ErrorMsg.create(gpa, zcu.navSrcLoc(emit.owner_nav), format, args);	260	emit.error_msg = try Zcu.ErrorMsg.create(gpa, zcu.navSrcLoc(emit.owner_nav), format, args);
261	return error.EmitFail;	261	return error.EmitFail;

src/arch/wasm/abi.zig+27-29

 @@ -22,16 +22,15 @@ const direct: [2]Class = .{ .direct, .none };
 /// Classifies a given Zig type to determine how they must be passed
 /// or returned as value within a wasm function.
 /// When all elements result in `.none`, no value must be passed in or returned.
-pub fn classifyType(ty: Type, pt: Zcu.PerThread) [2]Class {
+pub fn classifyType(ty: Type, zcu: *Zcu) [2]Class {
-    const mod = pt.zcu;
+    const ip = &zcu.intern_pool;
-    const ip = &mod.intern_pool;
+    const target = zcu.getTarget();
-    const target = mod.getTarget();
+    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return none;
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt)) return none;
+    switch (ty.zigTypeTag(zcu)) {
-    switch (ty.zigTypeTag(mod)) {
         .Struct => {
-            const struct_type = pt.zcu.typeToStruct(ty).?;
+            const struct_type = zcu.typeToStruct(ty).?;
             if (struct_type.layout == .@"packed") {
-                if (ty.bitSize(pt) <= 64) return direct;
+                if (ty.bitSize(zcu) <= 64) return direct;
                 return .{ .direct, .direct };
             }
             if (struct_type.field_types.len > 1) {
 @@ -41,13 +40,13 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) [2]Class {
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[0]);
             const explicit_align = struct_type.fieldAlign(ip, 0);
             if (explicit_align != .none) {
-                if (explicit_align.compareStrict(.gt, field_ty.abiAlignment(pt)))
+                if (explicit_align.compareStrict(.gt, field_ty.abiAlignment(zcu)))
                     return memory;
             }
-            return classifyType(field_ty, pt);
+            return classifyType(field_ty, zcu);
         },
         .Int, .Enum, .ErrorSet => {
-            const int_bits = ty.intInfo(pt.zcu).bits;
+            const int_bits = ty.intInfo(zcu).bits;
             if (int_bits <= 64) return direct;
             if (int_bits <= 128) return .{ .direct, .direct };
             return memory;
 @@ -62,24 +61,24 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) [2]Class {
         .Vector => return direct,
         .Array => return memory,
         .Optional => {
-            assert(ty.isPtrLikeOptional(pt.zcu));
+            assert(ty.isPtrLikeOptional(zcu));
             return direct;
         },
         .Pointer => {
-            assert(!ty.isSlice(pt.zcu));
+            assert(!ty.isSlice(zcu));
             return direct;
         },
         .Union => {
-            const union_obj = pt.zcu.typeToUnion(ty).?;
+            const union_obj = zcu.typeToUnion(ty).?;
             if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-                if (ty.bitSize(pt) <= 64) return direct;
+                if (ty.bitSize(zcu) <= 64) return direct;
                 return .{ .direct, .direct };
             }
-            const layout = ty.unionGetLayout(pt);
+            const layout = ty.unionGetLayout(zcu);
             assert(layout.tag_size == 0);
             if (union_obj.field_types.len > 1) return memory;
             const first_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[0]);
-            return classifyType(first_field_ty, pt);
+            return classifyType(first_field_ty, zcu);
         },
         .ErrorUnion,
         .Frame,
 @@ -101,29 +100,28 @@ pub fn classifyType(ty: Type, pt: Zcu.PerThread) [2]Class {
 /// Returns the scalar type a given type can represent.
 /// Asserts given type can be represented as scalar, such as
 /// a struct with a single scalar field.
-pub fn scalarType(ty: Type, pt: Zcu.PerThread) Type {
+pub fn scalarType(ty: Type, zcu: *Zcu) Type {
-    const mod = pt.zcu;
+    const ip = &zcu.intern_pool;
-    const ip = &mod.intern_pool;
+    switch (ty.zigTypeTag(zcu)) {
-    switch (ty.zigTypeTag(mod)) {
         .Struct => {
-            if (mod.typeToPackedStruct(ty)) |packed_struct| {
+            if (zcu.typeToPackedStruct(ty)) |packed_struct| {
-                return scalarType(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), pt);
+                return scalarType(Type.fromInterned(packed_struct.backingIntTypeUnordered(ip)), zcu);
             } else {
-                assert(ty.structFieldCount(mod) == 1);
+                assert(ty.structFieldCount(zcu) == 1);
-                return scalarType(ty.structFieldType(0, mod), pt);
+                return scalarType(ty.fieldType(0, zcu), zcu);
             }
         },
         .Union => {
-            const union_obj = mod.typeToUnion(ty).?;
+            const union_obj = zcu.typeToUnion(ty).?;
             if (union_obj.flagsUnordered(ip).layout != .@"packed") {
-                const layout = pt.getUnionLayout(union_obj);
+                const layout = Type.getUnionLayout(union_obj, zcu);
                 if (layout.payload_size == 0 and layout.tag_size != 0) {
-                    return scalarType(ty.unionTagTypeSafety(mod).?, pt);
+                    return scalarType(ty.unionTagTypeSafety(zcu).?, zcu);
                 }
                 assert(union_obj.field_types.len == 1);
             }
             const first_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[0]);
-            return scalarType(first_field_ty, pt);
+            return scalarType(first_field_ty, zcu);
         },
         else => return ty,
     }

src/arch/x86_64/CodeGen.zig+727-723

 @@ -732,14 +732,14 @@ const FrameAlloc = struct {
             .ref_count = 0,
         };
     }
-    fn initType(ty: Type, pt: Zcu.PerThread) FrameAlloc {
+    fn initType(ty: Type, zcu: *Zcu) FrameAlloc {
         return init(.{
-            .size = ty.abiSize(pt),
+            .size = ty.abiSize(zcu),
-            .alignment = ty.abiAlignment(pt),
+            .alignment = ty.abiAlignment(zcu),
         });
     }
-    fn initSpill(ty: Type, pt: Zcu.PerThread) FrameAlloc {
+    fn initSpill(ty: Type, zcu: *Zcu) FrameAlloc {
-        const abi_size = ty.abiSize(pt);
+        const abi_size = ty.abiSize(zcu);
         const spill_size = if (abi_size < 8)
             math.ceilPowerOfTwoAssert(u64, abi_size)
         else
 @@ -747,7 +747,7 @@ const FrameAlloc = struct {
         return init(.{
             .size = spill_size,
             .pad = @intCast(spill_size - abi_size),
-            .alignment = ty.abiAlignment(pt).maxStrict(
+            .alignment = ty.abiAlignment(zcu).maxStrict(
                 Alignment.fromNonzeroByteUnits(@min(spill_size, 8)),
             ),
         });
 @@ -756,7 +756,7 @@ const FrameAlloc = struct {
 const StackAllocation = struct {
     inst: ?Air.Inst.Index,
-    /// TODO do we need size? should be determined by inst.ty.abiSize(pt)
+    /// TODO do we need size? should be determined by inst.ty.abiSize(zcu)
     size: u32,
 };
 @@ -859,11 +859,11 @@ pub fn generate(
     function.args = call_info.args;
     function.ret_mcv = call_info.return_value;
     function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), FrameAlloc.init(.{
-        .size = Type.usize.abiSize(pt),
+        .size = Type.usize.abiSize(zcu),
-        .alignment = Type.usize.abiAlignment(pt).min(call_info.stack_align),
+        .alignment = Type.usize.abiAlignment(zcu).min(call_info.stack_align),
     }));
     function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), FrameAlloc.init(.{
-        .size = Type.usize.abiSize(pt),
+        .size = Type.usize.abiSize(zcu),
         .alignment = Alignment.min(
             call_info.stack_align,
             Alignment.fromNonzeroByteUnits(function.target.stackAlignment()),
 @@ -1872,8 +1872,8 @@ fn asmMemoryRegisterImmediate(
 fn gen(self: *Self) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const fn_info = mod.typeToFunc(self.fn_type).?;
+    const fn_info = zcu.typeToFunc(self.fn_type).?;
     const cc = abi.resolveCallingConvention(fn_info.cc, self.target.*);
     if (cc != .Naked) {
         try self.asmRegister(.{ ._, .push }, .rbp);
 @@ -1890,7 +1890,7 @@ fn gen(self: *Self) InnerError!void {
                 // The address where to store the return value for the caller is in a
                 // register which the callee is free to clobber. Therefore, we purposely
                 // spill it to stack immediately.
-                const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(Type.usize, pt));
+                const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(Type.usize, zcu));
                 try self.genSetMem(
                     .{ .frame = frame_index },
                     0,
 @@ -2099,8 +2099,8 @@ fn checkInvariantsAfterAirInst(self: *Self, inst: Air.Inst.Index, old_air_bookke
 fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const air_tags = self.air.instructions.items(.tag);
     self.arg_index = 0;
 @@ -2370,9 +2370,9 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
 fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (Type.fromInterned(lazy_sym.ty).zigTypeTag(mod)) {
+    switch (Type.fromInterned(lazy_sym.ty).zigTypeTag(zcu)) {
         .Enum => {
             const enum_ty = Type.fromInterned(lazy_sym.ty);
             wip_mir_log.debug("{}.@tagName:", .{enum_ty.fmt(pt)});
 @@ -2385,7 +2385,7 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
             const ret_reg = param_regs[0];
             const enum_mcv = MCValue{ .register = param_regs[1] };
-            const exitlude_jump_relocs = try self.gpa.alloc(Mir.Inst.Index, enum_ty.enumFieldCount(mod));
+            const exitlude_jump_relocs = try self.gpa.alloc(Mir.Inst.Index, enum_ty.enumFieldCount(zcu));
             defer self.gpa.free(exitlude_jump_relocs);
             const data_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
 @@ -2394,7 +2394,7 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
             try self.genLazySymbolRef(.lea, data_reg, .{ .kind = .const_data, .ty = enum_ty.toIntern() });
             var data_off: i32 = 0;
-            const tag_names = enum_ty.enumFields(mod);
+            const tag_names = enum_ty.enumFields(zcu);
             for (exitlude_jump_relocs, 0..) |*exitlude_jump_reloc, tag_index| {
                 const tag_name_len = tag_names.get(ip)[tag_index].length(ip);
                 const tag_val = try pt.enumValueFieldIndex(enum_ty, @intCast(tag_index));
 @@ -2630,14 +2630,14 @@ fn allocFrameIndex(self: *Self, alloc: FrameAlloc) !FrameIndex {
 /// Use a pointer instruction as the basis for allocating stack memory.
 fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !FrameIndex {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_ty = self.typeOfIndex(inst);
-    const val_ty = ptr_ty.childType(mod);
+    const val_ty = ptr_ty.childType(zcu);
     return self.allocFrameIndex(FrameAlloc.init(.{
-        .size = math.cast(u32, val_ty.abiSize(pt)) orelse {
+        .size = math.cast(u32, val_ty.abiSize(zcu)) orelse {
             return self.fail("type '{}' too big to fit into stack frame", .{val_ty.fmt(pt)});
         },
-        .alignment = ptr_ty.ptrAlignment(pt).max(.@"1"),
+        .alignment = ptr_ty.ptrAlignment(zcu).max(.@"1"),
     }));
 }
 @@ -2651,20 +2651,20 @@ fn allocTempRegOrMem(self: *Self, elem_ty: Type, reg_ok: bool) !MCValue {
 fn allocRegOrMemAdvanced(self: *Self, ty: Type, inst: ?Air.Inst.Index, reg_ok: bool) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = math.cast(u32, ty.abiSize(pt)) orelse {
+    const abi_size = math.cast(u32, ty.abiSize(zcu)) orelse {
         return self.fail("type '{}' too big to fit into stack frame", .{ty.fmt(pt)});
     };
     if (reg_ok) need_mem: {
-        if (abi_size <= @as(u32, switch (ty.zigTypeTag(mod)) {
+        if (abi_size <= @as(u32, switch (ty.zigTypeTag(zcu)) {
             .Float => switch (ty.floatBits(self.target.*)) {
                 16, 32, 64, 128 => 16,
                 80 => break :need_mem,
                 else => unreachable,
             },
-            .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+            .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
                     16, 32, 64, 128 => if (self.hasFeature(.avx)) 32 else 16,
                     80 => break :need_mem,
                     else => unreachable,
 @@ -2679,21 +2679,21 @@ fn allocRegOrMemAdvanced(self: *Self, ty: Type, inst: ?Air.Inst.Index, reg_ok: b
         }
     }
-    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, pt));
+    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, zcu));
     return .{ .load_frame = .{ .index = frame_index } };
 }
 fn regClassForType(self: *Self, ty: Type) RegisterManager.RegisterBitSet {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .Float => switch (ty.floatBits(self.target.*)) {
             80 => abi.RegisterClass.x87,
             else => abi.RegisterClass.sse,
         },
-        .Vector => switch (ty.childType(mod).toIntern()) {
+        .Vector => switch (ty.childType(zcu).toIntern()) {
             .bool_type, .u1_type => abi.RegisterClass.gp,
-            else => if (ty.isAbiInt(mod) and ty.intInfo(mod).bits == 1)
+            else => if (ty.isAbiInt(zcu) and ty.intInfo(zcu).bits == 1)
                 abi.RegisterClass.gp
             else
                 abi.RegisterClass.sse,
 @@ -3001,13 +3001,13 @@ fn airFptrunc(self: *Self, inst: Air.Inst.Index) !void {
 fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
-    const dst_scalar_ty = dst_ty.scalarType(mod);
+    const dst_scalar_ty = dst_ty.scalarType(zcu);
     const dst_bits = dst_scalar_ty.floatBits(self.target.*);
     const src_ty = self.typeOf(ty_op.operand);
-    const src_scalar_ty = src_ty.scalarType(mod);
+    const src_scalar_ty = src_ty.scalarType(zcu);
     const src_bits = src_scalar_ty.floatBits(self.target.*);
     const result = result: {
 @@ -3032,7 +3032,7 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
             },
             else => unreachable,
         }) {
-            if (dst_ty.isVector(mod)) break :result null;
+            if (dst_ty.isVector(zcu)) break :result null;
             var callee_buf: ["__extend?f?f2".len]u8 = undefined;
             break :result try self.genCall(.{ .lib = .{
                 .return_type = self.floatCompilerRtAbiType(dst_scalar_ty, src_scalar_ty).toIntern(),
 @@ -3044,18 +3044,18 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
             } }, &.{src_scalar_ty}, &.{.{ .air_ref = ty_op.operand }});
         }
-        const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+        const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
         const src_mcv = try self.resolveInst(ty_op.operand);
         const dst_mcv = if (src_mcv.isRegister() and self.reuseOperand(inst, ty_op.operand, 0, src_mcv))
             src_mcv
         else
             try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
         const dst_reg = dst_mcv.getReg().?;
-        const dst_alias = registerAlias(dst_reg, @intCast(@max(dst_ty.abiSize(pt), 16)));
+        const dst_alias = registerAlias(dst_reg, @intCast(@max(dst_ty.abiSize(zcu), 16)));
         const dst_lock = self.register_manager.lockReg(dst_reg);
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        const vec_len = if (dst_ty.isVector(mod)) dst_ty.vectorLen(mod) else 1;
+        const vec_len = if (dst_ty.isVector(zcu)) dst_ty.vectorLen(zcu) else 1;
         if (src_bits == 16) {
             assert(self.hasFeature(.f16c));
             const mat_src_reg = if (src_mcv.isRegister())
 @@ -3137,30 +3137,30 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) !void {
 fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const src_ty = self.typeOf(ty_op.operand);
     const dst_ty = self.typeOfIndex(inst);
     const result = @as(?MCValue, result: {
-        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-        const src_int_info = src_ty.intInfo(mod);
+        const src_int_info = src_ty.intInfo(zcu);
-        const dst_int_info = dst_ty.intInfo(mod);
+        const dst_int_info = dst_ty.intInfo(zcu);
         const extend = switch (src_int_info.signedness) {
             .signed => dst_int_info,
             .unsigned => src_int_info,
         }.signedness;
         const src_mcv = try self.resolveInst(ty_op.operand);
-        if (dst_ty.isVector(mod)) {
+        if (dst_ty.isVector(zcu)) {
-            const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+            const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
             const max_abi_size = @max(dst_abi_size, src_abi_size);
             if (max_abi_size > @as(u32, if (self.hasFeature(.avx2)) 32 else 16)) break :result null;
             const has_avx = self.hasFeature(.avx);
-            const dst_elem_abi_size = dst_ty.childType(mod).abiSize(pt);
+            const dst_elem_abi_size = dst_ty.childType(zcu).abiSize(zcu);
-            const src_elem_abi_size = src_ty.childType(mod).abiSize(pt);
+            const src_elem_abi_size = src_ty.childType(zcu).abiSize(zcu);
             switch (math.order(dst_elem_abi_size, src_elem_abi_size)) {
                 .lt => {
                     const mir_tag: Mir.Inst.FixedTag = switch (dst_elem_abi_size) {
 @@ -3396,13 +3396,13 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
 fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
-    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
     const src_ty = self.typeOf(ty_op.operand);
-    const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+    const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
     const result = result: {
         const src_mcv = try self.resolveInst(ty_op.operand);
 @@ -3414,7 +3414,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
             src_mcv
         else if (dst_abi_size <= 8)
             try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv)
-        else if (dst_abi_size <= 16 and !dst_ty.isVector(mod)) dst: {
+        else if (dst_abi_size <= 16 and !dst_ty.isVector(zcu)) dst: {
             const dst_regs =
                 try self.register_manager.allocRegs(2, .{ inst, inst }, abi.RegisterClass.gp);
             const dst_mcv: MCValue = .{ .register_pair = dst_regs };
 @@ -3429,16 +3429,16 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
             break :dst dst_mcv;
         };
-        if (dst_ty.zigTypeTag(mod) == .Vector) {
+        if (dst_ty.zigTypeTag(zcu) == .Vector) {
-            assert(src_ty.zigTypeTag(mod) == .Vector and dst_ty.vectorLen(mod) == src_ty.vectorLen(mod));
+            assert(src_ty.zigTypeTag(zcu) == .Vector and dst_ty.vectorLen(zcu) == src_ty.vectorLen(zcu));
-            const dst_elem_ty = dst_ty.childType(mod);
+            const dst_elem_ty = dst_ty.childType(zcu);
-            const dst_elem_abi_size: u32 = @intCast(dst_elem_ty.abiSize(pt));
+            const dst_elem_abi_size: u32 = @intCast(dst_elem_ty.abiSize(zcu));
-            const src_elem_ty = src_ty.childType(mod);
+            const src_elem_ty = src_ty.childType(zcu);
-            const src_elem_abi_size: u32 = @intCast(src_elem_ty.abiSize(pt));
+            const src_elem_abi_size: u32 = @intCast(src_elem_ty.abiSize(zcu));
             const mir_tag = @as(?Mir.Inst.FixedTag, switch (dst_elem_abi_size) {
                 1 => switch (src_elem_abi_size) {
-                    2 => switch (dst_ty.vectorLen(mod)) {
+                    2 => switch (dst_ty.vectorLen(zcu)) {
                         1...8 => if (self.hasFeature(.avx)) .{ .vp_b, .ackusw } else .{ .p_b, .ackusw },
                         9...16 => if (self.hasFeature(.avx2)) .{ .vp_b, .ackusw } else null,
                         else => null,
 @@ -3446,7 +3446,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
                     else => null,
                 },
                 2 => switch (src_elem_abi_size) {
-                    4 => switch (dst_ty.vectorLen(mod)) {
+                    4 => switch (dst_ty.vectorLen(zcu)) {
                         1...4 => if (self.hasFeature(.avx))
                             .{ .vp_w, .ackusd }
                         else if (self.hasFeature(.sse4_1))
 @@ -3461,8 +3461,8 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
                 else => null,
             }) orelse return self.fail("TODO implement airTrunc for {}", .{dst_ty.fmt(pt)});
-            const dst_info = dst_elem_ty.intInfo(mod);
+            const dst_info = dst_elem_ty.intInfo(zcu);
-            const src_info = src_elem_ty.intInfo(mod);
+            const src_info = src_elem_ty.intInfo(zcu);
             const mask_val = try pt.intValue(src_elem_ty, @as(u64, math.maxInt(u64)) >> @intCast(64 - dst_info.bits));
 @@ -3470,7 +3470,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
                 .len = @intCast(@divExact(@as(u64, if (src_abi_size > 16) 256 else 128), src_info.bits)),
                 .child = src_elem_ty.ip_index,
             });
-            const splat_abi_size: u32 = @intCast(splat_ty.abiSize(pt));
+            const splat_abi_size: u32 = @intCast(splat_ty.abiSize(zcu));
             const splat_val = try pt.intern(.{ .aggregate = .{
                 .ty = splat_ty.ip_index,
 @@ -3528,7 +3528,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
                 try self.truncateRegister(dst_ty, dst_mcv.register.to64());
             }
         } else if (dst_abi_size <= 16) {
-            const dst_info = dst_ty.intInfo(mod);
+            const dst_info = dst_ty.intInfo(zcu);
             const high_ty = try pt.intType(dst_info.signedness, dst_info.bits - 64);
             if (self.regExtraBits(high_ty) > 0) {
                 try self.truncateRegister(high_ty, dst_mcv.register_pair[1].to64());
 @@ -3554,12 +3554,12 @@ fn airIntFromBool(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const slice_ty = self.typeOfIndex(inst);
-    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(slice_ty, pt));
+    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(slice_ty, zcu));
     const ptr_ty = self.typeOf(bin_op.lhs);
     try self.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, .{ .air_ref = bin_op.lhs }, .{});
 @@ -3567,7 +3567,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
     const len_ty = self.typeOf(bin_op.rhs);
     try self.genSetMem(
         .{ .frame = frame_index },
-        @intCast(ptr_ty.abiSize(pt)),
+        @intCast(ptr_ty.abiSize(zcu)),
         len_ty,
         .{ .air_ref = bin_op.rhs },
         .{},
 @@ -3585,14 +3585,14 @@ fn airUnOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
 fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const dst_mcv = try self.genBinOp(inst, tag, bin_op.lhs, bin_op.rhs);
     const dst_ty = self.typeOfIndex(inst);
-    if (dst_ty.isAbiInt(mod)) {
+    if (dst_ty.isAbiInt(zcu)) {
-        const abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+        const abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-        const bit_size: u32 = @intCast(dst_ty.bitSize(pt));
+        const bit_size: u32 = @intCast(dst_ty.bitSize(zcu));
         if (abi_size * 8 > bit_size) {
             const dst_lock = switch (dst_mcv) {
                 .register => |dst_reg| self.register_manager.lockRegAssumeUnused(dst_reg),
 @@ -3607,7 +3607,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
                 const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                 defer self.register_manager.unlockReg(tmp_lock);
-                const hi_ty = try pt.intType(.unsigned, @intCast((dst_ty.bitSize(pt) - 1) % 64 + 1));
+                const hi_ty = try pt.intType(.unsigned, @intCast((dst_ty.bitSize(zcu) - 1) % 64 + 1));
                 const hi_mcv = dst_mcv.address().offset(@intCast(bit_size / 64 * 8)).deref();
                 try self.genSetReg(tmp_reg, hi_ty, hi_mcv, .{});
                 try self.truncateRegister(dst_ty, tmp_reg);
 @@ -3627,17 +3627,17 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void
 fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const air_tag = self.air.instructions.items(.tag);
     const air_data = self.air.instructions.items(.data);
     const dst_ty = self.typeOf(dst_air);
-    const dst_info = dst_ty.intInfo(mod);
+    const dst_info = dst_ty.intInfo(zcu);
     if (dst_air.toIndex()) |inst| {
         switch (air_tag[@intFromEnum(inst)]) {
             .intcast => {
                 const src_ty = self.typeOf(air_data[@intFromEnum(inst)].ty_op.operand);
-                const src_info = src_ty.intInfo(mod);
+                const src_info = src_ty.intInfo(zcu);
                 return @min(switch (src_info.signedness) {
                     .signed => switch (dst_info.signedness) {
                         .signed => src_info.bits,
 @@ -3653,7 +3653,7 @@ fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
         }
     } else if (dst_air.toInterned()) |ip_index| {
         var space: Value.BigIntSpace = undefined;
-        const src_int = Value.fromInterned(ip_index).toBigInt(&space, pt);
+        const src_int = Value.fromInterned(ip_index).toBigInt(&space, zcu);
         return @as(u16, @intCast(src_int.bitCountTwosComp())) +
             @intFromBool(src_int.positive and dst_info.signedness == .signed);
     }
 @@ -3662,18 +3662,18 @@ fn activeIntBits(self: *Self, dst_air: Air.Inst.Ref) u16 {
 fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const result = result: {
         const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
         const dst_ty = self.typeOfIndex(inst);
-        switch (dst_ty.zigTypeTag(mod)) {
+        switch (dst_ty.zigTypeTag(zcu)) {
             .Float, .Vector => break :result try self.genBinOp(inst, tag, bin_op.lhs, bin_op.rhs),
             else => {},
         }
-        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-        const dst_info = dst_ty.intInfo(mod);
+        const dst_info = dst_ty.intInfo(zcu);
         const src_ty = try pt.intType(dst_info.signedness, switch (tag) {
             else => unreachable,
             .mul, .mul_wrap => @max(
 @@ -3683,20 +3683,20 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
             ),
             .div_trunc, .div_floor, .div_exact, .rem, .mod => dst_info.bits,
         });
-        const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+        const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
         if (dst_abi_size == 16 and src_abi_size == 16) switch (tag) {
             else => unreachable,
             .mul, .mul_wrap => {},
             .div_trunc, .div_floor, .div_exact, .rem, .mod => {
-                const signed = dst_ty.isSignedInt(mod);
+                const signed = dst_ty.isSignedInt(zcu);
                 var callee_buf: ["__udiv?i3".len]u8 = undefined;
                 const signed_div_floor_state: struct {
                     frame_index: FrameIndex,
                     state: State,
                     reloc: Mir.Inst.Index,
                 } = if (signed and tag == .div_floor) state: {
-                    const frame_index = try self.allocFrameIndex(FrameAlloc.initType(Type.usize, pt));
+                    const frame_index = try self.allocFrameIndex(FrameAlloc.initType(Type.usize, zcu));
                     try self.asmMemoryImmediate(
                         .{ ._, .mov },
                         .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .qword } } },
 @@ -3771,7 +3771,7 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
                                 .rem, .mod => "mod",
                                 else => unreachable,
                             },
-                            intCompilerRtAbiName(@intCast(dst_ty.bitSize(pt))),
+                            intCompilerRtAbiName(@intCast(dst_ty.bitSize(zcu))),
                         }) catch unreachable,
                     } },
                     &.{ src_ty, src_ty },
 @@ -3800,7 +3800,7 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
                                 .return_type = dst_ty.toIntern(),
                                 .param_types = &.{ src_ty.toIntern(), src_ty.toIntern() },
                                 .callee = std.fmt.bufPrint(&callee_buf, "__div{c}i3", .{
-                                    intCompilerRtAbiName(@intCast(dst_ty.bitSize(pt))),
+                                    intCompilerRtAbiName(@intCast(dst_ty.bitSize(zcu))),
                                 }) catch unreachable,
                             } },
                             &.{ src_ty, src_ty },
 @@ -3892,10 +3892,10 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
 fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ty = self.typeOf(bin_op.lhs);
-    if (ty.zigTypeTag(mod) == .Vector or ty.abiSize(pt) > 8) return self.fail(
+    if (ty.zigTypeTag(zcu) == .Vector or ty.abiSize(zcu) > 8) return self.fail(
         "TODO implement airAddSat for {}",
         .{ty.fmt(pt)},
     );
 @@ -3923,7 +3923,7 @@ fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
     const reg_bits = self.regBitSize(ty);
     const reg_extra_bits = self.regExtraBits(ty);
-    const cc: Condition = if (ty.isSignedInt(mod)) cc: {
+    const cc: Condition = if (ty.isSignedInt(zcu)) cc: {
         if (reg_extra_bits > 0) {
             try self.genShiftBinOpMir(
                 .{ ._l, .sa },
 @@ -3962,7 +3962,7 @@ fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
         break :cc .o;
     } else cc: {
         try self.genSetReg(limit_reg, ty, .{
-            .immediate = @as(u64, math.maxInt(u64)) >> @intCast(64 - ty.bitSize(pt)),
+            .immediate = @as(u64, math.maxInt(u64)) >> @intCast(64 - ty.bitSize(zcu)),
         }, .{});
         try self.genBinOpMir(.{ ._, .add }, ty, dst_mcv, rhs_mcv);
 @@ -3973,14 +3973,14 @@ fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
         break :cc .c;
     };
-    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(pt))), 2);
+    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(zcu))), 2);
     try self.asmCmovccRegisterRegister(
         cc,
         registerAlias(dst_reg, cmov_abi_size),
         registerAlias(limit_reg, cmov_abi_size),
     );
-    if (reg_extra_bits > 0 and ty.isSignedInt(mod)) try self.genShiftBinOpMir(
+    if (reg_extra_bits > 0 and ty.isSignedInt(zcu)) try self.genShiftBinOpMir(
         .{ ._r, .sa },
         ty,
         dst_mcv,
 @@ -3993,10 +3993,10 @@ fn airAddSat(self: *Self, inst: Air.Inst.Index) !void {
 fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ty = self.typeOf(bin_op.lhs);
-    if (ty.zigTypeTag(mod) == .Vector or ty.abiSize(pt) > 8) return self.fail(
+    if (ty.zigTypeTag(zcu) == .Vector or ty.abiSize(zcu) > 8) return self.fail(
         "TODO implement airSubSat for {}",
         .{ty.fmt(pt)},
     );
 @@ -4024,7 +4024,7 @@ fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
     const reg_bits = self.regBitSize(ty);
     const reg_extra_bits = self.regExtraBits(ty);
-    const cc: Condition = if (ty.isSignedInt(mod)) cc: {
+    const cc: Condition = if (ty.isSignedInt(zcu)) cc: {
         if (reg_extra_bits > 0) {
             try self.genShiftBinOpMir(
                 .{ ._l, .sa },
 @@ -4067,14 +4067,14 @@ fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
         break :cc .c;
     };
-    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(pt))), 2);
+    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(zcu))), 2);
     try self.asmCmovccRegisterRegister(
         cc,
         registerAlias(dst_reg, cmov_abi_size),
         registerAlias(limit_reg, cmov_abi_size),
     );
-    if (reg_extra_bits > 0 and ty.isSignedInt(mod)) try self.genShiftBinOpMir(
+    if (reg_extra_bits > 0 and ty.isSignedInt(zcu)) try self.genShiftBinOpMir(
         .{ ._r, .sa },
         ty,
         dst_mcv,
 @@ -4087,7 +4087,7 @@ fn airSubSat(self: *Self, inst: Air.Inst.Index) !void {
 fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ty = self.typeOf(bin_op.lhs);
 @@ -4170,7 +4170,7 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
             break :result dst_mcv;
         }
-        if (ty.zigTypeTag(mod) == .Vector or ty.abiSize(pt) > 8) return self.fail(
+        if (ty.zigTypeTag(zcu) == .Vector or ty.abiSize(zcu) > 8) return self.fail(
             "TODO implement airMulSat for {}",
             .{ty.fmt(pt)},
         );
 @@ -4199,7 +4199,7 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
         defer self.register_manager.unlockReg(limit_lock);
         const reg_bits = self.regBitSize(ty);
-        const cc: Condition = if (ty.isSignedInt(mod)) cc: {
+        const cc: Condition = if (ty.isSignedInt(zcu)) cc: {
             try self.genSetReg(limit_reg, ty, lhs_mcv, .{});
             try self.genBinOpMir(.{ ._, .xor }, ty, limit_mcv, rhs_mcv);
             try self.genShiftBinOpMir(
 @@ -4221,7 +4221,7 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
         };
         const dst_mcv = try self.genMulDivBinOp(.mul, inst, ty, ty, lhs_mcv, rhs_mcv);
-        const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(pt))), 2);
+        const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(zcu))), 2);
         try self.asmCmovccRegisterRegister(
             cc,
             registerAlias(dst_mcv.register, cmov_abi_size),
 @@ -4234,13 +4234,13 @@ fn airMulSat(self: *Self, inst: Air.Inst.Index) !void {
 fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const result: MCValue = result: {
         const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
         const ty = self.typeOf(bin_op.lhs);
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement add/sub with overflow for Vector type", .{}),
             .Int => {
                 try self.spillEflagsIfOccupied();
 @@ -4253,7 +4253,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     .sub_with_overflow => .sub,
                     else => unreachable,
                 }, bin_op.lhs, bin_op.rhs);
-                const int_info = ty.intInfo(mod);
+                const int_info = ty.intInfo(zcu);
                 const cc: Condition = switch (int_info.signedness) {
                     .unsigned => .c,
                     .signed => .o,
 @@ -4270,17 +4270,17 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     }
                     const frame_index =
-                        try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                        try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                     try self.genSetMem(
                         .{ .frame = frame_index },
-                        @intCast(tuple_ty.structFieldOffset(1, pt)),
+                        @intCast(tuple_ty.structFieldOffset(1, zcu)),
                         Type.u1,
                         .{ .eflags = cc },
                         .{},
                     );
                     try self.genSetMem(
                         .{ .frame = frame_index },
-                        @intCast(tuple_ty.structFieldOffset(0, pt)),
+                        @intCast(tuple_ty.structFieldOffset(0, zcu)),
                         ty,
                         partial_mcv,
                         .{},
 @@ -4289,7 +4289,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                 }
                 const frame_index =
-                    try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                    try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                 try self.genSetFrameTruncatedOverflowCompare(tuple_ty, frame_index, partial_mcv, cc);
                 break :result .{ .load_frame = .{ .index = frame_index } };
             },
 @@ -4301,13 +4301,13 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
 fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const result: MCValue = result: {
         const lhs_ty = self.typeOf(bin_op.lhs);
         const rhs_ty = self.typeOf(bin_op.rhs);
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Vector => return self.fail("TODO implement shl with overflow for Vector type", .{}),
             .Int => {
                 try self.spillEflagsIfOccupied();
 @@ -4318,7 +4318,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                 const lhs = try self.resolveInst(bin_op.lhs);
                 const rhs = try self.resolveInst(bin_op.rhs);
-                const int_info = lhs_ty.intInfo(mod);
+                const int_info = lhs_ty.intInfo(zcu);
                 const partial_mcv = try self.genShiftBinOp(.shl, null, lhs, rhs, lhs_ty, rhs_ty);
                 const partial_lock = switch (partial_mcv) {
 @@ -4348,18 +4348,18 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     }
                     const frame_index =
-                        try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                        try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                     try self.genSetMem(
                         .{ .frame = frame_index },
-                        @intCast(tuple_ty.structFieldOffset(1, pt)),
+                        @intCast(tuple_ty.structFieldOffset(1, zcu)),
-                        tuple_ty.structFieldType(1, mod),
+                        tuple_ty.fieldType(1, zcu),
                         .{ .eflags = cc },
                         .{},
                     );
                     try self.genSetMem(
                         .{ .frame = frame_index },
-                        @intCast(tuple_ty.structFieldOffset(0, pt)),
+                        @intCast(tuple_ty.structFieldOffset(0, zcu)),
-                        tuple_ty.structFieldType(0, mod),
+                        tuple_ty.fieldType(0, zcu),
                         partial_mcv,
                         .{},
                     );
 @@ -4367,7 +4367,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                 }
                 const frame_index =
-                    try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                    try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                 try self.genSetFrameTruncatedOverflowCompare(tuple_ty, frame_index, partial_mcv, cc);
                 break :result .{ .load_frame = .{ .index = frame_index } };
             },
 @@ -4385,15 +4385,15 @@ fn genSetFrameTruncatedOverflowCompare(
     overflow_cc: ?Condition,
 ) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const src_lock = switch (src_mcv) {
         .register => |reg| self.register_manager.lockReg(reg),
         else => null,
     };
     defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
-    const ty = tuple_ty.structFieldType(0, mod);
+    const ty = tuple_ty.fieldType(0, zcu);
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const hi_bits = (int_info.bits - 1) % 64 + 1;
     const hi_ty = try pt.intType(int_info.signedness, hi_bits);
 @@ -4432,7 +4432,7 @@ fn genSetFrameTruncatedOverflowCompare(
         );
     }
-    const payload_off: i32 = @intCast(tuple_ty.structFieldOffset(0, pt));
+    const payload_off: i32 = @intCast(tuple_ty.structFieldOffset(0, zcu));
     if (hi_limb_off > 0) try self.genSetMem(
         .{ .frame = frame_index },
         payload_off,
 @@ -4449,8 +4449,8 @@ fn genSetFrameTruncatedOverflowCompare(
     );
     try self.genSetMem(
         .{ .frame = frame_index },
-        @intCast(tuple_ty.structFieldOffset(1, pt)),
+        @intCast(tuple_ty.structFieldOffset(1, zcu)),
-        tuple_ty.structFieldType(1, mod),
+        tuple_ty.fieldType(1, zcu),
         if (overflow_cc) |_| .{ .register = overflow_reg.to8() } else .{ .eflags = .ne },
         .{},
     );
 @@ -4458,18 +4458,18 @@ fn genSetFrameTruncatedOverflowCompare(
 fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
     const tuple_ty = self.typeOfIndex(inst);
     const dst_ty = self.typeOf(bin_op.lhs);
-    const result: MCValue = switch (dst_ty.zigTypeTag(mod)) {
+    const result: MCValue = switch (dst_ty.zigTypeTag(zcu)) {
         .Vector => return self.fail("TODO implement airMulWithOverflow for {}", .{dst_ty.fmt(pt)}),
         .Int => result: {
-            const dst_info = dst_ty.intInfo(mod);
+            const dst_info = dst_ty.intInfo(zcu);
             if (dst_info.bits > 128 and dst_info.signedness == .unsigned) {
                 const slow_inc = self.hasFeature(.slow_incdec);
-                const abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+                const abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
                 const limb_len = math.divCeil(u32, abi_size, 8) catch unreachable;
                 try self.spillRegisters(&.{ .rax, .rcx, .rdx });
 @@ -4480,7 +4480,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                 try self.genInlineMemset(
                     dst_mcv.address(),
                     .{ .immediate = 0 },
-                    .{ .immediate = tuple_ty.abiSize(pt) },
+                    .{ .immediate = tuple_ty.abiSize(zcu) },
                     .{},
                 );
                 const lhs_mcv = try self.resolveInst(bin_op.lhs);
 @@ -4520,7 +4520,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         .index = temp_regs[3].to64(),
                         .scale = .@"8",
                         .disp = dst_mcv.load_frame.off +
-                            @as(i32, @intCast(tuple_ty.structFieldOffset(0, pt))),
+                            @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
                     } },
                 }, .rdx);
                 try self.asmSetccRegister(.c, .cl);
 @@ -4544,7 +4544,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         .index = temp_regs[3].to64(),
                         .scale = .@"8",
                         .disp = dst_mcv.load_frame.off +
-                            @as(i32, @intCast(tuple_ty.structFieldOffset(0, pt))),
+                            @as(i32, @intCast(tuple_ty.structFieldOffset(0, zcu))),
                     } },
                 }, .rax);
                 try self.asmSetccRegister(.c, .ch);
 @@ -4593,7 +4593,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     .mod = .{ .rm = .{
                         .size = .byte,
                         .disp = dst_mcv.load_frame.off +
-                            @as(i32, @intCast(tuple_ty.structFieldOffset(1, pt))),
+                            @as(i32, @intCast(tuple_ty.structFieldOffset(1, zcu))),
                     } },
                 }, Immediate.u(1));
                 self.performReloc(no_overflow);
 @@ -4636,8 +4636,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     const dst_mcv = try self.allocRegOrMem(inst, false);
                     try self.genSetMem(
                         .{ .frame = dst_mcv.load_frame.index },
-                        @intCast(tuple_ty.structFieldOffset(0, pt)),
+                        @intCast(tuple_ty.structFieldOffset(0, zcu)),
-                        tuple_ty.structFieldType(0, mod),
+                        tuple_ty.fieldType(0, zcu),
                         result,
                         .{},
                     );
 @@ -4648,8 +4648,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     );
                     try self.genSetMem(
                         .{ .frame = dst_mcv.load_frame.index },
-                        @intCast(tuple_ty.structFieldOffset(1, pt)),
+                        @intCast(tuple_ty.structFieldOffset(1, zcu)),
-                        tuple_ty.structFieldType(1, mod),
+                        tuple_ty.fieldType(1, zcu),
                         .{ .eflags = .ne },
                         .{},
                     );
 @@ -4760,15 +4760,15 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     const dst_mcv = try self.allocRegOrMem(inst, false);
                     try self.genSetMem(
                         .{ .frame = dst_mcv.load_frame.index },
-                        @intCast(tuple_ty.structFieldOffset(0, pt)),
+                        @intCast(tuple_ty.structFieldOffset(0, zcu)),
-                        tuple_ty.structFieldType(0, mod),
+                        tuple_ty.fieldType(0, zcu),
                         .{ .register_pair = .{ .rax, .rdx } },
                         .{},
                     );
                     try self.genSetMem(
                         .{ .frame = dst_mcv.load_frame.index },
-                        @intCast(tuple_ty.structFieldOffset(1, pt)),
+                        @intCast(tuple_ty.structFieldOffset(1, zcu)),
-                        tuple_ty.structFieldType(1, mod),
+                        tuple_ty.fieldType(1, zcu),
                         .{ .register = tmp_regs[1] },
                         .{},
                     );
 @@ -4800,7 +4800,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     self.eflags_inst = inst;
                     break :result .{ .register_overflow = .{ .reg = reg, .eflags = cc } };
                 } else {
-                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                     try self.genSetFrameTruncatedOverflowCompare(tuple_ty, frame_index, partial_mcv, cc);
                     break :result .{ .load_frame = .{ .index = frame_index } };
                 },
 @@ -4811,19 +4811,19 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                             src_ty.fmt(pt), dst_ty.fmt(pt),
                         });
-                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, pt));
+                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(tuple_ty, zcu));
                     if (dst_info.bits >= lhs_active_bits + rhs_active_bits) {
                         try self.genSetMem(
                             .{ .frame = frame_index },
-                            @intCast(tuple_ty.structFieldOffset(0, pt)),
+                            @intCast(tuple_ty.structFieldOffset(0, zcu)),
-                            tuple_ty.structFieldType(0, mod),
+                            tuple_ty.fieldType(0, zcu),
                             partial_mcv,
                             .{},
                         );
                         try self.genSetMem(
                             .{ .frame = frame_index },
-                            @intCast(tuple_ty.structFieldOffset(1, pt)),
+                            @intCast(tuple_ty.structFieldOffset(1, zcu)),
-                            tuple_ty.structFieldType(1, mod),
+                            tuple_ty.fieldType(1, zcu),
                             .{ .immediate = 0 }, // cc being set is impossible
                             .{},
                         );
 @@ -4847,7 +4847,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
 /// Quotient is saved in .rax and remainder in .rdx.
 fn genIntMulDivOpMir(self: *Self, tag: Mir.Inst.FixedTag, ty: Type, lhs: MCValue, rhs: MCValue) !void {
     const pt = self.pt;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(pt.zcu));
     const bit_size: u32 = @intCast(self.regBitSize(ty));
     if (abi_size > 8) {
         return self.fail("TODO implement genIntMulDivOpMir for ABI size larger than 8", .{});
 @@ -4897,9 +4897,9 @@ fn genIntMulDivOpMir(self: *Self, tag: Mir.Inst.FixedTag, ty: Type, lhs: MCValue
 /// Clobbers .rax and .rdx registers.
 fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
-    const int_info = ty.intInfo(mod);
+    const int_info = ty.intInfo(zcu);
     const dividend = switch (lhs) {
         .register => |reg| reg,
         else => try self.copyToTmpRegister(ty, lhs),
 @@ -4950,7 +4950,7 @@ fn genInlineIntDivFloor(self: *Self, ty: Type, lhs: MCValue, rhs: MCValue) !MCVa
 fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const air_tags = self.air.instructions.items(.tag);
 @@ -4958,7 +4958,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
     const lhs_ty = self.typeOf(bin_op.lhs);
     const rhs_ty = self.typeOf(bin_op.rhs);
     const result: MCValue = result: {
-        switch (lhs_ty.zigTypeTag(mod)) {
+        switch (lhs_ty.zigTypeTag(zcu)) {
             .Int => {
                 try self.spillRegisters(&.{.rcx});
                 try self.register_manager.getKnownReg(.rcx, null);
 @@ -4977,7 +4977,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                             const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                             defer self.register_manager.unlockReg(tmp_lock);
-                            const lhs_bits: u31 = @intCast(lhs_ty.bitSize(pt));
+                            const lhs_bits: u31 = @intCast(lhs_ty.bitSize(zcu));
                             const tmp_ty = if (lhs_bits > 64) Type.usize else lhs_ty;
                             const off = frame_addr.off + (lhs_bits - 1) / 64 * 8;
                             try self.genSetReg(
 @@ -5001,14 +5001,14 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                 }
                 break :result dst_mcv;
             },
-            .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+            .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                .Int => if (@as(?Mir.Inst.FixedTag, switch (lhs_ty.childType(mod).intInfo(mod).bits) {
+                .Int => if (@as(?Mir.Inst.FixedTag, switch (lhs_ty.childType(zcu).intInfo(zcu).bits) {
                     else => null,
-                    16 => switch (lhs_ty.vectorLen(mod)) {
+                    16 => switch (lhs_ty.vectorLen(zcu)) {
                         else => null,
                         1...8 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx))
                                     .{ .vp_w, .sra }
                                 else
 @@ -5025,18 +5025,18 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                         },
                         9...16 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx2)) .{ .vp_w, .sra } else null,
                                 .unsigned => if (self.hasFeature(.avx2)) .{ .vp_w, .srl } else null,
                             },
                             .shl, .shl_exact => if (self.hasFeature(.avx2)) .{ .vp_w, .sll } else null,
                         },
                     },
-                    32 => switch (lhs_ty.vectorLen(mod)) {
+                    32 => switch (lhs_ty.vectorLen(zcu)) {
                         else => null,
                         1...4 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx))
                                     .{ .vp_d, .sra }
                                 else
 @@ -5053,18 +5053,18 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                         },
                         5...8 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx2)) .{ .vp_d, .sra } else null,
                                 .unsigned => if (self.hasFeature(.avx2)) .{ .vp_d, .srl } else null,
                             },
                             .shl, .shl_exact => if (self.hasFeature(.avx2)) .{ .vp_d, .sll } else null,
                         },
                     },
-                    64 => switch (lhs_ty.vectorLen(mod)) {
+                    64 => switch (lhs_ty.vectorLen(zcu)) {
                         else => null,
                         1...2 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx))
                                     .{ .vp_q, .sra }
                                 else
 @@ -5081,7 +5081,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                         },
                         3...4 => switch (tag) {
                             else => unreachable,
-                            .shr, .shr_exact => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                            .shr, .shr_exact => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                                 .signed => if (self.hasFeature(.avx2)) .{ .vp_q, .sra } else null,
                                 .unsigned => if (self.hasFeature(.avx2)) .{ .vp_q, .srl } else null,
                             },
 @@ -5089,10 +5089,10 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                         },
                     },
                 })) |mir_tag| if (try self.air.value(bin_op.rhs, pt)) |rhs_val| {
-                    switch (mod.intern_pool.indexToKey(rhs_val.toIntern())) {
+                    switch (zcu.intern_pool.indexToKey(rhs_val.toIntern())) {
                         .aggregate => |rhs_aggregate| switch (rhs_aggregate.storage) {
                             .repeated_elem => |rhs_elem| {
-                                const abi_size: u32 = @intCast(lhs_ty.abiSize(pt));
+                                const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
                                 const lhs_mcv = try self.resolveInst(bin_op.lhs);
                                 const dst_reg, const lhs_reg = if (lhs_mcv.isRegister() and
 @@ -5112,7 +5112,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                                     self.register_manager.unlockReg(lock);
                                 const shift_imm =
-                                    Immediate.u(@intCast(Value.fromInterned(rhs_elem).toUnsignedInt(pt)));
+                                    Immediate.u(@intCast(Value.fromInterned(rhs_elem).toUnsignedInt(zcu)));
                                 if (self.hasFeature(.avx)) try self.asmRegisterRegisterImmediate(
                                     mir_tag,
                                     registerAlias(dst_reg, abi_size),
 @@ -5134,7 +5134,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                     }
                 } else if (bin_op.rhs.toIndex()) |rhs_inst| switch (air_tags[@intFromEnum(rhs_inst)]) {
                     .splat => {
-                        const abi_size: u32 = @intCast(lhs_ty.abiSize(pt));
+                        const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
                         const lhs_mcv = try self.resolveInst(bin_op.lhs);
                         const dst_reg, const lhs_reg = if (lhs_mcv.isRegister() and
 @@ -5161,7 +5161,7 @@ fn airShlShrBinOp(self: *Self, inst: Air.Inst.Index) !void {
                         const mask_mcv = try self.genTypedValue(Value.fromInterned(try pt.intern(.{ .aggregate = .{
                             .ty = mask_ty.toIntern(),
                             .storage = .{ .elems = &([1]InternPool.Index{
-                                (try rhs_ty.childType(mod).maxIntScalar(pt, Type.u8)).toIntern(),
+                                (try rhs_ty.childType(zcu).maxIntScalar(pt, Type.u8)).toIntern(),
                             } ++ [1]InternPool.Index{
                                 (try pt.intValue(Type.u8, 0)).toIntern(),
                             } ** 15) },
 @@ -5224,11 +5224,11 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const pl_ty = self.typeOfIndex(inst);
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const opt_mcv = try self.resolveInst(ty_op.operand);
         if (self.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) {
 @@ -5271,15 +5271,15 @@ fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result = result: {
         const dst_ty = self.typeOfIndex(inst);
         const src_ty = self.typeOf(ty_op.operand);
-        const opt_ty = src_ty.childType(mod);
+        const opt_ty = src_ty.childType(zcu);
         const src_mcv = try self.resolveInst(ty_op.operand);
-        if (opt_ty.optionalReprIsPayload(mod)) {
+        if (opt_ty.optionalReprIsPayload(zcu)) {
             break :result if (self.liveness.isUnused(inst))
                 .unreach
             else if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv))
 @@ -5296,8 +5296,8 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
         else
             try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
-        const pl_ty = dst_ty.childType(mod);
+        const pl_ty = dst_ty.childType(zcu);
-        const pl_abi_size: i32 = @intCast(pl_ty.abiSize(pt));
+        const pl_abi_size: i32 = @intCast(pl_ty.abiSize(zcu));
         try self.genSetMem(
             .{ .reg = dst_mcv.getReg().? },
             pl_abi_size,
 @@ -5312,23 +5312,23 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
 fn airUnwrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const err_union_ty = self.typeOf(ty_op.operand);
-    const err_ty = err_union_ty.errorUnionSet(mod);
+    const err_ty = err_union_ty.errorUnionSet(zcu);
-    const payload_ty = err_union_ty.errorUnionPayload(mod);
+    const payload_ty = err_union_ty.errorUnionPayload(zcu);
     const operand = try self.resolveInst(ty_op.operand);
     const result: MCValue = result: {
-        if (err_ty.errorSetIsEmpty(mod)) {
+        if (err_ty.errorSetIsEmpty(zcu)) {
             break :result MCValue{ .immediate = 0 };
         }
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             break :result operand;
         }
-        const err_off = errUnionErrorOffset(payload_ty, pt);
+        const err_off = errUnionErrorOffset(payload_ty, zcu);
         switch (operand) {
             .register => |reg| {
                 // TODO reuse operand
 @@ -5366,7 +5366,7 @@ fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
 // *(E!T) -> E
 fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const src_ty = self.typeOf(ty_op.operand);
 @@ -5383,11 +5383,11 @@ fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {
     const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
     defer self.register_manager.unlockReg(dst_lock);
-    const eu_ty = src_ty.childType(mod);
+    const eu_ty = src_ty.childType(zcu);
-    const pl_ty = eu_ty.errorUnionPayload(mod);
+    const pl_ty = eu_ty.errorUnionPayload(zcu);
-    const err_ty = eu_ty.errorUnionSet(mod);
+    const err_ty = eu_ty.errorUnionSet(zcu);
-    const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+    const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
-    const err_abi_size: u32 = @intCast(err_ty.abiSize(pt));
+    const err_abi_size: u32 = @intCast(err_ty.abiSize(zcu));
     try self.asmRegisterMemory(
         .{ ._, .mov },
         registerAlias(dst_reg, err_abi_size),
 @@ -5414,7 +5414,7 @@ fn airUnwrapErrUnionPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const src_ty = self.typeOf(ty_op.operand);
 @@ -5426,11 +5426,11 @@ fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
         const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
         defer self.register_manager.unlockReg(src_lock);
-        const eu_ty = src_ty.childType(mod);
+        const eu_ty = src_ty.childType(zcu);
-        const pl_ty = eu_ty.errorUnionPayload(mod);
+        const pl_ty = eu_ty.errorUnionPayload(zcu);
-        const err_ty = eu_ty.errorUnionSet(mod);
+        const err_ty = eu_ty.errorUnionSet(zcu);
-        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
-        const err_abi_size: u32 = @intCast(err_ty.abiSize(pt));
+        const err_abi_size: u32 = @intCast(err_ty.abiSize(zcu));
         try self.asmMemoryImmediate(
             .{ ._, .mov },
             .{
 @@ -5453,8 +5453,8 @@ fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockReg(dst_reg);
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
-        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+        const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
         try self.asmRegisterMemory(
             .{ ._, .lea },
             registerAlias(dst_reg, dst_abi_size),
 @@ -5475,13 +5475,13 @@ fn genUnwrapErrUnionPayloadMir(
     err_union: MCValue,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const payload_ty = err_union_ty.errorUnionPayload(mod);
+    const payload_ty = err_union_ty.errorUnionPayload(zcu);
     const result: MCValue = result: {
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
-        const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, pt));
+        const payload_off: u31 = @intCast(errUnionPayloadOffset(payload_ty, zcu));
         switch (err_union) {
             .load_frame => |frame_addr| break :result .{ .load_frame = .{
                 .index = frame_addr.index,
 @@ -5525,12 +5525,12 @@ fn genUnwrapErrUnionPayloadPtrMir(
     ptr_mcv: MCValue,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const err_union_ty = ptr_ty.childType(mod);
+    const err_union_ty = ptr_ty.childType(zcu);
-    const payload_ty = err_union_ty.errorUnionPayload(mod);
+    const payload_ty = err_union_ty.errorUnionPayload(zcu);
     const result: MCValue = result: {
-        const payload_off = errUnionPayloadOffset(payload_ty, pt);
+        const payload_off = errUnionPayloadOffset(payload_ty, zcu);
         const result_mcv: MCValue = if (maybe_inst) |inst|
             try self.copyToRegisterWithInstTracking(inst, ptr_ty, ptr_mcv)
         else
 @@ -5560,15 +5560,15 @@ fn airSaveErrReturnTraceIndex(self: *Self, inst: Air.Inst.Index) !void {
 fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         const pl_ty = self.typeOf(ty_op.operand);
-        if (!pl_ty.hasRuntimeBits(pt)) break :result .{ .immediate = 1 };
+        if (!pl_ty.hasRuntimeBits(zcu)) break :result .{ .immediate = 1 };
         const opt_ty = self.typeOfIndex(inst);
         const pl_mcv = try self.resolveInst(ty_op.operand);
-        const same_repr = opt_ty.optionalReprIsPayload(mod);
+        const same_repr = opt_ty.optionalReprIsPayload(zcu);
         if (same_repr and self.reuseOperand(inst, ty_op.operand, 0, pl_mcv)) break :result pl_mcv;
         const pl_lock: ?RegisterLock = switch (pl_mcv) {
 @@ -5581,7 +5581,7 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
         try self.genCopy(pl_ty, opt_mcv, pl_mcv, .{});
         if (!same_repr) {
-            const pl_abi_size: i32 = @intCast(pl_ty.abiSize(pt));
+            const pl_abi_size: i32 = @intCast(pl_ty.abiSize(zcu));
             switch (opt_mcv) {
                 else => unreachable,
 @@ -5615,20 +5615,20 @@ fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
 /// T to E!T
 fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const eu_ty = ty_op.ty.toType();
-    const pl_ty = eu_ty.errorUnionPayload(mod);
+    const pl_ty = eu_ty.errorUnionPayload(zcu);
-    const err_ty = eu_ty.errorUnionSet(mod);
+    const err_ty = eu_ty.errorUnionSet(zcu);
     const operand = try self.resolveInst(ty_op.operand);
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .{ .immediate = 0 };
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .{ .immediate = 0 };
-        const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(eu_ty, pt));
+        const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
-        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
-        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
         try self.genSetMem(.{ .frame = frame_index }, pl_off, pl_ty, operand, .{});
         try self.genSetMem(.{ .frame = frame_index }, err_off, err_ty, .{ .immediate = 0 }, .{});
         break :result .{ .load_frame = .{ .index = frame_index } };
 @@ -5639,19 +5639,19 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
 /// E to E!T
 fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const eu_ty = ty_op.ty.toType();
-    const pl_ty = eu_ty.errorUnionPayload(mod);
+    const pl_ty = eu_ty.errorUnionPayload(zcu);
-    const err_ty = eu_ty.errorUnionSet(mod);
+    const err_ty = eu_ty.errorUnionSet(zcu);
     const result: MCValue = result: {
-        if (!pl_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result try self.resolveInst(ty_op.operand);
+        if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result try self.resolveInst(ty_op.operand);
-        const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(eu_ty, pt));
+        const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(eu_ty, zcu));
-        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, pt));
+        const pl_off: i32 = @intCast(errUnionPayloadOffset(pl_ty, zcu));
-        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, pt));
+        const err_off: i32 = @intCast(errUnionErrorOffset(pl_ty, zcu));
         try self.genSetMem(.{ .frame = frame_index }, pl_off, pl_ty, .undef, .{});
         const operand = try self.resolveInst(ty_op.operand);
         try self.genSetMem(.{ .frame = frame_index }, err_off, err_ty, operand, .{});
 @@ -5719,7 +5719,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
     const dst_lock = self.register_manager.lockReg(dst_reg);
     defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt.zcu));
     try self.asmRegisterMemory(
         .{ ._, .lea },
         registerAlias(dst_reg, dst_abi_size),
 @@ -5767,7 +5767,7 @@ fn elemOffset(self: *Self, index_ty: Type, index: MCValue, elem_size: u64) !Regi
 fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const slice_ty = self.typeOf(lhs);
     const slice_mcv = try self.resolveInst(lhs);
     const slice_mcv_lock: ?RegisterLock = switch (slice_mcv) {
 @@ -5776,9 +5776,9 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
     };
     defer if (slice_mcv_lock) |lock| self.register_manager.unlockReg(lock);
-    const elem_ty = slice_ty.childType(mod);
+    const elem_ty = slice_ty.childType(zcu);
-    const elem_size = elem_ty.abiSize(pt);
+    const elem_size = elem_ty.abiSize(zcu);
-    const slice_ptr_field_type = slice_ty.slicePtrFieldType(mod);
+    const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
     const index_ty = self.typeOf(rhs);
     const index_mcv = try self.resolveInst(rhs);
 @@ -5804,15 +5804,15 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
 fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const result: MCValue = result: {
         const elem_ty = self.typeOfIndex(inst);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const slice_ty = self.typeOf(bin_op.lhs);
-        const slice_ptr_field_type = slice_ty.slicePtrFieldType(mod);
+        const slice_ptr_field_type = slice_ty.slicePtrFieldType(zcu);
         const elem_ptr = try self.genSliceElemPtr(bin_op.lhs, bin_op.rhs);
         const dst_mcv = try self.allocRegOrMem(inst, false);
         try self.load(dst_mcv, slice_ptr_field_type, elem_ptr);
 @@ -5830,12 +5830,12 @@ fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const result: MCValue = result: {
         const array_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = array_ty.childType(mod);
+        const elem_ty = array_ty.childType(zcu);
         const array_mcv = try self.resolveInst(bin_op.lhs);
         const array_lock: ?RegisterLock = switch (array_mcv) {
 @@ -5853,7 +5853,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
         defer if (index_lock) |lock| self.register_manager.unlockReg(lock);
         try self.spillEflagsIfOccupied();
-        if (array_ty.isVector(mod) and elem_ty.bitSize(pt) == 1) {
+        if (array_ty.isVector(zcu) and elem_ty.bitSize(zcu) == 1) {
             const index_reg = switch (index_mcv) {
                 .register => |reg| reg,
                 else => try self.copyToTmpRegister(index_ty, index_mcv),
 @@ -5866,7 +5866,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
                         index_reg.to64(),
                     ),
                     .sse => {
-                        const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, pt));
+                        const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, zcu));
                         try self.genSetMem(.{ .frame = frame_index }, 0, array_ty, array_mcv, .{});
                         try self.asmMemoryRegister(
                             .{ ._, .bt },
 @@ -5904,14 +5904,14 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
             break :result .{ .register = dst_reg };
         }
-        const elem_abi_size = elem_ty.abiSize(pt);
+        const elem_abi_size = elem_ty.abiSize(zcu);
         const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
         const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
         defer self.register_manager.unlockReg(addr_lock);
         switch (array_mcv) {
             .register => {
-                const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, pt));
+                const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, zcu));
                 try self.genSetMem(.{ .frame = frame_index }, 0, array_ty, array_mcv, .{});
                 try self.asmRegisterMemory(
                     .{ ._, .lea },
 @@ -5960,7 +5960,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr_ty = self.typeOf(bin_op.lhs);
 @@ -5968,10 +5968,10 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
     // additional `mov` is needed at the end to get the actual value
     const result = result: {
-        const elem_ty = ptr_ty.elemType2(mod);
+        const elem_ty = ptr_ty.elemType2(zcu);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
-        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(pt));
+        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
         const index_ty = self.typeOf(bin_op.rhs);
         const index_mcv = try self.resolveInst(bin_op.rhs);
         const index_lock = switch (index_mcv) {
 @@ -6011,7 +6011,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
 @@ -6026,15 +6026,15 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
         };
         defer if (base_ptr_lock) |lock| self.register_manager.unlockReg(lock);
-        if (elem_ptr_ty.ptrInfo(mod).flags.vector_index != .none) {
+        if (elem_ptr_ty.ptrInfo(zcu).flags.vector_index != .none) {
             break :result if (self.reuseOperand(inst, extra.lhs, 0, base_ptr_mcv))
                 base_ptr_mcv
             else
                 try self.copyToRegisterWithInstTracking(inst, elem_ptr_ty, base_ptr_mcv);
         }
-        const elem_ty = base_ptr_ty.elemType2(mod);
+        const elem_ty = base_ptr_ty.elemType2(zcu);
-        const elem_abi_size = elem_ty.abiSize(pt);
+        const elem_abi_size = elem_ty.abiSize(zcu);
         const index_ty = self.typeOf(extra.rhs);
         const index_mcv = try self.resolveInst(extra.rhs);
         const index_lock: ?RegisterLock = switch (index_mcv) {
 @@ -6057,12 +6057,12 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     const ptr_union_ty = self.typeOf(bin_op.lhs);
-    const union_ty = ptr_union_ty.childType(mod);
+    const union_ty = ptr_union_ty.childType(zcu);
     const tag_ty = self.typeOf(bin_op.rhs);
-    const layout = union_ty.unionGetLayout(pt);
+    const layout = union_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) {
         return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none });
 @@ -6101,12 +6101,12 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const tag_ty = self.typeOfIndex(inst);
     const union_ty = self.typeOf(ty_op.operand);
-    const layout = union_ty.unionGetLayout(pt);
+    const layout = union_ty.unionGetLayout(zcu);
     if (layout.tag_size == 0) {
         return self.finishAir(inst, .none, .{ ty_op.operand, .none, .none });
 @@ -6120,7 +6120,7 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
     };
     defer if (operand_lock) |lock| self.register_manager.unlockReg(lock);
-    const tag_abi_size = tag_ty.abiSize(pt);
+    const tag_abi_size = tag_ty.abiSize(zcu);
     const dst_mcv: MCValue = blk: {
         switch (operand) {
             .load_frame => |frame_addr| {
 @@ -6159,14 +6159,14 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
 fn airClz(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result = result: {
         try self.spillEflagsIfOccupied();
         const dst_ty = self.typeOfIndex(inst);
         const src_ty = self.typeOf(ty_op.operand);
-        if (src_ty.zigTypeTag(mod) == .Vector) return self.fail("TODO implement airClz for {}", .{
+        if (src_ty.zigTypeTag(zcu) == .Vector) return self.fail("TODO implement airClz for {}", .{
             src_ty.fmt(pt),
         });
 @@ -6186,8 +6186,8 @@ fn airClz(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
         defer self.register_manager.unlockReg(dst_lock);
-        const abi_size: u31 = @intCast(src_ty.abiSize(pt));
+        const abi_size: u31 = @intCast(src_ty.abiSize(zcu));
-        const src_bits: u31 = @intCast(src_ty.bitSize(pt));
+        const src_bits: u31 = @intCast(src_ty.bitSize(zcu));
         const has_lzcnt = self.hasFeature(.lzcnt);
         if (src_bits > @as(u32, if (has_lzcnt) 128 else 64)) {
             const limbs_len = math.divCeil(u32, abi_size, 8) catch unreachable;
 @@ -6297,7 +6297,7 @@ fn airClz(self: *Self, inst: Air.Inst.Index) !void {
         }
         assert(src_bits <= 64);
-        const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(pt))), 2);
+        const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(zcu))), 2);
         if (math.isPowerOfTwo(src_bits)) {
             const imm_reg = try self.copyToTmpRegister(dst_ty, .{
                 .immediate = src_bits ^ (src_bits - 1),
 @@ -6356,14 +6356,14 @@ fn airClz(self: *Self, inst: Air.Inst.Index) !void {
 fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result = result: {
         try self.spillEflagsIfOccupied();
         const dst_ty = self.typeOfIndex(inst);
         const src_ty = self.typeOf(ty_op.operand);
-        if (src_ty.zigTypeTag(mod) == .Vector) return self.fail("TODO implement airCtz for {}", .{
+        if (src_ty.zigTypeTag(zcu) == .Vector) return self.fail("TODO implement airCtz for {}", .{
             src_ty.fmt(pt),
         });
 @@ -6383,8 +6383,8 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockReg(dst_reg);
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        const abi_size: u31 = @intCast(src_ty.abiSize(pt));
+        const abi_size: u31 = @intCast(src_ty.abiSize(zcu));
-        const src_bits: u31 = @intCast(src_ty.bitSize(pt));
+        const src_bits: u31 = @intCast(src_ty.bitSize(zcu));
         const has_bmi = self.hasFeature(.bmi);
         if (src_bits > @as(u32, if (has_bmi) 128 else 64)) {
             const limbs_len = math.divCeil(u32, abi_size, 8) catch unreachable;
 @@ -6505,7 +6505,7 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
             try self.genBinOpMir(.{ ._, .bsf }, wide_ty, dst_mcv, .{ .register = wide_reg });
         } else try self.genBinOpMir(.{ ._, .bsf }, src_ty, dst_mcv, mat_src_mcv);
-        const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(pt))), 2);
+        const cmov_abi_size = @max(@as(u32, @intCast(dst_ty.abiSize(zcu))), 2);
         try self.asmCmovccRegisterRegister(
             .z,
             registerAlias(dst_reg, cmov_abi_size),
 @@ -6518,14 +6518,14 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) !void {
 fn airPopCount(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const result: MCValue = result: {
         try self.spillEflagsIfOccupied();
         const src_ty = self.typeOf(ty_op.operand);
-        const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+        const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
-        if (src_ty.zigTypeTag(mod) == .Vector or src_abi_size > 16)
+        if (src_ty.zigTypeTag(zcu) == .Vector or src_abi_size > 16)
             return self.fail("TODO implement airPopCount for {}", .{src_ty.fmt(pt)});
         const src_mcv = try self.resolveInst(ty_op.operand);
 @@ -6562,7 +6562,7 @@ fn airPopCount(self: *Self, inst: Air.Inst.Index) !void {
             mat_src_mcv
         else
             .{ .register = mat_src_mcv.register_pair[0] }, false);
-        const src_info = src_ty.intInfo(mod);
+        const src_info = src_ty.intInfo(zcu);
         const hi_ty = try pt.intType(src_info.signedness, (src_info.bits - 1) % 64 + 1);
         try self.genPopCount(tmp_regs[1], hi_ty, if (mat_src_mcv.isMemory())
             mat_src_mcv.address().offset(8).deref()
 @@ -6583,7 +6583,7 @@ fn genPopCount(
 ) !void {
     const pt = self.pt;
-    const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+    const src_abi_size: u32 = @intCast(src_ty.abiSize(pt.zcu));
     if (self.hasFeature(.popcnt)) return self.genBinOpMir(
         .{ ._, .popcnt },
         if (src_abi_size > 1) src_ty else Type.u32,
 @@ -6674,11 +6674,11 @@ fn genByteSwap(
     mem_ok: bool,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const has_movbe = self.hasFeature(.movbe);
-    if (src_ty.zigTypeTag(mod) == .Vector) return self.fail(
+    if (src_ty.zigTypeTag(zcu) == .Vector) return self.fail(
         "TODO implement genByteSwap for {}",
         .{src_ty.fmt(pt)},
     );
 @@ -6689,7 +6689,7 @@ fn genByteSwap(
     };
     defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
-    const abi_size: u32 = @intCast(src_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(src_ty.abiSize(zcu));
     switch (abi_size) {
         0 => unreachable,
         1 => return if ((mem_ok or src_mcv.isRegister()) and
 @@ -6838,35 +6838,35 @@ fn genByteSwap(
 fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const src_ty = self.typeOf(ty_op.operand);
-    const src_bits: u32 = @intCast(src_ty.bitSize(pt));
+    const src_bits: u32 = @intCast(src_ty.bitSize(zcu));
     const src_mcv = try self.resolveInst(ty_op.operand);
     const dst_mcv = try self.genByteSwap(inst, src_ty, src_mcv, true);
     try self.genShiftBinOpMir(
-        .{ ._r, switch (if (src_ty.isAbiInt(mod)) src_ty.intInfo(mod).signedness else .unsigned) {
+        .{ ._r, switch (if (src_ty.isAbiInt(zcu)) src_ty.intInfo(zcu).signedness else .unsigned) {
             .signed => .sa,
             .unsigned => .sh,
         } },
         src_ty,
         dst_mcv,
         if (src_bits > 256) Type.u16 else Type.u8,
-        .{ .immediate = src_ty.abiSize(pt) * 8 - src_bits },
+        .{ .immediate = src_ty.abiSize(zcu) * 8 - src_bits },
     );
     return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none });
 }
 fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const src_ty = self.typeOf(ty_op.operand);
-    const abi_size: u32 = @intCast(src_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(src_ty.abiSize(zcu));
-    const bit_size: u32 = @intCast(src_ty.bitSize(pt));
+    const bit_size: u32 = @intCast(src_ty.bitSize(zcu));
     const src_mcv = try self.resolveInst(ty_op.operand);
     const dst_mcv = try self.genByteSwap(inst, src_ty, src_mcv, false);
 @@ -6973,7 +6973,7 @@ fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
     const extra_bits = abi_size * 8 - bit_size;
     const signedness: std.builtin.Signedness =
-        if (src_ty.isAbiInt(mod)) src_ty.intInfo(mod).signedness else .unsigned;
+        if (src_ty.isAbiInt(zcu)) src_ty.intInfo(zcu).signedness else .unsigned;
     if (extra_bits > 0) try self.genShiftBinOpMir(switch (signedness) {
         .signed => .{ ._r, .sa },
         .unsigned => .{ ._r, .sh },
 @@ -6984,13 +6984,13 @@ fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
 fn floatSign(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, ty: Type) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
     const result = result: {
-        const scalar_bits = ty.scalarType(mod).floatBits(self.target.*);
+        const scalar_bits = ty.scalarType(zcu).floatBits(self.target.*);
         if (scalar_bits == 80) {
-            if (ty.zigTypeTag(mod) != .Float) return self.fail("TODO implement floatSign for {}", .{
+            if (ty.zigTypeTag(zcu) != .Float) return self.fail("TODO implement floatSign for {}", .{
                 ty.fmt(pt),
             });
 @@ -7011,7 +7011,7 @@ fn floatSign(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, ty: Type)
             break :result dst_mcv;
         }
-        const abi_size: u32 = switch (ty.abiSize(pt)) {
+        const abi_size: u32 = switch (ty.abiSize(zcu)) {
             1...16 => 16,
             17...32 => 32,
             else => return self.fail("TODO implement floatSign for {}", .{
 @@ -7161,23 +7161,23 @@ fn airRound(self: *Self, inst: Air.Inst.Index, mode: RoundMode) !void {
 fn getRoundTag(self: *Self, ty: Type) ?Mir.Inst.FixedTag {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return if (self.hasFeature(.sse4_1)) switch (ty.zigTypeTag(mod)) {
+    return if (self.hasFeature(.sse4_1)) switch (ty.zigTypeTag(zcu)) {
         .Float => switch (ty.floatBits(self.target.*)) {
             32 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },
             64 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round },
             16, 80, 128 => null,
             else => unreachable,
         },
-        .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+        .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-            .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+            .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                32 => switch (ty.vectorLen(mod)) {
+                32 => switch (ty.vectorLen(zcu)) {
                     1 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },
                     2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else .{ ._ps, .round },
                     5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else null,
                     else => null,
                 },
-                64 => switch (ty.vectorLen(mod)) {
+                64 => switch (ty.vectorLen(zcu)) {
                     1 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round },
                     2 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else .{ ._pd, .round },
                     3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else null,
 @@ -7194,10 +7194,10 @@ fn getRoundTag(self: *Self, ty: Type) ?Mir.Inst.FixedTag {
 fn genRoundLibcall(self: *Self, ty: Type, src_mcv: MCValue, mode: RoundMode) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     if (self.getRoundTag(ty)) |_| return .none;
-    if (ty.zigTypeTag(mod) != .Float)
+    if (ty.zigTypeTag(zcu) != .Float)
         return self.fail("TODO implement genRound for {}", .{ty.fmt(pt)});
     var callee_buf: ["__trunc?".len]u8 = undefined;
 @@ -7223,7 +7223,7 @@ fn genRound(self: *Self, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: Ro
         const result = try self.genRoundLibcall(ty, src_mcv, mode);
         return self.genSetReg(dst_reg, ty, result, .{});
     };
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(pt.zcu));
     const dst_alias = registerAlias(dst_reg, abi_size);
     switch (mir_tag[0]) {
         .v_ss, .v_sd => if (src_mcv.isMemory()) try self.asmRegisterRegisterMemoryImmediate(
 @@ -7261,14 +7261,14 @@ fn genRound(self: *Self, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: Ro
 fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const ty = self.typeOf(ty_op.operand);
     const result: MCValue = result: {
-        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(mod)) {
+        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(zcu)) {
             else => null,
-            .Int => switch (ty.abiSize(pt)) {
+            .Int => switch (ty.abiSize(zcu)) {
                 0 => unreachable,
                 1...8 => {
                     try self.spillEflagsIfOccupied();
 @@ -7277,7 +7277,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                     try self.genUnOpMir(.{ ._, .neg }, ty, dst_mcv);
-                    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(pt))), 2);
+                    const cmov_abi_size = @max(@as(u32, @intCast(ty.abiSize(zcu))), 2);
                     switch (src_mcv) {
                         .register => |val_reg| try self.asmCmovccRegisterRegister(
                             .l,
 @@ -7336,7 +7336,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                     break :result dst_mcv;
                 },
                 else => {
-                    const abi_size: u31 = @intCast(ty.abiSize(pt));
+                    const abi_size: u31 = @intCast(ty.abiSize(zcu));
                     const limb_len = math.divCeil(u31, abi_size, 8) catch unreachable;
                     const tmp_regs =
 @@ -7397,11 +7397,11 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                 },
             },
             .Float => return self.floatSign(inst, ty_op.operand, ty),
-            .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+            .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
                 else => null,
-                .Int => switch (ty.childType(mod).intInfo(mod).bits) {
+                .Int => switch (ty.childType(zcu).intInfo(zcu).bits) {
                     else => null,
-                    8 => switch (ty.vectorLen(mod)) {
+                    8 => switch (ty.vectorLen(zcu)) {
                         else => null,
                         1...16 => if (self.hasFeature(.avx))
                             .{ .vp_b, .abs }
 @@ -7411,7 +7411,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                             null,
                         17...32 => if (self.hasFeature(.avx2)) .{ .vp_b, .abs } else null,
                     },
-                    16 => switch (ty.vectorLen(mod)) {
+                    16 => switch (ty.vectorLen(zcu)) {
                         else => null,
                         1...8 => if (self.hasFeature(.avx))
                             .{ .vp_w, .abs }
 @@ -7421,7 +7421,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                             null,
                         9...16 => if (self.hasFeature(.avx2)) .{ .vp_w, .abs } else null,
                     },
-                    32 => switch (ty.vectorLen(mod)) {
+                    32 => switch (ty.vectorLen(zcu)) {
                         else => null,
                         1...4 => if (self.hasFeature(.avx))
                             .{ .vp_d, .abs }
 @@ -7436,7 +7436,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
             },
         }) orelse return self.fail("TODO implement airAbs for {}", .{ty.fmt(pt)});
-        const abi_size: u32 = @intCast(ty.abiSize(pt));
+        const abi_size: u32 = @intCast(ty.abiSize(zcu));
         const src_mcv = try self.resolveInst(ty_op.operand);
         const dst_reg = if (src_mcv.isRegister() and self.reuseOperand(inst, ty_op.operand, 0, src_mcv))
             src_mcv.getReg().?
 @@ -7462,13 +7462,13 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
 fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const ty = self.typeOf(un_op);
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const result: MCValue = result: {
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             .Float => {
                 const float_bits = ty.floatBits(self.target.*);
                 if (switch (float_bits) {
 @@ -7500,7 +7500,7 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockReg(dst_reg);
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(mod)) {
+        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(zcu)) {
             .Float => switch (ty.floatBits(self.target.*)) {
                 16 => {
                     assert(self.hasFeature(.f16c));
 @@ -7522,9 +7522,9 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
                 64 => if (self.hasFeature(.avx)) .{ .v_sd, .sqrt } else .{ ._sd, .sqrt },
                 else => unreachable,
             },
-            .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+            .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                    16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen(mod)) {
+                    16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen(zcu)) {
                         1 => {
                             try self.asmRegisterRegister(
                                 .{ .v_ps, .cvtph2 },
 @@ -7575,13 +7575,13 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
                         },
                         else => null,
                     } else null,
-                    32 => switch (ty.vectorLen(mod)) {
+                    32 => switch (ty.vectorLen(zcu)) {
                         1 => if (self.hasFeature(.avx)) .{ .v_ss, .sqrt } else .{ ._ss, .sqrt },
                         2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else .{ ._ps, .sqrt },
                         5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else null,
                         else => null,
                     },
-                    64 => switch (ty.vectorLen(mod)) {
+                    64 => switch (ty.vectorLen(zcu)) {
                         1 => if (self.hasFeature(.avx)) .{ .v_sd, .sqrt } else .{ ._sd, .sqrt },
                         2 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else .{ ._pd, .sqrt },
                         3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else null,
 @@ -7708,14 +7708,14 @@ fn reuseOperandAdvanced(
 fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ptr_info = ptr_ty.ptrInfo(mod);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
     const val_ty = Type.fromInterned(ptr_info.child);
-    if (!val_ty.hasRuntimeBitsIgnoreComptime(pt)) return;
+    if (!val_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
-    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt));
+    const val_abi_size: u32 = @intCast(val_ty.abiSize(zcu));
-    const val_bit_size: u32 = @intCast(val_ty.bitSize(pt));
+    const val_bit_size: u32 = @intCast(val_ty.bitSize(zcu));
     const ptr_bit_off = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) {
         .none => 0,
         .runtime => unreachable,
 @@ -7821,9 +7821,9 @@ fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) Inn
 fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const dst_ty = ptr_ty.childType(mod);
+    const dst_ty = ptr_ty.childType(zcu);
-    if (!dst_ty.hasRuntimeBitsIgnoreComptime(pt)) return;
+    if (!dst_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
 @@ -7864,18 +7864,18 @@ fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerErro
 fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const elem_ty = self.typeOfIndex(inst);
     const result: MCValue = result: {
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
         const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx });
         defer for (reg_locks) |lock| self.register_manager.unlockReg(lock);
         const ptr_ty = self.typeOf(ty_op.operand);
-        const elem_size = elem_ty.abiSize(pt);
+        const elem_size = elem_ty.abiSize(zcu);
         const elem_rc = self.regClassForType(elem_ty);
         const ptr_rc = self.regClassForType(ptr_ty);
 @@ -7888,14 +7888,14 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
         else
             try self.allocRegOrMem(inst, true);
-        const ptr_info = ptr_ty.ptrInfo(mod);
+        const ptr_info = ptr_ty.ptrInfo(zcu);
         if (ptr_info.flags.vector_index != .none or ptr_info.packed_offset.host_size > 0) {
             try self.packedLoad(dst_mcv, ptr_ty, ptr_mcv);
         } else {
             try self.load(dst_mcv, ptr_ty, ptr_mcv);
         }
-        if (elem_ty.isAbiInt(mod) and elem_size * 8 > elem_ty.bitSize(pt)) {
+        if (elem_ty.isAbiInt(zcu) and elem_size * 8 > elem_ty.bitSize(zcu)) {
             const high_mcv: MCValue = switch (dst_mcv) {
                 .register => |dst_reg| .{ .register = dst_reg },
                 .register_pair => |dst_regs| .{ .register = dst_regs[1] },
 @@ -7923,16 +7923,16 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
 fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ptr_info = ptr_ty.ptrInfo(mod);
+    const ptr_info = ptr_ty.ptrInfo(zcu);
     const src_ty = Type.fromInterned(ptr_info.child);
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(pt)) return;
+    if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
     const limb_abi_size: u16 = @min(ptr_info.packed_offset.host_size, 8);
     const limb_abi_bits = limb_abi_size * 8;
     const limb_ty = try pt.intType(.unsigned, limb_abi_bits);
-    const src_bit_size = src_ty.bitSize(pt);
+    const src_bit_size = src_ty.bitSize(zcu);
     const ptr_bit_off = ptr_info.packed_offset.bit_offset + switch (ptr_info.flags.vector_index) {
         .none => 0,
         .runtime => unreachable,
 @@ -8029,9 +8029,9 @@ fn store(
     opts: CopyOptions,
 ) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const src_ty = ptr_ty.childType(mod);
+    const src_ty = ptr_ty.childType(zcu);
-    if (!src_ty.hasRuntimeBitsIgnoreComptime(pt)) return;
+    if (!src_ty.hasRuntimeBitsIgnoreComptime(zcu)) return;
     switch (ptr_mcv) {
         .none,
         .unreach,
 @@ -8072,7 +8072,7 @@ fn store(
 fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     result: {
 @@ -8086,7 +8086,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
         const ptr_mcv = try self.resolveInst(bin_op.lhs);
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const ptr_info = ptr_ty.ptrInfo(mod);
+        const ptr_info = ptr_ty.ptrInfo(zcu);
         if (ptr_info.flags.vector_index != .none or ptr_info.packed_offset.host_size > 0) {
             try self.packedStore(ptr_ty, ptr_mcv, src_mcv);
         } else {
 @@ -8111,16 +8111,16 @@ fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void {
 fn fieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_field_ty = self.typeOfIndex(inst);
     const ptr_container_ty = self.typeOf(operand);
-    const container_ty = ptr_container_ty.childType(mod);
+    const container_ty = ptr_container_ty.childType(zcu);
-    const field_off: i32 = switch (container_ty.containerLayout(mod)) {
+    const field_off: i32 = switch (container_ty.containerLayout(zcu)) {
-        .auto, .@"extern" => @intCast(container_ty.structFieldOffset(index, pt)),
+        .auto, .@"extern" => @intCast(container_ty.structFieldOffset(index, zcu)),
-        .@"packed" => @divExact(@as(i32, ptr_container_ty.ptrInfo(mod).packed_offset.bit_offset) +
+        .@"packed" => @divExact(@as(i32, ptr_container_ty.ptrInfo(zcu).packed_offset.bit_offset) +
-            (if (mod.typeToStruct(container_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, index) else 0) -
+            (if (zcu.typeToStruct(container_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, index) else 0) -
-            ptr_field_ty.ptrInfo(mod).packed_offset.bit_offset, 8),
+            ptr_field_ty.ptrInfo(zcu).packed_offset.bit_offset, 8),
     };
     const src_mcv = try self.resolveInst(operand);
 @@ -8134,7 +8134,7 @@ fn fieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32
 fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.StructField, ty_pl.payload).data;
     const result: MCValue = result: {
 @@ -8143,15 +8143,15 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
         const container_ty = self.typeOf(operand);
         const container_rc = self.regClassForType(container_ty);
-        const field_ty = container_ty.structFieldType(index, mod);
+        const field_ty = container_ty.fieldType(index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) break :result .none;
+        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none;
         const field_rc = self.regClassForType(field_ty);
         const field_is_gp = field_rc.supersetOf(abi.RegisterClass.gp);
         const src_mcv = try self.resolveInst(operand);
-        const field_off: u32 = switch (container_ty.containerLayout(mod)) {
+        const field_off: u32 = switch (container_ty.containerLayout(zcu)) {
-            .auto, .@"extern" => @intCast(container_ty.structFieldOffset(extra.field_index, pt) * 8),
+            .auto, .@"extern" => @intCast(container_ty.structFieldOffset(extra.field_index, zcu) * 8),
-            .@"packed" => if (mod.typeToStruct(container_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, extra.field_index) else 0,
+            .@"packed" => if (zcu.typeToStruct(container_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, extra.field_index) else 0,
         };
         switch (src_mcv) {
 @@ -8182,7 +8182,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                     );
                 }
                 if (abi.RegisterClass.gp.isSet(RegisterManager.indexOfRegIntoTracked(dst_reg).?) and
-                    container_ty.abiSize(pt) * 8 > field_ty.bitSize(pt))
+                    container_ty.abiSize(zcu) * 8 > field_ty.bitSize(zcu))
                     try self.truncateRegister(field_ty, dst_reg);
                 break :result if (field_off == 0 or field_rc.supersetOf(abi.RegisterClass.gp))
 @@ -8194,7 +8194,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                 const src_regs_lock = self.register_manager.lockRegsAssumeUnused(2, src_regs);
                 defer for (src_regs_lock) |lock| self.register_manager.unlockReg(lock);
-                const field_bit_size: u32 = @intCast(field_ty.bitSize(pt));
+                const field_bit_size: u32 = @intCast(field_ty.bitSize(zcu));
                 const src_reg = if (field_off + field_bit_size <= 64)
                     src_regs[0]
                 else if (field_off >= 64)
 @@ -8293,15 +8293,15 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                 }
             },
             .load_frame => |frame_addr| {
-                const field_abi_size: u32 = @intCast(field_ty.abiSize(pt));
+                const field_abi_size: u32 = @intCast(field_ty.abiSize(zcu));
                 if (field_off % 8 == 0) {
                     const field_byte_off = @divExact(field_off, 8);
                     const off_mcv = src_mcv.address().offset(@intCast(field_byte_off)).deref();
-                    const field_bit_size = field_ty.bitSize(pt);
+                    const field_bit_size = field_ty.bitSize(zcu);
                     if (field_abi_size <= 8) {
                         const int_ty = try pt.intType(
-                            if (field_ty.isAbiInt(mod)) field_ty.intInfo(mod).signedness else .unsigned,
+                            if (field_ty.isAbiInt(zcu)) field_ty.intInfo(zcu).signedness else .unsigned,
                             @intCast(field_bit_size),
                         );
 @@ -8321,7 +8321,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                             try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv);
                     }
-                    const container_abi_size: u32 = @intCast(container_ty.abiSize(pt));
+                    const container_abi_size: u32 = @intCast(container_ty.abiSize(zcu));
                     const dst_mcv = if (field_byte_off + field_abi_size <= container_abi_size and
                         self.reuseOperand(inst, operand, 0, src_mcv))
                         off_mcv
 @@ -8423,17 +8423,17 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
     const inst_ty = self.typeOfIndex(inst);
-    const parent_ty = inst_ty.childType(mod);
+    const parent_ty = inst_ty.childType(zcu);
-    const field_off: i32 = switch (parent_ty.containerLayout(mod)) {
+    const field_off: i32 = switch (parent_ty.containerLayout(zcu)) {
-        .auto, .@"extern" => @intCast(parent_ty.structFieldOffset(extra.field_index, pt)),
+        .auto, .@"extern" => @intCast(parent_ty.structFieldOffset(extra.field_index, zcu)),
-        .@"packed" => @divExact(@as(i32, inst_ty.ptrInfo(mod).packed_offset.bit_offset) +
+        .@"packed" => @divExact(@as(i32, inst_ty.ptrInfo(zcu).packed_offset.bit_offset) +
-            (if (mod.typeToStruct(parent_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, extra.field_index) else 0) -
+            (if (zcu.typeToStruct(parent_ty)) |struct_obj| pt.structPackedFieldBitOffset(struct_obj, extra.field_index) else 0) -
-            self.typeOf(extra.field_ptr).ptrInfo(mod).packed_offset.bit_offset, 8),
+            self.typeOf(extra.field_ptr).ptrInfo(zcu).packed_offset.bit_offset, 8),
     };
     const src_mcv = try self.resolveInst(extra.field_ptr);
 @@ -8448,9 +8448,9 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn genUnOp(self: *Self, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air: Air.Inst.Ref) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const src_ty = self.typeOf(src_air);
-    if (src_ty.zigTypeTag(mod) == .Vector)
+    if (src_ty.zigTypeTag(zcu) == .Vector)
         return self.fail("TODO implement genUnOp for {}", .{src_ty.fmt(pt)});
     var src_mcv = try self.resolveInst(src_air);
 @@ -8486,14 +8486,14 @@ fn genUnOp(self: *Self, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air:
     };
     defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-    const abi_size: u16 = @intCast(src_ty.abiSize(pt));
+    const abi_size: u16 = @intCast(src_ty.abiSize(zcu));
     switch (tag) {
         .not => {
             const limb_abi_size: u16 = @min(abi_size, 8);
             const int_info = if (src_ty.ip_index == .bool_type)
                 std.builtin.Type.Int{ .signedness = .unsigned, .bits = 1 }
             else
-                src_ty.intInfo(mod);
+                src_ty.intInfo(zcu);
             var byte_off: i32 = 0;
             while (byte_off * 8 < int_info.bits) : (byte_off += limb_abi_size) {
                 const limb_bits: u16 = @intCast(@min(switch (int_info.signedness) {
 @@ -8514,7 +8514,7 @@ fn genUnOp(self: *Self, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air:
         },
         .neg => {
             try self.genUnOpMir(.{ ._, .neg }, src_ty, dst_mcv);
-            const bit_size = src_ty.intInfo(mod).bits;
+            const bit_size = src_ty.intInfo(zcu).bits;
             if (abi_size * 8 > bit_size) {
                 if (dst_mcv.isRegister()) {
                     try self.truncateRegister(src_ty, dst_mcv.getReg().?);
 @@ -8537,7 +8537,7 @@ fn genUnOp(self: *Self, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air:
 fn genUnOpMir(self: *Self, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: MCValue) !void {
     const pt = self.pt;
-    const abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(dst_ty.abiSize(pt.zcu));
     if (abi_size > 8) return self.fail("TODO implement {} for {}", .{ mir_tag, dst_ty.fmt(pt) });
     switch (dst_mcv) {
         .none,
 @@ -8586,8 +8586,9 @@ fn genShiftBinOpMir(
     rhs_mcv: MCValue,
 ) !void {
     const pt = self.pt;
-    const abi_size: u32 = @intCast(lhs_ty.abiSize(pt));
+    const zcu = pt.zcu;
-    const shift_abi_size: u32 = @intCast(rhs_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
+    const shift_abi_size: u32 = @intCast(rhs_ty.abiSize(zcu));
     try self.spillEflagsIfOccupied();
     if (abi_size > 16) {
 @@ -9243,8 +9244,8 @@ fn genShiftBinOp(
     rhs_ty: Type,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (lhs_ty.zigTypeTag(mod) == .Vector) return self.fail("TODO implement genShiftBinOp for {}", .{
+    if (lhs_ty.zigTypeTag(zcu) == .Vector) return self.fail("TODO implement genShiftBinOp for {}", .{
         lhs_ty.fmt(pt),
     });
 @@ -9274,7 +9275,7 @@ fn genShiftBinOp(
         break :dst dst_mcv;
     };
-    const signedness = lhs_ty.intInfo(mod).signedness;
+    const signedness = lhs_ty.intInfo(zcu).signedness;
     try self.genShiftBinOpMir(switch (air_tag) {
         .shl, .shl_exact => switch (signedness) {
             .signed => .{ ._l, .sa },
 @@ -9302,13 +9303,13 @@ fn genMulDivBinOp(
     rhs_mcv: MCValue,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    if (dst_ty.zigTypeTag(mod) == .Vector or dst_ty.zigTypeTag(mod) == .Float) return self.fail(
+    if (dst_ty.zigTypeTag(zcu) == .Vector or dst_ty.zigTypeTag(zcu) == .Float) return self.fail(
         "TODO implement genMulDivBinOp for {s} from {} to {}",
         .{ @tagName(tag), src_ty.fmt(pt), dst_ty.fmt(pt) },
     );
-    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
-    const src_abi_size: u32 = @intCast(src_ty.abiSize(pt));
+    const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu));
     assert(self.register_manager.isRegFree(.rax));
     assert(self.register_manager.isRegFree(.rcx));
 @@ -9384,7 +9385,7 @@ fn genMulDivBinOp(
         .mul, .mul_wrap => dst_abi_size != src_abi_size and dst_abi_size != src_abi_size * 2,
         .div_trunc, .div_floor, .div_exact, .rem, .mod => dst_abi_size != src_abi_size,
     } or src_abi_size > 8) {
-        const src_info = src_ty.intInfo(mod);
+        const src_info = src_ty.intInfo(zcu);
         switch (tag) {
             .mul, .mul_wrap => {
                 const slow_inc = self.hasFeature(.slow_incdec);
 @@ -9555,7 +9556,7 @@ fn genMulDivBinOp(
     const reg_locks = self.register_manager.lockRegs(2, .{ .rax, .rdx });
     defer for (reg_locks) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock);
-    const signedness = ty.intInfo(mod).signedness;
+    const signedness = ty.intInfo(zcu).signedness;
     switch (tag) {
         .mul,
         .mul_wrap,
 @@ -9714,10 +9715,10 @@ fn genBinOp(
     rhs_air: Air.Inst.Ref,
 ) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const lhs_ty = self.typeOf(lhs_air);
     const rhs_ty = self.typeOf(rhs_air);
-    const abi_size: u32 = @intCast(lhs_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
     if (lhs_ty.isRuntimeFloat()) libcall: {
         const float_bits = lhs_ty.floatBits(self.target.*);
 @@ -9889,23 +9890,23 @@ fn genBinOp(
         };
     }
-    const sse_op = switch (lhs_ty.zigTypeTag(mod)) {
+    const sse_op = switch (lhs_ty.zigTypeTag(zcu)) {
         else => false,
         .Float => true,
-        .Vector => switch (lhs_ty.childType(mod).toIntern()) {
+        .Vector => switch (lhs_ty.childType(zcu).toIntern()) {
             .bool_type, .u1_type => false,
             else => true,
         },
     };
-    if (sse_op and ((lhs_ty.scalarType(mod).isRuntimeFloat() and
+    if (sse_op and ((lhs_ty.scalarType(zcu).isRuntimeFloat() and
-        lhs_ty.scalarType(mod).floatBits(self.target.*) == 80) or
+        lhs_ty.scalarType(zcu).floatBits(self.target.*) == 80) or
-        lhs_ty.abiSize(pt) > @as(u6, if (self.hasFeature(.avx)) 32 else 16)))
+        lhs_ty.abiSize(zcu) > @as(u6, if (self.hasFeature(.avx)) 32 else 16)))
         return self.fail("TODO implement genBinOp for {s} {}", .{ @tagName(air_tag), lhs_ty.fmt(pt) });
     const maybe_mask_reg = switch (air_tag) {
         else => null,
         .rem, .mod => unreachable,
-        .max, .min => if (lhs_ty.scalarType(mod).isRuntimeFloat()) registerAlias(
+        .max, .min => if (lhs_ty.scalarType(zcu).isRuntimeFloat()) registerAlias(
             if (!self.hasFeature(.avx) and self.hasFeature(.sse4_1)) mask: {
                 try self.register_manager.getKnownReg(.xmm0, null);
                 break :mask .xmm0;
 @@ -9917,8 +9918,8 @@ fn genBinOp(
         if (maybe_mask_reg) |mask_reg| self.register_manager.lockRegAssumeUnused(mask_reg) else null;
     defer if (mask_lock) |lock| self.register_manager.unlockReg(lock);
-    const ordered_air: [2]Air.Inst.Ref = if (lhs_ty.isVector(mod) and
+    const ordered_air: [2]Air.Inst.Ref = if (lhs_ty.isVector(zcu) and
-        switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+        switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
         .Bool => false,
         .Int => switch (air_tag) {
             .cmp_lt, .cmp_gte => true,
 @@ -9931,7 +9932,7 @@ fn genBinOp(
         else => unreachable,
     }) .{ rhs_air, lhs_air } else .{ lhs_air, rhs_air };
-    if (lhs_ty.isAbiInt(mod)) for (ordered_air) |op_air| {
+    if (lhs_ty.isAbiInt(zcu)) for (ordered_air) |op_air| {
         switch (try self.resolveInst(op_air)) {
             .register => |op_reg| switch (op_reg.class()) {
                 .sse => try self.register_manager.getReg(op_reg, null),
 @@ -10056,7 +10057,7 @@ fn genBinOp(
                 const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                 defer self.register_manager.unlockReg(tmp_lock);
-                const elem_size = lhs_ty.elemType2(mod).abiSize(pt);
+                const elem_size = lhs_ty.elemType2(zcu).abiSize(zcu);
                 try self.genIntMulComplexOpMir(rhs_ty, tmp_mcv, .{ .immediate = elem_size });
                 try self.genBinOpMir(
                     switch (air_tag) {
 @@ -10112,7 +10113,7 @@ fn genBinOp(
                     const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
                     defer self.register_manager.unlockReg(tmp_lock);
-                    const signed = lhs_ty.isSignedInt(mod);
+                    const signed = lhs_ty.isSignedInt(zcu);
                     const cc: Condition = switch (air_tag) {
                         .min => if (signed) .nl else .nb,
                         .max => if (signed) .nge else .nae,
 @@ -10188,7 +10189,7 @@ fn genBinOp(
                     try self.genBinOpMir(.{ ._, .cmp }, lhs_ty, dst_mcv, mat_src_mcv);
-                    const int_info = lhs_ty.intInfo(mod);
+                    const int_info = lhs_ty.intInfo(zcu);
                     const cc: Condition = switch (int_info.signedness) {
                         .unsigned => switch (air_tag) {
                             .min => .a,
 @@ -10202,7 +10203,7 @@ fn genBinOp(
                         },
                     };
-                    const cmov_abi_size = @max(@as(u32, @intCast(lhs_ty.abiSize(pt))), 2);
+                    const cmov_abi_size = @max(@as(u32, @intCast(lhs_ty.abiSize(zcu))), 2);
                     const tmp_reg = switch (dst_mcv) {
                         .register => |reg| reg,
                         else => try self.copyToTmpRegister(lhs_ty, dst_mcv),
 @@ -10271,7 +10272,7 @@ fn genBinOp(
             },
             .cmp_eq, .cmp_neq => {
-                assert(lhs_ty.isVector(mod) and lhs_ty.childType(mod).toIntern() == .bool_type);
+                assert(lhs_ty.isVector(zcu) and lhs_ty.childType(zcu).toIntern() == .bool_type);
                 try self.genBinOpMir(.{ ._, .xor }, lhs_ty, dst_mcv, src_mcv);
                 switch (air_tag) {
                     .cmp_eq => try self.genUnOpMir(.{ ._, .not }, lhs_ty, dst_mcv),
 @@ -10288,7 +10289,7 @@ fn genBinOp(
     }
     const dst_reg = registerAlias(dst_mcv.getReg().?, abi_size);
-    const mir_tag = @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(mod)) {
+    const mir_tag = @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
         else => unreachable,
         .Float => switch (lhs_ty.floatBits(self.target.*)) {
             16 => {
 @@ -10383,10 +10384,10 @@ fn genBinOp(
             80, 128 => null,
             else => unreachable,
         },
-        .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+        .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
             else => null,
-            .Int => switch (lhs_ty.childType(mod).intInfo(mod).bits) {
+            .Int => switch (lhs_ty.childType(zcu).intInfo(zcu).bits) {
-                8 => switch (lhs_ty.vectorLen(mod)) {
+                8 => switch (lhs_ty.vectorLen(zcu)) {
                     1...16 => switch (air_tag) {
                         .add,
                         .add_wrap,
 @@ -10400,7 +10401,7 @@ fn genBinOp(
                             .{ .p_, .@"and" },
                         .bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
                         .xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_b, .mins }
                             else if (self.hasFeature(.sse4_1))
 @@ -10414,7 +10415,7 @@ fn genBinOp(
                             else
                                 null,
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_b, .maxs }
                             else if (self.hasFeature(.sse4_1))
 @@ -10432,7 +10433,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_b, .cmpgt }
                             else
 @@ -10454,11 +10455,11 @@ fn genBinOp(
                         .bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
                         .bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
                         .xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_b, .mins } else null,
                             .unsigned => if (self.hasFeature(.avx)) .{ .vp_b, .minu } else null,
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_b, .maxs } else null,
                             .unsigned => if (self.hasFeature(.avx2)) .{ .vp_b, .maxu } else null,
                         },
 @@ -10466,7 +10467,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx)) .{ .vp_b, .cmpgt } else null,
                             .unsigned => null,
                         },
 @@ -10477,7 +10478,7 @@ fn genBinOp(
                     },
                     else => null,
                 },
-                16 => switch (lhs_ty.vectorLen(mod)) {
+                16 => switch (lhs_ty.vectorLen(zcu)) {
                     1...8 => switch (air_tag) {
                         .add,
                         .add_wrap,
 @@ -10494,7 +10495,7 @@ fn genBinOp(
                             .{ .p_, .@"and" },
                         .bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
                         .xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_w, .mins }
                             else
 @@ -10504,7 +10505,7 @@ fn genBinOp(
                             else
                                 .{ .p_w, .minu },
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_w, .maxs }
                             else
 @@ -10518,7 +10519,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_w, .cmpgt }
                             else
 @@ -10543,11 +10544,11 @@ fn genBinOp(
                         .bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
                         .bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
                         .xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_w, .mins } else null,
                             .unsigned => if (self.hasFeature(.avx)) .{ .vp_w, .minu } else null,
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_w, .maxs } else null,
                             .unsigned => if (self.hasFeature(.avx2)) .{ .vp_w, .maxu } else null,
                         },
 @@ -10555,7 +10556,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx)) .{ .vp_w, .cmpgt } else null,
                             .unsigned => null,
                         },
 @@ -10566,7 +10567,7 @@ fn genBinOp(
                     },
                     else => null,
                 },
-                32 => switch (lhs_ty.vectorLen(mod)) {
+                32 => switch (lhs_ty.vectorLen(zcu)) {
                     1...4 => switch (air_tag) {
                         .add,
                         .add_wrap,
 @@ -10588,7 +10589,7 @@ fn genBinOp(
                             .{ .p_, .@"and" },
                         .bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
                         .xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_d, .mins }
                             else if (self.hasFeature(.sse4_1))
 @@ -10602,7 +10603,7 @@ fn genBinOp(
                             else
                                 null,
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_d, .maxs }
                             else if (self.hasFeature(.sse4_1))
 @@ -10620,7 +10621,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_d, .cmpgt }
                             else
 @@ -10645,11 +10646,11 @@ fn genBinOp(
                         .bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
                         .bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
                         .xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
-                        .min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .min => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_d, .mins } else null,
                             .unsigned => if (self.hasFeature(.avx)) .{ .vp_d, .minu } else null,
                         },
-                        .max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        .max => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx2)) .{ .vp_d, .maxs } else null,
                             .unsigned => if (self.hasFeature(.avx2)) .{ .vp_d, .maxu } else null,
                         },
 @@ -10657,7 +10658,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx)) .{ .vp_d, .cmpgt } else null,
                             .unsigned => null,
                         },
 @@ -10668,7 +10669,7 @@ fn genBinOp(
                     },
                     else => null,
                 },
-                64 => switch (lhs_ty.vectorLen(mod)) {
+                64 => switch (lhs_ty.vectorLen(zcu)) {
                     1...2 => switch (air_tag) {
                         .add,
                         .add_wrap,
 @@ -10686,7 +10687,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gte,
                         .cmp_gt,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx))
                                 .{ .vp_q, .cmpgt }
                             else if (self.hasFeature(.sse4_2))
 @@ -10722,7 +10723,7 @@ fn genBinOp(
                         .cmp_lte,
                         .cmp_gt,
                         .cmp_gte,
-                        => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
+                        => switch (lhs_ty.childType(zcu).intInfo(zcu).signedness) {
                             .signed => if (self.hasFeature(.avx)) .{ .vp_d, .cmpgt } else null,
                             .unsigned => null,
                         },
 @@ -10732,10 +10733,10 @@ fn genBinOp(
                 },
                 else => null,
             },
-            .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+            .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
                 16 => tag: {
                     assert(self.hasFeature(.f16c));
-                    switch (lhs_ty.vectorLen(mod)) {
+                    switch (lhs_ty.vectorLen(zcu)) {
                         1 => {
                             const tmp_reg = (try self.register_manager.allocReg(
                                 null,
 @@ -10923,7 +10924,7 @@ fn genBinOp(
                         else => break :tag null,
                     }
                 },
-                32 => switch (lhs_ty.vectorLen(mod)) {
+                32 => switch (lhs_ty.vectorLen(zcu)) {
                     1 => switch (air_tag) {
                         .add => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add },
                         .sub => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub },
 @@ -10976,7 +10977,7 @@ fn genBinOp(
                     } else null,
                     else => null,
                 },
-                64 => switch (lhs_ty.vectorLen(mod)) {
+                64 => switch (lhs_ty.vectorLen(zcu)) {
                     1 => switch (air_tag) {
                         .add => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add },
                         .sub => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub },
 @@ -11052,7 +11053,7 @@ fn genBinOp(
                 mir_tag,
                 dst_reg,
                 lhs_reg,
-                try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(mod)) {
+                try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(zcu)) {
                     else => Memory.Size.fromSize(abi_size),
                     .Vector => Memory.Size.fromBitSize(dst_reg.bitSize()),
                 }),
 @@ -11070,7 +11071,7 @@ fn genBinOp(
             if (src_mcv.isMemory()) try self.asmRegisterMemory(
                 mir_tag,
                 dst_reg,
-                try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(mod)) {
+                try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(zcu)) {
                     else => Memory.Size.fromSize(abi_size),
                     .Vector => Memory.Size.fromBitSize(dst_reg.bitSize()),
                 }),
 @@ -11098,7 +11099,7 @@ fn genBinOp(
                     mir_tag,
                     dst_reg,
                     lhs_reg,
-                    try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(mod)) {
+                    try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(zcu)) {
                         else => Memory.Size.fromSize(abi_size),
                         .Vector => Memory.Size.fromBitSize(dst_reg.bitSize()),
                     }),
 @@ -11118,7 +11119,7 @@ fn genBinOp(
                 if (src_mcv.isMemory()) try self.asmRegisterMemoryImmediate(
                     mir_tag,
                     dst_reg,
-                    try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(mod)) {
+                    try src_mcv.mem(self, switch (lhs_ty.zigTypeTag(zcu)) {
                         else => Memory.Size.fromSize(abi_size),
                         .Vector => Memory.Size.fromBitSize(dst_reg.bitSize()),
                     }),
 @@ -11151,21 +11152,21 @@ fn genBinOp(
             const rhs_copy_reg = registerAlias(src_mcv.getReg().?, abi_size);
             try self.asmRegisterRegisterRegisterImmediate(
-                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(mod)) {
+                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
                     .Float => switch (lhs_ty.floatBits(self.target.*)) {
                         32 => .{ .v_ss, .cmp },
                         64 => .{ .v_sd, .cmp },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
-                    .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+                    .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+                        .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
-                            32 => switch (lhs_ty.vectorLen(mod)) {
+                            32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ .v_ss, .cmp },
                                 2...8 => .{ .v_ps, .cmp },
                                 else => null,
                             },
-                            64 => switch (lhs_ty.vectorLen(mod)) {
+                            64 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ .v_sd, .cmp },
                                 2...4 => .{ .v_pd, .cmp },
                                 else => null,
 @@ -11185,20 +11186,20 @@ fn genBinOp(
                 Immediate.u(3), // unord
             );
             try self.asmRegisterRegisterRegisterRegister(
-                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(mod)) {
+                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
                     .Float => switch (lhs_ty.floatBits(self.target.*)) {
                         32 => .{ .v_ps, .blendv },
                         64 => .{ .v_pd, .blendv },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
-                    .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+                    .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+                        .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
-                            32 => switch (lhs_ty.vectorLen(mod)) {
+                            32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...8 => .{ .v_ps, .blendv },
                                 else => null,
                             },
-                            64 => switch (lhs_ty.vectorLen(mod)) {
+                            64 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...4 => .{ .v_pd, .blendv },
                                 else => null,
                             },
 @@ -11219,21 +11220,21 @@ fn genBinOp(
         } else {
             const has_blend = self.hasFeature(.sse4_1);
             try self.asmRegisterRegisterImmediate(
-                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(mod)) {
+                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
                     .Float => switch (lhs_ty.floatBits(self.target.*)) {
                         32 => .{ ._ss, .cmp },
                         64 => .{ ._sd, .cmp },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
-                    .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+                    .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+                        .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
-                            32 => switch (lhs_ty.vectorLen(mod)) {
+                            32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ ._ss, .cmp },
                                 2...4 => .{ ._ps, .cmp },
                                 else => null,
                             },
-                            64 => switch (lhs_ty.vectorLen(mod)) {
+                            64 => switch (lhs_ty.vectorLen(zcu)) {
                                 1 => .{ ._sd, .cmp },
                                 2 => .{ ._pd, .cmp },
                                 else => null,
 @@ -11252,20 +11253,20 @@ fn genBinOp(
                 Immediate.u(if (has_blend) 3 else 7), // unord, ord
             );
             if (has_blend) try self.asmRegisterRegisterRegister(
-                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(mod)) {
+                @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) {
                     .Float => switch (lhs_ty.floatBits(self.target.*)) {
                         32 => .{ ._ps, .blendv },
                         64 => .{ ._pd, .blendv },
                         16, 80, 128 => null,
                         else => unreachable,
                     },
-                    .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+                    .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+                        .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
-                            32 => switch (lhs_ty.vectorLen(mod)) {
+                            32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...4 => .{ ._ps, .blendv },
                                 else => null,
                             },
-                            64 => switch (lhs_ty.vectorLen(mod)) {
+                            64 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...2 => .{ ._pd, .blendv },
                                 else => null,
                             },
 @@ -11282,20 +11283,20 @@ fn genBinOp(
                 lhs_copy_reg.?,
                 mask_reg,
             ) else {
-                const mir_fixes = @as(?Mir.Inst.Fixes, switch (lhs_ty.zigTypeTag(mod)) {
+                const mir_fixes = @as(?Mir.Inst.Fixes, switch (lhs_ty.zigTypeTag(zcu)) {
                     .Float => switch (lhs_ty.floatBits(self.target.*)) {
                         32 => ._ps,
                         64 => ._pd,
                         16, 80, 128 => null,
                         else => unreachable,
                     },
-                    .Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+                    .Vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
-                        .Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
+                        .Float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) {
-                            32 => switch (lhs_ty.vectorLen(mod)) {
+                            32 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...4 => ._ps,
                                 else => null,
                             },
-                            64 => switch (lhs_ty.vectorLen(mod)) {
+                            64 => switch (lhs_ty.vectorLen(zcu)) {
                                 1...2 => ._pd,
                                 else => null,
                             },
 @@ -11314,7 +11315,7 @@ fn genBinOp(
             }
         },
         .cmp_lt, .cmp_lte, .cmp_eq, .cmp_gte, .cmp_gt, .cmp_neq => {
-            switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+            switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) {
                 .Int => switch (air_tag) {
                     .cmp_lt,
                     .cmp_eq,
 @@ -11395,8 +11396,8 @@ fn genBinOpMir(
     src_mcv: MCValue,
 ) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     try self.spillEflagsIfOccupied();
     switch (dst_mcv) {
         .none,
 @@ -11643,7 +11644,7 @@ fn genBinOpMir(
             defer if (src_info) |info| self.register_manager.unlockReg(info.addr_lock);
             const ty_signedness =
-                if (ty.isAbiInt(mod)) ty.intInfo(mod).signedness else .unsigned;
+                if (ty.isAbiInt(zcu)) ty.intInfo(zcu).signedness else .unsigned;
             const limb_ty = if (abi_size <= 8) ty else switch (ty_signedness) {
                 .signed => Type.usize,
                 .unsigned => Type.isize,
 @@ -11820,7 +11821,7 @@ fn genBinOpMir(
 /// Does not support byte-size operands.
 fn genIntMulComplexOpMir(self: *Self, dst_ty: Type, dst_mcv: MCValue, src_mcv: MCValue) InnerError!void {
     const pt = self.pt;
-    const abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const abi_size: u32 = @intCast(dst_ty.abiSize(pt.zcu));
     try self.spillEflagsIfOccupied();
     switch (dst_mcv) {
         .none,
 @@ -12009,7 +12010,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
                 try self.genInlineMemset(
                     dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)),
                     .{ .immediate = 0 },
-                    .{ .immediate = arg_ty.abiSize(pt) - @intFromBool(regs_frame_addr.regs > 0) },
+                    .{ .immediate = arg_ty.abiSize(zcu) - @intFromBool(regs_frame_addr.regs > 0) },
                     .{},
                 );
 @@ -12104,7 +12105,7 @@ fn genLocalDebugInfo(
                             self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op.operand,
                         ),
                     };
-                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, self.pt));
+                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ty, self.pt.zcu));
                     try self.genSetMem(.{ .frame = frame_index }, 0, ty, mcv, .{});
                     try self.asmAirMemory(.dbg_local, inst, .{
                         .base = .{ .frame = frame_index },
 @@ -12296,7 +12297,7 @@ fn genCall(self: *Self, info: union(enum) {
                 try reg_locks.appendSlice(&self.register_manager.lockRegs(2, regs));
             },
             .indirect => |reg_off| {
-                frame_index.* = try self.allocFrameIndex(FrameAlloc.initType(arg_ty, pt));
+                frame_index.* = try self.allocFrameIndex(FrameAlloc.initType(arg_ty, zcu));
                 try self.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, .{});
                 try self.register_manager.getReg(reg_off.reg, null);
                 try reg_locks.append(self.register_manager.lockReg(reg_off.reg));
 @@ -12368,7 +12369,7 @@ fn genCall(self: *Self, info: union(enum) {
         .none, .unreach => {},
         .indirect => |reg_off| {
             const ret_ty = Type.fromInterned(fn_info.return_type);
-            const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ret_ty, pt));
+            const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(ret_ty, zcu));
             try self.genSetReg(reg_off.reg, Type.usize, .{
                 .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
             }, .{});
 @@ -12383,14 +12384,14 @@ fn genCall(self: *Self, info: union(enum) {
             .none, .load_frame => {},
             .register => |dst_reg| switch (fn_info.cc) {
                 else => try self.genSetReg(
-                    registerAlias(dst_reg, @intCast(arg_ty.abiSize(pt))),
+                    registerAlias(dst_reg, @intCast(arg_ty.abiSize(zcu))),
                     arg_ty,
                     src_arg,
                     .{},
                 ),
                 .C, .SysV, .Win64 => {
                     const promoted_ty = self.promoteInt(arg_ty);
-                    const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(pt));
+                    const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(zcu));
                     const dst_alias = registerAlias(dst_reg, promoted_abi_size);
                     try self.genSetReg(dst_alias, promoted_ty, src_arg, .{});
                     if (promoted_ty.toIntern() != arg_ty.toIntern())
 @@ -12514,10 +12515,10 @@ fn genCall(self: *Self, info: union(enum) {
 fn airRet(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
-    const ret_ty = self.fn_type.fnReturnType(mod);
+    const ret_ty = self.fn_type.fnReturnType(zcu);
     switch (self.ret_mcv.short) {
         .none => {},
         .register,
 @@ -12570,7 +12571,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
 fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     var ty = self.typeOf(bin_op.lhs);
     var null_compare: ?Mir.Inst.Index = null;
 @@ -12602,7 +12603,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
         };
         defer for (rhs_locks) |rhs_lock| if (rhs_lock) |lock| self.register_manager.unlockReg(lock);
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             .Float => {
                 const float_bits = ty.floatBits(self.target.*);
                 if (switch (float_bits) {
 @@ -12638,11 +12639,11 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
                     };
                 }
             },
-            .Optional => if (!ty.optionalReprIsPayload(mod)) {
+            .Optional => if (!ty.optionalReprIsPayload(zcu)) {
                 const opt_ty = ty;
-                const opt_abi_size: u31 = @intCast(opt_ty.abiSize(pt));
+                const opt_abi_size: u31 = @intCast(opt_ty.abiSize(zcu));
-                ty = opt_ty.optionalChild(mod);
+                ty = opt_ty.optionalChild(zcu);
-                const payload_abi_size: u31 = @intCast(ty.abiSize(pt));
+                const payload_abi_size: u31 = @intCast(ty.abiSize(zcu));
                 const temp_lhs_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
                 const temp_lhs_lock = self.register_manager.lockRegAssumeUnused(temp_lhs_reg);
 @@ -12699,9 +12700,9 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
             else => {},
         }
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             else => {
-                const abi_size: u16 = @intCast(ty.abiSize(pt));
+                const abi_size: u16 = @intCast(ty.abiSize(zcu));
                 const may_flip: enum {
                     may_flip,
                     must_flip,
 @@ -12734,7 +12735,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
                 defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
                 break :result Condition.fromCompareOperator(
-                    if (ty.isAbiInt(mod)) ty.intInfo(mod).signedness else .unsigned,
+                    if (ty.isAbiInt(zcu)) ty.intInfo(zcu).signedness else .unsigned,
                     result_op: {
                         const flipped_op = if (flipped) op.reverse() else op;
                         if (abi_size > 8) switch (flipped_op) {
 @@ -13029,6 +13030,7 @@ fn airCmpVector(self: *Self, inst: Air.Inst.Index) !void {
 fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
 @@ -13040,7 +13042,7 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
     try self.spillEflagsIfOccupied();
     const op_ty = self.typeOf(un_op);
-    const op_abi_size: u32 = @intCast(op_ty.abiSize(pt));
+    const op_abi_size: u32 = @intCast(op_ty.abiSize(zcu));
     const op_mcv = try self.resolveInst(un_op);
     const dst_reg = switch (op_mcv) {
         .register => |reg| reg,
 @@ -13164,7 +13166,7 @@ fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
 fn genCondBrMir(self: *Self, ty: Type, mcv: MCValue) !Mir.Inst.Index {
     const pt = self.pt;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(pt.zcu);
     switch (mcv) {
         .eflags => |cc| {
             // Here we map the opposites since the jump is to the false branch.
 @@ -13237,7 +13239,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
 fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     switch (opt_mcv) {
         .register_overflow => |ro| return .{ .eflags = ro.eflags.negate() },
         else => {},
 @@ -13245,12 +13247,12 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
     try self.spillEflagsIfOccupied();
-    const pl_ty = opt_ty.optionalChild(mod);
+    const pl_ty = opt_ty.optionalChild(zcu);
-    const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))
+    const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu))
-        .{ .off = 0, .ty = if (pl_ty.isSlice(mod)) pl_ty.slicePtrFieldType(mod) else pl_ty }
+        .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty }
     else
-        .{ .off = @intCast(pl_ty.abiSize(pt)), .ty = Type.bool };
+        .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = Type.bool };
     self.eflags_inst = inst;
     switch (opt_mcv) {
 @@ -13279,14 +13281,14 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
         .register => |opt_reg| {
             if (some_info.off == 0) {
-                const some_abi_size: u32 = @intCast(some_info.ty.abiSize(pt));
+                const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
                 const alias_reg = registerAlias(opt_reg, some_abi_size);
                 assert(some_abi_size * 8 == alias_reg.bitSize());
                 try self.asmRegisterRegister(.{ ._, .@"test" }, alias_reg, alias_reg);
                 return .{ .eflags = .z };
             }
             assert(some_info.ty.ip_index == .bool_type);
-            const opt_abi_size: u32 = @intCast(opt_ty.abiSize(pt));
+            const opt_abi_size: u32 = @intCast(opt_ty.abiSize(zcu));
             try self.asmRegisterImmediate(
                 .{ ._, .bt },
                 registerAlias(opt_reg, opt_abi_size),
 @@ -13306,7 +13308,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
             defer self.register_manager.unlockReg(addr_reg_lock);
             try self.genSetReg(addr_reg, Type.usize, opt_mcv.address(), .{});
-            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(pt));
+            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
             try self.asmMemoryImmediate(
                 .{ ._, .cmp },
                 .{
 @@ -13322,7 +13324,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
         },
         .indirect, .load_frame => {
-            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(pt));
+            const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
             try self.asmMemoryImmediate(
                 .{ ._, .cmp },
                 switch (opt_mcv) {
 @@ -13351,16 +13353,16 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
 fn isNullPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const opt_ty = ptr_ty.childType(mod);
+    const opt_ty = ptr_ty.childType(zcu);
-    const pl_ty = opt_ty.optionalChild(mod);
+    const pl_ty = opt_ty.optionalChild(zcu);
     try self.spillEflagsIfOccupied();
-    const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))
+    const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu))
-        .{ .off = 0, .ty = if (pl_ty.isSlice(mod)) pl_ty.slicePtrFieldType(mod) else pl_ty }
+        .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty }
     else
-        .{ .off = @intCast(pl_ty.abiSize(pt)), .ty = Type.bool };
+        .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = Type.bool };
     const ptr_reg = switch (ptr_mcv) {
         .register => |reg| reg,
 @@ -13369,7 +13371,7 @@ fn isNullPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue)
     const ptr_lock = self.register_manager.lockReg(ptr_reg);
     defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);
-    const some_abi_size: u32 = @intCast(some_info.ty.abiSize(pt));
+    const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu));
     try self.asmMemoryImmediate(
         .{ ._, .cmp },
         .{
 @@ -13388,13 +13390,13 @@ fn isNullPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue)
 fn isErr(self: *Self, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const err_ty = eu_ty.errorUnionSet(mod);
+    const err_ty = eu_ty.errorUnionSet(zcu);
-    if (err_ty.errorSetIsEmpty(mod)) return MCValue{ .immediate = 0 }; // always false
+    if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false
     try self.spillEflagsIfOccupied();
-    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(mod), pt));
+    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
     switch (eu_mcv) {
         .register => |reg| {
             const eu_lock = self.register_manager.lockReg(reg);
 @@ -13437,10 +13439,10 @@ fn isErr(self: *Self, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue)
 fn isErrPtr(self: *Self, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const eu_ty = ptr_ty.childType(mod);
+    const eu_ty = ptr_ty.childType(zcu);
-    const err_ty = eu_ty.errorUnionSet(mod);
+    const err_ty = eu_ty.errorUnionSet(zcu);
-    if (err_ty.errorSetIsEmpty(mod)) return MCValue{ .immediate = 0 }; // always false
+    if (err_ty.errorSetIsEmpty(zcu)) return MCValue{ .immediate = 0 }; // always false
     try self.spillEflagsIfOccupied();
 @@ -13451,7 +13453,7 @@ fn isErrPtr(self: *Self, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCV
     const ptr_lock = self.register_manager.lockReg(ptr_reg);
     defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock);
-    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(mod), pt));
+    const err_off: u31 = @intCast(errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
     try self.asmMemoryImmediate(
         .{ ._, .cmp },
         .{
 @@ -13724,12 +13726,12 @@ fn performReloc(self: *Self, reloc: Mir.Inst.Index) void {
 }
 fn airBr(self: *Self, inst: Air.Inst.Index) !void {
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
     const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
     const block_ty = self.typeOfIndex(br.block_inst);
     const block_unused =
-        !block_ty.hasRuntimeBitsIgnoreComptime(pt) or self.liveness.isUnused(br.block_inst);
+        !block_ty.hasRuntimeBitsIgnoreComptime(zcu) or self.liveness.isUnused(br.block_inst);
     const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
     const block_data = self.blocks.getPtr(br.block_inst).?;
     const first_br = block_data.relocs.items.len == 0;
 @@ -13786,7 +13788,7 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
 fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Asm, ty_pl.payload);
     const clobbers_len: u31 = @truncate(extra.data.flags);
 @@ -13825,7 +13827,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
         };
         const ty = switch (output) {
             .none => self.typeOfIndex(inst),
-            else => self.typeOf(output).childType(mod),
+            else => self.typeOf(output).childType(zcu),
         };
         const is_read = switch (constraint[0]) {
             '=' => false,
 @@ -13850,7 +13852,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
                         'x' => abi.RegisterClass.sse,
                         else => unreachable,
                     }) orelse return self.fail("ran out of registers lowering inline asm", .{}),
-                    @intCast(ty.abiSize(pt)),
+                    @intCast(ty.abiSize(zcu)),
                 )
             else if (mem.eql(u8, rest, "m"))
                 if (output != .none) null else return self.fail(
 @@ -13920,7 +13922,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
                 break :arg input_mcv;
             const reg = try self.register_manager.allocReg(null, rc);
             try self.genSetReg(reg, ty, input_mcv, .{});
-            break :arg .{ .register = registerAlias(reg, @intCast(ty.abiSize(pt))) };
+            break :arg .{ .register = registerAlias(reg, @intCast(ty.abiSize(zcu))) };
         } else if (mem.eql(u8, constraint, "i") or mem.eql(u8, constraint, "n"))
             switch (input_mcv) {
                 .immediate => |imm| .{ .immediate = imm },
 @@ -14497,18 +14499,18 @@ const MoveStrategy = union(enum) {
 };
 fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !MoveStrategy {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     switch (class) {
         .general_purpose, .segment => return .{ .move = .{ ._, .mov } },
         .x87 => return .x87_load_store,
         .mmx => {},
-        .sse => switch (ty.zigTypeTag(mod)) {
+        .sse => switch (ty.zigTypeTag(zcu)) {
             else => {
-                const classes = mem.sliceTo(&abi.classifySystemV(ty, pt, self.target.*, .other), .none);
+                const classes = mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .other), .none);
                 assert(std.mem.indexOfNone(abi.Class, classes, &.{
                     .integer, .sse, .sseup, .memory, .float, .float_combine,
                 }) == null);
-                const abi_size = ty.abiSize(pt);
+                const abi_size = ty.abiSize(zcu);
                 if (abi_size < 4 or
                     std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) {
                     1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{
 @@ -14579,16 +14581,16 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                 else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
                 else => {},
             },
-            .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+            .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                .Bool => switch (ty.vectorLen(mod)) {
+                .Bool => switch (ty.vectorLen(zcu)) {
                     33...64 => return .{ .move = if (self.hasFeature(.avx))
                         .{ .v_q, .mov }
                     else
                         .{ ._q, .mov } },
                     else => {},
                 },
-                .Int => switch (ty.childType(mod).intInfo(mod).bits) {
+                .Int => switch (ty.childType(zcu).intInfo(zcu).bits) {
-                    1...8 => switch (ty.vectorLen(mod)) {
+                    1...8 => switch (ty.vectorLen(zcu)) {
                         1...16 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14599,7 +14601,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    9...16 => switch (ty.vectorLen(mod)) {
+                    9...16 => switch (ty.vectorLen(zcu)) {
                         1...8 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14610,7 +14612,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    17...32 => switch (ty.vectorLen(mod)) {
+                    17...32 => switch (ty.vectorLen(zcu)) {
                         1...4 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14621,7 +14623,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    33...64 => switch (ty.vectorLen(mod)) {
+                    33...64 => switch (ty.vectorLen(zcu)) {
                         1...2 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14632,7 +14634,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    65...128 => switch (ty.vectorLen(mod)) {
+                    65...128 => switch (ty.vectorLen(zcu)) {
                         1 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14643,7 +14645,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    129...256 => switch (ty.vectorLen(mod)) {
+                    129...256 => switch (ty.vectorLen(zcu)) {
                         1 => if (self.hasFeature(.avx))
                             return .{ .move = if (aligned)
                                 .{ .v_, .movdqa }
 @@ -14653,8 +14655,8 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                     },
                     else => {},
                 },
-                .Pointer, .Optional => if (ty.childType(mod).isPtrAtRuntime(mod))
+                .Pointer, .Optional => if (ty.childType(zcu).isPtrAtRuntime(zcu))
-                    switch (ty.vectorLen(mod)) {
+                    switch (ty.vectorLen(zcu)) {
                         1...2 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14667,8 +14669,8 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                     }
                 else
                     unreachable,
-                .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                    16 => switch (ty.vectorLen(mod)) {
+                    16 => switch (ty.vectorLen(zcu)) {
                         1...8 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14679,7 +14681,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_, .movdqu } },
                         else => {},
                     },
-                    32 => switch (ty.vectorLen(mod)) {
+                    32 => switch (ty.vectorLen(zcu)) {
                         1...4 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_ps, .mova } else .{ .v_ps, .movu }
                         else if (aligned) .{ ._ps, .mova } else .{ ._ps, .movu } },
 @@ -14690,7 +14692,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_ps, .movu } },
                         else => {},
                     },
-                    64 => switch (ty.vectorLen(mod)) {
+                    64 => switch (ty.vectorLen(zcu)) {
                         1...2 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_pd, .mova } else .{ .v_pd, .movu }
                         else if (aligned) .{ ._pd, .mova } else .{ ._pd, .movu } },
 @@ -14701,7 +14703,7 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                                 .{ .v_pd, .movu } },
                         else => {},
                     },
-                    128 => switch (ty.vectorLen(mod)) {
+                    128 => switch (ty.vectorLen(zcu)) {
                         1 => return .{ .move = if (self.hasFeature(.avx))
                             if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
                         else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
 @@ -14804,7 +14806,7 @@ fn genCopy(self: *Self, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: Copy
                     } },
                     else => unreachable,
                 }, opts);
-                part_disp += @intCast(dst_ty.abiSize(pt));
+                part_disp += @intCast(dst_ty.abiSize(pt.zcu));
             }
         },
         .indirect => |reg_off| try self.genSetMem(
 @@ -14846,9 +14848,9 @@ fn genSetReg(
     opts: CopyOptions,
 ) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
-    if (ty.bitSize(pt) > dst_reg.bitSize())
+    if (ty.bitSize(zcu) > dst_reg.bitSize())
         return self.fail("genSetReg called with a value larger than dst_reg", .{});
     switch (src_mcv) {
         .none,
 @@ -14965,13 +14967,13 @@ fn genSetReg(
                 ),
                 .x87, .mmx, .ip => unreachable,
                 .sse => try self.asmRegisterRegister(
-                    @as(?Mir.Inst.FixedTag, switch (ty.scalarType(mod).zigTypeTag(mod)) {
+                    @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
                         else => switch (abi_size) {
                             1...16 => if (self.hasFeature(.avx)) .{ .v_, .movdqa } else .{ ._, .movdqa },
                             17...32 => if (self.hasFeature(.avx)) .{ .v_, .movdqa } else null,
                             else => null,
                         },
-                        .Float => switch (ty.scalarType(mod).floatBits(self.target.*)) {
+                        .Float => switch (ty.scalarType(zcu).floatBits(self.target.*)) {
                             16, 128 => switch (abi_size) {
                                 2...16 => if (self.hasFeature(.avx))
                                     .{ .v_, .movdqa }
 @@ -15035,7 +15037,7 @@ fn genSetReg(
                     return (try self.moveStrategy(
                         ty,
                         dst_reg.class(),
-                        ty.abiAlignment(pt).check(@as(u32, @bitCast(small_addr))),
+                        ty.abiAlignment(zcu).check(@as(u32, @bitCast(small_addr))),
                     )).read(self, registerAlias(dst_reg, abi_size), .{
                         .base = .{ .reg = .ds },
                         .mod = .{ .rm = .{
 @@ -15136,8 +15138,8 @@ fn genSetMem(
     opts: CopyOptions,
 ) InnerError!void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const dst_ptr_mcv: MCValue = switch (base) {
         .none => .{ .immediate = @bitCast(@as(i64, disp)) },
         .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } },
 @@ -15159,8 +15161,8 @@ fn genSetMem(
         ),
         .immediate => |imm| switch (abi_size) {
             1, 2, 4 => {
-                const immediate = switch (if (ty.isAbiInt(mod))
+                const immediate = switch (if (ty.isAbiInt(zcu))
-                    ty.intInfo(mod).signedness
+                    ty.intInfo(zcu).signedness
                 else
                     .unsigned) {
                     .signed => Immediate.s(@truncate(@as(i64, @bitCast(imm)))),
 @@ -15193,7 +15195,7 @@ fn genSetMem(
                         .size = .dword,
                         .disp = disp + offset,
                     } } },
-                    if (ty.isSignedInt(mod)) Immediate.s(
+                    if (ty.isSignedInt(zcu)) Immediate.s(
                         @truncate(@as(i64, @bitCast(imm)) >> (math.cast(u6, offset * 8) orelse 63)),
                     ) else Immediate.u(
                         @as(u32, @truncate(if (math.cast(u6, offset * 8)) |shift| imm >> shift else 0)),
 @@ -15263,33 +15265,33 @@ fn genSetMem(
             var part_disp: i32 = disp;
             for (try self.splitType(ty), src_regs) |src_ty, src_reg| {
                 try self.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts);
-                part_disp += @intCast(src_ty.abiSize(pt));
+                part_disp += @intCast(src_ty.abiSize(zcu));
             }
         },
-        .register_overflow => |ro| switch (ty.zigTypeTag(mod)) {
+        .register_overflow => |ro| switch (ty.zigTypeTag(zcu)) {
             .Struct => {
                 try self.genSetMem(
                     base,
-                    disp + @as(i32, @intCast(ty.structFieldOffset(0, pt))),
+                    disp + @as(i32, @intCast(ty.structFieldOffset(0, zcu))),
-                    ty.structFieldType(0, mod),
+                    ty.fieldType(0, zcu),
                     .{ .register = ro.reg },
                     opts,
                 );
                 try self.genSetMem(
                     base,
-                    disp + @as(i32, @intCast(ty.structFieldOffset(1, pt))),
+                    disp + @as(i32, @intCast(ty.structFieldOffset(1, zcu))),
-                    ty.structFieldType(1, mod),
+                    ty.fieldType(1, zcu),
                     .{ .eflags = ro.eflags },
                     opts,
                 );
             },
             .Optional => {
-                assert(!ty.optionalReprIsPayload(mod));
+                assert(!ty.optionalReprIsPayload(zcu));
-                const child_ty = ty.optionalChild(mod);
+                const child_ty = ty.optionalChild(zcu);
                 try self.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts);
                 try self.genSetMem(
                     base,
-                    disp + @as(i32, @intCast(child_ty.abiSize(pt))),
+                    disp + @as(i32, @intCast(child_ty.abiSize(zcu))),
                     Type.bool,
                     .{ .eflags = ro.eflags },
                     opts,
 @@ -15521,14 +15523,14 @@ fn airIntFromPtr(self: *Self, inst: Air.Inst.Index) !void {
 fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
     const src_ty = self.typeOf(ty_op.operand);
     const result = result: {
         const src_mcv = try self.resolveInst(ty_op.operand);
-        if (dst_ty.isPtrAtRuntime(mod) and src_ty.isPtrAtRuntime(mod)) switch (src_mcv) {
+        if (dst_ty.isPtrAtRuntime(zcu) and src_ty.isPtrAtRuntime(zcu)) switch (src_mcv) {
             .lea_frame => break :result src_mcv,
             else => if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv,
         };
 @@ -15539,10 +15541,10 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
         const src_lock = if (src_mcv.getReg()) |reg| self.register_manager.lockReg(reg) else null;
         defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
-        const dst_mcv = if (dst_rc.supersetOf(src_rc) and dst_ty.abiSize(pt) <= src_ty.abiSize(pt) and
+        const dst_mcv = if (dst_rc.supersetOf(src_rc) and dst_ty.abiSize(zcu) <= src_ty.abiSize(zcu) and
             self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) src_mcv else dst: {
             const dst_mcv = try self.allocRegOrMem(inst, true);
-            try self.genCopy(switch (math.order(dst_ty.abiSize(pt), src_ty.abiSize(pt))) {
+            try self.genCopy(switch (math.order(dst_ty.abiSize(zcu), src_ty.abiSize(zcu))) {
                 .lt => dst_ty,
                 .eq => if (!dst_mcv.isMemory() or src_mcv.isMemory()) dst_ty else src_ty,
                 .gt => src_ty,
 @@ -15552,12 +15554,12 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
         if (dst_ty.isRuntimeFloat()) break :result dst_mcv;
-        if (dst_ty.isAbiInt(mod) and src_ty.isAbiInt(mod) and
+        if (dst_ty.isAbiInt(zcu) and src_ty.isAbiInt(zcu) and
-            dst_ty.intInfo(mod).signedness == src_ty.intInfo(mod).signedness) break :result dst_mcv;
+            dst_ty.intInfo(zcu).signedness == src_ty.intInfo(zcu).signedness) break :result dst_mcv;
-        const abi_size = dst_ty.abiSize(pt);
+        const abi_size = dst_ty.abiSize(zcu);
-        const bit_size = dst_ty.bitSize(pt);
+        const bit_size = dst_ty.bitSize(zcu);
-        if (abi_size * 8 <= bit_size or dst_ty.isVector(mod)) break :result dst_mcv;
+        if (abi_size * 8 <= bit_size or dst_ty.isVector(zcu)) break :result dst_mcv;
         const dst_limbs_len = math.divCeil(i32, @intCast(bit_size), 64) catch unreachable;
         const high_mcv: MCValue = switch (dst_mcv) {
 @@ -15586,20 +15588,20 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
 fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const slice_ty = self.typeOfIndex(inst);
     const ptr_ty = self.typeOf(ty_op.operand);
     const ptr = try self.resolveInst(ty_op.operand);
-    const array_ty = ptr_ty.childType(mod);
+    const array_ty = ptr_ty.childType(zcu);
-    const array_len = array_ty.arrayLen(mod);
+    const array_len = array_ty.arrayLen(zcu);
-    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(slice_ty, pt));
+    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(slice_ty, zcu));
     try self.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, ptr, .{});
     try self.genSetMem(
         .{ .frame = frame_index },
-        @intCast(ptr_ty.abiSize(pt)),
+        @intCast(ptr_ty.abiSize(zcu)),
         Type.usize,
         .{ .immediate = array_len },
         .{},
 @@ -15611,16 +15613,16 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
 fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
     const dst_bits = dst_ty.floatBits(self.target.*);
     const src_ty = self.typeOf(ty_op.operand);
-    const src_bits: u32 = @intCast(src_ty.bitSize(pt));
+    const src_bits: u32 = @intCast(src_ty.bitSize(zcu));
     const src_signedness =
-        if (src_ty.isAbiInt(mod)) src_ty.intInfo(mod).signedness else .unsigned;
+        if (src_ty.isAbiInt(zcu)) src_ty.intInfo(zcu).signedness else .unsigned;
     const src_size = math.divCeil(u32, @max(switch (src_signedness) {
         .signed => src_bits,
         .unsigned => src_bits + 1,
 @@ -15666,7 +15668,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
         defer self.register_manager.unlockReg(dst_lock);
-        const mir_tag = @as(?Mir.Inst.FixedTag, switch (dst_ty.zigTypeTag(mod)) {
+        const mir_tag = @as(?Mir.Inst.FixedTag, switch (dst_ty.zigTypeTag(zcu)) {
             .Float => switch (dst_ty.floatBits(self.target.*)) {
                 32 => if (self.hasFeature(.avx)) .{ .v_ss, .cvtsi2 } else .{ ._ss, .cvtsi2 },
                 64 => if (self.hasFeature(.avx)) .{ .v_sd, .cvtsi2 } else .{ ._sd, .cvtsi2 },
 @@ -15691,13 +15693,13 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void {
 fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const dst_ty = self.typeOfIndex(inst);
-    const dst_bits: u32 = @intCast(dst_ty.bitSize(pt));
+    const dst_bits: u32 = @intCast(dst_ty.bitSize(zcu));
     const dst_signedness =
-        if (dst_ty.isAbiInt(mod)) dst_ty.intInfo(mod).signedness else .unsigned;
+        if (dst_ty.isAbiInt(zcu)) dst_ty.intInfo(zcu).signedness else .unsigned;
     const dst_size = math.divCeil(u32, @max(switch (dst_signedness) {
         .signed => dst_bits,
         .unsigned => dst_bits + 1,
 @@ -15768,7 +15770,7 @@ fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
     const ptr_ty = self.typeOf(extra.ptr);
     const val_ty = self.typeOf(extra.expected_value);
-    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt));
+    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt.zcu));
     try self.spillRegisters(&.{ .rax, .rdx, .rbx, .rcx });
     const regs_lock = self.register_manager.lockRegsAssumeUnused(4, .{ .rax, .rdx, .rbx, .rcx });
 @@ -15859,7 +15861,7 @@ fn atomicOp(
     order: std.builtin.AtomicOrder,
 ) InnerError!MCValue {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ptr_lock = switch (ptr_mcv) {
         .register => |reg| self.register_manager.lockReg(reg),
         else => null,
 @@ -15872,7 +15874,7 @@ fn atomicOp(
     };
     defer if (val_lock) |lock| self.register_manager.unlockReg(lock);
-    const val_abi_size: u32 = @intCast(val_ty.abiSize(pt));
+    const val_abi_size: u32 = @intCast(val_ty.abiSize(zcu));
     const mem_size = Memory.Size.fromSize(val_abi_size);
     const ptr_mem: Memory = switch (ptr_mcv) {
         .immediate, .register, .register_offset, .lea_frame => try ptr_mcv.deref().mem(self, mem_size),
 @@ -16031,8 +16033,8 @@ fn atomicOp(
                 .Or => try self.genBinOpMir(.{ ._, .@"or" }, val_ty, tmp_mcv, val_mcv),
                 .Xor => try self.genBinOpMir(.{ ._, .xor }, val_ty, tmp_mcv, val_mcv),
                 .Min, .Max => {
-                    const cc: Condition = switch (if (val_ty.isAbiInt(mod))
+                    const cc: Condition = switch (if (val_ty.isAbiInt(zcu))
-                        val_ty.intInfo(mod).signedness
+                        val_ty.intInfo(zcu).signedness
                     else
                         .unsigned) {
                         .unsigned => switch (op) {
 @@ -16156,8 +16158,8 @@ fn atomicOp(
                     try self.asmRegisterMemory(.{ ._, .xor }, .rcx, val_hi_mem);
                 },
                 .Min, .Max => {
-                    const cc: Condition = switch (if (val_ty.isAbiInt(mod))
+                    const cc: Condition = switch (if (val_ty.isAbiInt(zcu))
-                        val_ty.intInfo(mod).signedness
+                        val_ty.intInfo(zcu).signedness
                     else
                         .unsigned) {
                         .unsigned => switch (op) {
 @@ -16264,7 +16266,7 @@ fn airAtomicStore(self: *Self, inst: Air.Inst.Index, order: std.builtin.AtomicOr
 fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     result: {
 @@ -16290,19 +16292,19 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
         };
         defer if (src_val_lock) |lock| self.register_manager.unlockReg(lock);
-        const elem_abi_size: u31 = @intCast(elem_ty.abiSize(pt));
+        const elem_abi_size: u31 = @intCast(elem_ty.abiSize(zcu));
         if (elem_abi_size == 1) {
-            const ptr: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
+            const ptr: MCValue = switch (dst_ptr_ty.ptrSize(zcu)) {
                 // TODO: this only handles slices stored in the stack
                 .Slice => dst_ptr,
                 .One => dst_ptr,
                 .C, .Many => unreachable,
             };
-            const len: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
+            const len: MCValue = switch (dst_ptr_ty.ptrSize(zcu)) {
                 // TODO: this only handles slices stored in the stack
                 .Slice => dst_ptr.address().offset(8).deref(),
-                .One => .{ .immediate = dst_ptr_ty.childType(mod).arrayLen(mod) },
+                .One => .{ .immediate = dst_ptr_ty.childType(zcu).arrayLen(zcu) },
                 .C, .Many => unreachable,
             };
             const len_lock: ?RegisterLock = switch (len) {
 @@ -16318,9 +16320,9 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
         // Store the first element, and then rely on memcpy copying forwards.
         // Length zero requires a runtime check - so we handle arrays specially
         // here to elide it.
-        switch (dst_ptr_ty.ptrSize(mod)) {
+        switch (dst_ptr_ty.ptrSize(zcu)) {
             .Slice => {
-                const slice_ptr_ty = dst_ptr_ty.slicePtrFieldType(mod);
+                const slice_ptr_ty = dst_ptr_ty.slicePtrFieldType(zcu);
                 // TODO: this only handles slices stored in the stack
                 const ptr = dst_ptr;
 @@ -16365,7 +16367,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
             .One => {
                 const elem_ptr_ty = try pt.singleMutPtrType(elem_ty);
-                const len = dst_ptr_ty.childType(mod).arrayLen(mod);
+                const len = dst_ptr_ty.childType(zcu).arrayLen(zcu);
                 assert(len != 0); // prevented by Sema
                 try self.store(elem_ptr_ty, dst_ptr, src_val, .{ .safety = safety });
 @@ -16393,7 +16395,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
 fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
     try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
 @@ -16415,7 +16417,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
     };
     defer if (src_ptr_lock) |lock| self.register_manager.unlockReg(lock);
-    const len: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
+    const len: MCValue = switch (dst_ptr_ty.ptrSize(zcu)) {
         .Slice => len: {
             const len_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
             const len_lock = self.register_manager.lockRegAssumeUnused(len_reg);
 @@ -16425,13 +16427,13 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
                 .{ .i_, .mul },
                 len_reg,
                 try dst_ptr.address().offset(8).deref().mem(self, .qword),
-                Immediate.s(@intCast(dst_ptr_ty.childType(mod).abiSize(pt))),
+                Immediate.s(@intCast(dst_ptr_ty.childType(zcu).abiSize(zcu))),
             );
             break :len .{ .register = len_reg };
         },
         .One => len: {
-            const array_ty = dst_ptr_ty.childType(mod);
+            const array_ty = dst_ptr_ty.childType(zcu);
-            break :len .{ .immediate = array_ty.arrayLen(mod) * array_ty.childType(mod).abiSize(pt) };
+            break :len .{ .immediate = array_ty.arrayLen(zcu) * array_ty.childType(zcu).abiSize(zcu) };
         },
         .C, .Many => unreachable,
     };
 @@ -16449,6 +16451,7 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
 fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
+    const zcu = pt.zcu;
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const inst_ty = self.typeOfIndex(inst);
     const enum_ty = self.typeOf(un_op);
 @@ -16457,8 +16460,8 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
     // We need a properly aligned and sized call frame to be able to call this function.
     {
         const needed_call_frame = FrameAlloc.init(.{
-            .size = inst_ty.abiSize(pt),
+            .size = inst_ty.abiSize(zcu),
-            .alignment = inst_ty.abiAlignment(pt),
+            .alignment = inst_ty.abiAlignment(zcu),
         });
         const frame_allocs_slice = self.frame_allocs.slice();
         const stack_frame_size =
 @@ -16590,15 +16593,15 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
 fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const vector_ty = self.typeOfIndex(inst);
-    const vector_len = vector_ty.vectorLen(mod);
+    const vector_len = vector_ty.vectorLen(zcu);
     const dst_rc = self.regClassForType(vector_ty);
     const scalar_ty = self.typeOf(ty_op.operand);
     const result: MCValue = result: {
-        switch (scalar_ty.zigTypeTag(mod)) {
+        switch (scalar_ty.zigTypeTag(zcu)) {
             else => {},
             .Bool => {
                 const regs =
 @@ -16641,7 +16644,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
                 break :result .{ .register = regs[0] };
             },
             .Int => if (self.hasFeature(.avx2)) avx2: {
-                const mir_tag = @as(?Mir.Inst.FixedTag, switch (scalar_ty.intInfo(mod).bits) {
+                const mir_tag = @as(?Mir.Inst.FixedTag, switch (scalar_ty.intInfo(zcu).bits) {
                     else => null,
                     1...8 => switch (vector_len) {
                         else => null,
 @@ -16672,15 +16675,15 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
                 const src_mcv = try self.resolveInst(ty_op.operand);
                 if (src_mcv.isMemory()) try self.asmRegisterMemory(
                     mir_tag,
-                    registerAlias(dst_reg, @intCast(vector_ty.abiSize(pt))),
+                    registerAlias(dst_reg, @intCast(vector_ty.abiSize(zcu))),
                     try src_mcv.mem(self, self.memSize(scalar_ty)),
                 ) else {
                     if (mir_tag[0] == .v_i128) break :avx2;
                     try self.genSetReg(dst_reg, scalar_ty, src_mcv, .{});
                     try self.asmRegisterRegister(
                         mir_tag,
-                        registerAlias(dst_reg, @intCast(vector_ty.abiSize(pt))),
+                        registerAlias(dst_reg, @intCast(vector_ty.abiSize(zcu))),
-                        registerAlias(dst_reg, @intCast(scalar_ty.abiSize(pt))),
+                        registerAlias(dst_reg, @intCast(scalar_ty.abiSize(zcu))),
                     );
                 }
                 break :result .{ .register = dst_reg };
 @@ -16692,8 +16695,8 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
                 try self.genSetReg(dst_reg, scalar_ty, .{ .air_ref = ty_op.operand }, .{});
                 if (vector_len == 1) break :result .{ .register = dst_reg };
-                const dst_alias = registerAlias(dst_reg, @intCast(vector_ty.abiSize(pt)));
+                const dst_alias = registerAlias(dst_reg, @intCast(vector_ty.abiSize(zcu)));
-                const scalar_bits = scalar_ty.intInfo(mod).bits;
+                const scalar_bits = scalar_ty.intInfo(zcu).bits;
                 if (switch (scalar_bits) {
                     1...8 => true,
                     9...128 => false,
 @@ -16929,14 +16932,14 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
 fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
     const ty = self.typeOfIndex(inst);
-    const vec_len = ty.vectorLen(mod);
+    const vec_len = ty.vectorLen(zcu);
-    const elem_ty = ty.childType(mod);
+    const elem_ty = ty.childType(zcu);
-    const elem_abi_size: u32 = @intCast(elem_ty.abiSize(pt));
+    const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
-    const abi_size: u32 = @intCast(ty.abiSize(pt));
+    const abi_size: u32 = @intCast(ty.abiSize(zcu));
     const pred_ty = self.typeOf(pl_op.operand);
     const result = result: {
 @@ -17160,7 +17163,7 @@ fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
         const dst_lock = self.register_manager.lockReg(dst_reg);
         defer if (dst_lock) |lock| self.register_manager.unlockReg(lock);
-        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.childType(mod).zigTypeTag(mod)) {
+        const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.childType(zcu).zigTypeTag(zcu)) {
             else => null,
             .Int => switch (abi_size) {
                 0 => unreachable,
 @@ -17176,7 +17179,7 @@ fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
                     null,
                 else => null,
             },
-            .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+            .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
                 else => unreachable,
                 16, 80, 128 => null,
                 32 => switch (vec_len) {
 @@ -17230,7 +17233,7 @@ fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
                 try self.copyToTmpRegister(ty, lhs_mcv), abi_size),
             mask_alias,
         ) else {
-            const mir_fixes = @as(?Mir.Inst.Fixes, switch (elem_ty.zigTypeTag(mod)) {
+            const mir_fixes = @as(?Mir.Inst.Fixes, switch (elem_ty.zigTypeTag(zcu)) {
                 else => null,
                 .Int => .p_,
                 .Float => switch (elem_ty.floatBits(self.target.*)) {
 @@ -17262,18 +17265,18 @@ fn airSelect(self: *Self, inst: Air.Inst.Index) !void {
 fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
     const dst_ty = self.typeOfIndex(inst);
-    const elem_ty = dst_ty.childType(mod);
+    const elem_ty = dst_ty.childType(zcu);
-    const elem_abi_size: u16 = @intCast(elem_ty.abiSize(pt));
+    const elem_abi_size: u16 = @intCast(elem_ty.abiSize(zcu));
-    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(pt));
+    const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu));
     const lhs_ty = self.typeOf(extra.a);
-    const lhs_abi_size: u32 = @intCast(lhs_ty.abiSize(pt));
+    const lhs_abi_size: u32 = @intCast(lhs_ty.abiSize(zcu));
     const rhs_ty = self.typeOf(extra.b);
-    const rhs_abi_size: u32 = @intCast(rhs_ty.abiSize(pt));
+    const rhs_abi_size: u32 = @intCast(rhs_ty.abiSize(zcu));
     const max_abi_size = @max(dst_abi_size, lhs_abi_size, rhs_abi_size);
     const ExpectedContents = [32]?i32;
 @@ -17286,10 +17289,10 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
     for (mask_elems, 0..) |*mask_elem, elem_index| {
         const mask_elem_val =
             Value.fromInterned(extra.mask).elemValue(pt, elem_index) catch unreachable;
-        mask_elem.* = if (mask_elem_val.isUndef(mod))
+        mask_elem.* = if (mask_elem_val.isUndef(zcu))
             null
         else
-            @intCast(mask_elem_val.toSignedInt(pt));
+            @intCast(mask_elem_val.toSignedInt(zcu));
     }
     const has_avx = self.hasFeature(.avx);
 @@ -18028,7 +18031,7 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
             );
             if (has_avx) try self.asmRegisterRegisterRegister(
-                .{ switch (elem_ty.zigTypeTag(mod)) {
+                .{ switch (elem_ty.zigTypeTag(zcu)) {
                     else => break :result null,
                     .Int => .vp_,
                     .Float => switch (elem_ty.floatBits(self.target.*)) {
 @@ -18042,7 +18045,7 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
                 lhs_temp_alias,
                 rhs_temp_alias,
             ) else try self.asmRegisterRegister(
-                .{ switch (elem_ty.zigTypeTag(mod)) {
+                .{ switch (elem_ty.zigTypeTag(zcu)) {
                     else => break :result null,
                     .Int => .p_,
                     .Float => switch (elem_ty.floatBits(self.target.*)) {
 @@ -18068,19 +18071,19 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
 fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
     const result: MCValue = result: {
         const operand_ty = self.typeOf(reduce.operand);
-        if (operand_ty.isVector(mod) and operand_ty.childType(mod).toIntern() == .bool_type) {
+        if (operand_ty.isVector(zcu) and operand_ty.childType(zcu).toIntern() == .bool_type) {
             try self.spillEflagsIfOccupied();
             const operand_mcv = try self.resolveInst(reduce.operand);
-            const mask_len = (math.cast(u6, operand_ty.vectorLen(mod)) orelse
+            const mask_len = (math.cast(u6, operand_ty.vectorLen(zcu)) orelse
                 return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}));
             const mask = (@as(u64, 1) << mask_len) - 1;
-            const abi_size: u32 = @intCast(operand_ty.abiSize(pt));
+            const abi_size: u32 = @intCast(operand_ty.abiSize(zcu));
             switch (reduce.operation) {
                 .Or => {
                     if (operand_mcv.isMemory()) try self.asmMemoryImmediate(
 @@ -18126,36 +18129,36 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const result_ty = self.typeOfIndex(inst);
-    const len: usize = @intCast(result_ty.arrayLen(mod));
+    const len: usize = @intCast(result_ty.arrayLen(zcu));
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
     const result: MCValue = result: {
-        switch (result_ty.zigTypeTag(mod)) {
+        switch (result_ty.zigTypeTag(zcu)) {
             .Struct => {
-                const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, pt));
+                const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
-                if (result_ty.containerLayout(mod) == .@"packed") {
+                if (result_ty.containerLayout(zcu) == .@"packed") {
-                    const struct_obj = mod.typeToStruct(result_ty).?;
+                    const struct_obj = zcu.typeToStruct(result_ty).?;
                     try self.genInlineMemset(
                         .{ .lea_frame = .{ .index = frame_index } },
                         .{ .immediate = 0 },
-                        .{ .immediate = result_ty.abiSize(pt) },
+                        .{ .immediate = result_ty.abiSize(zcu) },
                         .{},
                     );
                     for (elements, 0..) |elem, elem_i_usize| {
                         const elem_i: u32 = @intCast(elem_i_usize);
                         if ((try result_ty.structFieldValueComptime(pt, elem_i)) != null) continue;
-                        const elem_ty = result_ty.structFieldType(elem_i, mod);
+                        const elem_ty = result_ty.fieldType(elem_i, zcu);
-                        const elem_bit_size: u32 = @intCast(elem_ty.bitSize(pt));
+                        const elem_bit_size: u32 = @intCast(elem_ty.bitSize(zcu));
                         if (elem_bit_size > 64) {
                             return self.fail(
                                 "TODO airAggregateInit implement packed structs with large fields",
                                 .{},
                             );
                         }
-                        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(pt));
+                        const elem_abi_size: u32 = @intCast(elem_ty.abiSize(zcu));
                         const elem_abi_bits = elem_abi_size * 8;
                         const elem_off = pt.structPackedFieldBitOffset(struct_obj, elem_i);
                         const elem_byte_off: i32 = @intCast(elem_off / elem_abi_bits * elem_abi_size);
 @@ -18229,8 +18232,8 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
                 } else for (elements, 0..) |elem, elem_i| {
                     if ((try result_ty.structFieldValueComptime(pt, elem_i)) != null) continue;
-                    const elem_ty = result_ty.structFieldType(elem_i, mod);
+                    const elem_ty = result_ty.fieldType(elem_i, zcu);
-                    const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, pt));
+                    const elem_off: i32 = @intCast(result_ty.structFieldOffset(elem_i, zcu));
                     const elem_mcv = try self.resolveInst(elem);
                     const mat_elem_mcv = switch (elem_mcv) {
                         .load_tlv => |sym_index| MCValue{ .lea_tlv = sym_index },
 @@ -18241,9 +18244,9 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
                 break :result .{ .load_frame = .{ .index = frame_index } };
             },
             .Array, .Vector => {
-                const elem_ty = result_ty.childType(mod);
+                const elem_ty = result_ty.childType(zcu);
-                if (result_ty.isVector(mod) and elem_ty.toIntern() == .bool_type) {
+                if (result_ty.isVector(zcu) and elem_ty.toIntern() == .bool_type) {
-                    const result_size: u32 = @intCast(result_ty.abiSize(pt));
+                    const result_size: u32 = @intCast(result_ty.abiSize(zcu));
                     const dst_reg = try self.register_manager.allocReg(inst, abi.RegisterClass.gp);
                     try self.asmRegisterRegister(
                         .{ ._, .xor },
 @@ -18274,8 +18277,8 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
                     }
                     break :result .{ .register = dst_reg };
                 } else {
-                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, pt));
+                    const frame_index = try self.allocFrameIndex(FrameAlloc.initSpill(result_ty, zcu));
-                    const elem_size: u32 = @intCast(elem_ty.abiSize(pt));
+                    const elem_size: u32 = @intCast(elem_ty.abiSize(zcu));
                     for (elements, 0..) |elem, elem_i| {
                         const elem_mcv = try self.resolveInst(elem);
 @@ -18292,7 +18295,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
                             .{},
                         );
                     }
-                    if (result_ty.sentinel(mod)) |sentinel| try self.genSetMem(
+                    if (result_ty.sentinel(zcu)) |sentinel| try self.genSetMem(
                         .{ .frame = frame_index },
                         @intCast(elem_size * elements.len),
                         elem_ty,
 @@ -18318,18 +18321,18 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
 fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
     const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
     const result: MCValue = result: {
         const union_ty = self.typeOfIndex(inst);
-        const layout = union_ty.unionGetLayout(pt);
+        const layout = union_ty.unionGetLayout(zcu);
         const src_ty = self.typeOf(extra.init);
         const src_mcv = try self.resolveInst(extra.init);
         if (layout.tag_size == 0) {
-            if (layout.abi_size <= src_ty.abiSize(pt) and
+            if (layout.abi_size <= src_ty.abiSize(zcu) and
                 self.reuseOperand(inst, extra.init, 0, src_mcv)) break :result src_mcv;
             const dst_mcv = try self.allocRegOrMem(inst, true);
 @@ -18339,13 +18342,13 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
         const dst_mcv = try self.allocRegOrMem(inst, false);
-        const union_obj = mod.typeToUnion(union_ty).?;
+        const union_obj = zcu.typeToUnion(union_ty).?;
         const field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
         const tag_ty = Type.fromInterned(union_obj.enum_tag_ty);
-        const field_index = tag_ty.enumFieldIndex(field_name, mod).?;
+        const field_index = tag_ty.enumFieldIndex(field_name, zcu).?;
         const tag_val = try pt.enumValueFieldIndex(tag_ty, field_index);
         const tag_int_val = try tag_val.intFromEnum(tag_ty, pt);
-        const tag_int = tag_int_val.toUnsignedInt(pt);
+        const tag_int = tag_int_val.toUnsignedInt(zcu);
         const tag_off: i32 = @intCast(layout.tagOffset());
         try self.genCopy(
             tag_ty,
 @@ -18369,19 +18372,19 @@ fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
 fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const extra = self.air.extraData(Air.Bin, pl_op.payload).data;
     const ty = self.typeOfIndex(inst);
     const ops = [3]Air.Inst.Ref{ extra.lhs, extra.rhs, pl_op.operand };
     const result = result: {
-        if (switch (ty.scalarType(mod).floatBits(self.target.*)) {
+        if (switch (ty.scalarType(zcu).floatBits(self.target.*)) {
             16, 80, 128 => true,
             32, 64 => !self.hasFeature(.fma),
             else => unreachable,
         }) {
-            if (ty.zigTypeTag(mod) != .Float) return self.fail("TODO implement airMulAdd for {}", .{
+            if (ty.zigTypeTag(zcu) != .Float) return self.fail("TODO implement airMulAdd for {}", .{
                 ty.fmt(pt),
             });
 @@ -18430,21 +18433,21 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
         const mir_tag = @as(?Mir.Inst.FixedTag, if (mem.eql(u2, &order, &.{ 1, 3, 2 }) or
             mem.eql(u2, &order, &.{ 3, 1, 2 }))
-            switch (ty.zigTypeTag(mod)) {
+            switch (ty.zigTypeTag(zcu)) {
                 .Float => switch (ty.floatBits(self.target.*)) {
                     32 => .{ .v_ss, .fmadd132 },
                     64 => .{ .v_sd, .fmadd132 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
-                .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+                .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                    .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                        32 => switch (ty.vectorLen(mod)) {
+                        32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd132 },
                             2...8 => .{ .v_ps, .fmadd132 },
                             else => null,
                         },
-                        64 => switch (ty.vectorLen(mod)) {
+                        64 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_sd, .fmadd132 },
                             2...4 => .{ .v_pd, .fmadd132 },
                             else => null,
 @@ -18457,21 +18460,21 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
                 else => unreachable,
             }
         else if (mem.eql(u2, &order, &.{ 2, 1, 3 }) or mem.eql(u2, &order, &.{ 1, 2, 3 }))
-            switch (ty.zigTypeTag(mod)) {
+            switch (ty.zigTypeTag(zcu)) {
                 .Float => switch (ty.floatBits(self.target.*)) {
                     32 => .{ .v_ss, .fmadd213 },
                     64 => .{ .v_sd, .fmadd213 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
-                .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+                .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                    .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                        32 => switch (ty.vectorLen(mod)) {
+                        32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd213 },
                             2...8 => .{ .v_ps, .fmadd213 },
                             else => null,
                         },
-                        64 => switch (ty.vectorLen(mod)) {
+                        64 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_sd, .fmadd213 },
                             2...4 => .{ .v_pd, .fmadd213 },
                             else => null,
 @@ -18484,21 +18487,21 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
                 else => unreachable,
             }
         else if (mem.eql(u2, &order, &.{ 2, 3, 1 }) or mem.eql(u2, &order, &.{ 3, 2, 1 }))
-            switch (ty.zigTypeTag(mod)) {
+            switch (ty.zigTypeTag(zcu)) {
                 .Float => switch (ty.floatBits(self.target.*)) {
                     32 => .{ .v_ss, .fmadd231 },
                     64 => .{ .v_sd, .fmadd231 },
                     16, 80, 128 => null,
                     else => unreachable,
                 },
-                .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
+                .Vector => switch (ty.childType(zcu).zigTypeTag(zcu)) {
-                    .Float => switch (ty.childType(mod).floatBits(self.target.*)) {
+                    .Float => switch (ty.childType(zcu).floatBits(self.target.*)) {
-                        32 => switch (ty.vectorLen(mod)) {
+                        32 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_ss, .fmadd231 },
                             2...8 => .{ .v_ps, .fmadd231 },
                             else => null,
                         },
-                        64 => switch (ty.vectorLen(mod)) {
+                        64 => switch (ty.vectorLen(zcu)) {
                             1 => .{ .v_sd, .fmadd231 },
                             2...4 => .{ .v_pd, .fmadd231 },
                             else => null,
 @@ -18516,7 +18519,7 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
         var mops: [3]MCValue = undefined;
         for (order, mcvs) |mop_index, mcv| mops[mop_index - 1] = mcv;
-        const abi_size: u32 = @intCast(ty.abiSize(pt));
+        const abi_size: u32 = @intCast(ty.abiSize(zcu));
         const mop1_reg = registerAlias(mops[0].getReg().?, abi_size);
         const mop2_reg = registerAlias(mops[1].getReg().?, abi_size);
         if (mops[2].isRegister()) try self.asmRegisterRegisterRegister(
 @@ -18537,17 +18540,17 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
 fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const va_list_ty = self.air.instructions.items(.data)[@intFromEnum(inst)].ty;
     const ptr_anyopaque_ty = try pt.singleMutPtrType(Type.anyopaque);
     const result: MCValue = switch (abi.resolveCallingConvention(
-        self.fn_type.fnCallingConvention(mod),
+        self.fn_type.fnCallingConvention(zcu),
         self.target.*,
     )) {
         .SysV => result: {
             const info = self.va_info.sysv;
-            const dst_fi = try self.allocFrameIndex(FrameAlloc.initSpill(va_list_ty, pt));
+            const dst_fi = try self.allocFrameIndex(FrameAlloc.initSpill(va_list_ty, zcu));
             var field_off: u31 = 0;
             // gp_offset: c_uint,
             try self.genSetMem(
 @@ -18557,7 +18560,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
                 .{ .immediate = info.gp_count * 8 },
                 .{},
             );
-            field_off += @intCast(Type.c_uint.abiSize(pt));
+            field_off += @intCast(Type.c_uint.abiSize(zcu));
             // fp_offset: c_uint,
             try self.genSetMem(
                 .{ .frame = dst_fi },
 @@ -18566,7 +18569,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
                 .{ .immediate = abi.SysV.c_abi_int_param_regs.len * 8 + info.fp_count * 16 },
                 .{},
             );
-            field_off += @intCast(Type.c_uint.abiSize(pt));
+            field_off += @intCast(Type.c_uint.abiSize(zcu));
             // overflow_arg_area: *anyopaque,
             try self.genSetMem(
                 .{ .frame = dst_fi },
 @@ -18575,7 +18578,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
                 .{ .lea_frame = info.overflow_arg_area },
                 .{},
             );
-            field_off += @intCast(ptr_anyopaque_ty.abiSize(pt));
+            field_off += @intCast(ptr_anyopaque_ty.abiSize(zcu));
             // reg_save_area: *anyopaque,
             try self.genSetMem(
                 .{ .frame = dst_fi },
 @@ -18584,7 +18587,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
                 .{ .lea_frame = info.reg_save_area },
                 .{},
             );
-            field_off += @intCast(ptr_anyopaque_ty.abiSize(pt));
+            field_off += @intCast(ptr_anyopaque_ty.abiSize(zcu));
             break :result .{ .load_frame = .{ .index = dst_fi } };
         },
         .Win64 => return self.fail("TODO implement c_va_start for Win64", .{}),
 @@ -18595,7 +18598,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
 fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
     const ty = self.typeOfIndex(inst);
     const promote_ty = self.promoteVarArg(ty);
 @@ -18603,7 +18606,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
     const unused = self.liveness.isUnused(inst);
     const result: MCValue = switch (abi.resolveCallingConvention(
-        self.fn_type.fnCallingConvention(mod),
+        self.fn_type.fnCallingConvention(zcu),
         self.target.*,
     )) {
         .SysV => result: {
 @@ -18633,7 +18636,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
             const overflow_arg_area: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 8 } };
             const reg_save_area: MCValue = .{ .indirect = .{ .reg = ptr_arg_list_reg, .off = 16 } };
-            const classes = mem.sliceTo(&abi.classifySystemV(promote_ty, pt, self.target.*, .arg), .none);
+            const classes = mem.sliceTo(&abi.classifySystemV(promote_ty, zcu, self.target.*, .arg), .none);
             switch (classes[0]) {
                 .integer => {
                     assert(classes.len == 1);
 @@ -18668,7 +18671,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                         .base = .{ .reg = addr_reg },
                         .mod = .{ .rm = .{
                             .size = .qword,
-                            .disp = @intCast(@max(promote_ty.abiSize(pt), 8)),
+                            .disp = @intCast(@max(promote_ty.abiSize(zcu), 8)),
                         } },
                     });
                     try self.genCopy(
 @@ -18716,7 +18719,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                         .base = .{ .reg = addr_reg },
                         .mod = .{ .rm = .{
                             .size = .qword,
-                            .disp = @intCast(@max(promote_ty.abiSize(pt), 8)),
+                            .disp = @intCast(@max(promote_ty.abiSize(zcu), 8)),
                         } },
                     });
                     try self.genCopy(
 @@ -18806,11 +18809,11 @@ fn airVaEnd(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!MCValue {
-    const pt = self.pt;
+    const zcu = self.pt.zcu;
     const ty = self.typeOf(ref);
     // If the type has no codegen bits, no need to store it.
-    if (!ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+    if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
     const mcv = if (ref.toIndex()) |inst| mcv: {
         break :mcv self.inst_tracking.getPtr(inst).?.short;
 @@ -18927,8 +18930,8 @@ fn resolveCallingConventionValues(
     stack_frame_base: FrameIndex,
 ) !CallMCValues {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const cc = fn_info.cc;
     const param_types = try self.gpa.alloc(Type, fn_info.param_types.len + var_args.len);
     defer self.gpa.free(param_types);
 @@ -18970,15 +18973,15 @@ fn resolveCallingConventionValues(
                 .SysV => {},
                 .Win64 => {
                     // Align the stack to 16bytes before allocating shadow stack space (if any).
-                    result.stack_byte_count += @intCast(4 * Type.usize.abiSize(pt));
+                    result.stack_byte_count += @intCast(4 * Type.usize.abiSize(zcu));
                 },
                 else => unreachable,
             }
             // Return values
-            if (ret_ty.zigTypeTag(mod) == .NoReturn) {
+            if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = InstTracking.init(.unreach);
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 // TODO: is this even possible for C calling convention?
                 result.return_value = InstTracking.init(.none);
             } else {
 @@ -18986,15 +18989,15 @@ fn resolveCallingConventionValues(
                 var ret_tracking_i: usize = 0;
                 const classes = switch (resolved_cc) {
-                    .SysV => mem.sliceTo(&abi.classifySystemV(ret_ty, pt, self.target.*, .ret), .none),
+                    .SysV => mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, self.target.*, .ret), .none),
-                    .Win64 => &.{abi.classifyWindows(ret_ty, pt)},
+                    .Win64 => &.{abi.classifyWindows(ret_ty, zcu)},
                     else => unreachable,
                 };
                 for (classes) |class| switch (class) {
                     .integer => {
                         const ret_int_reg = registerAlias(
                             abi.getCAbiIntReturnRegs(resolved_cc)[ret_int_reg_i],
-                            @intCast(@min(ret_ty.abiSize(pt), 8)),
+                            @intCast(@min(ret_ty.abiSize(zcu), 8)),
                         );
                         ret_int_reg_i += 1;
 @@ -19004,7 +19007,7 @@ fn resolveCallingConventionValues(
                     .sse, .float, .float_combine, .win_i128 => {
                         const ret_sse_reg = registerAlias(
                             abi.getCAbiSseReturnRegs(resolved_cc)[ret_sse_reg_i],
-                            @intCast(ret_ty.abiSize(pt)),
+                            @intCast(ret_ty.abiSize(zcu)),
                         );
                         ret_sse_reg_i += 1;
 @@ -19047,7 +19050,7 @@ fn resolveCallingConventionValues(
             // Input params
             for (param_types, result.args) |ty, *arg| {
-                assert(ty.hasRuntimeBitsIgnoreComptime(pt));
+                assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
                 switch (resolved_cc) {
                     .SysV => {},
                     .Win64 => {
 @@ -19061,8 +19064,8 @@ fn resolveCallingConventionValues(
                 var arg_mcv_i: usize = 0;
                 const classes = switch (resolved_cc) {
-                    .SysV => mem.sliceTo(&abi.classifySystemV(ty, pt, self.target.*, .arg), .none),
+                    .SysV => mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .arg), .none),
-                    .Win64 => &.{abi.classifyWindows(ty, pt)},
+                    .Win64 => &.{abi.classifyWindows(ty, zcu)},
                     else => unreachable,
                 };
                 for (classes) |class| switch (class) {
 @@ -19072,7 +19075,7 @@ fn resolveCallingConventionValues(
                         const param_int_reg = registerAlias(
                             abi.getCAbiIntParamRegs(resolved_cc)[param_int_reg_i],
-                            @intCast(@min(ty.abiSize(pt), 8)),
+                            @intCast(@min(ty.abiSize(zcu), 8)),
                         );
                         param_int_reg_i += 1;
 @@ -19085,7 +19088,7 @@ fn resolveCallingConventionValues(
                         const param_sse_reg = registerAlias(
                             abi.getCAbiSseParamRegs(resolved_cc)[param_sse_reg_i],
-                            @intCast(ty.abiSize(pt)),
+                            @intCast(ty.abiSize(zcu)),
                         );
                         param_sse_reg_i += 1;
 @@ -19098,7 +19101,7 @@ fn resolveCallingConventionValues(
                             .x87, .x87up, .complex_x87, .memory => break,
                             else => unreachable,
                         },
-                        .Win64 => if (ty.abiSize(pt) > 8) {
+                        .Win64 => if (ty.abiSize(zcu) > 8) {
                             const param_int_reg =
                                 abi.getCAbiIntParamRegs(resolved_cc)[param_int_reg_i].to64();
                             param_int_reg_i += 1;
 @@ -19117,10 +19120,10 @@ fn resolveCallingConventionValues(
                         param_int_reg_i = param_int_regs_len;
                         const frame_elem_align = 8;
-                        const frame_elems_len = ty.vectorLen(mod) - remaining_param_int_regs;
+                        const frame_elems_len = ty.vectorLen(zcu) - remaining_param_int_regs;
                         const frame_elem_size = mem.alignForward(
                             u64,
-                            ty.childType(mod).abiSize(pt),
+                            ty.childType(zcu).abiSize(zcu),
                             frame_elem_align,
                         );
                         const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);
 @@ -19144,9 +19147,9 @@ fn resolveCallingConventionValues(
                     continue;
                 }
-                const param_size: u31 = @intCast(ty.abiSize(pt));
+                const param_size: u31 = @intCast(ty.abiSize(zcu));
                 const param_align: u31 =
-                    @intCast(@max(ty.abiAlignment(pt).toByteUnits().?, 8));
+                    @intCast(@max(ty.abiAlignment(zcu).toByteUnits().?, 8));
                 result.stack_byte_count =
                     mem.alignForward(u31, result.stack_byte_count, param_align);
                 arg.* = .{ .load_frame = .{
 @@ -19164,13 +19167,13 @@ fn resolveCallingConventionValues(
             result.stack_align = .@"16";
             // Return values
-            if (ret_ty.zigTypeTag(mod) == .NoReturn) {
+            if (ret_ty.zigTypeTag(zcu) == .NoReturn) {
                 result.return_value = InstTracking.init(.unreach);
-            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 result.return_value = InstTracking.init(.none);
             } else {
                 const ret_reg = abi.getCAbiIntReturnRegs(resolved_cc)[0];
-                const ret_ty_size: u31 = @intCast(ret_ty.abiSize(pt));
+                const ret_ty_size: u31 = @intCast(ret_ty.abiSize(zcu));
                 if (ret_ty_size <= 8 and !ret_ty.isRuntimeFloat()) {
                     const aliased_reg = registerAlias(ret_reg, ret_ty_size);
                     result.return_value = .{ .short = .{ .register = aliased_reg }, .long = .none };
 @@ -19185,12 +19188,12 @@ fn resolveCallingConventionValues(
             // Input params
             for (param_types, result.args) |ty, *arg| {
-                if (!ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     arg.* = .none;
                     continue;
                 }
-                const param_size: u31 = @intCast(ty.abiSize(pt));
+                const param_size: u31 = @intCast(ty.abiSize(zcu));
-                const param_align: u31 = @intCast(ty.abiAlignment(pt).toByteUnits().?);
+                const param_align: u31 = @intCast(ty.abiAlignment(zcu).toByteUnits().?);
                 result.stack_byte_count =
                     mem.alignForward(u31, result.stack_byte_count, param_align);
                 arg.* = .{ .load_frame = .{
 @@ -19276,25 +19279,26 @@ fn registerAlias(reg: Register, size_bytes: u32) Register {
 fn memSize(self: *Self, ty: Type) Memory.Size {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .Float => Memory.Size.fromBitSize(ty.floatBits(self.target.*)),
-        else => Memory.Size.fromSize(@intCast(ty.abiSize(pt))),
+        else => Memory.Size.fromSize(@intCast(ty.abiSize(zcu))),
     };
 }
 fn splitType(self: *Self, ty: Type) ![2]Type {
     const pt = self.pt;
-    const classes = mem.sliceTo(&abi.classifySystemV(ty, pt, self.target.*, .other), .none);
+    const zcu = pt.zcu;
+    const classes = mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .other), .none);
     var parts: [2]Type = undefined;
     if (classes.len == 2) for (&parts, classes, 0..) |*part, class, part_i| {
         part.* = switch (class) {
             .integer => switch (part_i) {
                 0 => Type.u64,
                 1 => part: {
-                    const elem_size = ty.abiAlignment(pt).minStrict(.@"8").toByteUnits().?;
+                    const elem_size = ty.abiAlignment(zcu).minStrict(.@"8").toByteUnits().?;
                     const elem_ty = try pt.intType(.unsigned, @intCast(elem_size * 8));
-                    break :part switch (@divExact(ty.abiSize(pt) - 8, elem_size)) {
+                    break :part switch (@divExact(ty.abiSize(zcu) - 8, elem_size)) {
                         1 => elem_ty,
                         else => |len| try pt.arrayType(.{ .len = len, .child = elem_ty.toIntern() }),
                     };
 @@ -19306,7 +19310,7 @@ fn splitType(self: *Self, ty: Type) ![2]Type {
             .sse => Type.f64,
             else => break,
         };
-    } else if (parts[0].abiSize(pt) + parts[1].abiSize(pt) == ty.abiSize(pt)) return parts;
+    } else if (parts[0].abiSize(zcu) + parts[1].abiSize(zcu) == ty.abiSize(zcu)) return parts;
     return self.fail("TODO implement splitType for {}", .{ty.fmt(pt)});
 }
 @@ -19314,10 +19318,10 @@ fn splitType(self: *Self, ty: Type) ![2]Type {
 /// Clobbers any remaining bits.
 fn truncateRegister(self: *Self, ty: Type, reg: Register) !void {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const int_info = if (ty.isAbiInt(mod)) ty.intInfo(mod) else std.builtin.Type.Int{
+    const int_info = if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else std.builtin.Type.Int{
         .signedness = .unsigned,
-        .bits = @intCast(ty.bitSize(pt)),
+        .bits = @intCast(ty.bitSize(zcu)),
     };
     const shift = math.cast(u6, 64 - int_info.bits % 64) orelse return;
     try self.spillEflagsIfOccupied();
 @@ -19362,9 +19366,9 @@ fn truncateRegister(self: *Self, ty: Type, reg: Register) !void {
 fn regBitSize(self: *Self, ty: Type) u64 {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const abi_size = ty.abiSize(pt);
+    const abi_size = ty.abiSize(zcu);
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         else => switch (abi_size) {
             1 => 8,
             2 => 16,
 @@ -19381,7 +19385,7 @@ fn regBitSize(self: *Self, ty: Type) u64 {
 }
 fn regExtraBits(self: *Self, ty: Type) u64 {
-    return self.regBitSize(ty) - ty.bitSize(self.pt);
+    return self.regBitSize(ty) - ty.bitSize(self.pt.zcu);
 }
 fn hasFeature(self: *Self, feature: Target.x86.Feature) bool {
 @@ -19396,14 +19400,14 @@ fn hasAllFeatures(self: *Self, features: anytype) bool {
 fn typeOf(self: *Self, inst: Air.Inst.Ref) Type {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return self.air.typeOf(inst, &mod.intern_pool);
+    return self.air.typeOf(inst, &zcu.intern_pool);
 }
 fn typeOfIndex(self: *Self, inst: Air.Inst.Index) Type {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    return self.air.typeOfIndex(inst, &mod.intern_pool);
+    return self.air.typeOfIndex(inst, &zcu.intern_pool);
 }
 fn intCompilerRtAbiName(int_bits: u32) u8 {
 @@ -19455,17 +19459,17 @@ fn floatLibcAbiSuffix(ty: Type) []const u8 {
 fn promoteInt(self: *Self, ty: Type) Type {
     const pt = self.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const int_info: InternPool.Key.IntType = switch (ty.toIntern()) {
         .bool_type => .{ .signedness = .unsigned, .bits = 1 },
-        else => if (ty.isAbiInt(mod)) ty.intInfo(mod) else return ty,
+        else => if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else return ty,
     };
     for ([_]Type{
         Type.c_int,      Type.c_uint,
         Type.c_long,     Type.c_ulong,
         Type.c_longlong, Type.c_ulonglong,
     }) |promote_ty| {
-        const promote_info = promote_ty.intInfo(mod);
+        const promote_info = promote_ty.intInfo(zcu);
         if (int_info.signedness == .signed and promote_info.signedness == .unsigned) continue;
         if (int_info.bits + @intFromBool(int_info.signedness == .unsigned and
             promote_info.signedness == .signed) <= promote_info.bits) return promote_ty;

src/arch/x86_64/Emit.zig+1-1

...	@@ -357,7 +357,7 @@ pub fn emitMir(emit: *Emit) Error!void {	...	@@ -357,7 +357,7 @@ pub fn emitMir(emit: *Emit) Error!void {
357	} } };	357	} } };
358	},	358	},
359	};	359	};
360	const ip = &emit.lower.bin_file.comp.module.?.intern_pool;	360	const ip = &emit.lower.bin_file.comp.zcu.?.intern_pool;
361	const air_inst = emit.air.instructions.get(@intFromEnum(air_inst_index));	361	const air_inst = emit.air.instructions.get(@intFromEnum(air_inst_index));
362	const name: Air.NullTerminatedString = switch (air_inst.tag) {	362	const name: Air.NullTerminatedString = switch (air_inst.tag) {
363	else => unreachable,	363	else => unreachable,

src/arch/x86_64/abi.zig+35-35

...	@@ -44,7 +44,7 @@ pub const Class = enum {	...	@@ -44,7 +44,7 @@ pub const Class = enum {
44	}	44	}
45	};	45	};
46		46
47	pub fn classifyWindows(ty: Type, pt: Zcu.PerThread) Class {	47	pub fn classifyWindows(ty: Type, zcu: *Zcu) Class {
48	// https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017	48	// https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017
49	// "There's a strict one-to-one correspondence between a function call's arguments	49	// "There's a strict one-to-one correspondence between a function call's arguments
50	// and the registers used for those arguments. Any argument that doesn't fit in 8	50	// and the registers used for those arguments. Any argument that doesn't fit in 8
...	@@ -53,7 +53,7 @@ pub fn classifyWindows(ty: Type, pt: Zcu.PerThread) Class {	...	@@ -53,7 +53,7 @@ pub fn classifyWindows(ty: Type, pt: Zcu.PerThread) Class {
53	// "All floating point operations are done using the 16 XMM registers."	53	// "All floating point operations are done using the 16 XMM registers."
54	// "Structs and unions of size 8, 16, 32, or 64 bits, and __m64 types, are passed	54	// "Structs and unions of size 8, 16, 32, or 64 bits, and __m64 types, are passed
55	// as if they were integers of the same size."	55	// as if they were integers of the same size."
56	switch (ty.zigTypeTag(pt.zcu)) {	56	switch (ty.zigTypeTag(zcu)) {
57	.Pointer,	57	.Pointer,
58	.Int,	58	.Int,
59	.Bool,	59	.Bool,
...	@@ -68,12 +68,12 @@ pub fn classifyWindows(ty: Type, pt: Zcu.PerThread) Class {	...	@@ -68,12 +68,12 @@ pub fn classifyWindows(ty: Type, pt: Zcu.PerThread) Class {
68	.ErrorUnion,	68	.ErrorUnion,
69	.AnyFrame,	69	.AnyFrame,
70	.Frame,	70	.Frame,
71	=> switch (ty.abiSize(pt)) {	71	=> switch (ty.abiSize(zcu)) {
72	0 => unreachable,	72	0 => unreachable,
73	1, 2, 4, 8 => return .integer,	73	1, 2, 4, 8 => return .integer,
74	else => switch (ty.zigTypeTag(pt.zcu)) {	74	else => switch (ty.zigTypeTag(zcu)) {
75	.Int => return .win_i128,	75	.Int => return .win_i128,
76	.Struct, .Union => if (ty.containerLayout(pt.zcu) == .@"packed") {	76	.Struct, .Union => if (ty.containerLayout(zcu) == .@"packed") {
77	return .win_i128;	77	return .win_i128;
78	} else {	78	} else {
79	return .memory;	79	return .memory;
...	@@ -100,14 +100,14 @@ pub const Context = enum { ret, arg, field, other };	...	@@ -100,14 +100,14 @@ pub const Context = enum { ret, arg, field, other };
100		100
101	/// There are a maximum of 8 possible return slots. Returned values are in	101	/// There are a maximum of 8 possible return slots. Returned values are in
102	/// the beginning of the array; unused slots are filled with .none.	102	/// the beginning of the array; unused slots are filled with .none.
103	pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Context) [8]Class {	103	pub fn classifySystemV(ty: Type, zcu: *Zcu, target: std.Target, ctx: Context) [8]Class {
104	const memory_class = [_]Class{	104	const memory_class = [_]Class{
105	.memory, .none, .none, .none,	105	.memory, .none, .none, .none,
106	.none, .none, .none, .none,	106	.none, .none, .none, .none,
107	};	107	};
108	var result = [1]Class{.none} ** 8;	108	var result = [1]Class{.none} ** 8;
109	switch (ty.zigTypeTag(pt.zcu)) {	109	switch (ty.zigTypeTag(zcu)) {
110	.Pointer => switch (ty.ptrSize(pt.zcu)) {	110	.Pointer => switch (ty.ptrSize(zcu)) {
111	.Slice => {	111	.Slice => {
112	result[0] = .integer;	112	result[0] = .integer;
113	result[1] = .integer;	113	result[1] = .integer;
...	@@ -119,7 +119,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -119,7 +119,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
119	},	119	},
120	},	120	},
121	.Int, .Enum, .ErrorSet => {	121	.Int, .Enum, .ErrorSet => {
122	const bits = ty.intInfo(pt.zcu).bits;	122	const bits = ty.intInfo(zcu).bits;
123	if (bits <= 64) {	123	if (bits <= 64) {
124	result[0] = .integer;	124	result[0] = .integer;
125	return result;	125	return result;
...	@@ -185,8 +185,8 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -185,8 +185,8 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
185	else => unreachable,	185	else => unreachable,
186	},	186	},
187	.Vector => {	187	.Vector => {
188	const elem_ty = ty.childType(pt.zcu);	188	const elem_ty = ty.childType(zcu);
189	const bits = elem_ty.bitSize(pt) * ty.arrayLen(pt.zcu);	189	const bits = elem_ty.bitSize(zcu) * ty.arrayLen(zcu);
190	if (elem_ty.toIntern() == .bool_type) {	190	if (elem_ty.toIntern() == .bool_type) {
191	if (bits <= 32) return .{	191	if (bits <= 32) return .{
192	.integer, .none, .none, .none,	192	.integer, .none, .none, .none,
...	@@ -250,7 +250,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -250,7 +250,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
250	return memory_class;	250	return memory_class;
251	},	251	},
252	.Optional => {	252	.Optional => {
253	if (ty.isPtrLikeOptional(pt.zcu)) {	253	if (ty.isPtrLikeOptional(zcu)) {
254	result[0] = .integer;	254	result[0] = .integer;
255	return result;	255	return result;
256	}	256	}
...	@@ -261,8 +261,8 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -261,8 +261,8 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
261	// it contains unaligned fields, it has class MEMORY"	261	// it contains unaligned fields, it has class MEMORY"
262	// "If the size of the aggregate exceeds a single eightbyte, each is classified	262	// "If the size of the aggregate exceeds a single eightbyte, each is classified
263	// separately.".	263	// separately.".
264	const ty_size = ty.abiSize(pt);	264	const ty_size = ty.abiSize(zcu);
265	switch (ty.containerLayout(pt.zcu)) {	265	switch (ty.containerLayout(zcu)) {
266	.auto, .@"extern" => {},	266	.auto, .@"extern" => {},
267	.@"packed" => {	267	.@"packed" => {
268	assert(ty_size <= 16);	268	assert(ty_size <= 16);
...	@@ -274,10 +274,10 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -274,10 +274,10 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
274	if (ty_size > 64)	274	if (ty_size > 64)
275	return memory_class;	275	return memory_class;
276		276
277	_ = if (pt.zcu.typeToStruct(ty)) \|loaded_struct\|	277	_ = if (zcu.typeToStruct(ty)) \|loaded_struct\|
278	classifySystemVStruct(&result, 0, loaded_struct, pt, target)	278	classifySystemVStruct(&result, 0, loaded_struct, zcu, target)
279	else if (pt.zcu.typeToUnion(ty)) \|loaded_union\|	279	else if (zcu.typeToUnion(ty)) \|loaded_union\|
280	classifySystemVUnion(&result, 0, loaded_union, pt, target)	280	classifySystemVUnion(&result, 0, loaded_union, zcu, target)
281	else	281	else
282	unreachable;	282	unreachable;
283		283
...	@@ -306,7 +306,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con	...	@@ -306,7 +306,7 @@ pub fn classifySystemV(ty: Type, pt: Zcu.PerThread, target: std.Target, ctx: Con
306	return result;	306	return result;
307	},	307	},
308	.Array => {	308	.Array => {
309	const ty_size = ty.abiSize(pt);	309	const ty_size = ty.abiSize(zcu);
310	if (ty_size <= 8) {	310	if (ty_size <= 8) {
311	result[0] = .integer;	311	result[0] = .integer;
312	return result;	312	return result;
...	@@ -326,10 +326,10 @@ fn classifySystemVStruct(	...	@@ -326,10 +326,10 @@ fn classifySystemVStruct(
326	result: *[8]Class,	326	result: *[8]Class,
327	starting_byte_offset: u64,	327	starting_byte_offset: u64,
328	loaded_struct: InternPool.LoadedStructType,	328	loaded_struct: InternPool.LoadedStructType,
329	pt: Zcu.PerThread,	329	zcu: *Zcu,
330	target: std.Target,	330	target: std.Target,
331	) u64 {	331	) u64 {
332	const ip = &pt.zcu.intern_pool;	332	const ip = &zcu.intern_pool;
333	var byte_offset = starting_byte_offset;	333	var byte_offset = starting_byte_offset;
334	var field_it = loaded_struct.iterateRuntimeOrder(ip);	334	var field_it = loaded_struct.iterateRuntimeOrder(ip);
335	while (field_it.next()) \|field_index\| {	335	while (field_it.next()) \|field_index\| {
...	@@ -338,29 +338,29 @@ fn classifySystemVStruct(	...	@@ -338,29 +338,29 @@ fn classifySystemVStruct(
338	byte_offset = std.mem.alignForward(	338	byte_offset = std.mem.alignForward(
339	u64,	339	u64,
340	byte_offset,	340	byte_offset,
341	field_align.toByteUnits() orelse field_ty.abiAlignment(pt).toByteUnits().?,	341	field_align.toByteUnits() orelse field_ty.abiAlignment(zcu).toByteUnits().?,
342	);	342	);
343	if (pt.zcu.typeToStruct(field_ty)) \|field_loaded_struct\| {	343	if (zcu.typeToStruct(field_ty)) \|field_loaded_struct\| {
344	switch (field_loaded_struct.layout) {	344	switch (field_loaded_struct.layout) {
345	.auto, .@"extern" => {	345	.auto, .@"extern" => {
346	byte_offset = classifySystemVStruct(result, byte_offset, field_loaded_struct, pt, target);	346	byte_offset = classifySystemVStruct(result, byte_offset, field_loaded_struct, zcu, target);
347	continue;	347	continue;
348	},	348	},
349	.@"packed" => {},	349	.@"packed" => {},
350	}	350	}
351	} else if (pt.zcu.typeToUnion(field_ty)) \|field_loaded_union\| {	351	} else if (zcu.typeToUnion(field_ty)) \|field_loaded_union\| {
352	switch (field_loaded_union.flagsUnordered(ip).layout) {	352	switch (field_loaded_union.flagsUnordered(ip).layout) {
353	.auto, .@"extern" => {	353	.auto, .@"extern" => {
354	byte_offset = classifySystemVUnion(result, byte_offset, field_loaded_union, pt, target);	354	byte_offset = classifySystemVUnion(result, byte_offset, field_loaded_union, zcu, target);
355	continue;	355	continue;
356	},	356	},
357	.@"packed" => {},	357	.@"packed" => {},
358	}	358	}
359	}	359	}
360	const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, pt, target, .field), .none);	360	const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none);
361	for (result[@intCast(byte_offset / 8)..][0..field_classes.len], field_classes) \|*result_class, field_class\|	361	for (result[@intCast(byte_offset / 8)..][0..field_classes.len], field_classes) \|*result_class, field_class\|
362	result_class.* = result_class.combineSystemV(field_class);	362	result_class.* = result_class.combineSystemV(field_class);
363	byte_offset += field_ty.abiSize(pt);	363	byte_offset += field_ty.abiSize(zcu);
364	}	364	}
365	const final_byte_offset = starting_byte_offset + loaded_struct.sizeUnordered(ip);	365	const final_byte_offset = starting_byte_offset + loaded_struct.sizeUnordered(ip);
366	std.debug.assert(final_byte_offset == std.mem.alignForward(	366	std.debug.assert(final_byte_offset == std.mem.alignForward(
...	@@ -375,30 +375,30 @@ fn classifySystemVUnion(	...	@@ -375,30 +375,30 @@ fn classifySystemVUnion(
375	result: *[8]Class,	375	result: *[8]Class,
376	starting_byte_offset: u64,	376	starting_byte_offset: u64,
377	loaded_union: InternPool.LoadedUnionType,	377	loaded_union: InternPool.LoadedUnionType,
378	pt: Zcu.PerThread,	378	zcu: *Zcu,
379	target: std.Target,	379	target: std.Target,
380	) u64 {	380	) u64 {
381	const ip = &pt.zcu.intern_pool;	381	const ip = &zcu.intern_pool;
382	for (0..loaded_union.field_types.len) \|field_index\| {	382	for (0..loaded_union.field_types.len) \|field_index\| {
383	const field_ty = Type.fromInterned(loaded_union.field_types.get(ip)[field_index]);	383	const field_ty = Type.fromInterned(loaded_union.field_types.get(ip)[field_index]);
384	if (pt.zcu.typeToStruct(field_ty)) \|field_loaded_struct\| {	384	if (zcu.typeToStruct(field_ty)) \|field_loaded_struct\| {
385	switch (field_loaded_struct.layout) {	385	switch (field_loaded_struct.layout) {
386	.auto, .@"extern" => {	386	.auto, .@"extern" => {
387	_ = classifySystemVStruct(result, starting_byte_offset, field_loaded_struct, pt, target);	387	_ = classifySystemVStruct(result, starting_byte_offset, field_loaded_struct, zcu, target);
388	continue;	388	continue;
389	},	389	},
390	.@"packed" => {},	390	.@"packed" => {},
391	}	391	}
392	} else if (pt.zcu.typeToUnion(field_ty)) \|field_loaded_union\| {	392	} else if (zcu.typeToUnion(field_ty)) \|field_loaded_union\| {
393	switch (field_loaded_union.flagsUnordered(ip).layout) {	393	switch (field_loaded_union.flagsUnordered(ip).layout) {
394	.auto, .@"extern" => {	394	.auto, .@"extern" => {
395	_ = classifySystemVUnion(result, starting_byte_offset, field_loaded_union, pt, target);	395	_ = classifySystemVUnion(result, starting_byte_offset, field_loaded_union, zcu, target);
396	continue;	396	continue;
397	},	397	},
398	.@"packed" => {},	398	.@"packed" => {},
399	}	399	}
400	}	400	}
401	const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, pt, target, .field), .none);	401	const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none);
402	for (result[@intCast(starting_byte_offset / 8)..][0..field_classes.len], field_classes) \|*result_class, field_class\|	402	for (result[@intCast(starting_byte_offset / 8)..][0..field_classes.len], field_classes) \|*result_class, field_class\|
403	result_class.* = result_class.combineSystemV(field_class);	403	result_class.* = result_class.combineSystemV(field_class);
404	}	404	}

src/codegen.zig+66-65

 @@ -198,17 +198,17 @@ pub fn generateSymbol(
     const tracy = trace(@src());
     defer tracy.end();
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
-    const ty = val.typeOf(mod);
+    const ty = val.typeOf(zcu);
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     const endian = target.cpu.arch.endian();
     log.debug("generateSymbol: val = {}", .{val.fmtValue(pt)});
-    if (val.isUndefDeep(mod)) {
+    if (val.isUndefDeep(zcu)) {
-        const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+        const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
         try code.appendNTimes(0xaa, abi_size);
         return .ok;
     }
 @@ -254,9 +254,9 @@ pub fn generateSymbol(
         .empty_enum_value,
         => unreachable, // non-runtime values
         .int => {
-            const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+            const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
             var space: Value.BigIntSpace = undefined;
-            const int_val = val.toBigInt(&space, pt);
+            const int_val = val.toBigInt(&space, zcu);
             int_val.writeTwosComplement(try code.addManyAsSlice(abi_size), endian);
         },
         .err => |err| {
 @@ -264,20 +264,20 @@ pub fn generateSymbol(
             try code.writer().writeInt(u16, @intCast(int), endian);
         },
         .error_union => |error_union| {
-            const payload_ty = ty.errorUnionPayload(mod);
+            const payload_ty = ty.errorUnionPayload(zcu);
             const err_val: u16 = switch (error_union.val) {
                 .err_name => |err_name| @intCast(try pt.getErrorValue(err_name)),
                 .payload => 0,
             };
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 try code.writer().writeInt(u16, err_val, endian);
                 return .ok;
             }
-            const payload_align = payload_ty.abiAlignment(pt);
+            const payload_align = payload_ty.abiAlignment(zcu);
-            const error_align = Type.anyerror.abiAlignment(pt);
+            const error_align = Type.anyerror.abiAlignment(zcu);
-            const abi_align = ty.abiAlignment(pt);
+            const abi_align = ty.abiAlignment(zcu);
             // error value first when its type is larger than the error union's payload
             if (error_align.order(payload_align) == .gt) {
 @@ -317,7 +317,7 @@ pub fn generateSymbol(
             }
         },
         .enum_tag => |enum_tag| {
-            const int_tag_ty = ty.intTagType(mod);
+            const int_tag_ty = ty.intTagType(zcu);
             switch (try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), code, debug_output, reloc_info)) {
                 .ok => {},
                 .fail => |em| return .{ .fail = em },
 @@ -329,7 +329,7 @@ pub fn generateSymbol(
             .f64 => |f64_val| writeFloat(f64, f64_val, target, endian, try code.addManyAsArray(8)),
             .f80 => |f80_val| {
                 writeFloat(f80, f80_val, target, endian, try code.addManyAsArray(10));
-                const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+                const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
                 try code.appendNTimes(0, abi_size - 10);
             },
             .f128 => |f128_val| writeFloat(f128, f128_val, target, endian, try code.addManyAsArray(16)),
 @@ -349,11 +349,11 @@ pub fn generateSymbol(
             }
         },
         .opt => {
-            const payload_type = ty.optionalChild(mod);
+            const payload_type = ty.optionalChild(zcu);
-            const payload_val = val.optionalValue(mod);
+            const payload_val = val.optionalValue(zcu);
-            const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+            const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
-            if (ty.optionalReprIsPayload(mod)) {
+            if (ty.optionalReprIsPayload(zcu)) {
                 if (payload_val) |value| {
                     switch (try generateSymbol(bin_file, pt, src_loc, value, code, debug_output, reloc_info)) {
                         .ok => {},
 @@ -363,8 +363,8 @@ pub fn generateSymbol(
                     try code.appendNTimes(0, abi_size);
                 }
             } else {
-                const padding = abi_size - (math.cast(usize, payload_type.abiSize(pt)) orelse return error.Overflow) - 1;
+                const padding = abi_size - (math.cast(usize, payload_type.abiSize(zcu)) orelse return error.Overflow) - 1;
-                if (payload_type.hasRuntimeBits(pt)) {
+                if (payload_type.hasRuntimeBits(zcu)) {
                     const value = payload_val orelse Value.fromInterned(try pt.intern(.{
                         .undef = payload_type.toIntern(),
                     }));
 @@ -398,7 +398,7 @@ pub fn generateSymbol(
                 },
             },
             .vector_type => |vector_type| {
-                const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+                const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
                 if (vector_type.child == .bool_type) {
                     const bytes = try code.addManyAsSlice(abi_size);
                     @memset(bytes, 0xaa);
 @@ -458,7 +458,7 @@ pub fn generateSymbol(
                     }
                     const padding = abi_size -
-                        (math.cast(usize, Type.fromInterned(vector_type.child).abiSize(pt) * vector_type.len) orelse
+                        (math.cast(usize, Type.fromInterned(vector_type.child).abiSize(zcu) * vector_type.len) orelse
                         return error.Overflow);
                     if (padding > 0) try code.appendNTimes(0, padding);
                 }
 @@ -471,7 +471,7 @@ pub fn generateSymbol(
                     0..,
                 ) |field_ty, comptime_val, index| {
                     if (comptime_val != .none) continue;
-                    if (!Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
+                    if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
                     const field_val = switch (aggregate.storage) {
                         .bytes => |bytes| try pt.intern(.{ .int = .{
 @@ -489,7 +489,7 @@ pub fn generateSymbol(
                     const unpadded_field_end = code.items.len - struct_begin;
                     // Pad struct members if required
-                    const padded_field_end = ty.structFieldOffset(index + 1, pt);
+                    const padded_field_end = ty.structFieldOffset(index + 1, zcu);
                     const padding = math.cast(usize, padded_field_end - unpadded_field_end) orelse
                         return error.Overflow;
 @@ -502,7 +502,7 @@ pub fn generateSymbol(
                 const struct_type = ip.loadStructType(ty.toIntern());
                 switch (struct_type.layout) {
                     .@"packed" => {
-                        const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
+                        const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
                         const current_pos = code.items.len;
                         try code.appendNTimes(0, abi_size);
                         var bits: u16 = 0;
 @@ -519,8 +519,8 @@ pub fn generateSymbol(
                             // pointer may point to a decl which must be marked used
                             // but can also result in a relocation. Therefore we handle those separately.
-                            if (Type.fromInterned(field_ty).zigTypeTag(mod) == .Pointer) {
+                            if (Type.fromInterned(field_ty).zigTypeTag(zcu) == .Pointer) {
-                                const field_size = math.cast(usize, Type.fromInterned(field_ty).abiSize(pt)) orelse
+                                const field_size = math.cast(usize, Type.fromInterned(field_ty).abiSize(zcu)) orelse
                                     return error.Overflow;
                                 var tmp_list = try std.ArrayList(u8).initCapacity(code.allocator, field_size);
                                 defer tmp_list.deinit();
 @@ -531,7 +531,7 @@ pub fn generateSymbol(
                             } else {
                                 Value.fromInterned(field_val).writeToPackedMemory(Type.fromInterned(field_ty), pt, code.items[current_pos..], bits) catch unreachable;
                             }
-                            bits += @intCast(Type.fromInterned(field_ty).bitSize(pt));
+                            bits += @intCast(Type.fromInterned(field_ty).bitSize(zcu));
                         }
                     },
                     .auto, .@"extern" => {
 @@ -542,7 +542,7 @@ pub fn generateSymbol(
                         var it = struct_type.iterateRuntimeOrder(ip);
                         while (it.next()) |field_index| {
                             const field_ty = field_types[field_index];
-                            if (!Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
+                            if (!Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
                             const field_val = switch (ip.indexToKey(val.toIntern()).aggregate.storage) {
                                 .bytes => |bytes| try pt.intern(.{ .int = .{
 @@ -580,7 +580,7 @@ pub fn generateSymbol(
             else => unreachable,
         },
         .un => |un| {
-            const layout = ty.unionGetLayout(pt);
+            const layout = ty.unionGetLayout(zcu);
             if (layout.payload_size == 0) {
                 return generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, debug_output, reloc_info);
 @@ -594,11 +594,11 @@ pub fn generateSymbol(
                 }
             }
-            const union_obj = mod.typeToUnion(ty).?;
+            const union_obj = zcu.typeToUnion(ty).?;
             if (un.tag != .none) {
-                const field_index = ty.unionTagFieldIndex(Value.fromInterned(un.tag), mod).?;
+                const field_index = ty.unionTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
                 const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                if (!field_ty.hasRuntimeBits(pt)) {
+                if (!field_ty.hasRuntimeBits(zcu)) {
                     try code.appendNTimes(0xaa, math.cast(usize, layout.payload_size) orelse return error.Overflow);
                 } else {
                     switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, debug_output, reloc_info)) {
 @@ -606,7 +606,7 @@ pub fn generateSymbol(
                         .fail => |em| return Result{ .fail = em },
                     }
-                    const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(pt)) orelse return error.Overflow;
+                    const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(zcu)) orelse return error.Overflow;
                     if (padding > 0) {
                         try code.appendNTimes(0, padding);
                     }
 @@ -661,7 +661,7 @@ fn lowerPtr(
             reloc_info,
             offset + errUnionPayloadOffset(
                 Value.fromInterned(eu_ptr).typeOf(zcu).childType(zcu).errorUnionPayload(zcu),
-                pt,
+                zcu,
             ),
         ),
         .opt_payload => |opt_ptr| try lowerPtr(
 @@ -687,7 +687,7 @@ fn lowerPtr(
                     };
                 },
                 .Struct, .Union => switch (base_ty.containerLayout(zcu)) {
-                    .auto => base_ty.structFieldOffset(@intCast(field.index), pt),
+                    .auto => base_ty.structFieldOffset(@intCast(field.index), zcu),
                     .@"extern", .@"packed" => unreachable,
                 },
                 else => unreachable,
 @@ -713,15 +713,16 @@ fn lowerUavRef(
     offset: u64,
 ) CodeGenError!Result {
     _ = debug_output;
-    const ip = &pt.zcu.intern_pool;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     const target = lf.comp.root_mod.resolved_target.result;
     const ptr_width_bytes = @divExact(target.ptrBitWidth(), 8);
     const uav_val = uav.val;
     const uav_ty = Type.fromInterned(ip.typeOf(uav_val));
     log.debug("lowerUavRef: ty = {}", .{uav_ty.fmt(pt)});
-    const is_fn_body = uav_ty.zigTypeTag(pt.zcu) == .Fn;
+    const is_fn_body = uav_ty.zigTypeTag(zcu) == .Fn;
-    if (!is_fn_body and !uav_ty.hasRuntimeBits(pt)) {
+    if (!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) {
         try code.appendNTimes(0xaa, ptr_width_bytes);
         return Result.ok;
     }
 @@ -768,7 +769,7 @@ fn lowerNavRef(
     const ptr_width = target.ptrBitWidth();
     const nav_ty = Type.fromInterned(ip.getNav(nav_index).typeOf(ip));
     const is_fn_body = nav_ty.zigTypeTag(zcu) == .Fn;
-    if (!is_fn_body and !nav_ty.hasRuntimeBits(pt)) {
+    if (!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) {
         try code.appendNTimes(0xaa, @divExact(ptr_width, 8));
         return Result.ok;
     }
 @@ -860,7 +861,7 @@ fn genNavRef(
     const ty = val.typeOf(zcu);
     log.debug("genNavRef: val = {}", .{val.fmtValue(pt)});
-    if (!ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+    if (!ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
         const imm: u64 = switch (@divExact(target.ptrBitWidth(), 8)) {
             1 => 0xaa,
             2 => 0xaaaa,
 @@ -877,12 +878,12 @@ fn genNavRef(
     // TODO this feels clunky. Perhaps we should check for it in `genTypedValue`?
     if (ty.castPtrToFn(zcu)) |fn_ty| {
         if (zcu.typeToFunc(fn_ty).?.is_generic) {
-            return .{ .mcv = .{ .immediate = fn_ty.abiAlignment(pt).toByteUnits().? } };
+            return .{ .mcv = .{ .immediate = fn_ty.abiAlignment(zcu).toByteUnits().? } };
         }
     } else if (ty.zigTypeTag(zcu) == .Pointer) {
         const elem_ty = ty.elemType2(zcu);
-        if (!elem_ty.hasRuntimeBits(pt)) {
+        if (!elem_ty.hasRuntimeBits(zcu)) {
-            return .{ .mcv = .{ .immediate = elem_ty.abiAlignment(pt).toByteUnits().? } };
+            return .{ .mcv = .{ .immediate = elem_ty.abiAlignment(zcu).toByteUnits().? } };
         }
     }
 @@ -963,15 +964,15 @@ pub fn genTypedValue(
                 },
                 else => switch (ip.indexToKey(val.toIntern())) {
                     .int => {
-                        return .{ .mcv = .{ .immediate = val.toUnsignedInt(pt) } };
+                        return .{ .mcv = .{ .immediate = val.toUnsignedInt(zcu) } };
                     },
                     .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
                         .nav => |nav| return genNavRef(lf, pt, src_loc, val, nav, target),
-                        .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).hasRuntimeBits(pt))
+                        .uav => |uav| if (Value.fromInterned(uav.val).typeOf(zcu).hasRuntimeBits(zcu))
                             return switch (try lf.lowerUav(
                                 pt,
                                 uav.val,
-                                Type.fromInterned(uav.orig_ty).ptrAlignment(pt),
+                                Type.fromInterned(uav.orig_ty).ptrAlignment(zcu),
                                 src_loc,
                             )) {
                                 .mcv => |mcv| return .{ .mcv = switch (mcv) {
 @@ -982,7 +983,7 @@ pub fn genTypedValue(
                                 .fail => |em| return .{ .fail = em },
                             }
                         else
-                            return .{ .mcv = .{ .immediate = Type.fromInterned(uav.orig_ty).ptrAlignment(pt)
+                            return .{ .mcv = .{ .immediate = Type.fromInterned(uav.orig_ty).ptrAlignment(zcu)
                                 .forward(@intCast((@as(u66, 1) << @intCast(target.ptrBitWidth() | 1)) / 3)) } },
                         else => {},
                     },
 @@ -994,8 +995,8 @@ pub fn genTypedValue(
             const info = ty.intInfo(zcu);
             if (info.bits <= target.ptrBitWidth()) {
                 const unsigned: u64 = switch (info.signedness) {
-                    .signed => @bitCast(val.toSignedInt(pt)),
+                    .signed => @bitCast(val.toSignedInt(zcu)),
-                    .unsigned => val.toUnsignedInt(pt),
+                    .unsigned => val.toUnsignedInt(zcu),
                 };
                 return .{ .mcv = .{ .immediate = unsigned } };
             }
 @@ -1012,7 +1013,7 @@ pub fn genTypedValue(
                     val.optionalValue(zcu) orelse return .{ .mcv = .{ .immediate = 0 } },
                     target,
                 );
-            } else if (ty.abiSize(pt) == 1) {
+            } else if (ty.abiSize(zcu) == 1) {
                 return .{ .mcv = .{ .immediate = @intFromBool(!val.isNull(zcu)) } };
             }
         },
 @@ -1034,7 +1035,7 @@ pub fn genTypedValue(
         .ErrorUnion => {
             const err_type = ty.errorUnionSet(zcu);
             const payload_type = ty.errorUnionPayload(zcu);
-            if (!payload_type.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
                 // We use the error type directly as the type.
                 const err_int_ty = try pt.errorIntType();
                 switch (ip.indexToKey(val.toIntern()).error_union.val) {
 @@ -1074,23 +1075,23 @@ pub fn genTypedValue(
     return lf.lowerUav(pt, val.toIntern(), .none, src_loc);
 }
-pub fn errUnionPayloadOffset(payload_ty: Type, pt: Zcu.PerThread) u64 {
+pub fn errUnionPayloadOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0;
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
-    const payload_align = payload_ty.abiAlignment(pt);
+    const payload_align = payload_ty.abiAlignment(zcu);
-    const error_align = Type.anyerror.abiAlignment(pt);
+    const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (payload_align.compare(.gte, error_align) or !payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         return 0;
     } else {
-        return payload_align.forward(Type.anyerror.abiSize(pt));
+        return payload_align.forward(Type.anyerror.abiSize(zcu));
     }
 }
-pub fn errUnionErrorOffset(payload_ty: Type, pt: Zcu.PerThread) u64 {
+pub fn errUnionErrorOffset(payload_ty: Type, zcu: *Zcu) u64 {
-    if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return 0;
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return 0;
-    const payload_align = payload_ty.abiAlignment(pt);
+    const payload_align = payload_ty.abiAlignment(zcu);
-    const error_align = Type.anyerror.abiAlignment(pt);
+    const error_align = Type.anyerror.abiAlignment(zcu);
-    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (payload_align.compare(.gte, error_align) and payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-        return error_align.forward(payload_ty.abiSize(pt));
+        return error_align.forward(payload_ty.abiSize(zcu));
     } else {
         return 0;
     }

src/codegen/c.zig+123-118

src/codegen/c/Type.zig+13-12

...	@@ -1344,6 +1344,7 @@ pub const Pool = struct {	...	@@ -1344,6 +1344,7 @@ pub const Pool = struct {
1344	kind: Kind,	1344	kind: Kind,
1345	) !CType {	1345	) !CType {
1346	const ip = &pt.zcu.intern_pool;	1346	const ip = &pt.zcu.intern_pool;
		1347	const zcu = pt.zcu;
1347	switch (ty.toIntern()) {	1348	switch (ty.toIntern()) {
1348	.u0_type,	1349	.u0_type,
1349	.i0_type,	1350	.i0_type,
...	@@ -1476,7 +1477,7 @@ pub const Pool = struct {	...	@@ -1476,7 +1477,7 @@ pub const Pool = struct {
1476	),	1477	),
1477	.alignas = AlignAs.fromAlignment(.{	1478	.alignas = AlignAs.fromAlignment(.{
1478	.@"align" = ptr_info.flags.alignment,	1479	.@"align" = ptr_info.flags.alignment,
1479	.abi = Type.fromInterned(ptr_info.child).abiAlignment(pt),	1480	.abi = Type.fromInterned(ptr_info.child).abiAlignment(zcu),
1480	}),	1481	}),
1481	};	1482	};
1482	break :elem_ctype if (elem.alignas.abiOrder().compare(.gte))	1483	break :elem_ctype if (elem.alignas.abiOrder().compare(.gte))
...	@@ -1552,7 +1553,7 @@ pub const Pool = struct {	...	@@ -1552,7 +1553,7 @@ pub const Pool = struct {
1552	.{	1553	.{
1553	.name = .{ .index = .array },	1554	.name = .{ .index = .array },
1554	.ctype = array_ctype,	1555	.ctype = array_ctype,
1555	.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(pt)),	1556	.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
1556	},	1557	},
1557	};	1558	};
1558	return pool.fromFields(allocator, .@"struct", &fields, kind);	1559	return pool.fromFields(allocator, .@"struct", &fields, kind);
...	@@ -1578,7 +1579,7 @@ pub const Pool = struct {	...	@@ -1578,7 +1579,7 @@ pub const Pool = struct {
1578	.{	1579	.{
1579	.name = .{ .index = .array },	1580	.name = .{ .index = .array },
1580	.ctype = vector_ctype,	1581	.ctype = vector_ctype,
1581	.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(pt)),	1582	.alignas = AlignAs.fromAbiAlignment(elem_type.abiAlignment(zcu)),
1582	},	1583	},
1583	};	1584	};
1584	return pool.fromFields(allocator, .@"struct", &fields, kind);	1585	return pool.fromFields(allocator, .@"struct", &fields, kind);
...	@@ -1613,7 +1614,7 @@ pub const Pool = struct {	...	@@ -1613,7 +1614,7 @@ pub const Pool = struct {
1613	.name = .{ .index = .payload },	1614	.name = .{ .index = .payload },
1614	.ctype = payload_ctype,	1615	.ctype = payload_ctype,
1615	.alignas = AlignAs.fromAbiAlignment(	1616	.alignas = AlignAs.fromAbiAlignment(
1616	Type.fromInterned(payload_type).abiAlignment(pt),	1617	Type.fromInterned(payload_type).abiAlignment(zcu),
1617	),	1618	),
1618	},	1619	},
1619	};	1620	};
...	@@ -1649,7 +1650,7 @@ pub const Pool = struct {	...	@@ -1649,7 +1650,7 @@ pub const Pool = struct {
1649	.{	1650	.{
1650	.name = .{ .index = .payload },	1651	.name = .{ .index = .payload },
1651	.ctype = payload_ctype,	1652	.ctype = payload_ctype,
1652	.alignas = AlignAs.fromAbiAlignment(payload_type.abiAlignment(pt)),	1653	.alignas = AlignAs.fromAbiAlignment(payload_type.abiAlignment(zcu)),
1653	},	1654	},
1654	};	1655	};
1655	return pool.fromFields(allocator, .@"struct", &fields, kind);	1656	return pool.fromFields(allocator, .@"struct", &fields, kind);
...	@@ -1663,7 +1664,7 @@ pub const Pool = struct {	...	@@ -1663,7 +1664,7 @@ pub const Pool = struct {
1663	.tag = .@"struct",	1664	.tag = .@"struct",
1664	.name = .{ .index = ip_index },	1665	.name = .{ .index = ip_index },
1665	});	1666	});
1666	if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(pt))	1667	if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
1667	fwd_decl	1668	fwd_decl
1668	else	1669	else
1669	CType.void;	1670	CType.void;
...	@@ -1696,7 +1697,7 @@ pub const Pool = struct {	...	@@ -1696,7 +1697,7 @@ pub const Pool = struct {
1696	String.fromUnnamed(@intCast(field_index));	1697	String.fromUnnamed(@intCast(field_index));
1697	const field_alignas = AlignAs.fromAlignment(.{	1698	const field_alignas = AlignAs.fromAlignment(.{
1698	.@"align" = loaded_struct.fieldAlign(ip, field_index),	1699	.@"align" = loaded_struct.fieldAlign(ip, field_index),
1699	.abi = field_type.abiAlignment(pt),	1700	.abi = field_type.abiAlignment(zcu),
1700	});	1701	});
1701	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{	1702	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
1702	.name = field_name.index,	1703	.name = field_name.index,
...	@@ -1758,7 +1759,7 @@ pub const Pool = struct {	...	@@ -1758,7 +1759,7 @@ pub const Pool = struct {
1758	.name = field_name.index,	1759	.name = field_name.index,
1759	.ctype = field_ctype.index,	1760	.ctype = field_ctype.index,
1760	.flags = .{ .alignas = AlignAs.fromAbiAlignment(	1761	.flags = .{ .alignas = AlignAs.fromAbiAlignment(
1761	field_type.abiAlignment(pt),	1762	field_type.abiAlignment(zcu),
1762	) },	1763	) },
1763	});	1764	});
1764	}	1765	}
...	@@ -1802,7 +1803,7 @@ pub const Pool = struct {	...	@@ -1802,7 +1803,7 @@ pub const Pool = struct {
1802	.tag = if (has_tag) .@"struct" else .@"union",	1803	.tag = if (has_tag) .@"struct" else .@"union",
1803	.name = .{ .index = ip_index },	1804	.name = .{ .index = ip_index },
1804	});	1805	});
1805	if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(pt))	1806	if (kind.isForward()) return if (ty.hasRuntimeBitsIgnoreComptime(zcu))
1806	fwd_decl	1807	fwd_decl
1807	else	1808	else
1808	CType.void;	1809	CType.void;
...	@@ -1836,7 +1837,7 @@ pub const Pool = struct {	...	@@ -1836,7 +1837,7 @@ pub const Pool = struct {
1836	);	1837	);
1837	const field_alignas = AlignAs.fromAlignment(.{	1838	const field_alignas = AlignAs.fromAlignment(.{
1838	.@"align" = loaded_union.fieldAlign(ip, field_index),	1839	.@"align" = loaded_union.fieldAlign(ip, field_index),
1839	.abi = field_type.abiAlignment(pt),	1840	.abi = field_type.abiAlignment(zcu),
1840	});	1841	});
1841	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{	1842	pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
1842	.name = field_name.index,	1843	.name = field_name.index,
...	@@ -1881,7 +1882,7 @@ pub const Pool = struct {	...	@@ -1881,7 +1882,7 @@ pub const Pool = struct {
1881	struct_fields[struct_fields_len] = .{	1882	struct_fields[struct_fields_len] = .{
1882	.name = .{ .index = .tag },	1883	.name = .{ .index = .tag },
1883	.ctype = tag_ctype,	1884	.ctype = tag_ctype,
1884	.alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(pt)),	1885	.alignas = AlignAs.fromAbiAlignment(tag_type.abiAlignment(zcu)),
1885	};	1886	};
1886	struct_fields_len += 1;	1887	struct_fields_len += 1;
1887	}	1888	}
...	@@ -1929,7 +1930,7 @@ pub const Pool = struct {	...	@@ -1929,7 +1930,7 @@ pub const Pool = struct {
1929	},	1930	},
1930	.@"packed" => return pool.fromIntInfo(allocator, .{	1931	.@"packed" => return pool.fromIntInfo(allocator, .{
1931	.signedness = .unsigned,	1932	.signedness = .unsigned,
1932	.bits = @intCast(ty.bitSize(pt)),	1933	.bits = @intCast(ty.bitSize(zcu)),
1933	}, mod, kind),	1934	}, mod, kind),
1934	}	1935	}
1935	},	1936	},

src/codegen/llvm.zig+846-851

 @@ -864,7 +864,7 @@ pub const Object = struct {
             // into the garbage can by converting into absolute paths. What
             // a terrible tragedy.
             const compile_unit_dir = blk: {
-                if (comp.module) |zcu| m: {
+                if (comp.zcu) |zcu| m: {
                     const d = try zcu.main_mod.root.joinString(arena, "");
                     if (d.len == 0) break :m;
                     if (std.fs.path.isAbsolute(d)) break :blk d;
 @@ -955,7 +955,7 @@ pub const Object = struct {
             .gpa = gpa,
             .builder = builder,
             .pt = .{
-                .zcu = comp.module.?,
+                .zcu = comp.zcu.?,
                 .tid = .main,
             },
             .debug_compile_unit = debug_compile_unit,
 @@ -1001,12 +1001,12 @@ pub const Object = struct {
         if (o.error_name_table == .none) return;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const error_name_list = ip.global_error_set.getNamesFromMainThread();
-        const llvm_errors = try mod.gpa.alloc(Builder.Constant, 1 + error_name_list.len);
+        const llvm_errors = try zcu.gpa.alloc(Builder.Constant, 1 + error_name_list.len);
-        defer mod.gpa.free(llvm_errors);
+        defer zcu.gpa.free(llvm_errors);
         // TODO: Address space
         const slice_ty = Type.slice_const_u8_sentinel_0;
 @@ -1041,7 +1041,7 @@ pub const Object = struct {
         table_variable_index.setMutability(.constant, &o.builder);
         table_variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
         table_variable_index.setAlignment(
-            slice_ty.abiAlignment(pt).toLlvm(),
+            slice_ty.abiAlignment(zcu).toLlvm(),
             &o.builder,
         );
 @@ -1428,7 +1428,7 @@ pub const Object = struct {
         var llvm_arg_i: u32 = 0;
         // This gets the LLVM values from the function and stores them in `ng.args`.
-        const sret = firstParamSRet(fn_info, pt, target);
+        const sret = firstParamSRet(fn_info, zcu, target);
         const ret_ptr: Builder.Value = if (sret) param: {
             const param = wip.arg(llvm_arg_i);
             llvm_arg_i += 1;
 @@ -1469,8 +1469,8 @@ pub const Object = struct {
                         const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
                         const param = wip.arg(llvm_arg_i);
-                        if (isByRef(param_ty, pt)) {
+                        if (isByRef(param_ty, zcu)) {
-                            const alignment = param_ty.abiAlignment(pt).toLlvm();
+                            const alignment = param_ty.abiAlignment(zcu).toLlvm();
                             const param_llvm_ty = param.typeOfWip(&wip);
                             const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);
                             _ = try wip.store(.normal, param, arg_ptr, alignment);
 @@ -1486,12 +1486,12 @@ pub const Object = struct {
                         const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                         const param_llvm_ty = try o.lowerType(param_ty);
                         const param = wip.arg(llvm_arg_i);
-                        const alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const alignment = param_ty.abiAlignment(zcu).toLlvm();
                         try o.addByRefParamAttrs(&attributes, llvm_arg_i, alignment, it.byval_attr, param_llvm_ty);
                         llvm_arg_i += 1;
-                        if (isByRef(param_ty, pt)) {
+                        if (isByRef(param_ty, zcu)) {
                             args.appendAssumeCapacity(param);
                         } else {
                             args.appendAssumeCapacity(try wip.load(.normal, param_llvm_ty, param, alignment, ""));
 @@ -1501,12 +1501,12 @@ pub const Object = struct {
                         const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                         const param_llvm_ty = try o.lowerType(param_ty);
                         const param = wip.arg(llvm_arg_i);
-                        const alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const alignment = param_ty.abiAlignment(zcu).toLlvm();
                         try attributes.addParamAttr(llvm_arg_i, .noundef, &o.builder);
                         llvm_arg_i += 1;
-                        if (isByRef(param_ty, pt)) {
+                        if (isByRef(param_ty, zcu)) {
                             args.appendAssumeCapacity(param);
                         } else {
                             args.appendAssumeCapacity(try wip.load(.normal, param_llvm_ty, param, alignment, ""));
 @@ -1519,11 +1519,11 @@ pub const Object = struct {
                         llvm_arg_i += 1;
                         const param_llvm_ty = try o.lowerType(param_ty);
-                        const alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const alignment = param_ty.abiAlignment(zcu).toLlvm();
                         const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);
                         _ = try wip.store(.normal, param, arg_ptr, alignment);
-                        args.appendAssumeCapacity(if (isByRef(param_ty, pt))
+                        args.appendAssumeCapacity(if (isByRef(param_ty, zcu))
                             arg_ptr
                         else
                             try wip.load(.normal, param_llvm_ty, arg_ptr, alignment, ""));
 @@ -1547,7 +1547,7 @@ pub const Object = struct {
                         const elem_align = (if (ptr_info.flags.alignment != .none)
                             @as(InternPool.Alignment, ptr_info.flags.alignment)
                         else
-                            Type.fromInterned(ptr_info.child).abiAlignment(pt).max(.@"1")).toLlvm();
+                            Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1")).toLlvm();
                         try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
                         const ptr_param = wip.arg(llvm_arg_i);
                         llvm_arg_i += 1;
 @@ -1564,7 +1564,7 @@ pub const Object = struct {
                         const field_types = it.types_buffer[0..it.types_len];
                         const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                         const param_llvm_ty = try o.lowerType(param_ty);
-                        const param_alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const param_alignment = param_ty.abiAlignment(zcu).toLlvm();
                         const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, param_alignment, target);
                         const llvm_ty = try o.builder.structType(.normal, field_types);
                         for (0..field_types.len) |field_i| {
 @@ -1576,7 +1576,7 @@ pub const Object = struct {
                             _ = try wip.store(.normal, param, field_ptr, alignment);
                         }
-                        const is_by_ref = isByRef(param_ty, pt);
+                        const is_by_ref = isByRef(param_ty, zcu);
                         args.appendAssumeCapacity(if (is_by_ref)
                             arg_ptr
                         else
 @@ -1594,11 +1594,11 @@ pub const Object = struct {
                         const param = wip.arg(llvm_arg_i);
                         llvm_arg_i += 1;
-                        const alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const alignment = param_ty.abiAlignment(zcu).toLlvm();
                         const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);
                         _ = try wip.store(.normal, param, arg_ptr, alignment);
-                        args.appendAssumeCapacity(if (isByRef(param_ty, pt))
+                        args.appendAssumeCapacity(if (isByRef(param_ty, zcu))
                             arg_ptr
                         else
                             try wip.load(.normal, param_llvm_ty, arg_ptr, alignment, ""));
 @@ -1609,11 +1609,11 @@ pub const Object = struct {
                         const param = wip.arg(llvm_arg_i);
                         llvm_arg_i += 1;
-                        const alignment = param_ty.abiAlignment(pt).toLlvm();
+                        const alignment = param_ty.abiAlignment(zcu).toLlvm();
                         const arg_ptr = try buildAllocaInner(&wip, param.typeOfWip(&wip), alignment, target);
                         _ = try wip.store(.normal, param, arg_ptr, alignment);
-                        args.appendAssumeCapacity(if (isByRef(param_ty, pt))
+                        args.appendAssumeCapacity(if (isByRef(param_ty, zcu))
                             arg_ptr
                         else
                             try wip.load(.normal, param_llvm_ty, arg_ptr, alignment, ""));
 @@ -1738,13 +1738,13 @@ pub const Object = struct {
     fn updateExportedValue(
         o: *Object,
-        mod: *Zcu,
+        zcu: *Zcu,
         exported_value: InternPool.Index,
         export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
-        const gpa = mod.gpa;
+        const gpa = zcu.gpa;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const main_exp_name = try o.builder.strtabString(mod.all_exports.items[export_indices[0]].opts.name.toSlice(ip));
+        const main_exp_name = try o.builder.strtabString(zcu.all_exports.items[export_indices[0]].opts.name.toSlice(ip));
         const global_index = i: {
             const gop = try o.uav_map.getOrPut(gpa, exported_value);
             if (gop.found_existing) {
 @@ -1768,18 +1768,18 @@ pub const Object = struct {
             try variable_index.setInitializer(init_val, &o.builder);
             break :i global_index;
         };
-        return updateExportedGlobal(o, mod, global_index, export_indices);
+        return updateExportedGlobal(o, zcu, global_index, export_indices);
     }
     fn updateExportedGlobal(
         o: *Object,
-        mod: *Zcu,
+        zcu: *Zcu,
         global_index: Builder.Global.Index,
         export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
-        const comp = mod.comp;
+        const comp = zcu.comp;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const first_export = mod.all_exports.items[export_indices[0]];
+        const first_export = zcu.all_exports.items[export_indices[0]];
         // We will rename this global to have a name matching `first_export`.
         // Successive exports become aliases.
 @@ -1836,7 +1836,7 @@ pub const Object = struct {
         // Until then we iterate over existing aliases and make them point
         // to the correct decl, or otherwise add a new alias. Old aliases are leaked.
         for (export_indices[1..]) |export_idx| {
-            const exp = mod.all_exports.items[export_idx];
+            const exp = zcu.all_exports.items[export_idx];
             const exp_name = try o.builder.strtabString(exp.opts.name.toSlice(ip));
             if (o.builder.getGlobal(exp_name)) |global| {
                 switch (global.ptrConst(&o.builder).kind) {
 @@ -1923,7 +1923,7 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
                 const builder_name = try o.builder.metadataString(name);
-                const debug_bits = ty.abiSize(pt) * 8; // lldb cannot handle non-byte sized types
+                const debug_bits = ty.abiSize(zcu) * 8; // lldb cannot handle non-byte sized types
                 const debug_int_type = switch (info.signedness) {
                     .signed => try o.builder.debugSignedType(builder_name, debug_bits),
                     .unsigned => try o.builder.debugUnsignedType(builder_name, debug_bits),
 @@ -1932,7 +1932,7 @@ pub const Object = struct {
                 return debug_int_type;
             },
             .Enum => {
-                if (!ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const debug_enum_type = try o.makeEmptyNamespaceDebugType(ty);
                     try o.debug_type_map.put(gpa, ty, debug_enum_type);
                     return debug_enum_type;
 @@ -1949,7 +1949,7 @@ pub const Object = struct {
                 for (enum_type.names.get(ip), 0..) |field_name_ip, i| {
                     var bigint_space: Value.BigIntSpace = undefined;
                     const bigint = if (enum_type.values.len != 0)
-                        Value.fromInterned(enum_type.values.get(ip)[i]).toBigInt(&bigint_space, pt)
+                        Value.fromInterned(enum_type.values.get(ip)[i]).toBigInt(&bigint_space, zcu)
                     else
                         std.math.big.int.Mutable.init(&bigint_space.limbs, i).toConst();
 @@ -1976,8 +1976,8 @@ pub const Object = struct {
                     scope,
                     ty.typeDeclSrcLine(zcu).? + 1, // Line
                     try o.lowerDebugType(int_ty),
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(enumerators),
                 );
 @@ -2017,10 +2017,10 @@ pub const Object = struct {
                     ptr_info.flags.is_const or
                     ptr_info.flags.is_volatile or
                     ptr_info.flags.size == .Many or ptr_info.flags.size == .C or
-                    !Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(pt))
+                    !Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
                 {
                     const bland_ptr_ty = try pt.ptrType(.{
-                        .child = if (!Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(pt))
+                        .child = if (!Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
                             .anyopaque_type
                         else
                             ptr_info.child,
 @@ -2050,10 +2050,10 @@ pub const Object = struct {
                     defer gpa.free(name);
                     const line = 0;
-                    const ptr_size = ptr_ty.abiSize(pt);
+                    const ptr_size = ptr_ty.abiSize(zcu);
-                    const ptr_align = ptr_ty.abiAlignment(pt);
+                    const ptr_align = ptr_ty.abiAlignment(zcu);
-                    const len_size = len_ty.abiSize(pt);
+                    const len_size = len_ty.abiSize(zcu);
-                    const len_align = len_ty.abiAlignment(pt);
+                    const len_align = len_ty.abiAlignment(zcu);
                     const len_offset = len_align.forward(ptr_size);
 @@ -2085,8 +2085,8 @@ pub const Object = struct {
                         o.debug_compile_unit, // Scope
                         line,
                         .none, // Underlying type
-                        ty.abiSize(pt) * 8,
+                        ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                         try o.builder.debugTuple(&.{
                             debug_ptr_type,
                             debug_len_type,
 @@ -2114,7 +2114,7 @@ pub const Object = struct {
                     0, // Line
                     debug_elem_ty,
                     target.ptrBitWidth(),
-                    (ty.ptrAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.ptrAlignment(zcu).toByteUnits() orelse 0) * 8,
                     0, // Offset
                 );
 @@ -2165,8 +2165,8 @@ pub const Object = struct {
                     .none, // Scope
                     0, // Line
                     try o.lowerDebugType(ty.childType(zcu)),
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         try o.builder.debugSubrange(
                             try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),
 @@ -2208,8 +2208,8 @@ pub const Object = struct {
                     .none, // Scope
                     0, // Line
                     debug_elem_type,
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         try o.builder.debugSubrange(
                             try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),
 @@ -2225,7 +2225,7 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
                 const child_ty = ty.optionalChild(zcu);
-                if (!child_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!child_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const debug_bool_type = try o.builder.debugBoolType(
                         try o.builder.metadataString(name),
                         8,
 @@ -2252,10 +2252,10 @@ pub const Object = struct {
                 }
                 const non_null_ty = Type.u8;
-                const payload_size = child_ty.abiSize(pt);
+                const payload_size = child_ty.abiSize(zcu);
-                const payload_align = child_ty.abiAlignment(pt);
+                const payload_align = child_ty.abiAlignment(zcu);
-                const non_null_size = non_null_ty.abiSize(pt);
+                const non_null_size = non_null_ty.abiSize(zcu);
-                const non_null_align = non_null_ty.abiAlignment(pt);
+                const non_null_align = non_null_ty.abiAlignment(zcu);
                 const non_null_offset = non_null_align.forward(payload_size);
                 const debug_data_type = try o.builder.debugMemberType(
 @@ -2286,8 +2286,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         debug_data_type,
                         debug_some_type,
 @@ -2304,7 +2304,7 @@ pub const Object = struct {
             },
             .ErrorUnion => {
                 const payload_ty = ty.errorUnionPayload(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     // TODO: Maybe remove?
                     const debug_error_union_type = try o.lowerDebugType(Type.anyerror);
                     try o.debug_type_map.put(gpa, ty, debug_error_union_type);
 @@ -2314,10 +2314,10 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
-                const error_size = Type.anyerror.abiSize(pt);
+                const error_size = Type.anyerror.abiSize(zcu);
-                const error_align = Type.anyerror.abiAlignment(pt);
+                const error_align = Type.anyerror.abiAlignment(zcu);
-                const payload_size = payload_ty.abiSize(pt);
+                const payload_size = payload_ty.abiSize(zcu);
-                const payload_align = payload_ty.abiAlignment(pt);
+                const payload_align = payload_ty.abiAlignment(zcu);
                 var error_index: u32 = undefined;
                 var payload_index: u32 = undefined;
 @@ -2365,8 +2365,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Sope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&fields),
                 );
 @@ -2393,8 +2393,8 @@ pub const Object = struct {
                         const info = Type.fromInterned(backing_int_ty).intInfo(zcu);
                         const builder_name = try o.builder.metadataString(name);
                         const debug_int_type = switch (info.signedness) {
-                            .signed => try o.builder.debugSignedType(builder_name, ty.abiSize(pt) * 8),
+                            .signed => try o.builder.debugSignedType(builder_name, ty.abiSize(zcu) * 8),
-                            .unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(pt) * 8),
+                            .unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(zcu) * 8),
                         };
                         try o.debug_type_map.put(gpa, ty, debug_int_type);
                         return debug_int_type;
 @@ -2414,10 +2414,10 @@ pub const Object = struct {
                         const debug_fwd_ref = try o.builder.debugForwardReference();
                         for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, field_val, i| {
-                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
+                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
-                            const field_size = Type.fromInterned(field_ty).abiSize(pt);
+                            const field_size = Type.fromInterned(field_ty).abiSize(zcu);
-                            const field_align = Type.fromInterned(field_ty).abiAlignment(pt);
+                            const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
                             const field_offset = field_align.forward(offset);
                             offset = field_offset + field_size;
 @@ -2445,8 +2445,8 @@ pub const Object = struct {
                             o.debug_compile_unit, // Scope
                             0, // Line
                             .none, // Underlying type
-                            ty.abiSize(pt) * 8,
+                            ty.abiSize(zcu) * 8,
-                            (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                            (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                             try o.builder.debugTuple(fields.items),
                         );
 @@ -2472,7 +2472,7 @@ pub const Object = struct {
                     else => {},
                 }
-                if (!ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const debug_struct_type = try o.makeEmptyNamespaceDebugType(ty);
                     try o.debug_type_map.put(gpa, ty, debug_struct_type);
                     return debug_struct_type;
 @@ -2494,18 +2494,12 @@ pub const Object = struct {
                 var it = struct_type.iterateRuntimeOrder(ip);
                 while (it.next()) |field_index| {
                     const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    const field_size = field_ty.abiSize(pt);
+                    const field_size = field_ty.abiSize(zcu);
-                    const field_align = pt.structFieldAlignment(
+                    const field_align = ty.fieldAlignment(field_index, zcu);
-                        struct_type.fieldAlign(ip, field_index),
+                    const field_offset = ty.structFieldOffset(field_index, zcu);
-                        field_ty,
-                        struct_type.layout,
-                    );
-                    const field_offset = ty.structFieldOffset(field_index, pt);
                     const field_name = struct_type.fieldName(ip, field_index).unwrap() orelse
                         try ip.getOrPutStringFmt(gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
                     fields.appendAssumeCapacity(try o.builder.debugMemberType(
                         try o.builder.metadataString(field_name.toSlice(ip)),
                         .none, // File
 @@ -2524,8 +2518,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(fields.items),
                 );
 @@ -2543,7 +2537,7 @@ pub const Object = struct {
                 const union_type = ip.loadUnionType(ty.toIntern());
                 if (!union_type.haveFieldTypes(ip) or
-                    !ty.hasRuntimeBitsIgnoreComptime(pt) or
+                    !ty.hasRuntimeBitsIgnoreComptime(zcu) or
                     !union_type.haveLayout(ip))
                 {
                     const debug_union_type = try o.makeEmptyNamespaceDebugType(ty);
 @@ -2551,7 +2545,7 @@ pub const Object = struct {
                     return debug_union_type;
                 }
-                const layout = pt.getUnionLayout(union_type);
+                const layout = Type.getUnionLayout(union_type, zcu);
                 const debug_fwd_ref = try o.builder.debugForwardReference();
 @@ -2565,8 +2559,8 @@ pub const Object = struct {
                         o.debug_compile_unit, // Scope
                         0, // Line
                         .none, // Underlying type
-                        ty.abiSize(pt) * 8,
+                        ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                         try o.builder.debugTuple(
                             &.{try o.lowerDebugType(Type.fromInterned(union_type.enum_tag_ty))},
                         ),
 @@ -2593,12 +2587,12 @@ pub const Object = struct {
                 for (0..tag_type.names.len) |field_index| {
                     const field_ty = union_type.field_types.get(ip)[field_index];
-                    if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) continue;
+                    if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    const field_size = Type.fromInterned(field_ty).abiSize(pt);
+                    const field_size = Type.fromInterned(field_ty).abiSize(zcu);
                     const field_align: InternPool.Alignment = switch (union_type.flagsUnordered(ip).layout) {
                         .@"packed" => .none,
-                        .auto, .@"extern" => pt.unionFieldNormalAlignment(union_type, @intCast(field_index)),
+                        .auto, .@"extern" => ty.fieldAlignment(field_index, zcu),
                     };
                     const field_name = tag_type.names.get(ip)[field_index];
 @@ -2627,8 +2621,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(fields.items),
                 );
 @@ -2686,8 +2680,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(pt) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(pt).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&full_fields),
                 );
 @@ -2708,8 +2702,8 @@ pub const Object = struct {
                 try debug_param_types.ensureUnusedCapacity(3 + fn_info.param_types.len);
                 // Return type goes first.
-                if (Type.fromInterned(fn_info.return_type).hasRuntimeBitsIgnoreComptime(pt)) {
+                if (Type.fromInterned(fn_info.return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const sret = firstParamSRet(fn_info, pt, target);
+                    const sret = firstParamSRet(fn_info, zcu, target);
                     const ret_ty = if (sret) Type.void else Type.fromInterned(fn_info.return_type);
                     debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ret_ty));
 @@ -2730,9 +2724,9 @@ pub const Object = struct {
                 for (0..fn_info.param_types.len) |i| {
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[i]);
-                    if (!param_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                    if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    if (isByRef(param_ty, pt)) {
+                    if (isByRef(param_ty, zcu)) {
                         const ptr_ty = try pt.singleMutPtrType(param_ty);
                         debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));
                     } else {
 @@ -2842,7 +2836,7 @@ pub const Object = struct {
         const fn_info = zcu.typeToFunc(ty).?;
         const target = owner_mod.resolved_target.result;
-        const sret = firstParamSRet(fn_info, pt, target);
+        const sret = firstParamSRet(fn_info, zcu, target);
         const is_extern, const lib_name = switch (ip.indexToKey(val.toIntern())) {
             .variable => |variable| .{ false, variable.lib_name },
 @@ -2934,14 +2928,14 @@ pub const Object = struct {
                 .byval => {
                     const param_index = it.zig_index - 1;
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
-                    if (!isByRef(param_ty, pt)) {
+                    if (!isByRef(param_ty, zcu)) {
                         try o.addByValParamAttrs(&attributes, param_ty, param_index, fn_info, it.llvm_index - 1);
                     }
                 },
                 .byref => {
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                     const param_llvm_ty = try o.lowerType(param_ty);
-                    const alignment = param_ty.abiAlignment(pt);
+                    const alignment = param_ty.abiAlignment(zcu);
                     try o.addByRefParamAttrs(&attributes, it.llvm_index - 1, alignment.toLlvm(), it.byval_attr, param_llvm_ty);
                 },
                 .byref_mut => try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder),
 @@ -3042,8 +3036,8 @@ pub const Object = struct {
         }
         errdefer assert(o.uav_map.remove(uav));
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const decl_ty = mod.intern_pool.typeOf(uav);
+        const decl_ty = zcu.intern_pool.typeOf(uav);
         const variable_index = try o.builder.addVariable(
             try o.builder.strtabStringFmt("__anon_{d}", .{@intFromEnum(uav)}),
 @@ -3106,9 +3100,9 @@ pub const Object = struct {
     fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         return switch (t.toIntern()) {
             .u0_type, .i0_type => unreachable,
             inline .u1_type,
 @@ -3230,16 +3224,16 @@ pub const Object = struct {
                 ),
                 .opt_type => |child_ty| {
                     // Must stay in sync with `opt_payload` logic in `lowerPtr`.
-                    if (!Type.fromInterned(child_ty).hasRuntimeBitsIgnoreComptime(pt)) return .i8;
+                    if (!Type.fromInterned(child_ty).hasRuntimeBitsIgnoreComptime(zcu)) return .i8;
                     const payload_ty = try o.lowerType(Type.fromInterned(child_ty));
-                    if (t.optionalReprIsPayload(mod)) return payload_ty;
+                    if (t.optionalReprIsPayload(zcu)) return payload_ty;
                     comptime assert(optional_layout_version == 3);
                     var fields: [3]Builder.Type = .{ payload_ty, .i8, undefined };
                     var fields_len: usize = 2;
-                    const offset = Type.fromInterned(child_ty).abiSize(pt) + 1;
+                    const offset = Type.fromInterned(child_ty).abiSize(zcu) + 1;
-                    const abi_size = t.abiSize(pt);
+                    const abi_size = t.abiSize(zcu);
                     const padding_len = abi_size - offset;
                     if (padding_len > 0) {
                         fields[2] = try o.builder.arrayType(padding_len, .i8);
 @@ -3252,16 +3246,16 @@ pub const Object = struct {
                     // Must stay in sync with `codegen.errUnionPayloadOffset`.
                     // See logic in `lowerPtr`.
                     const error_type = try o.errorIntType();
-                    if (!Type.fromInterned(error_union_type.payload_type).hasRuntimeBitsIgnoreComptime(pt))
+                    if (!Type.fromInterned(error_union_type.payload_type).hasRuntimeBitsIgnoreComptime(zcu))
                         return error_type;
                     const payload_type = try o.lowerType(Type.fromInterned(error_union_type.payload_type));
                     const err_int_ty = try o.pt.errorIntType();
-                    const payload_align = Type.fromInterned(error_union_type.payload_type).abiAlignment(pt);
+                    const payload_align = Type.fromInterned(error_union_type.payload_type).abiAlignment(zcu);
-                    const error_align = err_int_ty.abiAlignment(pt);
+                    const error_align = err_int_ty.abiAlignment(zcu);
-                    const payload_size = Type.fromInterned(error_union_type.payload_type).abiSize(pt);
+                    const payload_size = Type.fromInterned(error_union_type.payload_type).abiSize(zcu);
-                    const error_size = err_int_ty.abiSize(pt);
+                    const error_size = err_int_ty.abiSize(zcu);
                     var fields: [3]Builder.Type = undefined;
                     var fields_len: usize = 2;
 @@ -3315,12 +3309,8 @@ pub const Object = struct {
                     var it = struct_type.iterateRuntimeOrder(ip);
                     while (it.next()) |field_index| {
                         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        const field_align = pt.structFieldAlignment(
+                        const field_align = t.fieldAlignment(field_index, zcu);
-                            struct_type.fieldAlign(ip, field_index),
+                        const field_ty_align = field_ty.abiAlignment(zcu);
-                            field_ty,
-                            struct_type.layout,
-                        );
-                        const field_ty_align = field_ty.abiAlignment(pt);
                         if (field_align.compare(.lt, field_ty_align)) struct_kind = .@"packed";
                         big_align = big_align.max(field_align);
                         const prev_offset = offset;
 @@ -3332,7 +3322,7 @@ pub const Object = struct {
                             try o.builder.arrayType(padding_len, .i8),
                         );
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                             // This is a zero-bit field. If there are runtime bits after this field,
                             // map to the next LLVM field (which we know exists): otherwise, don't
                             // map the field, indicating it's at the end of the struct.
 @@ -3351,7 +3341,7 @@ pub const Object = struct {
                         }, @intCast(llvm_field_types.items.len));
                         try llvm_field_types.append(o.gpa, try o.lowerType(field_ty));
-                        offset += field_ty.abiSize(pt);
+                        offset += field_ty.abiSize(zcu);
                     }
                     {
                         const prev_offset = offset;
 @@ -3384,7 +3374,7 @@ pub const Object = struct {
                     var offset: u64 = 0;
                     var big_align: InternPool.Alignment = .none;
-                    const struct_size = t.abiSize(pt);
+                    const struct_size = t.abiSize(zcu);
                     for (
                         anon_struct_type.types.get(ip),
 @@ -3393,7 +3383,7 @@ pub const Object = struct {
                     ) |field_ty, field_val, field_index| {
                         if (field_val != .none) continue;
-                        const field_align = Type.fromInterned(field_ty).abiAlignment(pt);
+                        const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
                         big_align = big_align.max(field_align);
                         const prev_offset = offset;
                         offset = field_align.forward(offset);
 @@ -3403,7 +3393,7 @@ pub const Object = struct {
                             o.gpa,
                             try o.builder.arrayType(padding_len, .i8),
                         );
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) {
+                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) {
                             // This is a zero-bit field. If there are runtime bits after this field,
                             // map to the next LLVM field (which we know exists): otherwise, don't
                             // map the field, indicating it's at the end of the struct.
 @@ -3421,7 +3411,7 @@ pub const Object = struct {
                         }, @intCast(llvm_field_types.items.len));
                         try llvm_field_types.append(o.gpa, try o.lowerType(Type.fromInterned(field_ty)));
-                        offset += Type.fromInterned(field_ty).abiSize(pt);
+                        offset += Type.fromInterned(field_ty).abiSize(zcu);
                     }
                     {
                         const prev_offset = offset;
 @@ -3438,10 +3428,10 @@ pub const Object = struct {
                     if (o.type_map.get(t.toIntern())) |value| return value;
                     const union_obj = ip.loadUnionType(t.toIntern());
-                    const layout = pt.getUnionLayout(union_obj);
+                    const layout = Type.getUnionLayout(union_obj, zcu);
                     if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-                        const int_ty = try o.builder.intType(@intCast(t.bitSize(pt)));
+                        const int_ty = try o.builder.intType(@intCast(t.bitSize(zcu)));
                         try o.type_map.put(o.gpa, t.toIntern(), int_ty);
                         return int_ty;
                     }
 @@ -3547,32 +3537,32 @@ pub const Object = struct {
     /// There are other similar cases handled here as well.
     fn lowerPtrElemTy(o: *Object, elem_ty: Type) Allocator.Error!Builder.Type {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const lower_elem_ty = switch (elem_ty.zigTypeTag(mod)) {
+        const lower_elem_ty = switch (elem_ty.zigTypeTag(zcu)) {
             .Opaque => true,
-            .Fn => !mod.typeToFunc(elem_ty).?.is_generic,
+            .Fn => !zcu.typeToFunc(elem_ty).?.is_generic,
-            .Array => elem_ty.childType(mod).hasRuntimeBitsIgnoreComptime(pt),
+            .Array => elem_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu),
-            else => elem_ty.hasRuntimeBitsIgnoreComptime(pt),
+            else => elem_ty.hasRuntimeBitsIgnoreComptime(zcu),
         };
         return if (lower_elem_ty) try o.lowerType(elem_ty) else .i8;
     }
     fn lowerTypeFn(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const ret_ty = try lowerFnRetTy(o, fn_info);
         var llvm_params = std.ArrayListUnmanaged(Builder.Type){};
         defer llvm_params.deinit(o.gpa);
-        if (firstParamSRet(fn_info, pt, target)) {
+        if (firstParamSRet(fn_info, zcu, target)) {
             try llvm_params.append(o.gpa, .ptr);
         }
-        if (Type.fromInterned(fn_info.return_type).isError(mod) and
+        if (Type.fromInterned(fn_info.return_type).isError(zcu) and
-            mod.comp.config.any_error_tracing)
+            zcu.comp.config.any_error_tracing)
         {
             const ptr_ty = try pt.singleMutPtrType(try o.getStackTraceType());
             try llvm_params.append(o.gpa, try o.lowerType(ptr_ty));
 @@ -3591,13 +3581,13 @@ pub const Object = struct {
             .abi_sized_int => {
                 const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                 try llvm_params.append(o.gpa, try o.builder.intType(
-                    @intCast(param_ty.abiSize(pt) * 8),
+                    @intCast(param_ty.abiSize(zcu) * 8),
                 ));
             },
             .slice => {
                 const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                 try llvm_params.appendSlice(o.gpa, &.{
-                    try o.builder.ptrType(toLlvmAddressSpace(param_ty.ptrAddressSpace(mod), target)),
+                    try o.builder.ptrType(toLlvmAddressSpace(param_ty.ptrAddressSpace(zcu), target)),
                     try o.lowerType(Type.usize),
                 });
             },
 @@ -3609,7 +3599,7 @@ pub const Object = struct {
             },
             .float_array => |count| {
                 const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
-                const float_ty = try o.lowerType(aarch64_c_abi.getFloatArrayType(param_ty, mod).?);
+                const float_ty = try o.lowerType(aarch64_c_abi.getFloatArrayType(param_ty, zcu).?);
                 try llvm_params.append(o.gpa, try o.builder.arrayType(count, float_ty));
             },
             .i32_array, .i64_array => |arr_len| {
 @@ -3630,14 +3620,14 @@ pub const Object = struct {
     fn lowerValueToInt(o: *Object, llvm_int_ty: Builder.Type, arg_val: InternPool.Index) Error!Builder.Constant {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const val = Value.fromInterned(arg_val);
         const val_key = ip.indexToKey(val.toIntern());
-        if (val.isUndefDeep(mod)) return o.builder.undefConst(llvm_int_ty);
+        if (val.isUndefDeep(zcu)) return o.builder.undefConst(llvm_int_ty);
         const ty = Type.fromInterned(val_key.typeOf());
         switch (val_key) {
 @@ -3661,7 +3651,7 @@ pub const Object = struct {
                     var running_int = try o.builder.intConst(llvm_int_ty, 0);
                     var running_bits: u16 = 0;
                     for (struct_type.field_types.get(ip), 0..) |field_ty, field_index| {
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) continue;
+                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
                         const shift_rhs = try o.builder.intConst(llvm_int_ty, running_bits);
                         const field_val = try o.lowerValueToInt(llvm_int_ty, (try val.fieldValue(pt, field_index)).toIntern());
 @@ -3669,7 +3659,7 @@ pub const Object = struct {
                         running_int = try o.builder.binConst(.xor, running_int, shifted);
-                        const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(pt));
+                        const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(zcu));
                         running_bits += ty_bit_size;
                     }
                     return running_int;
 @@ -3678,10 +3668,10 @@ pub const Object = struct {
                 else => unreachable,
             },
             .un => |un| {
-                const layout = ty.unionGetLayout(pt);
+                const layout = ty.unionGetLayout(zcu);
                 if (layout.payload_size == 0) return o.lowerValue(un.tag);
-                const union_obj = mod.typeToUnion(ty).?;
+                const union_obj = zcu.typeToUnion(ty).?;
                 const container_layout = union_obj.flagsUnordered(ip).layout;
                 assert(container_layout == .@"packed");
 @@ -3694,9 +3684,9 @@ pub const Object = struct {
                     need_unnamed = true;
                     return union_val;
                 }
-                const field_index = mod.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
+                const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
                 const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
-                if (!field_ty.hasRuntimeBits(pt)) return o.builder.intConst(llvm_int_ty, 0);
+                if (!field_ty.hasRuntimeBits(zcu)) return o.builder.intConst(llvm_int_ty, 0);
                 return o.lowerValueToInt(llvm_int_ty, un.val);
             },
             .simple_value => |simple_value| switch (simple_value) {
 @@ -3710,7 +3700,7 @@ pub const Object = struct {
             .opt => {}, // pointer like optional expected
             else => unreachable,
         }
-        const bits = ty.bitSize(pt);
+        const bits = ty.bitSize(zcu);
         const bytes: usize = @intCast(std.mem.alignForward(u64, bits, 8) / 8);
         var stack = std.heap.stackFallback(32, o.gpa);
 @@ -3743,14 +3733,14 @@ pub const Object = struct {
     fn lowerValue(o: *Object, arg_val: InternPool.Index) Error!Builder.Constant {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const val = Value.fromInterned(arg_val);
         const val_key = ip.indexToKey(val.toIntern());
-        if (val.isUndefDeep(mod)) {
+        if (val.isUndefDeep(zcu)) {
             return o.builder.undefConst(try o.lowerType(Type.fromInterned(val_key.typeOf())));
         }
 @@ -3800,7 +3790,7 @@ pub const Object = struct {
             },
             .int => {
                 var bigint_space: Value.BigIntSpace = undefined;
-                const bigint = val.toBigInt(&bigint_space, pt);
+                const bigint = val.toBigInt(&bigint_space, zcu);
                 return lowerBigInt(o, ty, bigint);
             },
             .err => |err| {
 @@ -3811,20 +3801,20 @@ pub const Object = struct {
             .error_union => |error_union| {
                 const err_val = switch (error_union.val) {
                     .err_name => |err_name| try pt.intern(.{ .err = .{
-                        .ty = ty.errorUnionSet(mod).toIntern(),
+                        .ty = ty.errorUnionSet(zcu).toIntern(),
                         .name = err_name,
                     } }),
                     .payload => (try pt.intValue(try pt.errorIntType(), 0)).toIntern(),
                 };
                 const err_int_ty = try pt.errorIntType();
-                const payload_type = ty.errorUnionPayload(mod);
+                const payload_type = ty.errorUnionPayload(zcu);
-                if (!payload_type.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_type.hasRuntimeBitsIgnoreComptime(zcu)) {
                     // We use the error type directly as the type.
                     return o.lowerValue(err_val);
                 }
-                const payload_align = payload_type.abiAlignment(pt);
+                const payload_align = payload_type.abiAlignment(zcu);
-                const error_align = err_int_ty.abiAlignment(pt);
+                const error_align = err_int_ty.abiAlignment(zcu);
                 const llvm_error_value = try o.lowerValue(err_val);
                 const llvm_payload_value = try o.lowerValue(switch (error_union.val) {
                     .err_name => try pt.intern(.{ .undef = payload_type.toIntern() }),
 @@ -3858,16 +3848,16 @@ pub const Object = struct {
             .enum_tag => |enum_tag| o.lowerValue(enum_tag.int),
             .float => switch (ty.floatBits(target)) {
                 16 => if (backendSupportsF16(target))
-                    try o.builder.halfConst(val.toFloat(f16, pt))
+                    try o.builder.halfConst(val.toFloat(f16, zcu))
                 else
-                    try o.builder.intConst(.i16, @as(i16, @bitCast(val.toFloat(f16, pt)))),
+                    try o.builder.intConst(.i16, @as(i16, @bitCast(val.toFloat(f16, zcu)))),
-                32 => try o.builder.floatConst(val.toFloat(f32, pt)),
+                32 => try o.builder.floatConst(val.toFloat(f32, zcu)),
-                64 => try o.builder.doubleConst(val.toFloat(f64, pt)),
+                64 => try o.builder.doubleConst(val.toFloat(f64, zcu)),
                 80 => if (backendSupportsF80(target))
-                    try o.builder.x86_fp80Const(val.toFloat(f80, pt))
+                    try o.builder.x86_fp80Const(val.toFloat(f80, zcu))
                 else
-                    try o.builder.intConst(.i80, @as(i80, @bitCast(val.toFloat(f80, pt)))),
+                    try o.builder.intConst(.i80, @as(i80, @bitCast(val.toFloat(f80, zcu)))),
-                128 => try o.builder.fp128Const(val.toFloat(f128, pt)),
+                128 => try o.builder.fp128Const(val.toFloat(f128, zcu)),
                 else => unreachable,
             },
             .ptr => try o.lowerPtr(arg_val, 0),
 @@ -3877,14 +3867,14 @@ pub const Object = struct {
             }),
             .opt => |opt| {
                 comptime assert(optional_layout_version == 3);
-                const payload_ty = ty.optionalChild(mod);
+                const payload_ty = ty.optionalChild(zcu);
                 const non_null_bit = try o.builder.intConst(.i8, @intFromBool(opt.val != .none));
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     return non_null_bit;
                 }
                 const llvm_ty = try o.lowerType(ty);
-                if (ty.optionalReprIsPayload(mod)) return switch (opt.val) {
+                if (ty.optionalReprIsPayload(zcu)) return switch (opt.val) {
                     .none => switch (llvm_ty.tag(&o.builder)) {
                         .integer => try o.builder.intConst(llvm_ty, 0),
                         .pointer => try o.builder.nullConst(llvm_ty),
 @@ -3893,7 +3883,7 @@ pub const Object = struct {
                     },
                     else => |payload| try o.lowerValue(payload),
                 };
-                assert(payload_ty.zigTypeTag(mod) != .Fn);
+                assert(payload_ty.zigTypeTag(zcu) != .Fn);
                 var fields: [3]Builder.Type = undefined;
                 var vals: [3]Builder.Constant = undefined;
 @@ -4047,9 +4037,9 @@ pub const Object = struct {
                         0..,
                     ) |field_ty, field_val, field_index| {
                         if (field_val != .none) continue;
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) continue;
+                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                        const field_align = Type.fromInterned(field_ty).abiAlignment(pt);
+                        const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
                         big_align = big_align.max(field_align);
                         const prev_offset = offset;
                         offset = field_align.forward(offset);
 @@ -4071,7 +4061,7 @@ pub const Object = struct {
                             need_unnamed = true;
                         llvm_index += 1;
-                        offset += Type.fromInterned(field_ty).abiSize(pt);
+                        offset += Type.fromInterned(field_ty).abiSize(zcu);
                     }
                     {
                         const prev_offset = offset;
 @@ -4098,7 +4088,7 @@ pub const Object = struct {
                     if (struct_type.layout == .@"packed") {
                         comptime assert(Type.packed_struct_layout_version == 2);
-                        const bits = ty.bitSize(pt);
+                        const bits = ty.bitSize(zcu);
                         const llvm_int_ty = try o.builder.intType(@intCast(bits));
                         return o.lowerValueToInt(llvm_int_ty, arg_val);
 @@ -4127,11 +4117,7 @@ pub const Object = struct {
                     var field_it = struct_type.iterateRuntimeOrder(ip);
                     while (field_it.next()) |field_index| {
                         const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                        const field_align = pt.structFieldAlignment(
+                        const field_align = ty.fieldAlignment(field_index, zcu);
-                            struct_type.fieldAlign(ip, field_index),
-                            field_ty,
-                            struct_type.layout,
-                        );
                         big_align = big_align.max(field_align);
                         const prev_offset = offset;
                         offset = field_align.forward(offset);
 @@ -4147,7 +4133,7 @@ pub const Object = struct {
                             llvm_index += 1;
                         }
-                        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                             // This is a zero-bit field - we only needed it for the alignment.
                             continue;
                         }
 @@ -4160,7 +4146,7 @@ pub const Object = struct {
                             need_unnamed = true;
                         llvm_index += 1;
-                        offset += field_ty.abiSize(pt);
+                        offset += field_ty.abiSize(zcu);
                     }
                     {
                         const prev_offset = offset;
 @@ -4184,19 +4170,19 @@ pub const Object = struct {
             },
             .un => |un| {
                 const union_ty = try o.lowerType(ty);
-                const layout = ty.unionGetLayout(pt);
+                const layout = ty.unionGetLayout(zcu);
                 if (layout.payload_size == 0) return o.lowerValue(un.tag);
-                const union_obj = mod.typeToUnion(ty).?;
+                const union_obj = zcu.typeToUnion(ty).?;
                 const container_layout = union_obj.flagsUnordered(ip).layout;
                 var need_unnamed = false;
                 const payload = if (un.tag != .none) p: {
-                    const field_index = mod.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
+                    const field_index = zcu.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;
                     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
                     if (container_layout == .@"packed") {
-                        if (!field_ty.hasRuntimeBits(pt)) return o.builder.intConst(union_ty, 0);
+                        if (!field_ty.hasRuntimeBits(zcu)) return o.builder.intConst(union_ty, 0);
-                        const bits = ty.bitSize(pt);
+                        const bits = ty.bitSize(zcu);
                         const llvm_int_ty = try o.builder.intType(@intCast(bits));
                         return o.lowerValueToInt(llvm_int_ty, arg_val);
 @@ -4208,7 +4194,7 @@ pub const Object = struct {
                     // must pointer cast to the expected type before accessing the union.
                     need_unnamed = layout.most_aligned_field != field_index;
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                         const padding_len = layout.payload_size;
                         break :p try o.builder.undefConst(try o.builder.arrayType(padding_len, .i8));
                     }
 @@ -4217,7 +4203,7 @@ pub const Object = struct {
                     if (payload_ty != union_ty.structFields(&o.builder)[
                         @intFromBool(layout.tag_align.compare(.gte, layout.payload_align))
                     ]) need_unnamed = true;
-                    const field_size = field_ty.abiSize(pt);
+                    const field_size = field_ty.abiSize(zcu);
                     if (field_size == layout.payload_size) break :p payload;
                     const padding_len = layout.payload_size - field_size;
                     const padding_ty = try o.builder.arrayType(padding_len, .i8);
 @@ -4228,7 +4214,7 @@ pub const Object = struct {
                 } else p: {
                     assert(layout.tag_size == 0);
                     if (container_layout == .@"packed") {
-                        const bits = ty.bitSize(pt);
+                        const bits = ty.bitSize(zcu);
                         const llvm_int_ty = try o.builder.intType(@intCast(bits));
                         return o.lowerValueToInt(llvm_int_ty, arg_val);
 @@ -4275,8 +4261,8 @@ pub const Object = struct {
         ty: Type,
         bigint: std.math.big.int.Const,
     ) Allocator.Error!Builder.Constant {
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        return o.builder.bigIntConst(try o.builder.intType(ty.intInfo(mod).bits), bigint);
+        return o.builder.bigIntConst(try o.builder.intType(ty.intInfo(zcu).bits), bigint);
     }
     fn lowerPtr(
 @@ -4310,7 +4296,7 @@ pub const Object = struct {
                 eu_ptr,
                 offset + @import("../codegen.zig").errUnionPayloadOffset(
                     Value.fromInterned(eu_ptr).typeOf(zcu).childType(zcu),
-                    pt,
+                    zcu,
                 ),
             ),
             .opt_payload => |opt_ptr| try o.lowerPtr(opt_ptr, offset),
 @@ -4326,7 +4312,7 @@ pub const Object = struct {
                         };
                     },
                     .Struct, .Union => switch (agg_ty.containerLayout(zcu)) {
-                        .auto => agg_ty.structFieldOffset(@intCast(field.index), pt),
+                        .auto => agg_ty.structFieldOffset(@intCast(field.index), zcu),
                         .@"extern", .@"packed" => unreachable,
                     },
                     else => unreachable,
 @@ -4344,11 +4330,11 @@ pub const Object = struct {
         uav: InternPool.Key.Ptr.BaseAddr.Uav,
     ) Error!Builder.Constant {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const uav_val = uav.val;
         const uav_ty = Type.fromInterned(ip.typeOf(uav_val));
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         switch (ip.indexToKey(uav_val)) {
             .func => @panic("TODO"),
 @@ -4358,15 +4344,15 @@ pub const Object = struct {
         const ptr_ty = Type.fromInterned(uav.orig_ty);
-        const is_fn_body = uav_ty.zigTypeTag(mod) == .Fn;
+        const is_fn_body = uav_ty.zigTypeTag(zcu) == .Fn;
-        if ((!is_fn_body and !uav_ty.hasRuntimeBits(pt)) or
+        if ((!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) or
-            (is_fn_body and mod.typeToFunc(uav_ty).?.is_generic)) return o.lowerPtrToVoid(ptr_ty);
+            (is_fn_body and zcu.typeToFunc(uav_ty).?.is_generic)) return o.lowerPtrToVoid(ptr_ty);
         if (is_fn_body)
             @panic("TODO");
-        const llvm_addr_space = toLlvmAddressSpace(ptr_ty.ptrAddressSpace(mod), target);
+        const llvm_addr_space = toLlvmAddressSpace(ptr_ty.ptrAddressSpace(zcu), target);
-        const alignment = ptr_ty.ptrAlignment(pt);
+        const alignment = ptr_ty.ptrAlignment(zcu);
         const llvm_global = (try o.resolveGlobalUav(uav.val, llvm_addr_space, alignment)).ptrConst(&o.builder).global;
         const llvm_val = try o.builder.convConst(
 @@ -4398,7 +4384,7 @@ pub const Object = struct {
         const ptr_ty = try pt.navPtrType(owner_nav_index);
         const is_fn_body = nav_ty.zigTypeTag(zcu) == .Fn;
-        if ((!is_fn_body and !nav_ty.hasRuntimeBits(pt)) or
+        if ((!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) or
             (is_fn_body and zcu.typeToFunc(nav_ty).?.is_generic))
         {
             return o.lowerPtrToVoid(ptr_ty);
 @@ -4418,19 +4404,19 @@ pub const Object = struct {
     }
     fn lowerPtrToVoid(o: *Object, ptr_ty: Type) Allocator.Error!Builder.Constant {
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         // Even though we are pointing at something which has zero bits (e.g. `void`),
         // Pointers are defined to have bits. So we must return something here.
         // The value cannot be undefined, because we use the `nonnull` annotation
         // for non-optional pointers. We also need to respect the alignment, even though
         // the address will never be dereferenced.
-        const int: u64 = ptr_ty.ptrInfo(mod).flags.alignment.toByteUnits() orelse
+        const int: u64 = ptr_ty.ptrInfo(zcu).flags.alignment.toByteUnits() orelse
             // Note that these 0xaa values are appropriate even in release-optimized builds
             // because we need a well-defined value that is not null, and LLVM does not
             // have an "undef_but_not_null" attribute. As an example, if this `alloc` AIR
             // instruction is followed by a `wrap_optional`, it will return this value
             // verbatim, and the result should test as non-null.
-            switch (mod.getTarget().ptrBitWidth()) {
+            switch (zcu.getTarget().ptrBitWidth()) {
             16 => 0xaaaa,
             32 => 0xaaaaaaaa,
             64 => 0xaaaaaaaa_aaaaaaaa,
 @@ -4447,20 +4433,20 @@ pub const Object = struct {
     /// types to work around a LLVM deficiency when targeting ARM/AArch64.
     fn getAtomicAbiType(o: *Object, ty: Type, is_rmw_xchg: bool) Allocator.Error!Builder.Type {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const int_ty = switch (ty.zigTypeTag(mod)) {
+        const int_ty = switch (ty.zigTypeTag(zcu)) {
             .Int => ty,
-            .Enum => ty.intTagType(mod),
+            .Enum => ty.intTagType(zcu),
             .Float => {
                 if (!is_rmw_xchg) return .none;
-                return o.builder.intType(@intCast(ty.abiSize(pt) * 8));
+                return o.builder.intType(@intCast(ty.abiSize(zcu) * 8));
             },
             .Bool => return .i8,
             else => return .none,
         };
-        const bit_count = int_ty.intInfo(mod).bits;
+        const bit_count = int_ty.intInfo(zcu).bits;
         if (!std.math.isPowerOfTwo(bit_count) or (bit_count % 8) != 0) {
-            return o.builder.intType(@intCast(int_ty.abiSize(pt) * 8));
+            return o.builder.intType(@intCast(int_ty.abiSize(zcu) * 8));
         } else {
             return .none;
         }
 @@ -4475,15 +4461,15 @@ pub const Object = struct {
         llvm_arg_i: u32,
     ) Allocator.Error!void {
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        if (param_ty.isPtrAtRuntime(mod)) {
+        if (param_ty.isPtrAtRuntime(zcu)) {
-            const ptr_info = param_ty.ptrInfo(mod);
+            const ptr_info = param_ty.ptrInfo(zcu);
             if (math.cast(u5, param_index)) |i| {
                 if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
                     try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
                 }
             }
-            if (!param_ty.isPtrLikeOptional(mod) and !ptr_info.flags.is_allowzero) {
+            if (!param_ty.isPtrLikeOptional(zcu) and !ptr_info.flags.is_allowzero) {
                 try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
             }
             if (fn_info.cc == .Interrupt) {
 @@ -4496,9 +4482,9 @@ pub const Object = struct {
             const elem_align = if (ptr_info.flags.alignment != .none)
                 ptr_info.flags.alignment
             else
-                Type.fromInterned(ptr_info.child).abiAlignment(pt).max(.@"1");
+                Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1");
             try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align.toLlvm() }, &o.builder);
-        } else if (ccAbiPromoteInt(fn_info.cc, mod, param_ty)) |s| switch (s) {
+        } else if (ccAbiPromoteInt(fn_info.cc, zcu, param_ty)) |s| switch (s) {
             .signed => try attributes.addParamAttr(llvm_arg_i, .signext, &o.builder),
             .unsigned => try attributes.addParamAttr(llvm_arg_i, .zeroext, &o.builder),
         };
 @@ -4814,14 +4800,14 @@ pub const FuncGen = struct {
     fn resolveValue(self: *FuncGen, val: Value) Error!Builder.Constant {
         const o = self.ng.object;
-        const pt = o.pt;
+        const zcu = o.pt.zcu;
-        const ty = val.typeOf(pt.zcu);
+        const ty = val.typeOf(zcu);
         const llvm_val = try o.lowerValue(val.toIntern());
-        if (!isByRef(ty, pt)) return llvm_val;
+        if (!isByRef(ty, zcu)) return llvm_val;
         // We have an LLVM value but we need to create a global constant and
         // set the value as its initializer, and then return a pointer to the global.
-        const target = pt.zcu.getTarget();
+        const target = zcu.getTarget();
         const variable_index = try o.builder.addVariable(
             .empty,
             llvm_val.typeOf(&o.builder),
 @@ -4831,7 +4817,7 @@ pub const FuncGen = struct {
         variable_index.setLinkage(.private, &o.builder);
         variable_index.setMutability(.constant, &o.builder);
         variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
-        variable_index.setAlignment(ty.abiAlignment(pt).toLlvm(), &o.builder);
+        variable_index.setAlignment(ty.abiAlignment(zcu).toLlvm(), &o.builder);
         return o.builder.convConst(
             variable_index.toConst(&o.builder),
             try o.builder.ptrType(toLlvmAddressSpace(.generic, target)),
 @@ -4852,8 +4838,8 @@ pub const FuncGen = struct {
     fn genBody(self: *FuncGen, body: []const Air.Inst.Index) Error!void {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const air_tags = self.air.instructions.items(.tag);
         for (body, 0..) |inst, i| {
             if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip)) continue;
 @@ -5200,19 +5186,19 @@ pub const FuncGen = struct {
         const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const callee_ty = self.typeOf(pl_op.operand);
-        const zig_fn_ty = switch (callee_ty.zigTypeTag(mod)) {
+        const zig_fn_ty = switch (callee_ty.zigTypeTag(zcu)) {
             .Fn => callee_ty,
-            .Pointer => callee_ty.childType(mod),
+            .Pointer => callee_ty.childType(zcu),
             else => unreachable,
         };
-        const fn_info = mod.typeToFunc(zig_fn_ty).?;
+        const fn_info = zcu.typeToFunc(zig_fn_ty).?;
         const return_type = Type.fromInterned(fn_info.return_type);
         const llvm_fn = try self.resolveInst(pl_op.operand);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
-        const sret = firstParamSRet(fn_info, pt, target);
+        const sret = firstParamSRet(fn_info, zcu, target);
         var llvm_args = std.ArrayList(Builder.Value).init(self.gpa);
         defer llvm_args.deinit();
 @@ -5230,13 +5216,13 @@ pub const FuncGen = struct {
             const llvm_ret_ty = try o.lowerType(return_type);
             try attributes.addParamAttr(0, .{ .sret = llvm_ret_ty }, &o.builder);
-            const alignment = return_type.abiAlignment(pt).toLlvm();
+            const alignment = return_type.abiAlignment(zcu).toLlvm();
             const ret_ptr = try self.buildAllocaWorkaround(return_type, alignment);
             try llvm_args.append(ret_ptr);
             break :blk ret_ptr;
         };
-        const err_return_tracing = return_type.isError(mod) and mod.comp.config.any_error_tracing;
+        const err_return_tracing = return_type.isError(zcu) and zcu.comp.config.any_error_tracing;
         if (err_return_tracing) {
             assert(self.err_ret_trace != .none);
             try llvm_args.append(self.err_ret_trace);
 @@ -5250,8 +5236,8 @@ pub const FuncGen = struct {
                 const param_ty = self.typeOf(arg);
                 const llvm_arg = try self.resolveInst(arg);
                 const llvm_param_ty = try o.lowerType(param_ty);
-                if (isByRef(param_ty, pt)) {
+                if (isByRef(param_ty, zcu)) {
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     const loaded = try self.wip.load(.normal, llvm_param_ty, llvm_arg, alignment, "");
                     try llvm_args.append(loaded);
                 } else {
 @@ -5262,10 +5248,10 @@ pub const FuncGen = struct {
                 const arg = args[it.zig_index - 1];
                 const param_ty = self.typeOf(arg);
                 const llvm_arg = try self.resolveInst(arg);
-                if (isByRef(param_ty, pt)) {
+                if (isByRef(param_ty, zcu)) {
                     try llvm_args.append(llvm_arg);
                 } else {
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     const param_llvm_ty = llvm_arg.typeOfWip(&self.wip);
                     const arg_ptr = try self.buildAlloca(param_llvm_ty, alignment);
                     _ = try self.wip.store(.normal, llvm_arg, arg_ptr, alignment);
 @@ -5277,10 +5263,10 @@ pub const FuncGen = struct {
                 const param_ty = self.typeOf(arg);
                 const llvm_arg = try self.resolveInst(arg);
-                const alignment = param_ty.abiAlignment(pt).toLlvm();
+                const alignment = param_ty.abiAlignment(zcu).toLlvm();
                 const param_llvm_ty = try o.lowerType(param_ty);
                 const arg_ptr = try self.buildAllocaWorkaround(param_ty, alignment);
-                if (isByRef(param_ty, pt)) {
+                if (isByRef(param_ty, zcu)) {
                     const loaded = try self.wip.load(.normal, param_llvm_ty, llvm_arg, alignment, "");
                     _ = try self.wip.store(.normal, loaded, arg_ptr, alignment);
                 } else {
 @@ -5292,16 +5278,16 @@ pub const FuncGen = struct {
                 const arg = args[it.zig_index - 1];
                 const param_ty = self.typeOf(arg);
                 const llvm_arg = try self.resolveInst(arg);
-                const int_llvm_ty = try o.builder.intType(@intCast(param_ty.abiSize(pt) * 8));
+                const int_llvm_ty = try o.builder.intType(@intCast(param_ty.abiSize(zcu) * 8));
-                if (isByRef(param_ty, pt)) {
+                if (isByRef(param_ty, zcu)) {
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     const loaded = try self.wip.load(.normal, int_llvm_ty, llvm_arg, alignment, "");
                     try llvm_args.append(loaded);
                 } else {
                     // LLVM does not allow bitcasting structs so we must allocate
                     // a local, store as one type, and then load as another type.
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     const int_ptr = try self.buildAllocaWorkaround(param_ty, alignment);
                     _ = try self.wip.store(.normal, llvm_arg, int_ptr, alignment);
                     const loaded = try self.wip.load(.normal, int_llvm_ty, int_ptr, alignment, "");
 @@ -5320,9 +5306,9 @@ pub const FuncGen = struct {
                 const param_ty = self.typeOf(arg);
                 const llvm_types = it.types_buffer[0..it.types_len];
                 const llvm_arg = try self.resolveInst(arg);
-                const is_by_ref = isByRef(param_ty, pt);
+                const is_by_ref = isByRef(param_ty, zcu);
                 const arg_ptr = if (is_by_ref) llvm_arg else ptr: {
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     const ptr = try self.buildAlloca(llvm_arg.typeOfWip(&self.wip), alignment);
                     _ = try self.wip.store(.normal, llvm_arg, ptr, alignment);
                     break :ptr ptr;
 @@ -5348,14 +5334,14 @@ pub const FuncGen = struct {
                 const arg = args[it.zig_index - 1];
                 const arg_ty = self.typeOf(arg);
                 var llvm_arg = try self.resolveInst(arg);
-                const alignment = arg_ty.abiAlignment(pt).toLlvm();
+                const alignment = arg_ty.abiAlignment(zcu).toLlvm();
-                if (!isByRef(arg_ty, pt)) {
+                if (!isByRef(arg_ty, zcu)) {
                     const ptr = try self.buildAlloca(llvm_arg.typeOfWip(&self.wip), alignment);
                     _ = try self.wip.store(.normal, llvm_arg, ptr, alignment);
                     llvm_arg = ptr;
                 }
-                const float_ty = try o.lowerType(aarch64_c_abi.getFloatArrayType(arg_ty, mod).?);
+                const float_ty = try o.lowerType(aarch64_c_abi.getFloatArrayType(arg_ty, zcu).?);
                 const array_ty = try o.builder.arrayType(count, float_ty);
                 const loaded = try self.wip.load(.normal, array_ty, llvm_arg, alignment, "");
 @@ -5366,8 +5352,8 @@ pub const FuncGen = struct {
                 const arg = args[it.zig_index - 1];
                 const arg_ty = self.typeOf(arg);
                 var llvm_arg = try self.resolveInst(arg);
-                const alignment = arg_ty.abiAlignment(pt).toLlvm();
+                const alignment = arg_ty.abiAlignment(zcu).toLlvm();
-                if (!isByRef(arg_ty, pt)) {
+                if (!isByRef(arg_ty, zcu)) {
                     const ptr = try self.buildAlloca(llvm_arg.typeOfWip(&self.wip), alignment);
                     _ = try self.wip.store(.normal, llvm_arg, ptr, alignment);
                     llvm_arg = ptr;
 @@ -5389,7 +5375,7 @@ pub const FuncGen = struct {
                 .byval => {
                     const param_index = it.zig_index - 1;
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
-                    if (!isByRef(param_ty, pt)) {
+                    if (!isByRef(param_ty, zcu)) {
                         try o.addByValParamAttrs(&attributes, param_ty, param_index, fn_info, it.llvm_index - 1);
                     }
                 },
 @@ -5397,7 +5383,7 @@ pub const FuncGen = struct {
                     const param_index = it.zig_index - 1;
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[param_index]);
                     const param_llvm_ty = try o.lowerType(param_ty);
-                    const alignment = param_ty.abiAlignment(pt).toLlvm();
+                    const alignment = param_ty.abiAlignment(zcu).toLlvm();
                     try o.addByRefParamAttrs(&attributes, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
                 },
                 .byref_mut => try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder),
 @@ -5414,7 +5400,7 @@ pub const FuncGen = struct {
                 .slice => {
                     assert(!it.byval_attr);
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
-                    const ptr_info = param_ty.ptrInfo(mod);
+                    const ptr_info = param_ty.ptrInfo(zcu);
                     const llvm_arg_i = it.llvm_index - 2;
                     if (math.cast(u5, it.zig_index - 1)) |i| {
 @@ -5422,7 +5408,7 @@ pub const FuncGen = struct {
                             try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
                         }
                     }
-                    if (param_ty.zigTypeTag(mod) != .Optional) {
+                    if (param_ty.zigTypeTag(zcu) != .Optional) {
                         try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
                     }
                     if (ptr_info.flags.is_const) {
 @@ -5431,7 +5417,7 @@ pub const FuncGen = struct {
                     const elem_align = (if (ptr_info.flags.alignment != .none)
                         @as(InternPool.Alignment, ptr_info.flags.alignment)
                     else
-                        Type.fromInterned(ptr_info.child).abiAlignment(pt).max(.@"1")).toLlvm();
+                        Type.fromInterned(ptr_info.child).abiAlignment(zcu).max(.@"1")).toLlvm();
                     try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
                 },
             };
 @@ -5456,17 +5442,17 @@ pub const FuncGen = struct {
             return .none;
         }
-        if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (self.liveness.isUnused(inst) or !return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
             return .none;
         }
         const llvm_ret_ty = try o.lowerType(return_type);
         if (ret_ptr) |rp| {
-            if (isByRef(return_type, pt)) {
+            if (isByRef(return_type, zcu)) {
                 return rp;
             } else {
                 // our by-ref status disagrees with sret so we must load.
-                const return_alignment = return_type.abiAlignment(pt).toLlvm();
+                const return_alignment = return_type.abiAlignment(zcu).toLlvm();
                 return self.wip.load(.normal, llvm_ret_ty, rp, return_alignment, "");
             }
         }
 @@ -5477,19 +5463,19 @@ pub const FuncGen = struct {
             // In this case the function return type is honoring the calling convention by having
             // a different LLVM type than the usual one. We solve this here at the callsite
             // by using our canonical type, then loading it if necessary.
-            const alignment = return_type.abiAlignment(pt).toLlvm();
+            const alignment = return_type.abiAlignment(zcu).toLlvm();
             const rp = try self.buildAlloca(abi_ret_ty, alignment);
             _ = try self.wip.store(.normal, call, rp, alignment);
-            return if (isByRef(return_type, pt))
+            return if (isByRef(return_type, zcu))
                 rp
             else
                 try self.wip.load(.normal, llvm_ret_ty, rp, alignment, "");
         }
-        if (isByRef(return_type, pt)) {
+        if (isByRef(return_type, zcu)) {
             // our by-ref status disagrees with sret so we must allocate, store,
             // and return the allocation pointer.
-            const alignment = return_type.abiAlignment(pt).toLlvm();
+            const alignment = return_type.abiAlignment(zcu).toLlvm();
             const rp = try self.buildAlloca(llvm_ret_ty, alignment);
             _ = try self.wip.store(.normal, call, rp, alignment);
             return rp;
 @@ -5540,8 +5526,8 @@ pub const FuncGen = struct {
     fn airRet(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const ret_ty = self.typeOf(un_op);
 @@ -5549,9 +5535,9 @@ pub const FuncGen = struct {
             const ptr_ty = try pt.singleMutPtrType(ret_ty);
             const operand = try self.resolveInst(un_op);
-            const val_is_undef = if (try self.air.value(un_op, pt)) |val| val.isUndefDeep(mod) else false;
+            const val_is_undef = if (try self.air.value(un_op, pt)) |val| val.isUndefDeep(zcu) else false;
             if (val_is_undef and safety) undef: {
-                const ptr_info = ptr_ty.ptrInfo(mod);
+                const ptr_info = ptr_ty.ptrInfo(zcu);
                 const needs_bitmask = (ptr_info.packed_offset.host_size != 0);
                 if (needs_bitmask) {
                     // TODO: only some bits are to be undef, we cannot write with a simple memset.
 @@ -5559,13 +5545,13 @@ pub const FuncGen = struct {
                     // https://github.com/ziglang/zig/issues/15337
                     break :undef;
                 }
-                const len = try o.builder.intValue(try o.lowerType(Type.usize), ret_ty.abiSize(pt));
+                const len = try o.builder.intValue(try o.lowerType(Type.usize), ret_ty.abiSize(zcu));
                 _ = try self.wip.callMemSet(
                     self.ret_ptr,
-                    ptr_ty.ptrAlignment(pt).toLlvm(),
+                    ptr_ty.ptrAlignment(zcu).toLlvm(),
                     try o.builder.intValue(.i8, 0xaa),
                     len,
-                    if (ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal,
+                    if (ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal,
                 );
                 const owner_mod = self.ng.ownerModule();
                 if (owner_mod.valgrind) {
 @@ -5588,9 +5574,9 @@ pub const FuncGen = struct {
             _ = try self.wip.retVoid();
             return .none;
         }
-        const fn_info = mod.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
+        const fn_info = zcu.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            if (Type.fromInterned(fn_info.return_type).isError(mod)) {
+            if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
                 // to functions that return anyerror.
 @@ -5603,13 +5589,13 @@ pub const FuncGen = struct {
         const abi_ret_ty = try lowerFnRetTy(o, fn_info);
         const operand = try self.resolveInst(un_op);
-        const val_is_undef = if (try self.air.value(un_op, pt)) |val| val.isUndefDeep(mod) else false;
+        const val_is_undef = if (try self.air.value(un_op, pt)) |val| val.isUndefDeep(zcu) else false;
-        const alignment = ret_ty.abiAlignment(pt).toLlvm();
+        const alignment = ret_ty.abiAlignment(zcu).toLlvm();
         if (val_is_undef and safety) {
             const llvm_ret_ty = operand.typeOfWip(&self.wip);
             const rp = try self.buildAlloca(llvm_ret_ty, alignment);
-            const len = try o.builder.intValue(try o.lowerType(Type.usize), ret_ty.abiSize(pt));
+            const len = try o.builder.intValue(try o.lowerType(Type.usize), ret_ty.abiSize(zcu));
             _ = try self.wip.callMemSet(
                 rp,
                 alignment,
 @@ -5625,7 +5611,7 @@ pub const FuncGen = struct {
             return .none;
         }
-        if (isByRef(ret_ty, pt)) {
+        if (isByRef(ret_ty, zcu)) {
             // operand is a pointer however self.ret_ptr is null so that means
             // we need to return a value.
             _ = try self.wip.ret(try self.wip.load(.normal, abi_ret_ty, operand, alignment, ""));
 @@ -5647,14 +5633,14 @@ pub const FuncGen = struct {
     fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const ptr_ty = self.typeOf(un_op);
-        const ret_ty = ptr_ty.childType(mod);
+        const ret_ty = ptr_ty.childType(zcu);
-        const fn_info = mod.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
+        const fn_info = zcu.typeToFunc(Type.fromInterned(ip.getNav(self.ng.nav_index).typeOf(ip))).?;
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            if (Type.fromInterned(fn_info.return_type).isError(mod)) {
+            if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
                 // to functions that return anyerror.
 @@ -5670,7 +5656,7 @@ pub const FuncGen = struct {
         }
         const ptr = try self.resolveInst(un_op);
         const abi_ret_ty = try lowerFnRetTy(o, fn_info);
-        const alignment = ret_ty.abiAlignment(pt).toLlvm();
+        const alignment = ret_ty.abiAlignment(zcu).toLlvm();
         _ = try self.wip.ret(try self.wip.load(.normal, abi_ret_ty, ptr, alignment, ""));
         return .none;
     }
 @@ -5688,16 +5674,17 @@ pub const FuncGen = struct {
     fn airCVaCopy(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const src_list = try self.resolveInst(ty_op.operand);
         const va_list_ty = ty_op.ty.toType();
         const llvm_va_list_ty = try o.lowerType(va_list_ty);
-        const result_alignment = va_list_ty.abiAlignment(pt).toLlvm();
+        const result_alignment = va_list_ty.abiAlignment(pt.zcu).toLlvm();
         const dest_list = try self.buildAllocaWorkaround(va_list_ty, result_alignment);
         _ = try self.wip.callIntrinsic(.normal, .none, .va_copy, &.{}, &.{ dest_list, src_list }, "");
-        return if (isByRef(va_list_ty, pt))
+        return if (isByRef(va_list_ty, zcu))
             dest_list
         else
             try self.wip.load(.normal, llvm_va_list_ty, dest_list, result_alignment, "");
 @@ -5714,14 +5701,15 @@ pub const FuncGen = struct {
     fn airCVaStart(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const va_list_ty = self.typeOfIndex(inst);
         const llvm_va_list_ty = try o.lowerType(va_list_ty);
-        const result_alignment = va_list_ty.abiAlignment(pt).toLlvm();
+        const result_alignment = va_list_ty.abiAlignment(pt.zcu).toLlvm();
         const dest_list = try self.buildAllocaWorkaround(va_list_ty, result_alignment);
         _ = try self.wip.callIntrinsic(.normal, .none, .va_start, &.{}, &.{dest_list}, "");
-        return if (isByRef(va_list_ty, pt))
+        return if (isByRef(va_list_ty, zcu))
             dest_list
         else
             try self.wip.load(.normal, llvm_va_list_ty, dest_list, result_alignment, "");
 @@ -5779,21 +5767,21 @@ pub const FuncGen = struct {
     ) Allocator.Error!Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const scalar_ty = operand_ty.scalarType(mod);
+        const scalar_ty = operand_ty.scalarType(zcu);
-        const int_ty = switch (scalar_ty.zigTypeTag(mod)) {
+        const int_ty = switch (scalar_ty.zigTypeTag(zcu)) {
-            .Enum => scalar_ty.intTagType(mod),
+            .Enum => scalar_ty.intTagType(zcu),
             .Int, .Bool, .Pointer, .ErrorSet => scalar_ty,
             .Optional => blk: {
-                const payload_ty = operand_ty.optionalChild(mod);
+                const payload_ty = operand_ty.optionalChild(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt) or
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu) or
-                    operand_ty.optionalReprIsPayload(mod))
+                    operand_ty.optionalReprIsPayload(zcu))
                 {
                     break :blk operand_ty;
                 }
                 // We need to emit instructions to check for equality/inequality
                 // of optionals that are not pointers.
-                const is_by_ref = isByRef(scalar_ty, pt);
+                const is_by_ref = isByRef(scalar_ty, zcu);
                 const opt_llvm_ty = try o.lowerType(scalar_ty);
                 const lhs_non_null = try self.optCmpNull(.ne, opt_llvm_ty, lhs, is_by_ref);
                 const rhs_non_null = try self.optCmpNull(.ne, opt_llvm_ty, rhs, is_by_ref);
 @@ -5860,7 +5848,7 @@ pub const FuncGen = struct {
             .Float => return self.buildFloatCmp(fast, op, operand_ty, .{ lhs, rhs }),
             else => unreachable,
         };
-        const is_signed = int_ty.isSignedInt(mod);
+        const is_signed = int_ty.isSignedInt(zcu);
         const cond: Builder.IntegerCondition = switch (op) {
             .eq => .eq,
             .neq => .ne,
 @@ -5886,15 +5874,15 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst_ty = self.typeOfIndex(inst);
-        if (inst_ty.isNoReturn(mod)) {
+        if (inst_ty.isNoReturn(zcu)) {
             try self.genBodyDebugScope(maybe_inline_func, body);
             return .none;
         }
-        const have_block_result = inst_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt);
+        const have_block_result = inst_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu);
         var breaks: BreakList = if (have_block_result) .{ .list = .{} } else .{ .len = 0 };
         defer if (have_block_result) breaks.list.deinit(self.gpa);
 @@ -5918,7 +5906,7 @@ pub const FuncGen = struct {
                 // a pointer to it. LLVM IR allows the call instruction to use function bodies instead
                 // of function pointers, however the phi makes it a runtime value and therefore
                 // the LLVM type has to be wrapped in a pointer.
-                if (inst_ty.zigTypeTag(mod) == .Fn or isByRef(inst_ty, pt)) {
+                if (inst_ty.zigTypeTag(zcu) == .Fn or isByRef(inst_ty, zcu)) {
                     break :ty .ptr;
                 }
                 break :ty raw_llvm_ty;
 @@ -5936,13 +5924,13 @@ pub const FuncGen = struct {
     fn airBr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const pt = o.pt;
+        const zcu = o.pt.zcu;
         const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
         const block = self.blocks.get(branch.block_inst).?;
         // Add the values to the lists only if the break provides a value.
         const operand_ty = self.typeOf(branch.operand);
-        if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+        if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
             const val = try self.resolveInst(branch.operand);
             // For the phi node, we need the basic blocks and the values of the
 @@ -5977,6 +5965,7 @@ pub const FuncGen = struct {
     fn airTry(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const err_union = try self.resolveInst(pl_op.operand);
 @@ -5984,19 +5973,19 @@ pub const FuncGen = struct {
         const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
         const err_union_ty = self.typeOf(pl_op.operand);
         const payload_ty = self.typeOfIndex(inst);
-        const can_elide_load = if (isByRef(payload_ty, pt)) self.canElideLoad(body_tail) else false;
+        const can_elide_load = if (isByRef(payload_ty, zcu)) self.canElideLoad(body_tail) else false;
         const is_unused = self.liveness.isUnused(inst);
         return lowerTry(self, err_union, body, err_union_ty, false, can_elide_load, is_unused);
     }
     fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
         const err_union_ptr = try self.resolveInst(extra.data.ptr);
         const body: []const Air.Inst.Index = @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]);
-        const err_union_ty = self.typeOf(extra.data.ptr).childType(mod);
+        const err_union_ty = self.typeOf(extra.data.ptr).childType(zcu);
         const is_unused = self.liveness.isUnused(inst);
         return lowerTry(self, err_union_ptr, body, err_union_ty, true, true, is_unused);
     }
 @@ -6012,13 +6001,13 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
-        const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(pt);
+        const payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu);
         const err_union_llvm_ty = try o.lowerType(err_union_ty);
         const error_type = try o.errorIntType();
-        if (!err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             const loaded = loaded: {
                 if (!payload_has_bits) {
                     // TODO add alignment to this load
 @@ -6028,7 +6017,7 @@ pub const FuncGen = struct {
                         err_union;
                 }
                 const err_field_index = try errUnionErrorOffset(payload_ty, pt);
-                if (operand_is_ptr or isByRef(err_union_ty, pt)) {
+                if (operand_is_ptr or isByRef(err_union_ty, zcu)) {
                     const err_field_ptr =
                         try fg.wip.gepStruct(err_union_llvm_ty, err_union, err_field_index, "");
                     // TODO add alignment to this load
 @@ -6059,10 +6048,10 @@ pub const FuncGen = struct {
         const offset = try errUnionPayloadOffset(payload_ty, pt);
         if (operand_is_ptr) {
             return fg.wip.gepStruct(err_union_llvm_ty, err_union, offset, "");
-        } else if (isByRef(err_union_ty, pt)) {
+        } else if (isByRef(err_union_ty, zcu)) {
             const payload_ptr = try fg.wip.gepStruct(err_union_llvm_ty, err_union, offset, "");
-            const payload_alignment = payload_ty.abiAlignment(pt).toLlvm();
+            const payload_alignment = payload_ty.abiAlignment(zcu).toLlvm();
-            if (isByRef(payload_ty, pt)) {
+            if (isByRef(payload_ty, zcu)) {
                 if (can_elide_load)
                     return payload_ptr;
 @@ -6140,7 +6129,7 @@ pub const FuncGen = struct {
     fn airLoop(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const loop = self.air.extraData(Air.Block, ty_pl.payload);
         const body: []const Air.Inst.Index = @ptrCast(self.air.extra[loop.end..][0..loop.data.body_len]);
 @@ -6156,7 +6145,7 @@ pub const FuncGen = struct {
         // would have been emitted already. Also the main loop in genBody can
         // be while(true) instead of for(body), which will eliminate 1 branch on
         // a hot path.
-        if (body.len == 0 or !self.typeOfIndex(body[body.len - 1]).isNoReturn(mod)) {
+        if (body.len == 0 or !self.typeOfIndex(body[body.len - 1]).isNoReturn(zcu)) {
             _ = try self.wip.br(loop_block);
         }
         return .none;
 @@ -6165,15 +6154,15 @@ pub const FuncGen = struct {
     fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand_ty = self.typeOf(ty_op.operand);
-        const array_ty = operand_ty.childType(mod);
+        const array_ty = operand_ty.childType(zcu);
         const llvm_usize = try o.lowerType(Type.usize);
-        const len = try o.builder.intValue(llvm_usize, array_ty.arrayLen(mod));
+        const len = try o.builder.intValue(llvm_usize, array_ty.arrayLen(zcu));
         const slice_llvm_ty = try o.lowerType(self.typeOfIndex(inst));
         const operand = try self.resolveInst(ty_op.operand);
-        if (!array_ty.hasRuntimeBitsIgnoreComptime(pt))
+        if (!array_ty.hasRuntimeBitsIgnoreComptime(zcu))
             return self.wip.buildAggregate(slice_llvm_ty, &.{ operand, len }, "");
         const ptr = try self.wip.gep(.inbounds, try o.lowerType(array_ty), operand, &.{
             try o.builder.intValue(llvm_usize, 0), try o.builder.intValue(llvm_usize, 0),
 @@ -6184,17 +6173,17 @@ pub const FuncGen = struct {
     fn airFloatFromInt(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const workaround_operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const operand_scalar_ty = operand_ty.scalarType(mod);
+        const operand_scalar_ty = operand_ty.scalarType(zcu);
-        const is_signed_int = operand_scalar_ty.isSignedInt(mod);
+        const is_signed_int = operand_scalar_ty.isSignedInt(zcu);
         const operand = o: {
             // Work around LLVM bug. See https://github.com/ziglang/zig/issues/17381.
-            const bit_size = operand_scalar_ty.bitSize(pt);
+            const bit_size = operand_scalar_ty.bitSize(zcu);
             for ([_]u8{ 8, 16, 32, 64, 128 }) |b| {
                 if (bit_size < b) {
                     break :o try self.wip.cast(
 @@ -6211,9 +6200,9 @@ pub const FuncGen = struct {
         };
         const dest_ty = self.typeOfIndex(inst);
-        const dest_scalar_ty = dest_ty.scalarType(mod);
+        const dest_scalar_ty = dest_ty.scalarType(zcu);
         const dest_llvm_ty = try o.lowerType(dest_ty);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         if (intrinsicsAllowed(dest_scalar_ty, target)) return self.wip.conv(
             if (is_signed_int) .signed else .unsigned,
 @@ -6222,7 +6211,7 @@ pub const FuncGen = struct {
             "",
         );
-        const rt_int_bits = compilerRtIntBits(@intCast(operand_scalar_ty.bitSize(pt)));
+        const rt_int_bits = compilerRtIntBits(@intCast(operand_scalar_ty.bitSize(zcu)));
         const rt_int_ty = try o.builder.intType(rt_int_bits);
         var extended = try self.wip.conv(
             if (is_signed_int) .signed else .unsigned,
 @@ -6269,29 +6258,29 @@ pub const FuncGen = struct {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const operand_scalar_ty = operand_ty.scalarType(mod);
+        const operand_scalar_ty = operand_ty.scalarType(zcu);
         const dest_ty = self.typeOfIndex(inst);
-        const dest_scalar_ty = dest_ty.scalarType(mod);
+        const dest_scalar_ty = dest_ty.scalarType(zcu);
         const dest_llvm_ty = try o.lowerType(dest_ty);
         if (intrinsicsAllowed(operand_scalar_ty, target)) {
             // TODO set fast math flag
             return self.wip.conv(
-                if (dest_scalar_ty.isSignedInt(mod)) .signed else .unsigned,
+                if (dest_scalar_ty.isSignedInt(zcu)) .signed else .unsigned,
                 operand,
                 dest_llvm_ty,
                 "",
             );
         }
-        const rt_int_bits = compilerRtIntBits(@intCast(dest_scalar_ty.bitSize(pt)));
+        const rt_int_bits = compilerRtIntBits(@intCast(dest_scalar_ty.bitSize(zcu)));
         const ret_ty = try o.builder.intType(rt_int_bits);
         const libc_ret_ty = if (rt_int_bits == 128 and (target.os.tag == .windows and target.cpu.arch == .x86_64)) b: {
             // On Windows x86-64, "ti" functions must use Vector(2, u64) instead of the standard
 @@ -6303,7 +6292,7 @@ pub const FuncGen = struct {
         const compiler_rt_operand_abbrev = compilerRtFloatAbbrev(operand_bits);
         const compiler_rt_dest_abbrev = compilerRtIntAbbrev(rt_int_bits);
-        const sign_prefix = if (dest_scalar_ty.isSignedInt(mod)) "" else "uns";
+        const sign_prefix = if (dest_scalar_ty.isSignedInt(zcu)) "" else "uns";
         const fn_name = try o.builder.strtabStringFmt("__fix{s}{s}f{s}i", .{
             sign_prefix,
 @@ -6330,29 +6319,29 @@ pub const FuncGen = struct {
     fn sliceOrArrayPtr(fg: *FuncGen, ptr: Builder.Value, ty: Type) Allocator.Error!Builder.Value {
         const o = fg.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        return if (ty.isSlice(mod)) fg.wip.extractValue(ptr, &.{0}, "") else ptr;
+        return if (ty.isSlice(zcu)) fg.wip.extractValue(ptr, &.{0}, "") else ptr;
     }
     fn sliceOrArrayLenInBytes(fg: *FuncGen, ptr: Builder.Value, ty: Type) Allocator.Error!Builder.Value {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const llvm_usize = try o.lowerType(Type.usize);
-        switch (ty.ptrSize(mod)) {
+        switch (ty.ptrSize(zcu)) {
             .Slice => {
                 const len = try fg.wip.extractValue(ptr, &.{1}, "");
-                const elem_ty = ty.childType(mod);
+                const elem_ty = ty.childType(zcu);
-                const abi_size = elem_ty.abiSize(pt);
+                const abi_size = elem_ty.abiSize(zcu);
                 if (abi_size == 1) return len;
                 const abi_size_llvm_val = try o.builder.intValue(llvm_usize, abi_size);
                 return fg.wip.bin(.@"mul nuw", len, abi_size_llvm_val, "");
             },
             .One => {
-                const array_ty = ty.childType(mod);
+                const array_ty = ty.childType(zcu);
-                const elem_ty = array_ty.childType(mod);
+                const elem_ty = array_ty.childType(zcu);
-                const abi_size = elem_ty.abiSize(pt);
+                const abi_size = elem_ty.abiSize(zcu);
-                return o.builder.intValue(llvm_usize, array_ty.arrayLen(mod) * abi_size);
+                return o.builder.intValue(llvm_usize, array_ty.arrayLen(zcu) * abi_size);
             },
             .Many, .C => unreachable,
         }
 @@ -6366,11 +6355,11 @@ pub const FuncGen = struct {
     fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const slice_ptr = try self.resolveInst(ty_op.operand);
         const slice_ptr_ty = self.typeOf(ty_op.operand);
-        const slice_llvm_ty = try o.lowerPtrElemTy(slice_ptr_ty.childType(mod));
+        const slice_llvm_ty = try o.lowerPtrElemTy(slice_ptr_ty.childType(zcu));
         return self.wip.gepStruct(slice_llvm_ty, slice_ptr, index, "");
     }
 @@ -6378,21 +6367,21 @@ pub const FuncGen = struct {
     fn airSliceElemVal(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const slice_ty = self.typeOf(bin_op.lhs);
         const slice = try self.resolveInst(bin_op.lhs);
         const index = try self.resolveInst(bin_op.rhs);
-        const elem_ty = slice_ty.childType(mod);
+        const elem_ty = slice_ty.childType(zcu);
         const llvm_elem_ty = try o.lowerPtrElemTy(elem_ty);
         const base_ptr = try self.wip.extractValue(slice, &.{0}, "");
         const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{index}, "");
-        if (isByRef(elem_ty, pt)) {
+        if (isByRef(elem_ty, zcu)) {
             if (self.canElideLoad(body_tail))
                 return ptr;
-            const elem_alignment = elem_ty.abiAlignment(pt).toLlvm();
+            const elem_alignment = elem_ty.abiAlignment(zcu).toLlvm();
             return self.loadByRef(ptr, elem_ty, elem_alignment, .normal);
         }
 @@ -6401,14 +6390,14 @@ pub const FuncGen = struct {
     fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const slice_ty = self.typeOf(bin_op.lhs);
         const slice = try self.resolveInst(bin_op.lhs);
         const index = try self.resolveInst(bin_op.rhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(slice_ty.childType(mod));
+        const llvm_elem_ty = try o.lowerPtrElemTy(slice_ty.childType(zcu));
         const base_ptr = try self.wip.extractValue(slice, &.{0}, "");
         return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, &.{index}, "");
     }
 @@ -6416,7 +6405,7 @@ pub const FuncGen = struct {
     fn airArrayElemVal(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
 @@ -6424,16 +6413,16 @@ pub const FuncGen = struct {
         const array_llvm_val = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const array_llvm_ty = try o.lowerType(array_ty);
-        const elem_ty = array_ty.childType(mod);
+        const elem_ty = array_ty.childType(zcu);
-        if (isByRef(array_ty, pt)) {
+        if (isByRef(array_ty, zcu)) {
             const indices: [2]Builder.Value = .{
                 try o.builder.intValue(try o.lowerType(Type.usize), 0), rhs,
             };
-            if (isByRef(elem_ty, pt)) {
+            if (isByRef(elem_ty, zcu)) {
                 const elem_ptr =
                     try self.wip.gep(.inbounds, array_llvm_ty, array_llvm_val, &indices, "");
                 if (canElideLoad(self, body_tail)) return elem_ptr;
-                const elem_alignment = elem_ty.abiAlignment(pt).toLlvm();
+                const elem_alignment = elem_ty.abiAlignment(zcu).toLlvm();
                 return self.loadByRef(elem_ptr, elem_ty, elem_alignment, .normal);
             } else {
                 const elem_ptr =
 @@ -6449,23 +6438,23 @@ pub const FuncGen = struct {
     fn airPtrElemVal(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const llvm_elem_ty = try o.lowerPtrElemTy(elem_ty);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         // TODO: when we go fully opaque pointers in LLVM 16 we can remove this branch
-        const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(mod))
+        const ptr = try self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(zcu))
             // If this is a single-item pointer to an array, we need another index in the GEP.
             &.{ try o.builder.intValue(try o.lowerType(Type.usize), 0), rhs }
         else
             &.{rhs}, "");
-        if (isByRef(elem_ty, pt)) {
+        if (isByRef(elem_ty, zcu)) {
             if (self.canElideLoad(body_tail)) return ptr;
-            const elem_alignment = elem_ty.abiAlignment(pt).toLlvm();
+            const elem_alignment = elem_ty.abiAlignment(zcu).toLlvm();
             return self.loadByRef(ptr, elem_ty, elem_alignment, .normal);
         }
 @@ -6475,21 +6464,21 @@ pub const FuncGen = struct {
     fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) return self.resolveInst(bin_op.lhs);
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return self.resolveInst(bin_op.lhs);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const elem_ptr = ty_pl.ty.toType();
-        if (elem_ptr.ptrInfo(mod).flags.vector_index != .none) return base_ptr;
+        if (elem_ptr.ptrInfo(zcu).flags.vector_index != .none) return base_ptr;
         const llvm_elem_ty = try o.lowerPtrElemTy(elem_ty);
-        return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(mod))
+        return self.wip.gep(.inbounds, llvm_elem_ty, base_ptr, if (ptr_ty.isSinglePointer(zcu))
             // If this is a single-item pointer to an array, we need another index in the GEP.
             &.{ try o.builder.intValue(try o.lowerType(Type.usize), 0), rhs }
         else
 @@ -6518,35 +6507,35 @@ pub const FuncGen = struct {
     fn airStructFieldVal(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
         const struct_ty = self.typeOf(struct_field.struct_operand);
         const struct_llvm_val = try self.resolveInst(struct_field.struct_operand);
         const field_index = struct_field.field_index;
-        const field_ty = struct_ty.structFieldType(field_index, mod);
+        const field_ty = struct_ty.fieldType(field_index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
-        if (!isByRef(struct_ty, pt)) {
+        if (!isByRef(struct_ty, zcu)) {
-            assert(!isByRef(field_ty, pt));
+            assert(!isByRef(field_ty, zcu));
-            switch (struct_ty.zigTypeTag(mod)) {
+            switch (struct_ty.zigTypeTag(zcu)) {
-                .Struct => switch (struct_ty.containerLayout(mod)) {
+                .Struct => switch (struct_ty.containerLayout(zcu)) {
                     .@"packed" => {
-                        const struct_type = mod.typeToStruct(struct_ty).?;
+                        const struct_type = zcu.typeToStruct(struct_ty).?;
                         const bit_offset = pt.structPackedFieldBitOffset(struct_type, field_index);
                         const containing_int = struct_llvm_val;
                         const shift_amt =
                             try o.builder.intValue(containing_int.typeOfWip(&self.wip), bit_offset);
                         const shifted_value = try self.wip.bin(.lshr, containing_int, shift_amt, "");
                         const elem_llvm_ty = try o.lowerType(field_ty);
-                        if (field_ty.zigTypeTag(mod) == .Float or field_ty.zigTypeTag(mod) == .Vector) {
+                        if (field_ty.zigTypeTag(zcu) == .Float or field_ty.zigTypeTag(zcu) == .Vector) {
-                            const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(pt)));
+                            const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
                             const truncated_int =
                                 try self.wip.cast(.trunc, shifted_value, same_size_int, "");
                             return self.wip.cast(.bitcast, truncated_int, elem_llvm_ty, "");
-                        } else if (field_ty.isPtrAtRuntime(mod)) {
+                        } else if (field_ty.isPtrAtRuntime(zcu)) {
-                            const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(pt)));
+                            const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
                             const truncated_int =
                                 try self.wip.cast(.trunc, shifted_value, same_size_int, "");
                             return self.wip.cast(.inttoptr, truncated_int, elem_llvm_ty, "");
 @@ -6559,16 +6548,16 @@ pub const FuncGen = struct {
                     },
                 },
                 .Union => {
-                    assert(struct_ty.containerLayout(mod) == .@"packed");
+                    assert(struct_ty.containerLayout(zcu) == .@"packed");
                     const containing_int = struct_llvm_val;
                     const elem_llvm_ty = try o.lowerType(field_ty);
-                    if (field_ty.zigTypeTag(mod) == .Float or field_ty.zigTypeTag(mod) == .Vector) {
+                    if (field_ty.zigTypeTag(zcu) == .Float or field_ty.zigTypeTag(zcu) == .Vector) {
-                        const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(pt)));
+                        const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
                         const truncated_int =
                             try self.wip.cast(.trunc, containing_int, same_size_int, "");
                         return self.wip.cast(.bitcast, truncated_int, elem_llvm_ty, "");
-                    } else if (field_ty.isPtrAtRuntime(mod)) {
+                    } else if (field_ty.isPtrAtRuntime(zcu)) {
-                        const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(pt)));
+                        const same_size_int = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
                         const truncated_int =
                             try self.wip.cast(.trunc, containing_int, same_size_int, "");
                         return self.wip.cast(.inttoptr, truncated_int, elem_llvm_ty, "");
 @@ -6579,20 +6568,20 @@ pub const FuncGen = struct {
             }
         }
-        switch (struct_ty.zigTypeTag(mod)) {
+        switch (struct_ty.zigTypeTag(zcu)) {
             .Struct => {
-                const layout = struct_ty.containerLayout(mod);
+                const layout = struct_ty.containerLayout(zcu);
                 assert(layout != .@"packed");
                 const struct_llvm_ty = try o.lowerType(struct_ty);
                 const llvm_field_index = o.llvmFieldIndex(struct_ty, field_index).?;
                 const field_ptr =
                     try self.wip.gepStruct(struct_llvm_ty, struct_llvm_val, llvm_field_index, "");
-                const alignment = struct_ty.structFieldAlign(field_index, pt);
+                const alignment = struct_ty.fieldAlignment(field_index, zcu);
                 const field_ptr_ty = try pt.ptrType(.{
                     .child = field_ty.toIntern(),
                     .flags = .{ .alignment = alignment },
                 });
-                if (isByRef(field_ty, pt)) {
+                if (isByRef(field_ty, zcu)) {
                     if (canElideLoad(self, body_tail))
                         return field_ptr;
 @@ -6605,12 +6594,12 @@ pub const FuncGen = struct {
             },
             .Union => {
                 const union_llvm_ty = try o.lowerType(struct_ty);
-                const layout = struct_ty.unionGetLayout(pt);
+                const layout = struct_ty.unionGetLayout(zcu);
                 const payload_index = @intFromBool(layout.tag_align.compare(.gte, layout.payload_align));
                 const field_ptr =
                     try self.wip.gepStruct(union_llvm_ty, struct_llvm_val, payload_index, "");
                 const payload_alignment = layout.payload_align.toLlvm();
-                if (isByRef(field_ty, pt)) {
+                if (isByRef(field_ty, zcu)) {
                     if (canElideLoad(self, body_tail)) return field_ptr;
                     return self.loadByRef(field_ptr, field_ty, payload_alignment, .normal);
                 } else {
 @@ -6624,14 +6613,14 @@ pub const FuncGen = struct {
     fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
         const field_ptr = try self.resolveInst(extra.field_ptr);
-        const parent_ty = ty_pl.ty.toType().childType(mod);
+        const parent_ty = ty_pl.ty.toType().childType(zcu);
-        const field_offset = parent_ty.structFieldOffset(extra.field_index, pt);
+        const field_offset = parent_ty.structFieldOffset(extra.field_index, zcu);
         if (field_offset == 0) return field_ptr;
         const res_ty = try o.lowerType(ty_pl.ty.toType());
 @@ -6686,7 +6675,7 @@ pub const FuncGen = struct {
     fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const operand = try self.resolveInst(pl_op.operand);
         const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
 @@ -6697,7 +6686,7 @@ pub const FuncGen = struct {
             self.file,
             self.scope,
             self.prev_dbg_line,
-            try o.lowerDebugType(ptr_ty.childType(mod)),
+            try o.lowerDebugType(ptr_ty.childType(zcu)),
         );
         _ = try self.wip.callIntrinsic(
 @@ -6741,9 +6730,9 @@ pub const FuncGen = struct {
             try o.lowerDebugType(operand_ty),
         );
-        const pt = o.pt;
+        const zcu = o.pt.zcu;
         const owner_mod = self.ng.ownerModule();
-        if (isByRef(operand_ty, pt)) {
+        if (isByRef(operand_ty, zcu)) {
             _ = try self.wip.callIntrinsic(
                 .normal,
                 .none,
 @@ -6760,7 +6749,7 @@ pub const FuncGen = struct {
             // We avoid taking this path for naked functions because there's no guarantee that such
             // functions even have a valid stack pointer, making the `alloca` + `store` unsafe.
-            const alignment = operand_ty.abiAlignment(pt).toLlvm();
+            const alignment = operand_ty.abiAlignment(zcu).toLlvm();
             const alloca = try self.buildAlloca(operand.typeOfWip(&self.wip), alignment);
             _ = try self.wip.store(.normal, operand, alloca, alignment);
             _ = try self.wip.callIntrinsic(
 @@ -6832,8 +6821,8 @@ pub const FuncGen = struct {
         // if so, the element type itself.
         const llvm_param_attrs = try arena.alloc(Builder.Type, max_param_count);
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         var llvm_ret_i: usize = 0;
         var llvm_param_i: usize = 0;
 @@ -6860,8 +6849,8 @@ pub const FuncGen = struct {
             if (output != .none) {
                 const output_inst = try self.resolveInst(output);
                 const output_ty = self.typeOf(output);
-                assert(output_ty.zigTypeTag(mod) == .Pointer);
+                assert(output_ty.zigTypeTag(zcu) == .Pointer);
-                const elem_llvm_ty = try o.lowerPtrElemTy(output_ty.childType(mod));
+                const elem_llvm_ty = try o.lowerPtrElemTy(output_ty.childType(zcu));
                 switch (constraint[0]) {
                     '=' => {},
 @@ -6932,13 +6921,13 @@ pub const FuncGen = struct {
             const arg_llvm_value = try self.resolveInst(input);
             const arg_ty = self.typeOf(input);
-            const is_by_ref = isByRef(arg_ty, pt);
+            const is_by_ref = isByRef(arg_ty, zcu);
             if (is_by_ref) {
                 if (constraintAllowsMemory(constraint)) {
                     llvm_param_values[llvm_param_i] = arg_llvm_value;
                     llvm_param_types[llvm_param_i] = arg_llvm_value.typeOfWip(&self.wip);
                 } else {
-                    const alignment = arg_ty.abiAlignment(pt).toLlvm();
+                    const alignment = arg_ty.abiAlignment(zcu).toLlvm();
                     const arg_llvm_ty = try o.lowerType(arg_ty);
                     const load_inst =
                         try self.wip.load(.normal, arg_llvm_ty, arg_llvm_value, alignment, "");
 @@ -6950,7 +6939,7 @@ pub const FuncGen = struct {
                     llvm_param_values[llvm_param_i] = arg_llvm_value;
                     llvm_param_types[llvm_param_i] = arg_llvm_value.typeOfWip(&self.wip);
                 } else {
-                    const alignment = arg_ty.abiAlignment(pt).toLlvm();
+                    const alignment = arg_ty.abiAlignment(zcu).toLlvm();
                     const arg_ptr = try self.buildAlloca(arg_llvm_value.typeOfWip(&self.wip), alignment);
                     _ = try self.wip.store(.normal, arg_llvm_value, arg_ptr, alignment);
                     llvm_param_values[llvm_param_i] = arg_ptr;
 @@ -6978,7 +6967,7 @@ pub const FuncGen = struct {
             // In the case of indirect inputs, LLVM requires the callsite to have
             // an elementtype(<ty>) attribute.
             llvm_param_attrs[llvm_param_i] = if (constraint[0] == '*')
-                try o.lowerPtrElemTy(if (is_by_ref) arg_ty else arg_ty.childType(mod))
+                try o.lowerPtrElemTy(if (is_by_ref) arg_ty else arg_ty.childType(zcu))
             else
                 .none;
 @@ -6997,12 +6986,12 @@ pub const FuncGen = struct {
             if (constraint[0] != '+') continue;
             const rw_ty = self.typeOf(output);
-            const llvm_elem_ty = try o.lowerPtrElemTy(rw_ty.childType(mod));
+            const llvm_elem_ty = try o.lowerPtrElemTy(rw_ty.childType(zcu));
             if (is_indirect) {
                 llvm_param_values[llvm_param_i] = llvm_rw_val;
                 llvm_param_types[llvm_param_i] = llvm_rw_val.typeOfWip(&self.wip);
             } else {
-                const alignment = rw_ty.abiAlignment(pt).toLlvm();
+                const alignment = rw_ty.abiAlignment(zcu).toLlvm();
                 const loaded = try self.wip.load(.normal, llvm_elem_ty, llvm_rw_val, alignment, "");
                 llvm_param_values[llvm_param_i] = loaded;
                 llvm_param_types[llvm_param_i] = llvm_elem_ty;
 @@ -7163,7 +7152,7 @@ pub const FuncGen = struct {
                 const output_ptr = try self.resolveInst(output);
                 const output_ptr_ty = self.typeOf(output);
-                const alignment = output_ptr_ty.ptrAlignment(pt).toLlvm();
+                const alignment = output_ptr_ty.ptrAlignment(zcu).toLlvm();
                 _ = try self.wip.store(.normal, output_value, output_ptr, alignment);
             } else {
                 ret_val = output_value;
 @@ -7182,23 +7171,23 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const operand = try self.resolveInst(un_op);
         const operand_ty = self.typeOf(un_op);
-        const optional_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
+        const optional_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty;
         const optional_llvm_ty = try o.lowerType(optional_ty);
-        const payload_ty = optional_ty.optionalChild(mod);
+        const payload_ty = optional_ty.optionalChild(zcu);
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             const loaded = if (operand_is_ptr)
                 try self.wip.load(.normal, optional_llvm_ty, operand, .default, "")
             else
                 operand;
-            if (payload_ty.isSlice(mod)) {
+            if (payload_ty.isSlice(zcu)) {
                 const slice_ptr = try self.wip.extractValue(loaded, &.{0}, "");
                 const ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(
-                    payload_ty.ptrAddressSpace(mod),
+                    payload_ty.ptrAddressSpace(zcu),
-                    mod.getTarget(),
+                    zcu.getTarget(),
                 ));
                 return self.wip.icmp(cond, slice_ptr, try o.builder.nullValue(ptr_ty), "");
             }
 @@ -7207,7 +7196,7 @@ pub const FuncGen = struct {
         comptime assert(optional_layout_version == 3);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             const loaded = if (operand_is_ptr)
                 try self.wip.load(.normal, optional_llvm_ty, operand, .default, "")
             else
 @@ -7215,7 +7204,7 @@ pub const FuncGen = struct {
             return self.wip.icmp(cond, loaded, try o.builder.intValue(.i8, 0), "");
         }
-        const is_by_ref = operand_is_ptr or isByRef(optional_ty, pt);
+        const is_by_ref = operand_is_ptr or isByRef(optional_ty, zcu);
         return self.optCmpNull(cond, optional_llvm_ty, operand, is_by_ref);
     }
 @@ -7227,16 +7216,16 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const operand = try self.resolveInst(un_op);
         const operand_ty = self.typeOf(un_op);
-        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty;
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
         const error_type = try o.errorIntType();
         const zero = try o.builder.intValue(error_type, 0);
-        if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             const val: Builder.Constant = switch (cond) {
                 .eq => .true, // 0 == 0
                 .ne => .false, // 0 != 0
 @@ -7245,7 +7234,7 @@ pub const FuncGen = struct {
             return val.toValue();
         }
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             const loaded = if (operand_is_ptr)
                 try self.wip.load(.normal, try o.lowerType(err_union_ty), operand, .default, "")
             else
 @@ -7255,7 +7244,7 @@ pub const FuncGen = struct {
         const err_field_index = try errUnionErrorOffset(payload_ty, pt);
-        const loaded = if (operand_is_ptr or isByRef(err_union_ty, pt)) loaded: {
+        const loaded = if (operand_is_ptr or isByRef(err_union_ty, zcu)) loaded: {
             const err_union_llvm_ty = try o.lowerType(err_union_ty);
             const err_field_ptr =
                 try self.wip.gepStruct(err_union_llvm_ty, operand, err_field_index, "");
 @@ -7267,17 +7256,17 @@ pub const FuncGen = struct {
     fn airOptionalPayloadPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const optional_ty = self.typeOf(ty_op.operand).childType(mod);
+        const optional_ty = self.typeOf(ty_op.operand).childType(zcu);
-        const payload_ty = optional_ty.optionalChild(mod);
+        const payload_ty = optional_ty.optionalChild(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             // We have a pointer to a zero-bit value and we need to return
             // a pointer to a zero-bit value.
             return operand;
         }
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             // The payload and the optional are the same value.
             return operand;
         }
 @@ -7289,18 +7278,18 @@ pub const FuncGen = struct {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const optional_ty = self.typeOf(ty_op.operand).childType(mod);
+        const optional_ty = self.typeOf(ty_op.operand).childType(zcu);
-        const payload_ty = optional_ty.optionalChild(mod);
+        const payload_ty = optional_ty.optionalChild(zcu);
         const non_null_bit = try o.builder.intValue(.i8, 1);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             // We have a pointer to a i8. We need to set it to 1 and then return the same pointer.
             _ = try self.wip.store(.normal, non_null_bit, operand, .default);
             return operand;
         }
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             // The payload and the optional are the same value.
             // Setting to non-null will be done when the payload is set.
             return operand;
 @@ -7321,21 +7310,21 @@ pub const FuncGen = struct {
     fn airOptionalPayload(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const optional_ty = self.typeOf(ty_op.operand);
         const payload_ty = self.typeOfIndex(inst);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             // Payload value is the same as the optional value.
             return operand;
         }
         const opt_llvm_ty = try o.lowerType(optional_ty);
-        const can_elide_load = if (isByRef(payload_ty, pt)) self.canElideLoad(body_tail) else false;
+        const can_elide_load = if (isByRef(payload_ty, zcu)) self.canElideLoad(body_tail) else false;
         return self.optPayloadHandle(opt_llvm_ty, operand, optional_ty, can_elide_load);
     }
 @@ -7346,26 +7335,26 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty;
         const result_ty = self.typeOfIndex(inst);
-        const payload_ty = if (operand_is_ptr) result_ty.childType(mod) else result_ty;
+        const payload_ty = if (operand_is_ptr) result_ty.childType(zcu) else result_ty;
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             return if (operand_is_ptr) operand else .none;
         }
         const offset = try errUnionPayloadOffset(payload_ty, pt);
         const err_union_llvm_ty = try o.lowerType(err_union_ty);
         if (operand_is_ptr) {
             return self.wip.gepStruct(err_union_llvm_ty, operand, offset, "");
-        } else if (isByRef(err_union_ty, pt)) {
+        } else if (isByRef(err_union_ty, zcu)) {
-            const payload_alignment = payload_ty.abiAlignment(pt).toLlvm();
+            const payload_alignment = payload_ty.abiAlignment(zcu).toLlvm();
             const payload_ptr = try self.wip.gepStruct(err_union_llvm_ty, operand, offset, "");
-            if (isByRef(payload_ty, pt)) {
+            if (isByRef(payload_ty, zcu)) {
                 if (self.canElideLoad(body_tail)) return payload_ptr;
                 return self.loadByRef(payload_ptr, payload_ty, payload_alignment, .normal);
             }
 @@ -7382,13 +7371,13 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
         const error_type = try o.errorIntType();
-        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty;
-        if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             if (operand_is_ptr) {
                 return operand;
             } else {
 @@ -7396,15 +7385,15 @@ pub const FuncGen = struct {
             }
         }
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             if (!operand_is_ptr) return operand;
             return self.wip.load(.normal, error_type, operand, .default, "");
         }
         const offset = try errUnionErrorOffset(payload_ty, pt);
-        if (operand_is_ptr or isByRef(err_union_ty, pt)) {
+        if (operand_is_ptr or isByRef(err_union_ty, zcu)) {
             const err_union_llvm_ty = try o.lowerType(err_union_ty);
             const err_field_ptr = try self.wip.gepStruct(err_union_llvm_ty, operand, offset, "");
             return self.wip.load(.normal, error_type, err_field_ptr, .default, "");
 @@ -7416,21 +7405,21 @@ pub const FuncGen = struct {
     fn airErrUnionPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const err_union_ty = self.typeOf(ty_op.operand).childType(mod);
+        const err_union_ty = self.typeOf(ty_op.operand).childType(zcu);
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
         const non_error_val = try o.builder.intValue(try o.errorIntType(), 0);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             _ = try self.wip.store(.normal, non_error_val, operand, .default);
             return operand;
         }
         const err_union_llvm_ty = try o.lowerType(err_union_ty);
         {
             const err_int_ty = try pt.errorIntType();
-            const error_alignment = err_int_ty.abiAlignment(pt).toLlvm();
+            const error_alignment = err_int_ty.abiAlignment(zcu).toLlvm();
             const error_offset = try errUnionErrorOffset(payload_ty, pt);
             // First set the non-error value.
             const non_null_ptr = try self.wip.gepStruct(err_union_llvm_ty, operand, error_offset, "");
 @@ -7457,7 +7446,7 @@ pub const FuncGen = struct {
     fn airSaveErrReturnTraceIndex(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const struct_ty = ty_pl.ty.toType();
 @@ -7468,8 +7457,8 @@ pub const FuncGen = struct {
         assert(self.err_ret_trace != .none);
         const field_ptr =
             try self.wip.gepStruct(struct_llvm_ty, self.err_ret_trace, llvm_field_index, "");
-        const field_alignment = struct_ty.structFieldAlign(field_index, pt);
+        const field_alignment = struct_ty.fieldAlignment(field_index, zcu);
-        const field_ty = struct_ty.structFieldType(field_index, mod);
+        const field_ty = struct_ty.fieldType(field_index, zcu);
         const field_ptr_ty = try pt.ptrType(.{
             .child = field_ty.toIntern(),
             .flags = .{ .alignment = field_alignment },
 @@ -7503,23 +7492,23 @@ pub const FuncGen = struct {
     fn airWrapOptional(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const payload_ty = self.typeOf(ty_op.operand);
         const non_null_bit = try o.builder.intValue(.i8, 1);
         comptime assert(optional_layout_version == 3);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return non_null_bit;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return non_null_bit;
         const operand = try self.resolveInst(ty_op.operand);
         const optional_ty = self.typeOfIndex(inst);
-        if (optional_ty.optionalReprIsPayload(mod)) return operand;
+        if (optional_ty.optionalReprIsPayload(zcu)) return operand;
         const llvm_optional_ty = try o.lowerType(optional_ty);
-        if (isByRef(optional_ty, pt)) {
+        if (isByRef(optional_ty, zcu)) {
             const directReturn = self.isNextRet(body_tail);
             const optional_ptr = if (directReturn)
                 self.ret_ptr
             else brk: {
-                const alignment = optional_ty.abiAlignment(pt).toLlvm();
+                const alignment = optional_ty.abiAlignment(zcu).toLlvm();
                 const optional_ptr = try self.buildAllocaWorkaround(optional_ty, alignment);
                 break :brk optional_ptr;
             };
 @@ -7537,12 +7526,13 @@ pub const FuncGen = struct {
     fn airWrapErrUnionPayload(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const err_un_ty = self.typeOfIndex(inst);
         const operand = try self.resolveInst(ty_op.operand);
         const payload_ty = self.typeOf(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             return operand;
         }
         const ok_err_code = try o.builder.intValue(try o.errorIntType(), 0);
 @@ -7550,19 +7540,19 @@ pub const FuncGen = struct {
         const payload_offset = try errUnionPayloadOffset(payload_ty, pt);
         const error_offset = try errUnionErrorOffset(payload_ty, pt);
-        if (isByRef(err_un_ty, pt)) {
+        if (isByRef(err_un_ty, zcu)) {
             const directReturn = self.isNextRet(body_tail);
             const result_ptr = if (directReturn)
                 self.ret_ptr
             else brk: {
-                const alignment = err_un_ty.abiAlignment(pt).toLlvm();
+                const alignment = err_un_ty.abiAlignment(pt.zcu).toLlvm();
                 const result_ptr = try self.buildAllocaWorkaround(err_un_ty, alignment);
                 break :brk result_ptr;
             };
             const err_ptr = try self.wip.gepStruct(err_un_llvm_ty, result_ptr, error_offset, "");
             const err_int_ty = try pt.errorIntType();
-            const error_alignment = err_int_ty.abiAlignment(pt).toLlvm();
+            const error_alignment = err_int_ty.abiAlignment(pt.zcu).toLlvm();
             _ = try self.wip.store(.normal, ok_err_code, err_ptr, error_alignment);
             const payload_ptr = try self.wip.gepStruct(err_un_llvm_ty, result_ptr, payload_offset, "");
             const payload_ptr_ty = try pt.singleMutPtrType(payload_ty);
 @@ -7578,30 +7568,30 @@ pub const FuncGen = struct {
     fn airWrapErrUnionErr(self: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const err_un_ty = self.typeOfIndex(inst);
-        const payload_ty = err_un_ty.errorUnionPayload(mod);
+        const payload_ty = err_un_ty.errorUnionPayload(zcu);
         const operand = try self.resolveInst(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return operand;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return operand;
         const err_un_llvm_ty = try o.lowerType(err_un_ty);
         const payload_offset = try errUnionPayloadOffset(payload_ty, pt);
         const error_offset = try errUnionErrorOffset(payload_ty, pt);
-        if (isByRef(err_un_ty, pt)) {
+        if (isByRef(err_un_ty, zcu)) {
             const directReturn = self.isNextRet(body_tail);
             const result_ptr = if (directReturn)
                 self.ret_ptr
             else brk: {
-                const alignment = err_un_ty.abiAlignment(pt).toLlvm();
+                const alignment = err_un_ty.abiAlignment(zcu).toLlvm();
                 const result_ptr = try self.buildAllocaWorkaround(err_un_ty, alignment);
                 break :brk result_ptr;
             };
             const err_ptr = try self.wip.gepStruct(err_un_llvm_ty, result_ptr, error_offset, "");
             const err_int_ty = try pt.errorIntType();
-            const error_alignment = err_int_ty.abiAlignment(pt).toLlvm();
+            const error_alignment = err_int_ty.abiAlignment(zcu).toLlvm();
             _ = try self.wip.store(.normal, operand, err_ptr, error_alignment);
             const payload_ptr = try self.wip.gepStruct(err_un_llvm_ty, result_ptr, payload_offset, "");
             const payload_ptr_ty = try pt.singleMutPtrType(payload_ty);
 @@ -7639,7 +7629,7 @@ pub const FuncGen = struct {
     fn airVectorStoreElem(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const data = self.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
         const extra = self.air.extraData(Air.Bin, data.payload).data;
 @@ -7649,9 +7639,9 @@ pub const FuncGen = struct {
         const operand = try self.resolveInst(extra.rhs);
         const access_kind: Builder.MemoryAccessKind =
-            if (vector_ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal;
+            if (vector_ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
-        const elem_llvm_ty = try o.lowerType(vector_ptr_ty.childType(mod));
+        const elem_llvm_ty = try o.lowerType(vector_ptr_ty.childType(zcu));
-        const alignment = vector_ptr_ty.ptrAlignment(pt).toLlvm();
+        const alignment = vector_ptr_ty.ptrAlignment(zcu).toLlvm();
         const loaded = try self.wip.load(access_kind, elem_llvm_ty, vector_ptr, alignment, "");
         const new_vector = try self.wip.insertElement(loaded, operand, index, "");
 @@ -7661,18 +7651,18 @@ pub const FuncGen = struct {
     fn airMin(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.fmin, .normal, inst_ty, 2, .{ lhs, rhs });
         return self.wip.callIntrinsic(
             .normal,
             .none,
-            if (scalar_ty.isSignedInt(mod)) .smin else .umin,
+            if (scalar_ty.isSignedInt(zcu)) .smin else .umin,
             &.{try o.lowerType(inst_ty)},
             &.{ lhs, rhs },
             "",
 @@ -7681,18 +7671,18 @@ pub const FuncGen = struct {
     fn airMax(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.fmax, .normal, inst_ty, 2, .{ lhs, rhs });
         return self.wip.callIntrinsic(
             .normal,
             .none,
-            if (scalar_ty.isSignedInt(mod)) .smax else .umax,
+            if (scalar_ty.isSignedInt(zcu)) .smax else .umax,
             &.{try o.lowerType(inst_ty)},
             &.{ lhs, rhs },
             "",
 @@ -7711,15 +7701,15 @@ pub const FuncGen = struct {
     fn airAdd(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.add, fast, inst_ty, 2, .{ lhs, rhs });
-        return self.wip.bin(if (scalar_ty.isSignedInt(mod)) .@"add nsw" else .@"add nuw", lhs, rhs, "");
+        return self.wip.bin(if (scalar_ty.isSignedInt(zcu)) .@"add nsw" else .@"add nuw", lhs, rhs, "");
     }
     fn airSafeArithmetic(
 @@ -7729,15 +7719,15 @@ pub const FuncGen = struct {
         unsigned_intrinsic: Builder.Intrinsic,
     ) !Builder.Value {
         const o = fg.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try fg.resolveInst(bin_op.lhs);
         const rhs = try fg.resolveInst(bin_op.rhs);
         const inst_ty = fg.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
-        const intrinsic = if (scalar_ty.isSignedInt(mod)) signed_intrinsic else unsigned_intrinsic;
+        const intrinsic = if (scalar_ty.isSignedInt(zcu)) signed_intrinsic else unsigned_intrinsic;
         const llvm_inst_ty = try o.lowerType(inst_ty);
         const results =
             try fg.wip.callIntrinsic(.normal, .none, intrinsic, &.{llvm_inst_ty}, &.{ lhs, rhs }, "");
 @@ -7777,18 +7767,18 @@ pub const FuncGen = struct {
     fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.todo("saturating float add", .{});
         return self.wip.callIntrinsic(
             .normal,
             .none,
-            if (scalar_ty.isSignedInt(mod)) .@"sadd.sat" else .@"uadd.sat",
+            if (scalar_ty.isSignedInt(zcu)) .@"sadd.sat" else .@"uadd.sat",
             &.{try o.lowerType(inst_ty)},
             &.{ lhs, rhs },
             "",
 @@ -7797,15 +7787,15 @@ pub const FuncGen = struct {
     fn airSub(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.sub, fast, inst_ty, 2, .{ lhs, rhs });
-        return self.wip.bin(if (scalar_ty.isSignedInt(mod)) .@"sub nsw" else .@"sub nuw", lhs, rhs, "");
+        return self.wip.bin(if (scalar_ty.isSignedInt(zcu)) .@"sub nsw" else .@"sub nuw", lhs, rhs, "");
     }
     fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
 @@ -7818,18 +7808,18 @@ pub const FuncGen = struct {
     fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.todo("saturating float sub", .{});
         return self.wip.callIntrinsic(
             .normal,
             .none,
-            if (scalar_ty.isSignedInt(mod)) .@"ssub.sat" else .@"usub.sat",
+            if (scalar_ty.isSignedInt(zcu)) .@"ssub.sat" else .@"usub.sat",
             &.{try o.lowerType(inst_ty)},
             &.{ lhs, rhs },
             "",
 @@ -7838,15 +7828,15 @@ pub const FuncGen = struct {
     fn airMul(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.buildFloatOp(.mul, fast, inst_ty, 2, .{ lhs, rhs });
-        return self.wip.bin(if (scalar_ty.isSignedInt(mod)) .@"mul nsw" else .@"mul nuw", lhs, rhs, "");
+        return self.wip.bin(if (scalar_ty.isSignedInt(zcu)) .@"mul nsw" else .@"mul nuw", lhs, rhs, "");
     }
     fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
 @@ -7859,18 +7849,18 @@ pub const FuncGen = struct {
     fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isAnyFloat()) return self.todo("saturating float mul", .{});
         return self.wip.callIntrinsic(
             .normal,
             .none,
-            if (scalar_ty.isSignedInt(mod)) .@"smul.fix.sat" else .@"umul.fix.sat",
+            if (scalar_ty.isSignedInt(zcu)) .@"smul.fix.sat" else .@"umul.fix.sat",
             &.{try o.lowerType(inst_ty)},
             &.{ lhs, rhs, .@"0" },
             "",
 @@ -7888,34 +7878,34 @@ pub const FuncGen = struct {
     fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isRuntimeFloat()) {
             const result = try self.buildFloatOp(.div, fast, inst_ty, 2, .{ lhs, rhs });
             return self.buildFloatOp(.trunc, fast, inst_ty, 1, .{result});
         }
-        return self.wip.bin(if (scalar_ty.isSignedInt(mod)) .sdiv else .udiv, lhs, rhs, "");
+        return self.wip.bin(if (scalar_ty.isSignedInt(zcu)) .sdiv else .udiv, lhs, rhs, "");
     }
     fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isRuntimeFloat()) {
             const result = try self.buildFloatOp(.div, fast, inst_ty, 2, .{ lhs, rhs });
             return self.buildFloatOp(.floor, fast, inst_ty, 1, .{result});
         }
-        if (scalar_ty.isSignedInt(mod)) {
+        if (scalar_ty.isSignedInt(zcu)) {
             const inst_llvm_ty = try o.lowerType(inst_ty);
             const bit_size_minus_one = try o.builder.splatValue(inst_llvm_ty, try o.builder.intConst(
                 inst_llvm_ty.scalarType(&o.builder),
 @@ -7936,16 +7926,16 @@ pub const FuncGen = struct {
     fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isRuntimeFloat()) return self.buildFloatOp(.div, fast, inst_ty, 2, .{ lhs, rhs });
         return self.wip.bin(
-            if (scalar_ty.isSignedInt(mod)) .@"sdiv exact" else .@"udiv exact",
+            if (scalar_ty.isSignedInt(zcu)) .@"sdiv exact" else .@"udiv exact",
             lhs,
             rhs,
             "",
 @@ -7954,16 +7944,16 @@ pub const FuncGen = struct {
     fn airRem(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isRuntimeFloat())
             return self.buildFloatOp(.fmod, fast, inst_ty, 2, .{ lhs, rhs });
-        return self.wip.bin(if (scalar_ty.isSignedInt(mod))
+        return self.wip.bin(if (scalar_ty.isSignedInt(zcu))
             .srem
         else
             .urem, lhs, rhs, "");
 @@ -7971,13 +7961,13 @@ pub const FuncGen = struct {
     fn airMod(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.typeOfIndex(inst);
         const inst_llvm_ty = try o.lowerType(inst_ty);
-        const scalar_ty = inst_ty.scalarType(mod);
+        const scalar_ty = inst_ty.scalarType(zcu);
         if (scalar_ty.isRuntimeFloat()) {
             const a = try self.buildFloatOp(.fmod, fast, inst_ty, 2, .{ lhs, rhs });
 @@ -7987,7 +7977,7 @@ pub const FuncGen = struct {
             const ltz = try self.buildFloatCmp(fast, .lt, inst_ty, .{ lhs, zero });
             return self.wip.select(fast, ltz, c, a, "");
         }
-        if (scalar_ty.isSignedInt(mod)) {
+        if (scalar_ty.isSignedInt(zcu)) {
             const bit_size_minus_one = try o.builder.splatValue(inst_llvm_ty, try o.builder.intConst(
                 inst_llvm_ty.scalarType(&o.builder),
                 inst_llvm_ty.scalarBits(&o.builder) - 1,
 @@ -8007,14 +7997,14 @@ pub const FuncGen = struct {
     fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const ptr = try self.resolveInst(bin_op.lhs);
         const offset = try self.resolveInst(bin_op.rhs);
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(ptr_ty.childType(mod));
+        const llvm_elem_ty = try o.lowerPtrElemTy(ptr_ty.childType(zcu));
-        switch (ptr_ty.ptrSize(mod)) {
+        switch (ptr_ty.ptrSize(zcu)) {
             // It's a pointer to an array, so according to LLVM we need an extra GEP index.
             .One => return self.wip.gep(.inbounds, llvm_elem_ty, ptr, &.{
                 try o.builder.intValue(try o.lowerType(Type.usize), 0), offset,
 @@ -8029,15 +8019,15 @@ pub const FuncGen = struct {
     fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const ptr = try self.resolveInst(bin_op.lhs);
         const offset = try self.resolveInst(bin_op.rhs);
         const negative_offset = try self.wip.neg(offset, "");
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const llvm_elem_ty = try o.lowerPtrElemTy(ptr_ty.childType(mod));
+        const llvm_elem_ty = try o.lowerPtrElemTy(ptr_ty.childType(zcu));
-        switch (ptr_ty.ptrSize(mod)) {
+        switch (ptr_ty.ptrSize(zcu)) {
             // It's a pointer to an array, so according to LLVM we need an extra GEP index.
             .One => return self.wip.gep(.inbounds, llvm_elem_ty, ptr, &.{
                 try o.builder.intValue(try o.lowerType(Type.usize), 0), negative_offset,
 @@ -8058,7 +8048,7 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
 @@ -8066,10 +8056,10 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(extra.rhs);
         const lhs_ty = self.typeOf(extra.lhs);
-        const scalar_ty = lhs_ty.scalarType(mod);
+        const scalar_ty = lhs_ty.scalarType(zcu);
         const inst_ty = self.typeOfIndex(inst);
-        const intrinsic = if (scalar_ty.isSignedInt(mod)) signed_intrinsic else unsigned_intrinsic;
+        const intrinsic = if (scalar_ty.isSignedInt(zcu)) signed_intrinsic else unsigned_intrinsic;
         const llvm_inst_ty = try o.lowerType(inst_ty);
         const llvm_lhs_ty = try o.lowerType(lhs_ty);
         const results =
 @@ -8081,8 +8071,8 @@ pub const FuncGen = struct {
         const result_index = o.llvmFieldIndex(inst_ty, 0).?;
         const overflow_index = o.llvmFieldIndex(inst_ty, 1).?;
-        if (isByRef(inst_ty, pt)) {
+        if (isByRef(inst_ty, zcu)) {
-            const result_alignment = inst_ty.abiAlignment(pt).toLlvm();
+            const result_alignment = inst_ty.abiAlignment(zcu).toLlvm();
             const alloca_inst = try self.buildAllocaWorkaround(inst_ty, result_alignment);
             {
                 const field_ptr = try self.wip.gepStruct(llvm_inst_ty, alloca_inst, result_index, "");
 @@ -8165,9 +8155,9 @@ pub const FuncGen = struct {
         params: [2]Builder.Value,
     ) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         const scalar_llvm_ty = try o.lowerType(scalar_ty);
         if (intrinsicsAllowed(scalar_ty, target)) {
 @@ -8205,8 +8195,8 @@ pub const FuncGen = struct {
             .gte => .sge,
         };
-        if (ty.zigTypeTag(mod) == .Vector) {
+        if (ty.zigTypeTag(zcu) == .Vector) {
-            const vec_len = ty.vectorLen(mod);
+            const vec_len = ty.vectorLen(zcu);
             const vector_result_ty = try o.builder.vectorType(.normal, vec_len, .i32);
             const init = try o.builder.poisonValue(vector_result_ty);
 @@ -8271,9 +8261,9 @@ pub const FuncGen = struct {
         params: [params_len]Builder.Value,
     ) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
         const llvm_ty = try o.lowerType(ty);
         if (op != .tan and intrinsicsAllowed(scalar_ty, target)) switch (op) {
 @@ -8382,9 +8372,9 @@ pub const FuncGen = struct {
             ([1]Builder.Type{scalar_llvm_ty} ** 3)[0..params.len],
             scalar_llvm_ty,
         );
-        if (ty.zigTypeTag(mod) == .Vector) {
+        if (ty.zigTypeTag(zcu) == .Vector) {
             const result = try o.builder.poisonValue(llvm_ty);
-            return self.buildElementwiseCall(libc_fn, &params, result, ty.vectorLen(mod));
+            return self.buildElementwiseCall(libc_fn, &params, result, ty.vectorLen(zcu));
         }
         return self.wip.call(
 @@ -8413,7 +8403,7 @@ pub const FuncGen = struct {
     fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
 @@ -8421,7 +8411,7 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(extra.rhs);
         const lhs_ty = self.typeOf(extra.lhs);
-        const lhs_scalar_ty = lhs_ty.scalarType(mod);
+        const lhs_scalar_ty = lhs_ty.scalarType(zcu);
         const dest_ty = self.typeOfIndex(inst);
         const llvm_dest_ty = try o.lowerType(dest_ty);
 @@ -8429,7 +8419,7 @@ pub const FuncGen = struct {
         const casted_rhs = try self.wip.conv(.unsigned, rhs, try o.lowerType(lhs_ty), "");
         const result = try self.wip.bin(.shl, lhs, casted_rhs, "");
-        const reconstructed = try self.wip.bin(if (lhs_scalar_ty.isSignedInt(mod))
+        const reconstructed = try self.wip.bin(if (lhs_scalar_ty.isSignedInt(zcu))
             .ashr
         else
             .lshr, result, casted_rhs, "");
 @@ -8439,8 +8429,8 @@ pub const FuncGen = struct {
         const result_index = o.llvmFieldIndex(dest_ty, 0).?;
         const overflow_index = o.llvmFieldIndex(dest_ty, 1).?;
-        if (isByRef(dest_ty, pt)) {
+        if (isByRef(dest_ty, zcu)) {
-            const result_alignment = dest_ty.abiAlignment(pt).toLlvm();
+            const result_alignment = dest_ty.abiAlignment(zcu).toLlvm();
             const alloca_inst = try self.buildAllocaWorkaround(dest_ty, result_alignment);
             {
                 const field_ptr = try self.wip.gepStruct(llvm_dest_ty, alloca_inst, result_index, "");
 @@ -8483,17 +8473,17 @@ pub const FuncGen = struct {
     fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const lhs_ty = self.typeOf(bin_op.lhs);
-        const lhs_scalar_ty = lhs_ty.scalarType(mod);
+        const lhs_scalar_ty = lhs_ty.scalarType(zcu);
         const casted_rhs = try self.wip.conv(.unsigned, rhs, try o.lowerType(lhs_ty), "");
-        return self.wip.bin(if (lhs_scalar_ty.isSignedInt(mod))
+        return self.wip.bin(if (lhs_scalar_ty.isSignedInt(zcu))
             .@"shl nsw"
         else
             .@"shl nuw", lhs, casted_rhs, "");
 @@ -8515,15 +8505,15 @@ pub const FuncGen = struct {
     fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const lhs_ty = self.typeOf(bin_op.lhs);
-        const lhs_scalar_ty = lhs_ty.scalarType(mod);
+        const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-        const lhs_bits = lhs_scalar_ty.bitSize(pt);
+        const lhs_bits = lhs_scalar_ty.bitSize(zcu);
         const casted_rhs = try self.wip.conv(.unsigned, rhs, try o.lowerType(lhs_ty), "");
 @@ -8532,7 +8522,7 @@ pub const FuncGen = struct {
         const result = try self.wip.callIntrinsic(
             .normal,
             .none,
-            if (lhs_scalar_ty.isSignedInt(mod)) .@"sshl.sat" else .@"ushl.sat",
+            if (lhs_scalar_ty.isSignedInt(zcu)) .@"sshl.sat" else .@"ushl.sat",
             &.{llvm_lhs_ty},
             &.{ lhs, casted_rhs },
             "",
 @@ -8557,17 +8547,17 @@ pub const FuncGen = struct {
     fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const lhs = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const lhs_ty = self.typeOf(bin_op.lhs);
-        const lhs_scalar_ty = lhs_ty.scalarType(mod);
+        const lhs_scalar_ty = lhs_ty.scalarType(zcu);
         const casted_rhs = try self.wip.conv(.unsigned, rhs, try o.lowerType(lhs_ty), "");
-        const is_signed_int = lhs_scalar_ty.isSignedInt(mod);
+        const is_signed_int = lhs_scalar_ty.isSignedInt(zcu);
         return self.wip.bin(if (is_exact)
             if (is_signed_int) .@"ashr exact" else .@"lshr exact"
 @@ -8576,13 +8566,13 @@ pub const FuncGen = struct {
     fn airAbs(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const scalar_ty = operand_ty.scalarType(mod);
+        const scalar_ty = operand_ty.scalarType(zcu);
-        switch (scalar_ty.zigTypeTag(mod)) {
+        switch (scalar_ty.zigTypeTag(zcu)) {
             .Int => return self.wip.callIntrinsic(
                 .normal,
                 .none,
 @@ -8598,13 +8588,13 @@ pub const FuncGen = struct {
     fn airIntCast(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const dest_ty = self.typeOfIndex(inst);
         const dest_llvm_ty = try o.lowerType(dest_ty);
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const operand_info = operand_ty.intInfo(mod);
+        const operand_info = operand_ty.intInfo(zcu);
         return self.wip.conv(switch (operand_info.signedness) {
             .signed => .signed,
 @@ -8622,12 +8612,12 @@ pub const FuncGen = struct {
     fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
         const dest_ty = self.typeOfIndex(inst);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const dest_bits = dest_ty.floatBits(target);
         const src_bits = operand_ty.floatBits(target);
 @@ -8656,12 +8646,12 @@ pub const FuncGen = struct {
     fn airFpext(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
         const dest_ty = self.typeOfIndex(inst);
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         if (intrinsicsAllowed(dest_ty, target) and intrinsicsAllowed(operand_ty, target)) {
             return self.wip.cast(.fpext, operand, try o.lowerType(dest_ty), "");
 @@ -8669,18 +8659,18 @@ pub const FuncGen = struct {
             const operand_llvm_ty = try o.lowerType(operand_ty);
             const dest_llvm_ty = try o.lowerType(dest_ty);
-            const dest_bits = dest_ty.scalarType(mod).floatBits(target);
+            const dest_bits = dest_ty.scalarType(zcu).floatBits(target);
-            const src_bits = operand_ty.scalarType(mod).floatBits(target);
+            const src_bits = operand_ty.scalarType(zcu).floatBits(target);
             const fn_name = try o.builder.strtabStringFmt("__extend{s}f{s}f2", .{
                 compilerRtFloatAbbrev(src_bits), compilerRtFloatAbbrev(dest_bits),
             });
             const libc_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, dest_llvm_ty);
-            if (dest_ty.isVector(mod)) return self.buildElementwiseCall(
+            if (dest_ty.isVector(zcu)) return self.buildElementwiseCall(
                 libc_fn,
                 &.{operand},
                 try o.builder.poisonValue(dest_llvm_ty),
-                dest_ty.vectorLen(mod),
+                dest_ty.vectorLen(zcu),
             );
             return self.wip.call(
                 .normal,
 @@ -8715,9 +8705,9 @@ pub const FuncGen = struct {
     fn bitCast(self: *FuncGen, operand: Builder.Value, operand_ty: Type, inst_ty: Type) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const operand_is_ref = isByRef(operand_ty, pt);
+        const operand_is_ref = isByRef(operand_ty, zcu);
-        const result_is_ref = isByRef(inst_ty, pt);
+        const result_is_ref = isByRef(inst_ty, zcu);
         const llvm_dest_ty = try o.lowerType(inst_ty);
         if (operand_is_ref and result_is_ref) {
 @@ -8731,18 +8721,18 @@ pub const FuncGen = struct {
             return self.wip.conv(.unsigned, operand, llvm_dest_ty, "");
         }
-        if (operand_ty.zigTypeTag(mod) == .Int and inst_ty.isPtrAtRuntime(mod)) {
+        if (operand_ty.zigTypeTag(zcu) == .Int and inst_ty.isPtrAtRuntime(zcu)) {
             return self.wip.cast(.inttoptr, operand, llvm_dest_ty, "");
         }
-        if (operand_ty.zigTypeTag(mod) == .Vector and inst_ty.zigTypeTag(mod) == .Array) {
+        if (operand_ty.zigTypeTag(zcu) == .Vector and inst_ty.zigTypeTag(zcu) == .Array) {
-            const elem_ty = operand_ty.childType(mod);
+            const elem_ty = operand_ty.childType(zcu);
             if (!result_is_ref) {
                 return self.ng.todo("implement bitcast vector to non-ref array", .{});
             }
-            const alignment = inst_ty.abiAlignment(pt).toLlvm();
+            const alignment = inst_ty.abiAlignment(zcu).toLlvm();
             const array_ptr = try self.buildAllocaWorkaround(inst_ty, alignment);
-            const bitcast_ok = elem_ty.bitSize(pt) == elem_ty.abiSize(pt) * 8;
+            const bitcast_ok = elem_ty.bitSize(zcu) == elem_ty.abiSize(zcu) * 8;
             if (bitcast_ok) {
                 _ = try self.wip.store(.normal, operand, array_ptr, alignment);
             } else {
 @@ -8750,7 +8740,7 @@ pub const FuncGen = struct {
                 // a simple bitcast will not work, and we fall back to extractelement.
                 const llvm_usize = try o.lowerType(Type.usize);
                 const usize_zero = try o.builder.intValue(llvm_usize, 0);
-                const vector_len = operand_ty.arrayLen(mod);
+                const vector_len = operand_ty.arrayLen(zcu);
                 var i: u64 = 0;
                 while (i < vector_len) : (i += 1) {
                     const elem_ptr = try self.wip.gep(.inbounds, llvm_dest_ty, array_ptr, &.{
 @@ -8762,16 +8752,16 @@ pub const FuncGen = struct {
                 }
             }
             return array_ptr;
-        } else if (operand_ty.zigTypeTag(mod) == .Array and inst_ty.zigTypeTag(mod) == .Vector) {
+        } else if (operand_ty.zigTypeTag(zcu) == .Array and inst_ty.zigTypeTag(zcu) == .Vector) {
-            const elem_ty = operand_ty.childType(mod);
+            const elem_ty = operand_ty.childType(zcu);
             const llvm_vector_ty = try o.lowerType(inst_ty);
             if (!operand_is_ref) return self.ng.todo("implement bitcast non-ref array to vector", .{});
-            const bitcast_ok = elem_ty.bitSize(pt) == elem_ty.abiSize(pt) * 8;
+            const bitcast_ok = elem_ty.bitSize(zcu) == elem_ty.abiSize(zcu) * 8;
             if (bitcast_ok) {
                 // The array is aligned to the element's alignment, while the vector might have a completely
                 // different alignment. This means we need to enforce the alignment of this load.
-                const alignment = elem_ty.abiAlignment(pt).toLlvm();
+                const alignment = elem_ty.abiAlignment(zcu).toLlvm();
                 return self.wip.load(.normal, llvm_vector_ty, operand, alignment, "");
             } else {
                 // If the ABI size of the element type is not evenly divisible by size in bits;
 @@ -8780,7 +8770,7 @@ pub const FuncGen = struct {
                 const elem_llvm_ty = try o.lowerType(elem_ty);
                 const llvm_usize = try o.lowerType(Type.usize);
                 const usize_zero = try o.builder.intValue(llvm_usize, 0);
-                const vector_len = operand_ty.arrayLen(mod);
+                const vector_len = operand_ty.arrayLen(zcu);
                 var vector = try o.builder.poisonValue(llvm_vector_ty);
                 var i: u64 = 0;
                 while (i < vector_len) : (i += 1) {
 @@ -8796,25 +8786,25 @@ pub const FuncGen = struct {
         }
         if (operand_is_ref) {
-            const alignment = operand_ty.abiAlignment(pt).toLlvm();
+            const alignment = operand_ty.abiAlignment(zcu).toLlvm();
             return self.wip.load(.normal, llvm_dest_ty, operand, alignment, "");
         }
         if (result_is_ref) {
-            const alignment = operand_ty.abiAlignment(pt).max(inst_ty.abiAlignment(pt)).toLlvm();
+            const alignment = operand_ty.abiAlignment(zcu).max(inst_ty.abiAlignment(zcu)).toLlvm();
             const result_ptr = try self.buildAllocaWorkaround(inst_ty, alignment);
             _ = try self.wip.store(.normal, operand, result_ptr, alignment);
             return result_ptr;
         }
         if (llvm_dest_ty.isStruct(&o.builder) or
-            ((operand_ty.zigTypeTag(mod) == .Vector or inst_ty.zigTypeTag(mod) == .Vector) and
+            ((operand_ty.zigTypeTag(zcu) == .Vector or inst_ty.zigTypeTag(zcu) == .Vector) and
-            operand_ty.bitSize(pt) != inst_ty.bitSize(pt)))
+            operand_ty.bitSize(zcu) != inst_ty.bitSize(zcu)))
         {
             // Both our operand and our result are values, not pointers,
             // but LLVM won't let us bitcast struct values or vectors with padding bits.
             // Therefore, we store operand to alloca, then load for result.
-            const alignment = operand_ty.abiAlignment(pt).max(inst_ty.abiAlignment(pt)).toLlvm();
+            const alignment = operand_ty.abiAlignment(zcu).max(inst_ty.abiAlignment(zcu)).toLlvm();
             const result_ptr = try self.buildAllocaWorkaround(inst_ty, alignment);
             _ = try self.wip.store(.normal, operand, result_ptr, alignment);
             return self.wip.load(.normal, llvm_dest_ty, result_ptr, alignment, "");
 @@ -8868,7 +8858,7 @@ pub const FuncGen = struct {
         };
         const mod = self.ng.ownerModule();
-        if (isByRef(inst_ty, pt)) {
+        if (isByRef(inst_ty, zcu)) {
             _ = try self.wip.callIntrinsic(
                 .normal,
                 .none,
 @@ -8882,7 +8872,7 @@ pub const FuncGen = struct {
                 "",
             );
         } else if (mod.optimize_mode == .Debug) {
-            const alignment = inst_ty.abiAlignment(pt).toLlvm();
+            const alignment = inst_ty.abiAlignment(zcu).toLlvm();
             const alloca = try self.buildAlloca(arg_val.typeOfWip(&self.wip), alignment);
             _ = try self.wip.store(.normal, arg_val, alloca, alignment);
             _ = try self.wip.callIntrinsic(
 @@ -8919,28 +8909,28 @@ pub const FuncGen = struct {
     fn airAlloc(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ptr_ty = self.typeOfIndex(inst);
-        const pointee_type = ptr_ty.childType(mod);
+        const pointee_type = ptr_ty.childType(zcu);
-        if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime(pt))
+        if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime(zcu))
             return (try o.lowerPtrToVoid(ptr_ty)).toValue();
         //const pointee_llvm_ty = try o.lowerType(pointee_type);
-        const alignment = ptr_ty.ptrAlignment(pt).toLlvm();
+        const alignment = ptr_ty.ptrAlignment(zcu).toLlvm();
         return self.buildAllocaWorkaround(pointee_type, alignment);
     }
     fn airRetPtr(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ptr_ty = self.typeOfIndex(inst);
-        const ret_ty = ptr_ty.childType(mod);
+        const ret_ty = ptr_ty.childType(zcu);
-        if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt))
+        if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu))
             return (try o.lowerPtrToVoid(ptr_ty)).toValue();
         if (self.ret_ptr != .none) return self.ret_ptr;
         //const ret_llvm_ty = try o.lowerType(ret_ty);
-        const alignment = ptr_ty.ptrAlignment(pt).toLlvm();
+        const alignment = ptr_ty.ptrAlignment(zcu).toLlvm();
         return self.buildAllocaWorkaround(ret_ty, alignment);
     }
 @@ -8962,19 +8952,19 @@ pub const FuncGen = struct {
         alignment: Builder.Alignment,
     ) Allocator.Error!Builder.Value {
         const o = self.ng.object;
-        return self.buildAlloca(try o.builder.arrayType(ty.abiSize(o.pt), .i8), alignment);
+        return self.buildAlloca(try o.builder.arrayType(ty.abiSize(o.pt.zcu), .i8), alignment);
     }
     fn airStore(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const dest_ptr = try self.resolveInst(bin_op.lhs);
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const operand_ty = ptr_ty.childType(mod);
+        const operand_ty = ptr_ty.childType(zcu);
-        const val_is_undef = if (try self.air.value(bin_op.rhs, pt)) |val| val.isUndefDeep(mod) else false;
+        const val_is_undef = if (try self.air.value(bin_op.rhs, pt)) |val| val.isUndefDeep(zcu) else false;
         if (val_is_undef) {
             const owner_mod = self.ng.ownerModule();
 @@ -8991,7 +8981,7 @@ pub const FuncGen = struct {
                 return .none;
             }
-            const ptr_info = ptr_ty.ptrInfo(mod);
+            const ptr_info = ptr_ty.ptrInfo(zcu);
             const needs_bitmask = (ptr_info.packed_offset.host_size != 0);
             if (needs_bitmask) {
                 // TODO: only some bits are to be undef, we cannot write with a simple memset.
 @@ -9000,13 +8990,13 @@ pub const FuncGen = struct {
                 return .none;
             }
-            const len = try o.builder.intValue(try o.lowerType(Type.usize), operand_ty.abiSize(pt));
+            const len = try o.builder.intValue(try o.lowerType(Type.usize), operand_ty.abiSize(zcu));
             _ = try self.wip.callMemSet(
                 dest_ptr,
-                ptr_ty.ptrAlignment(pt).toLlvm(),
+                ptr_ty.ptrAlignment(zcu).toLlvm(),
                 if (safety) try o.builder.intValue(.i8, 0xaa) else try o.builder.undefValue(.i8),
                 len,
-                if (ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal,
+                if (ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal,
             );
             if (safety and owner_mod.valgrind) {
                 try self.valgrindMarkUndef(dest_ptr, len);
 @@ -9027,8 +9017,8 @@ pub const FuncGen = struct {
     /// The first instruction of `body_tail` is the one whose copy we want to elide.
     fn canElideLoad(fg: *FuncGen, body_tail: []const Air.Inst.Index) bool {
         const o = fg.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         for (body_tail[1..]) |body_inst| {
             switch (fg.liveness.categorizeOperand(fg.air, body_inst, body_tail[0], ip)) {
                 .none => continue,
 @@ -9044,15 +9034,15 @@ pub const FuncGen = struct {
     fn airLoad(fg: *FuncGen, body_tail: []const Air.Inst.Index) !Builder.Value {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const inst = body_tail[0];
         const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const ptr_ty = fg.typeOf(ty_op.operand);
-        const ptr_info = ptr_ty.ptrInfo(mod);
+        const ptr_info = ptr_ty.ptrInfo(zcu);
         const ptr = try fg.resolveInst(ty_op.operand);
         elide: {
-            if (!isByRef(Type.fromInterned(ptr_info.child), pt)) break :elide;
+            if (!isByRef(Type.fromInterned(ptr_info.child), zcu)) break :elide;
             if (!canElideLoad(fg, body_tail)) break :elide;
             return ptr;
         }
 @@ -9105,34 +9095,34 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
         const ptr = try self.resolveInst(extra.ptr);
         const ptr_ty = self.typeOf(extra.ptr);
         var expected_value = try self.resolveInst(extra.expected_value);
         var new_value = try self.resolveInst(extra.new_value);
-        const operand_ty = ptr_ty.childType(mod);
+        const operand_ty = ptr_ty.childType(zcu);
         const llvm_operand_ty = try o.lowerType(operand_ty);
         const llvm_abi_ty = try o.getAtomicAbiType(operand_ty, false);
         if (llvm_abi_ty != .none) {
             // operand needs widening and truncating
             const signedness: Builder.Function.Instruction.Cast.Signedness =
-                if (operand_ty.isSignedInt(mod)) .signed else .unsigned;
+                if (operand_ty.isSignedInt(zcu)) .signed else .unsigned;
             expected_value = try self.wip.conv(signedness, expected_value, llvm_abi_ty, "");
             new_value = try self.wip.conv(signedness, new_value, llvm_abi_ty, "");
         }
         const result = try self.wip.cmpxchg(
             kind,
-            if (ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal,
+            if (ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal,
             ptr,
             expected_value,
             new_value,
             self.sync_scope,
             toLlvmAtomicOrdering(extra.successOrder()),
             toLlvmAtomicOrdering(extra.failureOrder()),
-            ptr_ty.ptrAlignment(pt).toLlvm(),
+            ptr_ty.ptrAlignment(zcu).toLlvm(),
             "",
         );
 @@ -9142,7 +9132,7 @@ pub const FuncGen = struct {
         if (llvm_abi_ty != .none) payload = try self.wip.cast(.trunc, payload, llvm_operand_ty, "");
         const success_bit = try self.wip.extractValue(result, &.{1}, "");
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             const zero = try o.builder.zeroInitValue(payload.typeOfWip(&self.wip));
             return self.wip.select(.normal, success_bit, zero, payload, "");
         }
 @@ -9156,14 +9146,14 @@ pub const FuncGen = struct {
     fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data;
         const ptr = try self.resolveInst(pl_op.operand);
         const ptr_ty = self.typeOf(pl_op.operand);
-        const operand_ty = ptr_ty.childType(mod);
+        const operand_ty = ptr_ty.childType(zcu);
         const operand = try self.resolveInst(extra.operand);
-        const is_signed_int = operand_ty.isSignedInt(mod);
+        const is_signed_int = operand_ty.isSignedInt(zcu);
         const is_float = operand_ty.isRuntimeFloat();
         const op = toLlvmAtomicRmwBinOp(extra.op(), is_signed_int, is_float);
         const ordering = toLlvmAtomicOrdering(extra.ordering());
 @@ -9171,8 +9161,8 @@ pub const FuncGen = struct {
         const llvm_operand_ty = try o.lowerType(operand_ty);
         const access_kind: Builder.MemoryAccessKind =
-            if (ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal;
+            if (ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
-        const ptr_alignment = ptr_ty.ptrAlignment(pt).toLlvm();
+        const ptr_alignment = ptr_ty.ptrAlignment(zcu).toLlvm();
         if (llvm_abi_ty != .none) {
             // operand needs widening and truncating or bitcasting.
 @@ -9220,19 +9210,19 @@ pub const FuncGen = struct {
     fn airAtomicLoad(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load;
         const ptr = try self.resolveInst(atomic_load.ptr);
         const ptr_ty = self.typeOf(atomic_load.ptr);
-        const info = ptr_ty.ptrInfo(mod);
+        const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
         const ordering = toLlvmAtomicOrdering(atomic_load.order);
         const llvm_abi_ty = try o.getAtomicAbiType(elem_ty, false);
         const ptr_alignment = (if (info.flags.alignment != .none)
             @as(InternPool.Alignment, info.flags.alignment)
         else
-            Type.fromInterned(info.child).abiAlignment(pt)).toLlvm();
+            Type.fromInterned(info.child).abiAlignment(zcu)).toLlvm();
         const access_kind: Builder.MemoryAccessKind =
             if (info.flags.is_volatile) .@"volatile" else .normal;
         const elem_llvm_ty = try o.lowerType(elem_ty);
 @@ -9268,11 +9258,11 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const operand_ty = ptr_ty.childType(mod);
+        const operand_ty = ptr_ty.childType(zcu);
-        if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) return .none;
+        if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return .none;
         const ptr = try self.resolveInst(bin_op.lhs);
         var element = try self.resolveInst(bin_op.rhs);
         const llvm_abi_ty = try o.getAtomicAbiType(operand_ty, false);
 @@ -9280,7 +9270,7 @@ pub const FuncGen = struct {
         if (llvm_abi_ty != .none) {
             // operand needs widening
             element = try self.wip.conv(
-                if (operand_ty.isSignedInt(mod)) .signed else .unsigned,
+                if (operand_ty.isSignedInt(zcu)) .signed else .unsigned,
                 element,
                 llvm_abi_ty,
                 "",
 @@ -9293,26 +9283,26 @@ pub const FuncGen = struct {
     fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const dest_slice = try self.resolveInst(bin_op.lhs);
         const ptr_ty = self.typeOf(bin_op.lhs);
         const elem_ty = self.typeOf(bin_op.rhs);
-        const dest_ptr_align = ptr_ty.ptrAlignment(pt).toLlvm();
+        const dest_ptr_align = ptr_ty.ptrAlignment(zcu).toLlvm();
         const dest_ptr = try self.sliceOrArrayPtr(dest_slice, ptr_ty);
         const access_kind: Builder.MemoryAccessKind =
-            if (ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal;
+            if (ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
         // Any WebAssembly runtime will trap when the destination pointer is out-of-bounds, regardless
         // of the length. This means we need to emit a check where we skip the memset when the length
         // is 0 as we allow for undefined pointers in 0-sized slices.
         // This logic can be removed once https://github.com/ziglang/zig/issues/16360 is done.
         const intrinsic_len0_traps = o.target.isWasm() and
-            ptr_ty.isSlice(mod) and
+            ptr_ty.isSlice(zcu) and
             std.Target.wasm.featureSetHas(o.target.cpu.features, .bulk_memory);
         if (try self.air.value(bin_op.rhs, pt)) |elem_val| {
-            if (elem_val.isUndefDeep(mod)) {
+            if (elem_val.isUndefDeep(zcu)) {
                 // Even if safety is disabled, we still emit a memset to undefined since it conveys
                 // extra information to LLVM. However, safety makes the difference between using
                 // 0xaa or actual undefined for the fill byte.
 @@ -9350,7 +9340,7 @@ pub const FuncGen = struct {
         }
         const value = try self.resolveInst(bin_op.rhs);
-        const elem_abi_size = elem_ty.abiSize(pt);
+        const elem_abi_size = elem_ty.abiSize(zcu);
         if (elem_abi_size == 1) {
             // In this case we can take advantage of LLVM's intrinsic.
 @@ -9387,9 +9377,9 @@ pub const FuncGen = struct {
         const end_block = try self.wip.block(1, "InlineMemsetEnd");
         const llvm_usize_ty = try o.lowerType(Type.usize);
-        const len = switch (ptr_ty.ptrSize(mod)) {
+        const len = switch (ptr_ty.ptrSize(zcu)) {
             .Slice => try self.wip.extractValue(dest_slice, &.{1}, ""),
-            .One => try o.builder.intValue(llvm_usize_ty, ptr_ty.childType(mod).arrayLen(mod)),
+            .One => try o.builder.intValue(llvm_usize_ty, ptr_ty.childType(zcu).arrayLen(zcu)),
             .Many, .C => unreachable,
         };
         const elem_llvm_ty = try o.lowerType(elem_ty);
 @@ -9402,9 +9392,9 @@ pub const FuncGen = struct {
         _ = try self.wip.brCond(end, body_block, end_block);
         self.wip.cursor = .{ .block = body_block };
-        const elem_abi_align = elem_ty.abiAlignment(pt);
+        const elem_abi_align = elem_ty.abiAlignment(zcu);
         const it_ptr_align = InternPool.Alignment.fromLlvm(dest_ptr_align).min(elem_abi_align).toLlvm();
-        if (isByRef(elem_ty, pt)) {
+        if (isByRef(elem_ty, zcu)) {
             _ = try self.wip.callMemCpy(
                 it_ptr.toValue(),
                 it_ptr_align,
 @@ -9447,7 +9437,7 @@ pub const FuncGen = struct {
     fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const dest_slice = try self.resolveInst(bin_op.lhs);
         const dest_ptr_ty = self.typeOf(bin_op.lhs);
 @@ -9456,8 +9446,8 @@ pub const FuncGen = struct {
         const src_ptr = try self.sliceOrArrayPtr(src_slice, src_ptr_ty);
         const len = try self.sliceOrArrayLenInBytes(dest_slice, dest_ptr_ty);
         const dest_ptr = try self.sliceOrArrayPtr(dest_slice, dest_ptr_ty);
-        const access_kind: Builder.MemoryAccessKind = if (src_ptr_ty.isVolatilePtr(mod) or
+        const access_kind: Builder.MemoryAccessKind = if (src_ptr_ty.isVolatilePtr(zcu) or
-            dest_ptr_ty.isVolatilePtr(mod)) .@"volatile" else .normal;
+            dest_ptr_ty.isVolatilePtr(zcu)) .@"volatile" else .normal;
         // When bulk-memory is enabled, this will be lowered to WebAssembly's memory.copy instruction.
         // This instruction will trap on an invalid address, regardless of the length.
 @@ -9466,7 +9456,7 @@ pub const FuncGen = struct {
         // This logic can be removed once https://github.com/ziglang/zig/issues/16360 is done.
         if (o.target.isWasm() and
             std.Target.wasm.featureSetHas(o.target.cpu.features, .bulk_memory) and
-            dest_ptr_ty.isSlice(mod))
+            dest_ptr_ty.isSlice(zcu))
         {
             const usize_zero = try o.builder.intValue(try o.lowerType(Type.usize), 0);
             const cond = try self.cmp(.normal, .neq, Type.usize, len, usize_zero);
 @@ -9476,9 +9466,9 @@ pub const FuncGen = struct {
             self.wip.cursor = .{ .block = memcpy_block };
             _ = try self.wip.callMemCpy(
                 dest_ptr,
-                dest_ptr_ty.ptrAlignment(pt).toLlvm(),
+                dest_ptr_ty.ptrAlignment(zcu).toLlvm(),
                 src_ptr,
-                src_ptr_ty.ptrAlignment(pt).toLlvm(),
+                src_ptr_ty.ptrAlignment(zcu).toLlvm(),
                 len,
                 access_kind,
             );
 @@ -9489,9 +9479,9 @@ pub const FuncGen = struct {
         _ = try self.wip.callMemCpy(
             dest_ptr,
-            dest_ptr_ty.ptrAlignment(pt).toLlvm(),
+            dest_ptr_ty.ptrAlignment(zcu).toLlvm(),
             src_ptr,
-            src_ptr_ty.ptrAlignment(pt).toLlvm(),
+            src_ptr_ty.ptrAlignment(zcu).toLlvm(),
             len,
             access_kind,
         );
 @@ -9501,10 +9491,10 @@ pub const FuncGen = struct {
     fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
-        const un_ty = self.typeOf(bin_op.lhs).childType(mod);
+        const un_ty = self.typeOf(bin_op.lhs).childType(zcu);
-        const layout = un_ty.unionGetLayout(pt);
+        const layout = un_ty.unionGetLayout(zcu);
         if (layout.tag_size == 0) return .none;
         const union_ptr = try self.resolveInst(bin_op.lhs);
         const new_tag = try self.resolveInst(bin_op.rhs);
 @@ -9523,12 +9513,13 @@ pub const FuncGen = struct {
     fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const un_ty = self.typeOf(ty_op.operand);
-        const layout = un_ty.unionGetLayout(pt);
+        const layout = un_ty.unionGetLayout(zcu);
         if (layout.tag_size == 0) return .none;
         const union_handle = try self.resolveInst(ty_op.operand);
-        if (isByRef(un_ty, pt)) {
+        if (isByRef(un_ty, zcu)) {
             const llvm_un_ty = try o.lowerType(un_ty);
             if (layout.payload_size == 0)
                 return self.wip.load(.normal, llvm_un_ty, union_handle, .default, "");
 @@ -9597,10 +9588,10 @@ pub const FuncGen = struct {
     fn airByteSwap(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand_ty = self.typeOf(ty_op.operand);
-        var bits = operand_ty.intInfo(mod).bits;
+        var bits = operand_ty.intInfo(zcu).bits;
         assert(bits % 8 == 0);
         const inst_ty = self.typeOfIndex(inst);
 @@ -9611,8 +9602,8 @@ pub const FuncGen = struct {
             // If not an even byte-multiple, we need zero-extend + shift-left 1 byte
             // The truncated result at the end will be the correct bswap
             const scalar_ty = try o.builder.intType(@intCast(bits + 8));
-            if (operand_ty.zigTypeTag(mod) == .Vector) {
+            if (operand_ty.zigTypeTag(zcu) == .Vector) {
-                const vec_len = operand_ty.vectorLen(mod);
+                const vec_len = operand_ty.vectorLen(zcu);
                 llvm_operand_ty = try o.builder.vectorType(.normal, vec_len, scalar_ty);
             } else llvm_operand_ty = scalar_ty;
 @@ -9631,13 +9622,13 @@ pub const FuncGen = struct {
     fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
         const error_set_ty = ty_op.ty.toType();
-        const names = error_set_ty.errorSetNames(mod);
+        const names = error_set_ty.errorSetNames(zcu);
         const valid_block = try self.wip.block(@intCast(names.len), "Valid");
         const invalid_block = try self.wip.block(1, "Invalid");
         const end_block = try self.wip.block(2, "End");
 @@ -9790,14 +9781,14 @@ pub const FuncGen = struct {
     fn airShuffle(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
         const a = try self.resolveInst(extra.a);
         const b = try self.resolveInst(extra.b);
         const mask = Value.fromInterned(extra.mask);
         const mask_len = extra.mask_len;
-        const a_len = self.typeOf(extra.a).vectorLen(mod);
+        const a_len = self.typeOf(extra.a).vectorLen(zcu);
         // LLVM uses integers larger than the length of the first array to
         // index into the second array. This was deemed unnecessarily fragile
 @@ -9809,10 +9800,10 @@ pub const FuncGen = struct {
         for (values, 0..) |*val, i| {
             const elem = try mask.elemValue(pt, i);
-            if (elem.isUndef(mod)) {
+            if (elem.isUndef(zcu)) {
                 val.* = try o.builder.undefConst(.i32);
             } else {
-                const int = elem.toSignedInt(pt);
+                const int = elem.toSignedInt(zcu);
                 const unsigned: u32 = @intCast(if (int >= 0) int else ~int + a_len);
                 val.* = try o.builder.intConst(.i32, unsigned);
             }
 @@ -9899,8 +9890,8 @@ pub const FuncGen = struct {
     fn airReduce(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) !Builder.Value {
         const o = self.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
         const operand = try self.resolveInst(reduce.operand);
 @@ -9916,13 +9907,13 @@ pub const FuncGen = struct {
                 .Xor => .@"vector.reduce.xor",
                 else => unreachable,
             }, &.{llvm_operand_ty}, &.{operand}, ""),
-            .Min, .Max => switch (scalar_ty.zigTypeTag(mod)) {
+            .Min, .Max => switch (scalar_ty.zigTypeTag(zcu)) {
                 .Int => return self.wip.callIntrinsic(.normal, .none, switch (reduce.operation) {
-                    .Min => if (scalar_ty.isSignedInt(mod))
+                    .Min => if (scalar_ty.isSignedInt(zcu))
                         .@"vector.reduce.smin"
                     else
                         .@"vector.reduce.umin",
-                    .Max => if (scalar_ty.isSignedInt(mod))
+                    .Max => if (scalar_ty.isSignedInt(zcu))
                         .@"vector.reduce.smax"
                     else
                         .@"vector.reduce.umax",
 @@ -9936,7 +9927,7 @@ pub const FuncGen = struct {
                     }, &.{llvm_operand_ty}, &.{operand}, ""),
                 else => unreachable,
             },
-            .Add, .Mul => switch (scalar_ty.zigTypeTag(mod)) {
+            .Add, .Mul => switch (scalar_ty.zigTypeTag(zcu)) {
                 .Int => return self.wip.callIntrinsic(.normal, .none, switch (reduce.operation) {
                     .Add => .@"vector.reduce.add",
                     .Mul => .@"vector.reduce.mul",
 @@ -10004,21 +9995,21 @@ pub const FuncGen = struct {
             ))),
             else => unreachable,
         };
-        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(mod), init_val);
+        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(zcu), init_val);
     }
     fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const result_ty = self.typeOfIndex(inst);
-        const len: usize = @intCast(result_ty.arrayLen(mod));
+        const len: usize = @intCast(result_ty.arrayLen(zcu));
         const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
         const llvm_result_ty = try o.lowerType(result_ty);
-        switch (result_ty.zigTypeTag(mod)) {
+        switch (result_ty.zigTypeTag(zcu)) {
             .Vector => {
                 var vector = try o.builder.poisonValue(llvm_result_ty);
                 for (elements, 0..) |elem, i| {
 @@ -10029,21 +10020,21 @@ pub const FuncGen = struct {
                 return vector;
             },
             .Struct => {
-                if (mod.typeToPackedStruct(result_ty)) |struct_type| {
+                if (zcu.typeToPackedStruct(result_ty)) |struct_type| {
                     const backing_int_ty = struct_type.backingIntTypeUnordered(ip);
                     assert(backing_int_ty != .none);
-                    const big_bits = Type.fromInterned(backing_int_ty).bitSize(pt);
+                    const big_bits = Type.fromInterned(backing_int_ty).bitSize(zcu);
                     const int_ty = try o.builder.intType(@intCast(big_bits));
                     comptime assert(Type.packed_struct_layout_version == 2);
                     var running_int = try o.builder.intValue(int_ty, 0);
                     var running_bits: u16 = 0;
                     for (elements, struct_type.field_types.get(ip)) |elem, field_ty| {
-                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(pt)) continue;
+                        if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
                         const non_int_val = try self.resolveInst(elem);
-                        const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(pt));
+                        const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(zcu));
                         const small_int_ty = try o.builder.intType(ty_bit_size);
-                        const small_int_val = if (Type.fromInterned(field_ty).isPtrAtRuntime(mod))
+                        const small_int_val = if (Type.fromInterned(field_ty).isPtrAtRuntime(zcu))
                             try self.wip.cast(.ptrtoint, non_int_val, small_int_ty, "")
                         else
                             try self.wip.cast(.bitcast, non_int_val, small_int_ty, "");
 @@ -10057,12 +10048,12 @@ pub const FuncGen = struct {
                     return running_int;
                 }
-                assert(result_ty.containerLayout(mod) != .@"packed");
+                assert(result_ty.containerLayout(zcu) != .@"packed");
-                if (isByRef(result_ty, pt)) {
+                if (isByRef(result_ty, zcu)) {
                     // TODO in debug builds init to undef so that the padding will be 0xaa
                     // even if we fully populate the fields.
-                    const alignment = result_ty.abiAlignment(pt).toLlvm();
+                    const alignment = result_ty.abiAlignment(zcu).toLlvm();
                     const alloca_inst = try self.buildAllocaWorkaround(result_ty, alignment);
                     for (elements, 0..) |elem, i| {
 @@ -10075,7 +10066,7 @@ pub const FuncGen = struct {
                         const field_ptr_ty = try pt.ptrType(.{
                             .child = self.typeOf(elem).toIntern(),
                             .flags = .{
-                                .alignment = result_ty.structFieldAlign(i, pt),
+                                .alignment = result_ty.fieldAlignment(i, zcu),
                             },
                         });
                         try self.store(field_ptr, field_ptr_ty, llvm_elem, .none);
 @@ -10095,14 +10086,14 @@ pub const FuncGen = struct {
                 }
             },
             .Array => {
-                assert(isByRef(result_ty, pt));
+                assert(isByRef(result_ty, zcu));
                 const llvm_usize = try o.lowerType(Type.usize);
                 const usize_zero = try o.builder.intValue(llvm_usize, 0);
-                const alignment = result_ty.abiAlignment(pt).toLlvm();
+                const alignment = result_ty.abiAlignment(zcu).toLlvm();
                 const alloca_inst = try self.buildAllocaWorkaround(result_ty, alignment);
-                const array_info = result_ty.arrayInfo(mod);
+                const array_info = result_ty.arrayInfo(zcu);
                 const elem_ptr_ty = try pt.ptrType(.{
                     .child = array_info.elem_type.toIntern(),
                 });
 @@ -10131,22 +10122,22 @@ pub const FuncGen = struct {
     fn airUnionInit(self: *FuncGen, inst: Air.Inst.Index) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
         const union_ty = self.typeOfIndex(inst);
         const union_llvm_ty = try o.lowerType(union_ty);
-        const layout = union_ty.unionGetLayout(pt);
+        const layout = union_ty.unionGetLayout(zcu);
-        const union_obj = mod.typeToUnion(union_ty).?;
+        const union_obj = zcu.typeToUnion(union_ty).?;
         if (union_obj.flagsUnordered(ip).layout == .@"packed") {
-            const big_bits = union_ty.bitSize(pt);
+            const big_bits = union_ty.bitSize(zcu);
             const int_llvm_ty = try o.builder.intType(@intCast(big_bits));
             const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
             const non_int_val = try self.resolveInst(extra.init);
-            const small_int_ty = try o.builder.intType(@intCast(field_ty.bitSize(pt)));
+            const small_int_ty = try o.builder.intType(@intCast(field_ty.bitSize(zcu)));
-            const small_int_val = if (field_ty.isPtrAtRuntime(mod))
+            const small_int_val = if (field_ty.isPtrAtRuntime(zcu))
                 try self.wip.cast(.ptrtoint, non_int_val, small_int_ty, "")
             else
                 try self.wip.cast(.bitcast, non_int_val, small_int_ty, "");
 @@ -10154,9 +10145,9 @@ pub const FuncGen = struct {
         }
         const tag_int_val = blk: {
-            const tag_ty = union_ty.unionTagTypeHypothetical(mod);
+            const tag_ty = union_ty.unionTagTypeHypothetical(zcu);
             const union_field_name = union_obj.loadTagType(ip).names.get(ip)[extra.field_index];
-            const enum_field_index = tag_ty.enumFieldIndex(union_field_name, mod).?;
+            const enum_field_index = tag_ty.enumFieldIndex(union_field_name, zcu).?;
             const tag_val = try pt.enumValueFieldIndex(tag_ty, enum_field_index);
             break :blk try tag_val.intFromEnum(tag_ty, pt);
         };
 @@ -10164,12 +10155,12 @@ pub const FuncGen = struct {
             if (layout.tag_size == 0) {
                 return .none;
             }
-            assert(!isByRef(union_ty, pt));
+            assert(!isByRef(union_ty, zcu));
             var big_int_space: Value.BigIntSpace = undefined;
-            const tag_big_int = tag_int_val.toBigInt(&big_int_space, pt);
+            const tag_big_int = tag_int_val.toBigInt(&big_int_space, zcu);
             return try o.builder.bigIntValue(union_llvm_ty, tag_big_int);
         }
-        assert(isByRef(union_ty, pt));
+        assert(isByRef(union_ty, zcu));
         // The llvm type of the alloca will be the named LLVM union type, and will not
         // necessarily match the format that we need, depending on which tag is active.
         // We must construct the correct unnamed struct type here, in order to then set
 @@ -10179,14 +10170,14 @@ pub const FuncGen = struct {
         const llvm_payload = try self.resolveInst(extra.init);
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
         const field_llvm_ty = try o.lowerType(field_ty);
-        const field_size = field_ty.abiSize(pt);
+        const field_size = field_ty.abiSize(zcu);
-        const field_align = pt.unionFieldNormalAlignment(union_obj, extra.field_index);
+        const field_align = union_ty.fieldAlignment(extra.field_index, zcu);
         const llvm_usize = try o.lowerType(Type.usize);
         const usize_zero = try o.builder.intValue(llvm_usize, 0);
         const llvm_union_ty = t: {
             const payload_ty = p: {
-                if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const padding_len = layout.payload_size;
                     break :p try o.builder.arrayType(padding_len, .i8);
                 }
 @@ -10242,9 +10233,9 @@ pub const FuncGen = struct {
             const field_ptr = try self.wip.gep(.inbounds, llvm_union_ty, result_ptr, &indices, "");
             const tag_ty = try o.lowerType(Type.fromInterned(union_obj.enum_tag_ty));
             var big_int_space: Value.BigIntSpace = undefined;
-            const tag_big_int = tag_int_val.toBigInt(&big_int_space, pt);
+            const tag_big_int = tag_int_val.toBigInt(&big_int_space, zcu);
             const llvm_tag = try o.builder.bigIntValue(tag_ty, tag_big_int);
-            const tag_alignment = Type.fromInterned(union_obj.enum_tag_ty).abiAlignment(pt).toLlvm();
+            const tag_alignment = Type.fromInterned(union_obj.enum_tag_ty).abiAlignment(zcu).toLlvm();
             _ = try self.wip.store(.normal, llvm_tag, field_ptr, tag_alignment);
         }
 @@ -10270,8 +10261,8 @@ pub const FuncGen = struct {
         // by the target.
         // To work around this, don't emit llvm.prefetch in this case.
         // See https://bugs.llvm.org/show_bug.cgi?id=21037
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         switch (prefetch.cache) {
             .instruction => switch (target.cpu.arch) {
                 .x86_64,
 @@ -10397,7 +10388,7 @@ pub const FuncGen = struct {
         variable_index.setMutability(.constant, &o.builder);
         variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
         variable_index.setAlignment(
-            Type.slice_const_u8_sentinel_0.abiAlignment(pt).toLlvm(),
+            Type.slice_const_u8_sentinel_0.abiAlignment(pt.zcu).toLlvm(),
             &o.builder,
         );
 @@ -10436,15 +10427,15 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const payload_ty = opt_ty.optionalChild(mod);
+        const payload_ty = opt_ty.optionalChild(zcu);
-        if (isByRef(opt_ty, pt)) {
+        if (isByRef(opt_ty, zcu)) {
             // We have a pointer and we need to return a pointer to the first field.
             const payload_ptr = try fg.wip.gepStruct(opt_llvm_ty, opt_handle, 0, "");
-            const payload_alignment = payload_ty.abiAlignment(pt).toLlvm();
+            const payload_alignment = payload_ty.abiAlignment(zcu).toLlvm();
-            if (isByRef(payload_ty, pt)) {
+            if (isByRef(payload_ty, zcu)) {
                 if (can_elide_load)
                     return payload_ptr;
 @@ -10453,7 +10444,7 @@ pub const FuncGen = struct {
             return fg.loadTruncate(.normal, payload_ty, payload_ptr, payload_alignment);
         }
-        assert(!isByRef(payload_ty, pt));
+        assert(!isByRef(payload_ty, zcu));
         return fg.wip.extractValue(opt_handle, &.{0}, "");
     }
 @@ -10465,11 +10456,12 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
+        const zcu = pt.zcu;
         const optional_llvm_ty = try o.lowerType(optional_ty);
         const non_null_field = try self.wip.cast(.zext, non_null_bit, .i8, "");
-        if (isByRef(optional_ty, pt)) {
+        if (isByRef(optional_ty, zcu)) {
-            const payload_alignment = optional_ty.abiAlignment(pt).toLlvm();
+            const payload_alignment = optional_ty.abiAlignment(pt.zcu).toLlvm();
             const alloca_inst = try self.buildAllocaWorkaround(optional_ty, payload_alignment);
             {
 @@ -10497,15 +10489,15 @@ pub const FuncGen = struct {
     ) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const struct_ty = struct_ptr_ty.childType(mod);
+        const struct_ty = struct_ptr_ty.childType(zcu);
-        switch (struct_ty.zigTypeTag(mod)) {
+        switch (struct_ty.zigTypeTag(zcu)) {
-            .Struct => switch (struct_ty.containerLayout(mod)) {
+            .Struct => switch (struct_ty.containerLayout(zcu)) {
                 .@"packed" => {
                     const result_ty = self.typeOfIndex(inst);
-                    const result_ty_info = result_ty.ptrInfo(mod);
+                    const result_ty_info = result_ty.ptrInfo(zcu);
-                    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(mod);
+                    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(zcu);
-                    const struct_type = mod.typeToStruct(struct_ty).?;
+                    const struct_type = zcu.typeToStruct(struct_ty).?;
                     if (result_ty_info.packed_offset.host_size != 0) {
                         // From LLVM's perspective, a pointer to a packed struct and a pointer
 @@ -10535,15 +10527,15 @@ pub const FuncGen = struct {
                         // the struct.
                         const llvm_index = try o.builder.intValue(
                             try o.lowerType(Type.usize),
-                            @intFromBool(struct_ty.hasRuntimeBitsIgnoreComptime(pt)),
+                            @intFromBool(struct_ty.hasRuntimeBitsIgnoreComptime(zcu)),
                         );
                         return self.wip.gep(.inbounds, struct_llvm_ty, struct_ptr, &.{llvm_index}, "");
                     }
                 },
             },
             .Union => {
-                const layout = struct_ty.unionGetLayout(pt);
+                const layout = struct_ty.unionGetLayout(zcu);
-                if (layout.payload_size == 0 or struct_ty.containerLayout(mod) == .@"packed") return struct_ptr;
+                if (layout.payload_size == 0 or struct_ty.containerLayout(zcu) == .@"packed") return struct_ptr;
                 const payload_index = @intFromBool(layout.tag_align.compare(.gte, layout.payload_align));
                 const union_llvm_ty = try o.lowerType(struct_ty);
                 return self.wip.gepStruct(union_llvm_ty, struct_ptr, payload_index, "");
 @@ -10566,9 +10558,9 @@ pub const FuncGen = struct {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const payload_llvm_ty = try o.lowerType(payload_ty);
-        const abi_size = payload_ty.abiSize(pt);
+        const abi_size = payload_ty.abiSize(zcu);
         // llvm bug workarounds:
         const workaround_explicit_mask = o.target.cpu.arch == .powerpc and abi_size >= 4;
 @@ -10580,7 +10572,7 @@ pub const FuncGen = struct {
             return try fg.wip.load(access_kind, payload_llvm_ty, payload_ptr, payload_alignment, "");
         }
-        const load_llvm_ty = if (payload_ty.isAbiInt(mod))
+        const load_llvm_ty = if (payload_ty.isAbiInt(zcu))
             try o.builder.intType(@intCast(abi_size * 8))
         else
             payload_llvm_ty;
 @@ -10588,7 +10580,7 @@ pub const FuncGen = struct {
         const shifted = if (payload_llvm_ty != load_llvm_ty and o.target.cpu.arch.endian() == .big)
             try fg.wip.bin(.lshr, loaded, try o.builder.intValue(
                 load_llvm_ty,
-                (payload_ty.abiSize(pt) - (std.math.divCeil(u64, payload_ty.bitSize(pt), 8) catch unreachable)) * 8,
+                (payload_ty.abiSize(zcu) - (std.math.divCeil(u64, payload_ty.bitSize(zcu), 8) catch unreachable)) * 8,
             ), "")
         else
             loaded;
 @@ -10614,9 +10606,10 @@ pub const FuncGen = struct {
         const o = fg.ng.object;
         const pt = o.pt;
         //const pointee_llvm_ty = try o.lowerType(pointee_type);
-        const result_align = InternPool.Alignment.fromLlvm(ptr_alignment).max(pointee_type.abiAlignment(pt)).toLlvm();
+        const result_align = InternPool.Alignment.fromLlvm(ptr_alignment)
+            .max(pointee_type.abiAlignment(pt.zcu)).toLlvm();
         const result_ptr = try fg.buildAllocaWorkaround(pointee_type, result_align);
-        const size_bytes = pointee_type.abiSize(pt);
+        const size_bytes = pointee_type.abiSize(pt.zcu);
         _ = try fg.wip.callMemCpy(
             result_ptr,
             result_align,
 @@ -10634,15 +10627,15 @@ pub const FuncGen = struct {
     fn load(self: *FuncGen, ptr: Builder.Value, ptr_ty: Type) !Builder.Value {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const info = ptr_ty.ptrInfo(mod);
+        const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) return .none;
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none;
         const ptr_alignment = (if (info.flags.alignment != .none)
             @as(InternPool.Alignment, info.flags.alignment)
         else
-            elem_ty.abiAlignment(pt)).toLlvm();
+            elem_ty.abiAlignment(zcu)).toLlvm();
         const access_kind: Builder.MemoryAccessKind =
             if (info.flags.is_volatile) .@"volatile" else .normal;
 @@ -10658,7 +10651,7 @@ pub const FuncGen = struct {
         }
         if (info.packed_offset.host_size == 0) {
-            if (isByRef(elem_ty, pt)) {
+            if (isByRef(elem_ty, zcu)) {
                 return self.loadByRef(ptr, elem_ty, ptr_alignment, access_kind);
             }
             return self.loadTruncate(access_kind, elem_ty, ptr, ptr_alignment);
 @@ -10668,13 +10661,13 @@ pub const FuncGen = struct {
         const containing_int =
             try self.wip.load(access_kind, containing_int_ty, ptr, ptr_alignment, "");
-        const elem_bits = ptr_ty.childType(mod).bitSize(pt);
+        const elem_bits = ptr_ty.childType(zcu).bitSize(zcu);
         const shift_amt = try o.builder.intValue(containing_int_ty, info.packed_offset.bit_offset);
         const shifted_value = try self.wip.bin(.lshr, containing_int, shift_amt, "");
         const elem_llvm_ty = try o.lowerType(elem_ty);
-        if (isByRef(elem_ty, pt)) {
+        if (isByRef(elem_ty, zcu)) {
-            const result_align = elem_ty.abiAlignment(pt).toLlvm();
+            const result_align = elem_ty.abiAlignment(zcu).toLlvm();
             const result_ptr = try self.buildAllocaWorkaround(elem_ty, result_align);
             const same_size_int = try o.builder.intType(@intCast(elem_bits));
 @@ -10683,13 +10676,13 @@ pub const FuncGen = struct {
             return result_ptr;
         }
-        if (elem_ty.zigTypeTag(mod) == .Float or elem_ty.zigTypeTag(mod) == .Vector) {
+        if (elem_ty.zigTypeTag(zcu) == .Float or elem_ty.zigTypeTag(zcu) == .Vector) {
             const same_size_int = try o.builder.intType(@intCast(elem_bits));
             const truncated_int = try self.wip.cast(.trunc, shifted_value, same_size_int, "");
             return self.wip.cast(.bitcast, truncated_int, elem_llvm_ty, "");
         }
-        if (elem_ty.isPtrAtRuntime(mod)) {
+        if (elem_ty.isPtrAtRuntime(zcu)) {
             const same_size_int = try o.builder.intType(@intCast(elem_bits));
             const truncated_int = try self.wip.cast(.trunc, shifted_value, same_size_int, "");
             return self.wip.cast(.inttoptr, truncated_int, elem_llvm_ty, "");
 @@ -10707,13 +10700,13 @@ pub const FuncGen = struct {
     ) !void {
         const o = self.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const info = ptr_ty.ptrInfo(mod);
+        const info = ptr_ty.ptrInfo(zcu);
         const elem_ty = Type.fromInterned(info.child);
-        if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+        if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
             return;
         }
-        const ptr_alignment = ptr_ty.ptrAlignment(pt).toLlvm();
+        const ptr_alignment = ptr_ty.ptrAlignment(zcu).toLlvm();
         const access_kind: Builder.MemoryAccessKind =
             if (info.flags.is_volatile) .@"volatile" else .normal;
 @@ -10737,12 +10730,12 @@ pub const FuncGen = struct {
             assert(ordering == .none);
             const containing_int =
                 try self.wip.load(access_kind, containing_int_ty, ptr, ptr_alignment, "");
-            const elem_bits = ptr_ty.childType(mod).bitSize(pt);
+            const elem_bits = ptr_ty.childType(zcu).bitSize(zcu);
             const shift_amt = try o.builder.intConst(containing_int_ty, info.packed_offset.bit_offset);
             // Convert to equally-sized integer type in order to perform the bit
             // operations on the value to store
             const value_bits_type = try o.builder.intType(@intCast(elem_bits));
-            const value_bits = if (elem_ty.isPtrAtRuntime(mod))
+            const value_bits = if (elem_ty.isPtrAtRuntime(zcu))
                 try self.wip.cast(.ptrtoint, elem, value_bits_type, "")
             else
                 try self.wip.cast(.bitcast, elem, value_bits_type, "");
 @@ -10772,7 +10765,7 @@ pub const FuncGen = struct {
             _ = try self.wip.store(access_kind, ored_value, ptr, ptr_alignment);
             return;
         }
-        if (!isByRef(elem_ty, pt)) {
+        if (!isByRef(elem_ty, zcu)) {
             _ = try self.wip.storeAtomic(
                 access_kind,
                 elem,
 @@ -10788,8 +10781,8 @@ pub const FuncGen = struct {
             ptr,
             ptr_alignment,
             elem,
-            elem_ty.abiAlignment(pt).toLlvm(),
+            elem_ty.abiAlignment(zcu).toLlvm(),
-            try o.builder.intValue(try o.lowerType(Type.usize), elem_ty.abiSize(pt)),
+            try o.builder.intValue(try o.lowerType(Type.usize), elem_ty.abiSize(zcu)),
             access_kind,
         );
     }
 @@ -10816,12 +10809,12 @@ pub const FuncGen = struct {
     ) Allocator.Error!Builder.Value {
         const o = fg.ng.object;
         const pt = o.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const target = mod.getTarget();
+        const target = zcu.getTarget();
         if (!target_util.hasValgrindSupport(target)) return default_value;
         const llvm_usize = try o.lowerType(Type.usize);
-        const usize_alignment = Type.usize.abiAlignment(pt).toLlvm();
+        const usize_alignment = Type.usize.abiAlignment(zcu).toLlvm();
         const array_llvm_ty = try o.builder.arrayType(6, llvm_usize);
         const array_ptr = if (fg.valgrind_client_request_array == .none) a: {
 @@ -10882,14 +10875,14 @@ pub const FuncGen = struct {
     fn typeOf(fg: *FuncGen, inst: Air.Inst.Ref) Type {
         const o = fg.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        return fg.air.typeOf(inst, &mod.intern_pool);
+        return fg.air.typeOf(inst, &zcu.intern_pool);
     }
     fn typeOfIndex(fg: *FuncGen, inst: Air.Inst.Index) Type {
         const o = fg.ng.object;
-        const mod = o.pt.zcu;
+        const zcu = o.pt.zcu;
-        return fg.air.typeOfIndex(inst, &mod.intern_pool);
+        return fg.air.typeOfIndex(inst, &zcu.intern_pool);
     }
 };
 @@ -11059,12 +11052,12 @@ fn toLlvmGlobalAddressSpace(wanted_address_space: std.builtin.AddressSpace, targ
     };
 }
-fn returnTypeByRef(pt: Zcu.PerThread, target: std.Target, ty: Type) bool {
+fn returnTypeByRef(zcu: *Zcu, target: std.Target, ty: Type) bool {
-    if (isByRef(ty, pt)) {
+    if (isByRef(ty, zcu)) {
         return true;
     } else if (target.cpu.arch.isX86() and
         !std.Target.x86.featureSetHas(target.cpu.features, .evex512) and
-        ty.totalVectorBits(pt) >= 512)
+        ty.totalVectorBits(zcu) >= 512)
     {
         // As of LLVM 18, passing a vector byval with fastcc that is 512 bits or more returns
         // "512-bit vector arguments require 'evex512' for AVX512"
 @@ -11074,38 +11067,38 @@ fn returnTypeByRef(pt: Zcu.PerThread, target: std.Target, ty: Type) bool {
     }
 }
-fn firstParamSRet(fn_info: InternPool.Key.FuncType, pt: Zcu.PerThread, target: std.Target) bool {
+fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: std.Target) bool {
     const return_type = Type.fromInterned(fn_info.return_type);
-    if (!return_type.hasRuntimeBitsIgnoreComptime(pt)) return false;
+    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false;
     return switch (fn_info.cc) {
-        .Unspecified, .Inline => returnTypeByRef(pt, target, return_type),
+        .Unspecified, .Inline => returnTypeByRef(zcu, target, return_type),
         .C => switch (target.cpu.arch) {
             .mips, .mipsel => false,
-            .x86 => isByRef(return_type, pt),
+            .x86 => isByRef(return_type, zcu),
             .x86_64 => switch (target.os.tag) {
-                .windows => x86_64_abi.classifyWindows(return_type, pt) == .memory,
+                .windows => x86_64_abi.classifyWindows(return_type, zcu) == .memory,
-                else => firstParamSRetSystemV(return_type, pt, target),
+                else => firstParamSRetSystemV(return_type, zcu, target),
             },
-            .wasm32 => wasm_c_abi.classifyType(return_type, pt)[0] == .indirect,
+            .wasm32 => wasm_c_abi.classifyType(return_type, zcu)[0] == .indirect,
-            .aarch64, .aarch64_be => aarch64_c_abi.classifyType(return_type, pt) == .memory,
+            .aarch64, .aarch64_be => aarch64_c_abi.classifyType(return_type, zcu) == .memory,
-            .arm, .armeb => switch (arm_c_abi.classifyType(return_type, pt, .ret)) {
+            .arm, .armeb => switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
                 .memory, .i64_array => true,
                 .i32_array => |size| size != 1,
                 .byval => false,
             },
-            .riscv32, .riscv64 => riscv_c_abi.classifyType(return_type, pt) == .memory,
+            .riscv32, .riscv64 => riscv_c_abi.classifyType(return_type, zcu) == .memory,
             else => false, // TODO investigate C ABI for other architectures
         },
-        .SysV => firstParamSRetSystemV(return_type, pt, target),
+        .SysV => firstParamSRetSystemV(return_type, zcu, target),
-        .Win64 => x86_64_abi.classifyWindows(return_type, pt) == .memory,
+        .Win64 => x86_64_abi.classifyWindows(return_type, zcu) == .memory,
-        .Stdcall => !isScalar(pt.zcu, return_type),
+        .Stdcall => !isScalar(zcu, return_type),
         else => false,
     };
 }
-fn firstParamSRetSystemV(ty: Type, pt: Zcu.PerThread, target: std.Target) bool {
+fn firstParamSRetSystemV(ty: Type, zcu: *Zcu, target: std.Target) bool {
-    const class = x86_64_abi.classifySystemV(ty, pt, target, .ret);
+    const class = x86_64_abi.classifySystemV(ty, zcu, target, .ret);
     if (class[0] == .memory) return true;
     if (class[0] == .x87 and class[2] != .none) return true;
     return false;
 @@ -11116,62 +11109,62 @@ fn firstParamSRetSystemV(ty: Type, pt: Zcu.PerThread, target: std.Target) bool {
 /// be effectively bitcasted to the actual return type.
 fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
     const pt = o.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
     const return_type = Type.fromInterned(fn_info.return_type);
-    if (!return_type.hasRuntimeBitsIgnoreComptime(pt)) {
+    if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
         // If the return type is an error set or an error union, then we make this
         // anyerror return type instead, so that it can be coerced into a function
         // pointer type which has anyerror as the return type.
-        return if (return_type.isError(mod)) try o.errorIntType() else .void;
+        return if (return_type.isError(zcu)) try o.errorIntType() else .void;
     }
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     switch (fn_info.cc) {
         .Unspecified,
         .Inline,
-        => return if (returnTypeByRef(pt, target, return_type)) .void else o.lowerType(return_type),
+        => return if (returnTypeByRef(zcu, target, return_type)) .void else o.lowerType(return_type),
         .C => {
             switch (target.cpu.arch) {
                 .mips, .mipsel => return o.lowerType(return_type),
-                .x86 => return if (isByRef(return_type, pt)) .void else o.lowerType(return_type),
+                .x86 => return if (isByRef(return_type, zcu)) .void else o.lowerType(return_type),
                 .x86_64 => switch (target.os.tag) {
                     .windows => return lowerWin64FnRetTy(o, fn_info),
                     else => return lowerSystemVFnRetTy(o, fn_info),
                 },
                 .wasm32 => {
-                    if (isScalar(mod, return_type)) {
+                    if (isScalar(zcu, return_type)) {
                         return o.lowerType(return_type);
                     }
-                    const classes = wasm_c_abi.classifyType(return_type, pt);
+                    const classes = wasm_c_abi.classifyType(return_type, zcu);
                     if (classes[0] == .indirect or classes[0] == .none) {
                         return .void;
                     }
                     assert(classes[0] == .direct and classes[1] == .none);
-                    const scalar_type = wasm_c_abi.scalarType(return_type, pt);
+                    const scalar_type = wasm_c_abi.scalarType(return_type, zcu);
-                    return o.builder.intType(@intCast(scalar_type.abiSize(pt) * 8));
+                    return o.builder.intType(@intCast(scalar_type.abiSize(zcu) * 8));
                 },
                 .aarch64, .aarch64_be => {
-                    switch (aarch64_c_abi.classifyType(return_type, pt)) {
+                    switch (aarch64_c_abi.classifyType(return_type, zcu)) {
                         .memory => return .void,
                         .float_array => return o.lowerType(return_type),
                         .byval => return o.lowerType(return_type),
-                        .integer => return o.builder.intType(@intCast(return_type.bitSize(pt))),
+                        .integer => return o.builder.intType(@intCast(return_type.bitSize(zcu))),
                         .double_integer => return o.builder.arrayType(2, .i64),
                     }
                 },
                 .arm, .armeb => {
-                    switch (arm_c_abi.classifyType(return_type, pt, .ret)) {
+                    switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
                         .memory, .i64_array => return .void,
                         .i32_array => |len| return if (len == 1) .i32 else .void,
                         .byval => return o.lowerType(return_type),
                     }
                 },
                 .riscv32, .riscv64 => {
-                    switch (riscv_c_abi.classifyType(return_type, pt)) {
+                    switch (riscv_c_abi.classifyType(return_type, zcu)) {
                         .memory => return .void,
                         .integer => {
-                            return o.builder.intType(@intCast(return_type.bitSize(pt)));
+                            return o.builder.intType(@intCast(return_type.bitSize(zcu)));
                         },
                         .double_integer => {
                             return o.builder.structType(.normal, &.{ .i64, .i64 });
 @@ -11180,9 +11173,9 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu
                         .fields => {
                             var types_len: usize = 0;
                             var types: [8]Builder.Type = undefined;
-                            for (0..return_type.structFieldCount(mod)) |field_index| {
+                            for (0..return_type.structFieldCount(zcu)) |field_index| {
-                                const field_ty = return_type.structFieldType(field_index, mod);
+                                const field_ty = return_type.fieldType(field_index, zcu);
-                                if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
                                 types[types_len] = try o.lowerType(field_ty);
                                 types_len += 1;
                             }
 @@ -11196,20 +11189,20 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu
         },
         .Win64 => return lowerWin64FnRetTy(o, fn_info),
         .SysV => return lowerSystemVFnRetTy(o, fn_info),
-        .Stdcall => return if (isScalar(mod, return_type)) o.lowerType(return_type) else .void,
+        .Stdcall => return if (isScalar(zcu, return_type)) o.lowerType(return_type) else .void,
         else => return o.lowerType(return_type),
     }
 }
 fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
-    const pt = o.pt;
+    const zcu = o.pt.zcu;
     const return_type = Type.fromInterned(fn_info.return_type);
-    switch (x86_64_abi.classifyWindows(return_type, pt)) {
+    switch (x86_64_abi.classifyWindows(return_type, zcu)) {
         .integer => {
-            if (isScalar(pt.zcu, return_type)) {
+            if (isScalar(zcu, return_type)) {
                 return o.lowerType(return_type);
             } else {
-                return o.builder.intType(@intCast(return_type.abiSize(pt) * 8));
+                return o.builder.intType(@intCast(return_type.abiSize(zcu) * 8));
             }
         },
         .win_i128 => return o.builder.vectorType(.normal, 2, .i64),
 @@ -11221,14 +11214,14 @@ fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Err
 fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
     const pt = o.pt;
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const return_type = Type.fromInterned(fn_info.return_type);
-    if (isScalar(mod, return_type)) {
+    if (isScalar(zcu, return_type)) {
         return o.lowerType(return_type);
     }
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
-    const classes = x86_64_abi.classifySystemV(return_type, pt, target, .ret);
+    const classes = x86_64_abi.classifySystemV(return_type, zcu, target, .ret);
     if (classes[0] == .memory) return .void;
     var types_index: u32 = 0;
     var types_buffer: [8]Builder.Type = undefined;
 @@ -11345,7 +11338,7 @@ const ParamTypeIterator = struct {
         const zcu = pt.zcu;
         const target = zcu.getTarget();
-        if (!ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             it.zig_index += 1;
             return .no_bits;
         }
 @@ -11358,11 +11351,11 @@ const ParamTypeIterator = struct {
                 {
                     it.llvm_index += 1;
                     return .slice;
-                } else if (isByRef(ty, pt)) {
+                } else if (isByRef(ty, zcu)) {
                     return .byref;
                 } else if (target.cpu.arch.isX86() and
                     !std.Target.x86.featureSetHas(target.cpu.features, .evex512) and
-                    ty.totalVectorBits(pt) >= 512)
+                    ty.totalVectorBits(zcu) >= 512)
                 {
                     // As of LLVM 18, passing a vector byval with fastcc that is 512 bits or more returns
                     // "512-bit vector arguments require 'evex512' for AVX512"
 @@ -11390,7 +11383,7 @@ const ParamTypeIterator = struct {
                     if (isScalar(zcu, ty)) {
                         return .byval;
                     }
-                    const classes = wasm_c_abi.classifyType(ty, pt);
+                    const classes = wasm_c_abi.classifyType(ty, zcu);
                     if (classes[0] == .indirect) {
                         return .byref;
                     }
 @@ -11399,7 +11392,7 @@ const ParamTypeIterator = struct {
                 .aarch64, .aarch64_be => {
                     it.zig_index += 1;
                     it.llvm_index += 1;
-                    switch (aarch64_c_abi.classifyType(ty, pt)) {
+                    switch (aarch64_c_abi.classifyType(ty, zcu)) {
                         .memory => return .byref_mut,
                         .float_array => |len| return Lowering{ .float_array = len },
                         .byval => return .byval,
 @@ -11414,7 +11407,7 @@ const ParamTypeIterator = struct {
                 .arm, .armeb => {
                     it.zig_index += 1;
                     it.llvm_index += 1;
-                    switch (arm_c_abi.classifyType(ty, pt, .arg)) {
+                    switch (arm_c_abi.classifyType(ty, zcu, .arg)) {
                         .memory => {
                             it.byval_attr = true;
                             return .byref;
 @@ -11429,7 +11422,7 @@ const ParamTypeIterator = struct {
                     it.llvm_index += 1;
                     if (ty.toIntern() == .f16_type and
                         !std.Target.riscv.featureSetHas(target.cpu.features, .d)) return .as_u16;
-                    switch (riscv_c_abi.classifyType(ty, pt)) {
+                    switch (riscv_c_abi.classifyType(ty, zcu)) {
                         .memory => return .byref_mut,
                         .byval => return .byval,
                         .integer => return .abi_sized_int,
 @@ -11437,8 +11430,8 @@ const ParamTypeIterator = struct {
                         .fields => {
                             it.types_len = 0;
                             for (0..ty.structFieldCount(zcu)) |field_index| {
-                                const field_ty = ty.structFieldType(field_index, zcu);
+                                const field_ty = ty.fieldType(field_index, zcu);
-                                if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                                if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
                                 it.types_buffer[it.types_len] = try it.object.lowerType(field_ty);
                                 it.types_len += 1;
                             }
 @@ -11476,10 +11469,10 @@ const ParamTypeIterator = struct {
     }
     fn nextWin64(it: *ParamTypeIterator, ty: Type) ?Lowering {
-        const pt = it.object.pt;
+        const zcu = it.object.pt.zcu;
-        switch (x86_64_abi.classifyWindows(ty, pt)) {
+        switch (x86_64_abi.classifyWindows(ty, zcu)) {
             .integer => {
-                if (isScalar(pt.zcu, ty)) {
+                if (isScalar(zcu, ty)) {
                     it.zig_index += 1;
                     it.llvm_index += 1;
                     return .byval;
 @@ -11509,17 +11502,17 @@ const ParamTypeIterator = struct {
     }
     fn nextSystemV(it: *ParamTypeIterator, ty: Type) Allocator.Error!?Lowering {
-        const pt = it.object.pt;
+        const zcu = it.object.pt.zcu;
-        const ip = &pt.zcu.intern_pool;
+        const ip = &zcu.intern_pool;
-        const target = pt.zcu.getTarget();
+        const target = zcu.getTarget();
-        const classes = x86_64_abi.classifySystemV(ty, pt, target, .arg);
+        const classes = x86_64_abi.classifySystemV(ty, zcu, target, .arg);
         if (classes[0] == .memory) {
             it.zig_index += 1;
             it.llvm_index += 1;
             it.byval_attr = true;
             return .byref;
         }
-        if (isScalar(pt.zcu, ty)) {
+        if (isScalar(zcu, ty)) {
             it.zig_index += 1;
             it.llvm_index += 1;
             return .byval;
 @@ -11620,17 +11613,17 @@ fn iterateParamTypes(object: *Object, fn_info: InternPool.Key.FuncType) ParamTyp
 fn ccAbiPromoteInt(
     cc: std.builtin.CallingConvention,
-    mod: *Zcu,
+    zcu: *Zcu,
     ty: Type,
 ) ?std.builtin.Signedness {
-    const target = mod.getTarget();
+    const target = zcu.getTarget();
     switch (cc) {
         .Unspecified, .Inline, .Async => return null,
         else => {},
     }
-    const int_info = switch (ty.zigTypeTag(mod)) {
+    const int_info = switch (ty.zigTypeTag(zcu)) {
-        .Bool => Type.u1.intInfo(mod),
+        .Bool => Type.u1.intInfo(zcu),
-        .Int, .Enum, .ErrorSet => ty.intInfo(mod),
+        .Int, .Enum, .ErrorSet => ty.intInfo(zcu),
         else => return null,
     };
     return switch (target.os.tag) {
 @@ -11668,13 +11661,13 @@ fn ccAbiPromoteInt(
 /// This is the one source of truth for whether a type is passed around as an LLVM pointer,
 /// or as an LLVM value.
-fn isByRef(ty: Type, pt: Zcu.PerThread) bool {
+fn isByRef(ty: Type, zcu: *Zcu) bool {
     // For tuples and structs, if there are more than this many non-void
     // fields, then we make it byref, otherwise byval.
     const max_fields_byval = 0;
-    const ip = &pt.zcu.intern_pool;
+    const ip = &zcu.intern_pool;
-    switch (ty.zigTypeTag(pt.zcu)) {
+    switch (ty.zigTypeTag(zcu)) {
         .Type,
         .ComptimeInt,
         .ComptimeFloat,
 @@ -11697,17 +11690,17 @@ fn isByRef(ty: Type, pt: Zcu.PerThread) bool {
         .AnyFrame,
         => return false,
-        .Array, .Frame => return ty.hasRuntimeBits(pt),
+        .Array, .Frame => return ty.hasRuntimeBits(zcu),
         .Struct => {
             const struct_type = switch (ip.indexToKey(ty.toIntern())) {
                 .anon_struct_type => |tuple| {
                     var count: usize = 0;
                     for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_val| {
-                        if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
+                        if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
                         count += 1;
                         if (count > max_fields_byval) return true;
-                        if (isByRef(Type.fromInterned(field_ty), pt)) return true;
+                        if (isByRef(Type.fromInterned(field_ty), zcu)) return true;
                     }
                     return false;
                 },
 @@ -11725,27 +11718,27 @@ fn isByRef(ty: Type, pt: Zcu.PerThread) bool {
                 count += 1;
                 if (count > max_fields_byval) return true;
                 const field_ty = Type.fromInterned(field_types[field_index]);
-                if (isByRef(field_ty, pt)) return true;
+                if (isByRef(field_ty, zcu)) return true;
             }
             return false;
         },
-        .Union => switch (ty.containerLayout(pt.zcu)) {
+        .Union => switch (ty.containerLayout(zcu)) {
             .@"packed" => return false,
-            else => return ty.hasRuntimeBits(pt),
+            else => return ty.hasRuntimeBits(zcu),
         },
         .ErrorUnion => {
-            const payload_ty = ty.errorUnionPayload(pt.zcu);
+            const payload_ty = ty.errorUnionPayload(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 return false;
             }
             return true;
         },
         .Optional => {
-            const payload_ty = ty.optionalChild(pt.zcu);
+            const payload_ty = ty.optionalChild(zcu);
-            if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+            if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 return false;
             }
-            if (ty.optionalReprIsPayload(pt.zcu)) {
+            if (ty.optionalReprIsPayload(zcu)) {
                 return false;
             }
             return true;
 @@ -11753,8 +11746,8 @@ fn isByRef(ty: Type, pt: Zcu.PerThread) bool {
     }
 }
-fn isScalar(mod: *Zcu, ty: Type) bool {
+fn isScalar(zcu: *Zcu, ty: Type) bool {
-    return switch (ty.zigTypeTag(mod)) {
+    return switch (ty.zigTypeTag(zcu)) {
         .Void,
         .Bool,
         .NoReturn,
 @@ -11768,8 +11761,8 @@ fn isScalar(mod: *Zcu, ty: Type) bool {
         .Vector,
         => true,
-        .Struct => ty.containerLayout(mod) == .@"packed",
+        .Struct => ty.containerLayout(zcu) == .@"packed",
-        .Union => ty.containerLayout(mod) == .@"packed",
+        .Union => ty.containerLayout(zcu) == .@"packed",
         else => false,
     };
 }
 @@ -11892,13 +11885,15 @@ fn buildAllocaInner(
 }
 fn errUnionPayloadOffset(payload_ty: Type, pt: Zcu.PerThread) !u1 {
+    const zcu = pt.zcu;
     const err_int_ty = try pt.errorIntType();
-    return @intFromBool(err_int_ty.abiAlignment(pt).compare(.gt, payload_ty.abiAlignment(pt)));
+    return @intFromBool(err_int_ty.abiAlignment(zcu).compare(.gt, payload_ty.abiAlignment(zcu)));
 }
 fn errUnionErrorOffset(payload_ty: Type, pt: Zcu.PerThread) !u1 {
+    const zcu = pt.zcu;
     const err_int_ty = try pt.errorIntType();
-    return @intFromBool(err_int_ty.abiAlignment(pt).compare(.lte, payload_ty.abiAlignment(pt)));
+    return @intFromBool(err_int_ty.abiAlignment(zcu).compare(.lte, payload_ty.abiAlignment(zcu)));
 }
 /// Returns true for asm constraint (e.g. "=*m", "=r") if it accepts a memory location

src/codegen/spirv.zig+334-333

 @@ -436,16 +436,16 @@ const NavGen = struct {
     /// Fetch the result-id for a previously generated instruction or constant.
     fn resolve(self: *NavGen, inst: Air.Inst.Ref) !IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         if (try self.air.value(inst, pt)) |val| {
             const ty = self.typeOf(inst);
-            if (ty.zigTypeTag(mod) == .Fn) {
+            if (ty.zigTypeTag(zcu) == .Fn) {
-                const fn_nav = switch (mod.intern_pool.indexToKey(val.ip_index)) {
+                const fn_nav = switch (zcu.intern_pool.indexToKey(val.ip_index)) {
                     .@"extern" => |@"extern"| @"extern".owner_nav,
                     .func => |func| func.owner_nav,
                     else => unreachable,
                 };
-                const spv_decl_index = try self.object.resolveNav(mod, fn_nav);
+                const spv_decl_index = try self.object.resolveNav(zcu, fn_nav);
                 try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
                 return self.spv.declPtr(spv_decl_index).result_id;
             }
 @@ -459,8 +459,8 @@ const NavGen = struct {
     fn resolveUav(self: *NavGen, val: InternPool.Index) !IdRef {
         // TODO: This cannot be a function at this point, but it should probably be handled anyway.
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const ty = Type.fromInterned(mod.intern_pool.typeOf(val));
+        const ty = Type.fromInterned(zcu.intern_pool.typeOf(val));
         const decl_ptr_ty_id = try self.ptrType(ty, .Generic);
         const spv_decl_index = blk: {
 @@ -639,15 +639,15 @@ const NavGen = struct {
     /// Checks whether the type can be directly translated to SPIR-V vectors
     fn isSpvVector(self: *NavGen, ty: Type) bool {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const target = self.getTarget();
-        if (ty.zigTypeTag(mod) != .Vector) return false;
+        if (ty.zigTypeTag(zcu) != .Vector) return false;
         // TODO: This check must be expanded for types that can be represented
         // as integers (enums / packed structs?) and types that are represented
         // by multiple SPIR-V values.
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
-        switch (scalar_ty.zigTypeTag(mod)) {
+        switch (scalar_ty.zigTypeTag(zcu)) {
             .Bool,
             .Int,
             .Float,
 @@ -655,24 +655,24 @@ const NavGen = struct {
             else => return false,
         }
-        const elem_ty = ty.childType(mod);
+        const elem_ty = ty.childType(zcu);
-        const len = ty.vectorLen(mod);
+        const len = ty.vectorLen(zcu);
-        const is_scalar = elem_ty.isNumeric(mod) or elem_ty.toIntern() == .bool_type;
+        const is_scalar = elem_ty.isNumeric(zcu) or elem_ty.toIntern() == .bool_type;
         const spirv_len = len > 1 and len <= 4;
         const opencl_len = if (target.os.tag == .opencl) (len == 8 or len == 16) else false;
         return is_scalar and (spirv_len or opencl_len);
     }
     fn arithmeticTypeInfo(self: *NavGen, ty: Type) ArithmeticTypeInfo {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const target = self.getTarget();
-        var scalar_ty = ty.scalarType(mod);
+        var scalar_ty = ty.scalarType(zcu);
-        if (scalar_ty.zigTypeTag(mod) == .Enum) {
+        if (scalar_ty.zigTypeTag(zcu) == .Enum) {
-            scalar_ty = scalar_ty.intTagType(mod);
+            scalar_ty = scalar_ty.intTagType(zcu);
         }
-        const vector_len = if (ty.isVector(mod)) ty.vectorLen(mod) else null;
+        const vector_len = if (ty.isVector(zcu)) ty.vectorLen(zcu) else null;
-        return switch (scalar_ty.zigTypeTag(mod)) {
+        return switch (scalar_ty.zigTypeTag(zcu)) {
             .Bool => ArithmeticTypeInfo{
                 .bits = 1, // Doesn't matter for this class.
                 .backing_bits = self.backingIntBits(1).?,
 @@ -688,7 +688,7 @@ const NavGen = struct {
                 .class = .float,
             },
             .Int => blk: {
-                const int_info = scalar_ty.intInfo(mod);
+                const int_info = scalar_ty.intInfo(zcu);
                 // TODO: Maybe it's useful to also return this value.
                 const maybe_backing_bits = self.backingIntBits(int_info.bits);
                 break :blk ArithmeticTypeInfo{
 @@ -741,9 +741,9 @@ const NavGen = struct {
     /// the value to an unsigned int first for Kernels.
     fn constInt(self: *NavGen, ty: Type, value: anytype, repr: Repr) !IdRef {
         // TODO: Cache?
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const scalar_ty = ty.scalarType(mod);
+        const scalar_ty = ty.scalarType(zcu);
-        const int_info = scalar_ty.intInfo(mod);
+        const int_info = scalar_ty.intInfo(zcu);
         // Use backing bits so that negatives are sign extended
         const backing_bits = self.backingIntBits(int_info.bits).?; // Assertion failure means big int
 @@ -783,11 +783,11 @@ const NavGen = struct {
             else => unreachable, // TODO: Large integer constants
         }
-        if (!ty.isVector(mod)) {
+        if (!ty.isVector(zcu)) {
             return result_id;
         }
-        const n = ty.vectorLen(mod);
+        const n = ty.vectorLen(zcu);
         const ids = try self.gpa.alloc(IdRef, n);
         defer self.gpa.free(ids);
         @memset(ids, result_id);
 @@ -821,8 +821,8 @@ const NavGen = struct {
     /// Construct a vector at runtime.
     /// ty must be an vector type.
     fn constructVector(self: *NavGen, ty: Type, constituents: []const IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        assert(ty.vectorLen(mod) == constituents.len);
+        assert(ty.vectorLen(zcu) == constituents.len);
         // Note: older versions of the Khronos SPRIV-LLVM translator crash on this instruction
         // because it cannot construct structs which' operands are not constant.
 @@ -845,8 +845,8 @@ const NavGen = struct {
     /// Construct a vector at runtime with all lanes set to the same value.
     /// ty must be an vector type.
     fn constructVectorSplat(self: *NavGen, ty: Type, constituent: IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const n = ty.vectorLen(mod);
+        const n = ty.vectorLen(zcu);
         const constituents = try self.gpa.alloc(IdRef, n);
         defer self.gpa.free(constituents);
 @@ -884,13 +884,13 @@ const NavGen = struct {
         }
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const target = self.getTarget();
         const result_ty_id = try self.resolveType(ty, repr);
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         log.debug("lowering constant: ty = {}, val = {}", .{ ty.fmt(pt), val.fmtValue(pt) });
-        if (val.isUndefDeep(mod)) {
+        if (val.isUndefDeep(zcu)) {
             return self.spv.constUndef(result_ty_id);
         }
 @@ -937,17 +937,17 @@ const NavGen = struct {
                     .false, .true => break :cache try self.constBool(val.toBool(), repr),
                 },
                 .int => {
-                    if (ty.isSignedInt(mod)) {
+                    if (ty.isSignedInt(zcu)) {
-                        break :cache try self.constInt(ty, val.toSignedInt(pt), repr);
+                        break :cache try self.constInt(ty, val.toSignedInt(zcu), repr);
                     } else {
-                        break :cache try self.constInt(ty, val.toUnsignedInt(pt), repr);
+                        break :cache try self.constInt(ty, val.toUnsignedInt(zcu), repr);
                     }
                 },
                 .float => {
                     const lit: spec.LiteralContextDependentNumber = switch (ty.floatBits(target)) {
-                        16 => .{ .uint32 = @as(u16, @bitCast(val.toFloat(f16, pt))) },
+                        16 => .{ .uint32 = @as(u16, @bitCast(val.toFloat(f16, zcu))) },
-                        32 => .{ .float32 = val.toFloat(f32, pt) },
+                        32 => .{ .float32 = val.toFloat(f32, zcu) },
-                        64 => .{ .float64 = val.toFloat(f64, pt) },
+                        64 => .{ .float64 = val.toFloat(f64, zcu) },
                         80, 128 => unreachable, // TODO
                         else => unreachable,
                     };
 @@ -968,17 +968,17 @@ const NavGen = struct {
                     // allows it. For now, just generate it here regardless.
                     const err_int_ty = try pt.errorIntType();
                     const err_ty = switch (error_union.val) {
-                        .err_name => ty.errorUnionSet(mod),
+                        .err_name => ty.errorUnionSet(zcu),
                         .payload => err_int_ty,
                     };
                     const err_val = switch (error_union.val) {
                         .err_name => |err_name| Value.fromInterned(try pt.intern(.{ .err = .{
-                            .ty = ty.errorUnionSet(mod).toIntern(),
+                            .ty = ty.errorUnionSet(zcu).toIntern(),
                             .name = err_name,
                         } })),
                         .payload => try pt.intValue(err_int_ty, 0),
                     };
-                    const payload_ty = ty.errorUnionPayload(mod);
+                    const payload_ty = ty.errorUnionPayload(zcu);
                     const eu_layout = self.errorUnionLayout(payload_ty);
                     if (!eu_layout.payload_has_bits) {
                         // We use the error type directly as the type.
 @@ -1006,12 +1006,12 @@ const NavGen = struct {
                 },
                 .enum_tag => {
                     const int_val = try val.intFromEnum(ty, pt);
-                    const int_ty = ty.intTagType(mod);
+                    const int_ty = ty.intTagType(zcu);
                     break :cache try self.constant(int_ty, int_val, repr);
                 },
                 .ptr => return self.constantPtr(val),
                 .slice => |slice| {
-                    const ptr_ty = ty.slicePtrFieldType(mod);
+                    const ptr_ty = ty.slicePtrFieldType(zcu);
                     const ptr_id = try self.constantPtr(Value.fromInterned(slice.ptr));
                     const len_id = try self.constant(Type.usize, Value.fromInterned(slice.len), .indirect);
                     return self.constructStruct(
 @@ -1021,12 +1021,12 @@ const NavGen = struct {
                     );
                 },
                 .opt => {
-                    const payload_ty = ty.optionalChild(mod);
+                    const payload_ty = ty.optionalChild(zcu);
-                    const maybe_payload_val = val.optionalValue(mod);
+                    const maybe_payload_val = val.optionalValue(zcu);
-                    if (!payload_ty.hasRuntimeBits(pt)) {
+                    if (!payload_ty.hasRuntimeBits(zcu)) {
                         break :cache try self.constBool(maybe_payload_val != null, .indirect);
-                    } else if (ty.optionalReprIsPayload(mod)) {
+                    } else if (ty.optionalReprIsPayload(zcu)) {
                         // Optional representation is a nullable pointer or slice.
                         if (maybe_payload_val) |payload_val| {
                             return try self.constant(payload_ty, payload_val, .indirect);
 @@ -1054,7 +1054,7 @@ const NavGen = struct {
                     inline .array_type, .vector_type => |array_type, tag| {
                         const elem_ty = Type.fromInterned(array_type.child);
-                        const constituents = try self.gpa.alloc(IdRef, @intCast(ty.arrayLenIncludingSentinel(mod)));
+                        const constituents = try self.gpa.alloc(IdRef, @intCast(ty.arrayLenIncludingSentinel(zcu)));
                         defer self.gpa.free(constituents);
                         const child_repr: Repr = switch (tag) {
 @@ -1088,7 +1088,7 @@ const NavGen = struct {
                         }
                     },
                     .struct_type => {
-                        const struct_type = mod.typeToStruct(ty).?;
+                        const struct_type = zcu.typeToStruct(ty).?;
                         if (struct_type.layout == .@"packed") {
                             return self.todo("packed struct constants", .{});
                         }
 @@ -1102,7 +1102,7 @@ const NavGen = struct {
                         var it = struct_type.iterateRuntimeOrder(ip);
                         while (it.next()) |field_index| {
                             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                            if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                            if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                                 // This is a zero-bit field - we only needed it for the alignment.
                                 continue;
                             }
 @@ -1121,10 +1121,10 @@ const NavGen = struct {
                     else => unreachable,
                 },
                 .un => |un| {
-                    const active_field = ty.unionTagFieldIndex(Value.fromInterned(un.tag), mod).?;
+                    const active_field = ty.unionTagFieldIndex(Value.fromInterned(un.tag), zcu).?;
-                    const union_obj = mod.typeToUnion(ty).?;
+                    const union_obj = zcu.typeToUnion(ty).?;
                     const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[active_field]);
-                    const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(pt))
+                    const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
                         try self.constant(field_ty, Value.fromInterned(un.val), .direct)
                     else
                         null;
 @@ -1232,8 +1232,8 @@ const NavGen = struct {
         // TODO: Merge this function with constantDeclRef.
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_id = try self.resolveType(ty, .direct);
         const uav_ty = Type.fromInterned(ip.typeOf(uav.val));
 @@ -1243,14 +1243,14 @@ const NavGen = struct {
             else => {},
         }
-        // const is_fn_body = decl_ty.zigTypeTag(mod) == .Fn;
+        // const is_fn_body = decl_ty.zigTypeTag(zcu) == .Fn;
-        if (!uav_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+        if (!uav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
             // Pointer to nothing - return undefined
             return self.spv.constUndef(ty_id);
         }
         // Uav refs are always generic.
-        assert(ty.ptrAddressSpace(mod) == .generic);
+        assert(ty.ptrAddressSpace(zcu) == .generic);
         const decl_ptr_ty_id = try self.ptrType(uav_ty, .Generic);
         const ptr_id = try self.resolveUav(uav.val);
 @@ -1270,12 +1270,12 @@ const NavGen = struct {
     fn constantNavRef(self: *NavGen, ty: Type, nav_index: InternPool.Nav.Index) !IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_id = try self.resolveType(ty, .direct);
         const nav = ip.getNav(nav_index);
-        const nav_val = mod.navValue(nav_index);
+        const nav_val = zcu.navValue(nav_index);
-        const nav_ty = nav_val.typeOf(mod);
+        const nav_ty = nav_val.typeOf(zcu);
         switch (ip.indexToKey(nav_val.toIntern())) {
             .func => {
 @@ -1287,12 +1287,12 @@ const NavGen = struct {
             else => {},
         }
-        if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+        if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
             // Pointer to nothing - return undefined.
             return self.spv.constUndef(ty_id);
         }
-        const spv_decl_index = try self.object.resolveNav(mod, nav_index);
+        const spv_decl_index = try self.object.resolveNav(zcu, nav_index);
         const spv_decl = self.spv.declPtr(spv_decl_index);
         const decl_id = switch (spv_decl.kind) {
 @@ -1452,9 +1452,9 @@ const NavGen = struct {
     ///  }
     /// If any of the fields' size is 0, it will be omitted.
     fn resolveUnionType(self: *NavGen, ty: Type) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const union_obj = mod.typeToUnion(ty).?;
+        const union_obj = zcu.typeToUnion(ty).?;
         if (union_obj.flagsUnordered(ip).layout == .@"packed") {
             return self.todo("packed union types", .{});
 @@ -1503,12 +1503,12 @@ const NavGen = struct {
     }
     fn resolveFnReturnType(self: *NavGen, ret_ty: Type) !IdRef {
-        const pt = self.pt;
+        const zcu = self.pt.zcu;
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             // If the return type is an error set or an error union, then we make this
             // anyerror return type instead, so that it can be coerced into a function
             // pointer type which has anyerror as the return type.
-            if (ret_ty.isError(pt.zcu)) {
+            if (ret_ty.isError(zcu)) {
                 return self.resolveType(Type.anyerror, .direct);
             } else {
                 return self.resolveType(Type.void, .direct);
 @@ -1531,14 +1531,14 @@ const NavGen = struct {
     fn resolveTypeInner(self: *NavGen, ty: Type, repr: Repr) Error!IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         log.debug("resolveType: ty = {}", .{ty.fmt(pt)});
         const target = self.getTarget();
         const section = &self.spv.sections.types_globals_constants;
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             .NoReturn => {
                 assert(repr == .direct);
                 return try self.spv.voidType();
 @@ -1562,7 +1562,7 @@ const NavGen = struct {
                 .indirect => return try self.resolveType(Type.u1, .indirect),
             },
             .Int => {
-                const int_info = ty.intInfo(mod);
+                const int_info = ty.intInfo(zcu);
                 if (int_info.bits == 0) {
                     // Some times, the backend will be asked to generate a pointer to i0. OpTypeInt
                     // with 0 bits is invalid, so return an opaque type in this case.
 @@ -1577,7 +1577,7 @@ const NavGen = struct {
                 return try self.intType(int_info.signedness, int_info.bits);
             },
             .Enum => {
-                const tag_ty = ty.intTagType(mod);
+                const tag_ty = ty.intTagType(zcu);
                 return try self.resolveType(tag_ty, repr);
             },
             .Float => {
 @@ -1599,13 +1599,13 @@ const NavGen = struct {
                 return try self.spv.floatType(bits);
             },
             .Array => {
-                const elem_ty = ty.childType(mod);
+                const elem_ty = ty.childType(zcu);
                 const elem_ty_id = try self.resolveType(elem_ty, .indirect);
-                const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel(mod)) orelse {
+                const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel(zcu)) orelse {
-                    return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(mod)});
+                    return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(zcu)});
                 };
-                if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     // The size of the array would be 0, but that is not allowed in SPIR-V.
                     // This path can be reached when the backend is asked to generate a pointer to
                     // an array of some zero-bit type. This should always be an indirect path.
 @@ -1635,7 +1635,7 @@ const NavGen = struct {
             },
             .Fn => switch (repr) {
                 .direct => {
-                    const fn_info = mod.typeToFunc(ty).?;
+                    const fn_info = zcu.typeToFunc(ty).?;
                     comptime assert(zig_call_abi_ver == 3);
                     switch (fn_info.cc) {
 @@ -1653,7 +1653,7 @@ const NavGen = struct {
                     var param_index: usize = 0;
                     for (fn_info.param_types.get(ip)) |param_ty_index| {
                         const param_ty = Type.fromInterned(param_ty_index);
-                        if (!param_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                        if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
                         param_ty_ids[param_index] = try self.resolveType(param_ty, .direct);
                         param_index += 1;
 @@ -1677,7 +1677,7 @@ const NavGen = struct {
                 },
             },
             .Pointer => {
-                const ptr_info = ty.ptrInfo(mod);
+                const ptr_info = ty.ptrInfo(zcu);
                 const storage_class = self.spvStorageClass(ptr_info.flags.address_space);
                 const ptr_ty_id = try self.ptrType(Type.fromInterned(ptr_info.child), storage_class);
 @@ -1693,9 +1693,9 @@ const NavGen = struct {
                 );
             },
             .Vector => {
-                const elem_ty = ty.childType(mod);
+                const elem_ty = ty.childType(zcu);
                 const elem_ty_id = try self.resolveType(elem_ty, repr);
-                const len = ty.vectorLen(mod);
+                const len = ty.vectorLen(zcu);
                 if (self.isSpvVector(ty)) {
                     return try self.spv.vectorType(len, elem_ty_id);
 @@ -1711,7 +1711,7 @@ const NavGen = struct {
                         var member_index: usize = 0;
                         for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_val| {
-                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(pt)) continue;
+                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
                             member_types[member_index] = try self.resolveType(Type.fromInterned(field_ty), .indirect);
                             member_index += 1;
 @@ -1740,13 +1740,13 @@ const NavGen = struct {
                 var it = struct_type.iterateRuntimeOrder(ip);
                 while (it.next()) |field_index| {
                     const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                         // This is a zero-bit field - we only needed it for the alignment.
                         continue;
                     }
                     const field_name = struct_type.fieldName(ip, field_index).unwrap() orelse
-                        try ip.getOrPutStringFmt(mod.gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
+                        try ip.getOrPutStringFmt(zcu.gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
                     try member_types.append(try self.resolveType(field_ty, .indirect));
                     try member_names.append(field_name.toSlice(ip));
                 }
 @@ -1758,8 +1758,8 @@ const NavGen = struct {
                 return result_id;
             },
             .Optional => {
-                const payload_ty = ty.optionalChild(mod);
+                const payload_ty = ty.optionalChild(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     // Just use a bool.
                     // Note: Always generate the bool with indirect format, to save on some sanity
                     // Perform the conversion to a direct bool when the field is extracted.
 @@ -1767,7 +1767,7 @@ const NavGen = struct {
                 }
                 const payload_ty_id = try self.resolveType(payload_ty, .indirect);
-                if (ty.optionalReprIsPayload(mod)) {
+                if (ty.optionalReprIsPayload(zcu)) {
                     // Optional is actually a pointer or a slice.
                     return payload_ty_id;
                 }
 @@ -1782,7 +1782,7 @@ const NavGen = struct {
             .Union => return try self.resolveUnionType(ty),
             .ErrorSet => return try self.resolveType(Type.u16, repr),
             .ErrorUnion => {
-                const payload_ty = ty.errorUnionPayload(mod);
+                const payload_ty = ty.errorUnionPayload(zcu);
                 const error_ty_id = try self.resolveType(Type.anyerror, .indirect);
                 const eu_layout = self.errorUnionLayout(payload_ty);
 @@ -1877,13 +1877,14 @@ const NavGen = struct {
     fn errorUnionLayout(self: *NavGen, payload_ty: Type) ErrorUnionLayout {
         const pt = self.pt;
+        const zcu = pt.zcu;
-        const error_align = Type.anyerror.abiAlignment(pt);
+        const error_align = Type.anyerror.abiAlignment(zcu);
-        const payload_align = payload_ty.abiAlignment(pt);
+        const payload_align = payload_ty.abiAlignment(zcu);
         const error_first = error_align.compare(.gt, payload_align);
         return .{
-            .payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(pt),
+            .payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(zcu),
             .error_first = error_first,
         };
     }
 @@ -1908,10 +1909,10 @@ const NavGen = struct {
     fn unionLayout(self: *NavGen, ty: Type) UnionLayout {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const layout = ty.unionGetLayout(pt);
+        const layout = ty.unionGetLayout(zcu);
-        const union_obj = mod.typeToUnion(ty).?;
+        const union_obj = zcu.typeToUnion(ty).?;
         var union_layout = UnionLayout{
             .has_payload = layout.payload_size != 0,
 @@ -1931,7 +1932,7 @@ const NavGen = struct {
             const most_aligned_field = layout.most_aligned_field;
             const most_aligned_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[most_aligned_field]);
             union_layout.payload_ty = most_aligned_field_ty;
-            union_layout.payload_size = @intCast(most_aligned_field_ty.abiSize(pt));
+            union_layout.payload_size = @intCast(most_aligned_field_ty.abiSize(zcu));
         } else {
             union_layout.payload_size = 0;
         }
 @@ -1998,12 +1999,12 @@ const NavGen = struct {
         }
         fn materialize(self: Temporary, ng: *NavGen) !IdResult {
-            const mod = ng.pt.zcu;
+            const zcu = ng.pt.zcu;
             switch (self.value) {
                 .singleton => |id| return id,
                 .exploded_vector => |range| {
-                    assert(self.ty.isVector(mod));
+                    assert(self.ty.isVector(zcu));
-                    assert(self.ty.vectorLen(mod) == range.len);
+                    assert(self.ty.vectorLen(zcu) == range.len);
                     const consituents = try ng.gpa.alloc(IdRef, range.len);
                     defer ng.gpa.free(consituents);
                     for (consituents, 0..range.len) |*id, i| {
 @@ -2028,18 +2029,18 @@ const NavGen = struct {
         /// 'Explode' a temporary into separate elements. This turns a vector
         /// into a bag of elements.
         fn explode(self: Temporary, ng: *NavGen) !IdRange {
-            const mod = ng.pt.zcu;
+            const zcu = ng.pt.zcu;
             // If the value is a scalar, then this is a no-op.
-            if (!self.ty.isVector(mod)) {
+            if (!self.ty.isVector(zcu)) {
                 return switch (self.value) {
                     .singleton => |id| .{ .base = @intFromEnum(id), .len = 1 },
                     .exploded_vector => |range| range,
                 };
             }
-            const ty_id = try ng.resolveType(self.ty.scalarType(mod), .direct);
+            const ty_id = try ng.resolveType(self.ty.scalarType(zcu), .direct);
-            const n = self.ty.vectorLen(mod);
+            const n = self.ty.vectorLen(zcu);
             const results = ng.spv.allocIds(n);
             const id = switch (self.value) {
 @@ -2087,13 +2088,13 @@ const NavGen = struct {
         /// only checks the size, but the source-of-truth is implemented
         /// by `isSpvVector()`.
         fn fromType(ty: Type, ng: *NavGen) Vectorization {
-            const mod = ng.pt.zcu;
+            const zcu = ng.pt.zcu;
-            if (!ty.isVector(mod)) {
+            if (!ty.isVector(zcu)) {
                 return .scalar;
             } else if (ng.isSpvVector(ty)) {
-                return .{ .spv_vectorized = ty.vectorLen(mod) };
+                return .{ .spv_vectorized = ty.vectorLen(zcu) };
             } else {
-                return .{ .unrolled = ty.vectorLen(mod) };
+                return .{ .unrolled = ty.vectorLen(zcu) };
             }
         }
 @@ -2339,10 +2340,10 @@ const NavGen = struct {
     /// This function builds an OpSConvert of OpUConvert depending on the
     /// signedness of the types.
     fn buildIntConvert(self: *NavGen, dst_ty: Type, src: Temporary) !Temporary {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const dst_ty_id = try self.resolveType(dst_ty.scalarType(mod), .direct);
+        const dst_ty_id = try self.resolveType(dst_ty.scalarType(zcu), .direct);
-        const src_ty_id = try self.resolveType(src.ty.scalarType(mod), .direct);
+        const src_ty_id = try self.resolveType(src.ty.scalarType(zcu), .direct);
         const v = self.vectorization(.{ dst_ty, src });
         const result_ty = try v.resultType(self, dst_ty);
 @@ -2363,7 +2364,7 @@ const NavGen = struct {
         const op_result_ty = try v.operationType(self, dst_ty);
         const op_result_ty_id = try self.resolveType(op_result_ty, .direct);
-        const opcode: Opcode = if (dst_ty.isSignedInt(mod)) .OpSConvert else .OpUConvert;
+        const opcode: Opcode = if (dst_ty.isSignedInt(zcu)) .OpSConvert else .OpUConvert;
         const op_src = try v.prepare(self, src);
 @@ -2418,7 +2419,7 @@ const NavGen = struct {
     }
     fn buildSelect(self: *NavGen, condition: Temporary, lhs: Temporary, rhs: Temporary) !Temporary {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const v = self.vectorization(.{ condition, lhs, rhs });
         const ops = v.operations();
 @@ -2428,7 +2429,7 @@ const NavGen = struct {
         const op_result_ty_id = try self.resolveType(op_result_ty, .direct);
         const result_ty = try v.resultType(self, lhs.ty);
-        assert(condition.ty.scalarType(mod).zigTypeTag(mod) == .Bool);
+        assert(condition.ty.scalarType(zcu).zigTypeTag(zcu) == .Bool);
         const cond = try v.prepare(self, condition);
         const object_1 = try v.prepare(self, lhs);
 @@ -2764,9 +2765,9 @@ const NavGen = struct {
         rhs: Temporary,
     ) !struct { Temporary, Temporary } {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const target = self.getTarget();
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const v = lhs.vectorization(self).unify(rhs.vectorization(self));
         const ops = v.operations();
 @@ -2814,7 +2815,7 @@ const NavGen = struct {
                     // where T is maybe vectorized.
                     const types = [2]InternPool.Index{ arith_op_ty.toIntern(), arith_op_ty.toIntern() };
                     const values = [2]InternPool.Index{ .none, .none };
-                    const index = try ip.getAnonStructType(mod.gpa, pt.tid, .{
+                    const index = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
                         .types = &types,
                         .values = &values,
                         .names = &.{},
 @@ -2941,17 +2942,17 @@ const NavGen = struct {
     fn genNav(self: *NavGen) !void {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const spv_decl_index = try self.object.resolveNav(mod, self.owner_nav);
+        const spv_decl_index = try self.object.resolveNav(zcu, self.owner_nav);
         const result_id = self.spv.declPtr(spv_decl_index).result_id;
         const nav = ip.getNav(self.owner_nav);
-        const val = mod.navValue(self.owner_nav);
+        const val = zcu.navValue(self.owner_nav);
-        const ty = val.typeOf(mod);
+        const ty = val.typeOf(zcu);
         switch (self.spv.declPtr(spv_decl_index).kind) {
             .func => {
-                const fn_info = mod.typeToFunc(ty).?;
+                const fn_info = zcu.typeToFunc(ty).?;
                 const return_ty_id = try self.resolveFnReturnType(Type.fromInterned(fn_info.return_type));
                 const prototype_ty_id = try self.resolveType(ty, .direct);
 @@ -2969,7 +2970,7 @@ const NavGen = struct {
                 try self.args.ensureUnusedCapacity(self.gpa, fn_info.param_types.len);
                 for (fn_info.param_types.get(ip)) |param_ty_index| {
                     const param_ty = Type.fromInterned(param_ty_index);
-                    if (!param_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+                    if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
                     const param_type_id = try self.resolveType(param_ty, .direct);
                     const arg_result_id = self.spv.allocId();
 @@ -3116,8 +3117,8 @@ const NavGen = struct {
     /// Convert representation from indirect (in memory) to direct (in 'register')
     /// This converts the argument type from resolveType(ty, .indirect) to resolveType(ty, .direct).
     fn convertToDirect(self: *NavGen, ty: Type, operand_id: IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        switch (ty.scalarType(mod).zigTypeTag(mod)) {
+        switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
             .Bool => {
                 const false_id = try self.constBool(false, .indirect);
                 // The operation below requires inputs in direct representation, but the operand
 @@ -3142,8 +3143,8 @@ const NavGen = struct {
     /// Convert representation from direct (in 'register) to direct (in memory)
     /// This converts the argument type from resolveType(ty, .direct) to resolveType(ty, .indirect).
     fn convertToIndirect(self: *NavGen, ty: Type, operand_id: IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        switch (ty.scalarType(mod).zigTypeTag(mod)) {
+        switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
             .Bool => {
                 const result = try self.intFromBool(Temporary.init(ty, operand_id));
                 return try result.materialize(self);
 @@ -3219,8 +3220,8 @@ const NavGen = struct {
     }
     fn genInst(self: *NavGen, inst: Air.Inst.Index) !void {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip))
             return;
 @@ -3399,7 +3400,7 @@ const NavGen = struct {
     }
     fn airShift(self: *NavGen, inst: Air.Inst.Index, unsigned: BinaryOp, signed: BinaryOp) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const base = try self.temporary(bin_op.lhs);
 @@ -3420,7 +3421,7 @@ const NavGen = struct {
         // Note: The sign may differ here between the shift and the base type, in case
         // of an arithmetic right shift. SPIR-V still expects the same type,
         // so in that case we have to cast convert to signed.
-        const casted_shift = try self.buildIntConvert(base.ty.scalarType(mod), shift);
+        const casted_shift = try self.buildIntConvert(base.ty.scalarType(zcu), shift);
         const shifted = switch (info.signedness) {
             .unsigned => try self.buildBinary(unsigned, base, casted_shift),
 @@ -3477,7 +3478,7 @@ const NavGen = struct {
     /// All other values are returned unmodified (this makes strange integer
     /// wrapping easier to use in generic operations).
     fn normalize(self: *NavGen, value: Temporary, info: ArithmeticTypeInfo) !Temporary {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty = value.ty;
         switch (info.class) {
             .integer, .bool, .float => return value,
 @@ -3485,13 +3486,13 @@ const NavGen = struct {
             .strange_integer => switch (info.signedness) {
                 .unsigned => {
                     const mask_value = if (info.bits == 64) 0xFFFF_FFFF_FFFF_FFFF else (@as(u64, 1) << @as(u6, @intCast(info.bits))) - 1;
-                    const mask_id = try self.constInt(ty.scalarType(mod), mask_value, .direct);
+                    const mask_id = try self.constInt(ty.scalarType(zcu), mask_value, .direct);
-                    return try self.buildBinary(.bit_and, value, Temporary.init(ty.scalarType(mod), mask_id));
+                    return try self.buildBinary(.bit_and, value, Temporary.init(ty.scalarType(zcu), mask_id));
                 },
                 .signed => {
                     // Shift left and right so that we can copy the sight bit that way.
-                    const shift_amt_id = try self.constInt(ty.scalarType(mod), info.backing_bits - info.bits, .direct);
+                    const shift_amt_id = try self.constInt(ty.scalarType(zcu), info.backing_bits - info.bits, .direct);
-                    const shift_amt = Temporary.init(ty.scalarType(mod), shift_amt_id);
+                    const shift_amt = Temporary.init(ty.scalarType(zcu), shift_amt_id);
                     const left = try self.buildBinary(.sll, value, shift_amt);
                     return try self.buildBinary(.sra, left, shift_amt);
                 },
 @@ -3897,7 +3898,7 @@ const NavGen = struct {
     }
     fn airShlOverflow(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
 @@ -3916,7 +3917,7 @@ const NavGen = struct {
         // Sometimes Zig doesn't make both of the arguments the same types here. SPIR-V expects that,
         // so just manually upcast it if required.
-        const casted_shift = try self.buildIntConvert(base.ty.scalarType(mod), shift);
+        const casted_shift = try self.buildIntConvert(base.ty.scalarType(zcu), shift);
         const left = try self.buildBinary(.sll, base, casted_shift);
         const result = try self.normalize(left, info);
 @@ -3955,12 +3956,12 @@ const NavGen = struct {
     fn airClzCtz(self: *NavGen, inst: Air.Inst.Index, op: UnaryOp) !?IdRef {
         if (self.liveness.isUnused(inst)) return null;
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const target = self.getTarget();
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand = try self.temporary(ty_op.operand);
-        const scalar_result_ty = self.typeOfIndex(inst).scalarType(mod);
+        const scalar_result_ty = self.typeOfIndex(inst).scalarType(zcu);
         const info = self.arithmeticTypeInfo(operand.ty);
         switch (info.class) {
 @@ -4004,16 +4005,16 @@ const NavGen = struct {
     }
     fn airReduce(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce;
         const operand = try self.resolve(reduce.operand);
         const operand_ty = self.typeOf(reduce.operand);
-        const scalar_ty = operand_ty.scalarType(mod);
+        const scalar_ty = operand_ty.scalarType(zcu);
         const scalar_ty_id = try self.resolveType(scalar_ty, .direct);
         const info = self.arithmeticTypeInfo(operand_ty);
-        const len = operand_ty.vectorLen(mod);
+        const len = operand_ty.vectorLen(zcu);
         const first = try self.extractVectorComponent(scalar_ty, operand, 0);
 @@ -4080,7 +4081,7 @@ const NavGen = struct {
     fn airShuffle(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Shuffle, ty_pl.payload).data;
         const a = try self.resolve(extra.a);
 @@ -4092,7 +4093,7 @@ const NavGen = struct {
         const a_ty = self.typeOf(extra.a);
         const b_ty = self.typeOf(extra.b);
-        const scalar_ty = result_ty.scalarType(mod);
+        const scalar_ty = result_ty.scalarType(zcu);
         const scalar_ty_id = try self.resolveType(scalar_ty, .direct);
         // If all of the types are SPIR-V vectors, we can use OpVectorShuffle.
 @@ -4100,20 +4101,20 @@ const NavGen = struct {
             // The SPIR-V shuffle instruction is similar to the Air instruction, except that the elements are
             // numbered consecutively instead of using negatives.
-            const components = try self.gpa.alloc(Word, result_ty.vectorLen(mod));
+            const components = try self.gpa.alloc(Word, result_ty.vectorLen(zcu));
             defer self.gpa.free(components);
-            const a_len = a_ty.vectorLen(mod);
+            const a_len = a_ty.vectorLen(zcu);
             for (components, 0..) |*component, i| {
                 const elem = try mask.elemValue(pt, i);
-                if (elem.isUndef(mod)) {
+                if (elem.isUndef(zcu)) {
                     // This is explicitly valid for OpVectorShuffle, it indicates undefined.
                     component.* = 0xFFFF_FFFF;
                     continue;
                 }
-                const index = elem.toSignedInt(pt);
+                const index = elem.toSignedInt(zcu);
                 if (index >= 0) {
                     component.* = @intCast(index);
                 } else {
 @@ -4134,17 +4135,17 @@ const NavGen = struct {
         // Fall back to manually extracting and inserting components.
-        const components = try self.gpa.alloc(IdRef, result_ty.vectorLen(mod));
+        const components = try self.gpa.alloc(IdRef, result_ty.vectorLen(zcu));
         defer self.gpa.free(components);
         for (components, 0..) |*id, i| {
             const elem = try mask.elemValue(pt, i);
-            if (elem.isUndef(mod)) {
+            if (elem.isUndef(zcu)) {
                 id.* = try self.spv.constUndef(scalar_ty_id);
                 continue;
             }
-            const index = elem.toSignedInt(pt);
+            const index = elem.toSignedInt(zcu);
             if (index >= 0) {
                 id.* = try self.extractVectorComponent(scalar_ty, a, @intCast(index));
             } else {
 @@ -4218,10 +4219,10 @@ const NavGen = struct {
     }
     fn ptrAdd(self: *NavGen, result_ty: Type, ptr_ty: Type, ptr_id: IdRef, offset_id: IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const result_ty_id = try self.resolveType(result_ty, .direct);
-        switch (ptr_ty.ptrSize(mod)) {
+        switch (ptr_ty.ptrSize(zcu)) {
             .One => {
                 // Pointer to array
                 // TODO: Is this correct?
 @@ -4275,15 +4276,15 @@ const NavGen = struct {
         rhs: Temporary,
     ) !Temporary {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const scalar_ty = lhs.ty.scalarType(mod);
+        const scalar_ty = lhs.ty.scalarType(zcu);
-        const is_vector = lhs.ty.isVector(mod);
+        const is_vector = lhs.ty.isVector(zcu);
-        switch (scalar_ty.zigTypeTag(mod)) {
+        switch (scalar_ty.zigTypeTag(zcu)) {
             .Int, .Bool, .Float => {},
             .Enum => {
                 assert(!is_vector);
-                const ty = lhs.ty.intTagType(mod);
+                const ty = lhs.ty.intTagType(zcu);
                 return try self.cmp(op, lhs.pun(ty), rhs.pun(ty));
             },
             .ErrorSet => {
 @@ -4321,10 +4322,10 @@ const NavGen = struct {
                 const ty = lhs.ty;
-                const payload_ty = ty.optionalChild(mod);
+                const payload_ty = ty.optionalChild(zcu);
-                if (ty.optionalReprIsPayload(mod)) {
+                if (ty.optionalReprIsPayload(zcu)) {
-                    assert(payload_ty.hasRuntimeBitsIgnoreComptime(pt));
+                    assert(payload_ty.hasRuntimeBitsIgnoreComptime(zcu));
-                    assert(!payload_ty.isSlice(mod));
+                    assert(!payload_ty.isSlice(zcu));
                     return try self.cmp(op, lhs.pun(payload_ty), rhs.pun(payload_ty));
                 }
 @@ -4332,12 +4333,12 @@ const NavGen = struct {
                 const lhs_id = try lhs.materialize(self);
                 const rhs_id = try rhs.materialize(self);
-                const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(pt))
+                const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
                     try self.extractField(Type.bool, lhs_id, 1)
                 else
                     try self.convertToDirect(Type.bool, lhs_id);
-                const rhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(pt))
+                const rhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
                     try self.extractField(Type.bool, rhs_id, 1)
                 else
                     try self.convertToDirect(Type.bool, rhs_id);
 @@ -4345,7 +4346,7 @@ const NavGen = struct {
                 const lhs_valid = Temporary.init(Type.bool, lhs_valid_id);
                 const rhs_valid = Temporary.init(Type.bool, rhs_valid_id);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     return try self.cmp(op, lhs_valid, rhs_valid);
                 }
 @@ -4465,7 +4466,7 @@ const NavGen = struct {
         src_ty: Type,
         src_id: IdRef,
     ) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const src_ty_id = try self.resolveType(src_ty, .direct);
         const dst_ty_id = try self.resolveType(dst_ty, .direct);
 @@ -4477,7 +4478,7 @@ const NavGen = struct {
             // TODO: Some more cases are missing here
             //   See fn bitCast in llvm.zig
-            if (src_ty.zigTypeTag(mod) == .Int and dst_ty.isPtrAtRuntime(mod)) {
+            if (src_ty.zigTypeTag(zcu) == .Int and dst_ty.isPtrAtRuntime(zcu)) {
                 const result_id = self.spv.allocId();
                 try self.func.body.emit(self.spv.gpa, .OpConvertUToPtr, .{
                     .id_result_type = dst_ty_id,
 @@ -4490,7 +4491,7 @@ const NavGen = struct {
             // We can only use OpBitcast for specific conversions: between numerical types, and
             // between pointers. If the resolved spir-v types fall into this category then emit OpBitcast,
             // otherwise use a temporary and perform a pointer cast.
-            const can_bitcast = (src_ty.isNumeric(mod) and dst_ty.isNumeric(mod)) or (src_ty.isPtrAtRuntime(mod) and dst_ty.isPtrAtRuntime(mod));
+            const can_bitcast = (src_ty.isNumeric(zcu) and dst_ty.isNumeric(zcu)) or (src_ty.isPtrAtRuntime(zcu) and dst_ty.isPtrAtRuntime(zcu));
             if (can_bitcast) {
                 const result_id = self.spv.allocId();
                 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
 @@ -4519,7 +4520,7 @@ const NavGen = struct {
         // the result here.
         // TODO: This detail could cause stuff like @as(*const i1, @ptrCast(&@as(u1, 1))) to break
         // should we change the representation of strange integers?
-        if (dst_ty.zigTypeTag(mod) == .Int) {
+        if (dst_ty.zigTypeTag(zcu) == .Int) {
             const info = self.arithmeticTypeInfo(dst_ty);
             const result = try self.normalize(Temporary.init(dst_ty, result_id), info);
             return try result.materialize(self);
 @@ -4675,19 +4676,19 @@ const NavGen = struct {
     fn airArrayToSlice(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const array_ptr_ty = self.typeOf(ty_op.operand);
-        const array_ty = array_ptr_ty.childType(mod);
+        const array_ty = array_ptr_ty.childType(zcu);
         const slice_ty = self.typeOfIndex(inst);
-        const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
+        const elem_ptr_ty = slice_ty.slicePtrFieldType(zcu);
         const elem_ptr_ty_id = try self.resolveType(elem_ptr_ty, .direct);
         const array_ptr_id = try self.resolve(ty_op.operand);
-        const len_id = try self.constInt(Type.usize, array_ty.arrayLen(mod), .direct);
+        const len_id = try self.constInt(Type.usize, array_ty.arrayLen(zcu), .direct);
-        const elem_ptr_id = if (!array_ty.hasRuntimeBitsIgnoreComptime(pt))
+        const elem_ptr_id = if (!array_ty.hasRuntimeBitsIgnoreComptime(zcu))
             // Note: The pointer is something like *opaque{}, so we need to bitcast it to the element type.
             try self.bitCast(elem_ptr_ty, array_ptr_ty, array_ptr_id)
         else
 @@ -4720,16 +4721,16 @@ const NavGen = struct {
     fn airAggregateInit(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const result_ty = self.typeOfIndex(inst);
-        const len: usize = @intCast(result_ty.arrayLen(mod));
+        const len: usize = @intCast(result_ty.arrayLen(zcu));
         const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
-        switch (result_ty.zigTypeTag(mod)) {
+        switch (result_ty.zigTypeTag(zcu)) {
             .Struct => {
-                if (mod.typeToPackedStruct(result_ty)) |struct_type| {
+                if (zcu.typeToPackedStruct(result_ty)) |struct_type| {
                     _ = struct_type;
                     unreachable; // TODO
                 }
 @@ -4744,7 +4745,7 @@ const NavGen = struct {
                     .anon_struct_type => |tuple| {
                         for (tuple.types.get(ip), elements, 0..) |field_ty, element, i| {
                             if ((try result_ty.structFieldValueComptime(pt, i)) != null) continue;
-                            assert(Type.fromInterned(field_ty).hasRuntimeBits(pt));
+                            assert(Type.fromInterned(field_ty).hasRuntimeBits(zcu));
                             const id = try self.resolve(element);
                             types[index] = Type.fromInterned(field_ty);
 @@ -4759,7 +4760,7 @@ const NavGen = struct {
                             const field_index = it.next().?;
                             if ((try result_ty.structFieldValueComptime(pt, i)) != null) continue;
                             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                            assert(field_ty.hasRuntimeBitsIgnoreComptime(pt));
+                            assert(field_ty.hasRuntimeBitsIgnoreComptime(zcu));
                             const id = try self.resolve(element);
                             types[index] = field_ty;
 @@ -4777,7 +4778,7 @@ const NavGen = struct {
                 );
             },
             .Vector => {
-                const n_elems = result_ty.vectorLen(mod);
+                const n_elems = result_ty.vectorLen(zcu);
                 const elem_ids = try self.gpa.alloc(IdRef, n_elems);
                 defer self.gpa.free(elem_ids);
 @@ -4788,8 +4789,8 @@ const NavGen = struct {
                 return try self.constructVector(result_ty, elem_ids);
             },
             .Array => {
-                const array_info = result_ty.arrayInfo(mod);
+                const array_info = result_ty.arrayInfo(zcu);
-                const n_elems: usize = @intCast(result_ty.arrayLenIncludingSentinel(mod));
+                const n_elems: usize = @intCast(result_ty.arrayLenIncludingSentinel(zcu));
                 const elem_ids = try self.gpa.alloc(IdRef, n_elems);
                 defer self.gpa.free(elem_ids);
 @@ -4810,14 +4811,14 @@ const NavGen = struct {
     fn sliceOrArrayLen(self: *NavGen, operand_id: IdRef, ty: Type) !IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        switch (ty.ptrSize(mod)) {
+        switch (ty.ptrSize(zcu)) {
             .Slice => return self.extractField(Type.usize, operand_id, 1),
             .One => {
-                const array_ty = ty.childType(mod);
+                const array_ty = ty.childType(zcu);
-                const elem_ty = array_ty.childType(mod);
+                const elem_ty = array_ty.childType(zcu);
-                const abi_size = elem_ty.abiSize(pt);
+                const abi_size = elem_ty.abiSize(zcu);
-                const size = array_ty.arrayLenIncludingSentinel(mod) * abi_size;
+                const size = array_ty.arrayLenIncludingSentinel(zcu) * abi_size;
                 return try self.constInt(Type.usize, size, .direct);
             },
             .Many, .C => unreachable,
 @@ -4825,9 +4826,9 @@ const NavGen = struct {
     }
     fn sliceOrArrayPtr(self: *NavGen, operand_id: IdRef, ty: Type) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        if (ty.isSlice(mod)) {
+        if (ty.isSlice(zcu)) {
-            const ptr_ty = ty.slicePtrFieldType(mod);
+            const ptr_ty = ty.slicePtrFieldType(zcu);
             return self.extractField(ptr_ty, operand_id, 0);
         }
         return operand_id;
 @@ -4857,11 +4858,11 @@ const NavGen = struct {
     }
     fn airSliceElemPtr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const slice_ty = self.typeOf(bin_op.lhs);
-        if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
+        if (!slice_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) return null;
         const slice_id = try self.resolve(bin_op.lhs);
         const index_id = try self.resolve(bin_op.rhs);
 @@ -4874,28 +4875,28 @@ const NavGen = struct {
     }
     fn airSliceElemVal(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const slice_ty = self.typeOf(bin_op.lhs);
-        if (!slice_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
+        if (!slice_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) return null;
         const slice_id = try self.resolve(bin_op.lhs);
         const index_id = try self.resolve(bin_op.rhs);
-        const ptr_ty = slice_ty.slicePtrFieldType(mod);
+        const ptr_ty = slice_ty.slicePtrFieldType(zcu);
         const ptr_ty_id = try self.resolveType(ptr_ty, .direct);
         const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
         const elem_ptr = try self.ptrAccessChain(ptr_ty_id, slice_ptr, index_id, &.{});
-        return try self.load(slice_ty.childType(mod), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(mod) });
+        return try self.load(slice_ty.childType(zcu), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(zcu) });
     }
     fn ptrElemPtr(self: *NavGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         // Construct new pointer type for the resulting pointer
-        const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
+        const elem_ty = ptr_ty.elemType2(zcu); // use elemType() so that we get T for *[N]T.
-        const elem_ptr_ty_id = try self.ptrType(elem_ty, self.spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
+        const elem_ptr_ty_id = try self.ptrType(elem_ty, self.spvStorageClass(ptr_ty.ptrAddressSpace(zcu)));
-        if (ptr_ty.isSinglePointer(mod)) {
+        if (ptr_ty.isSinglePointer(zcu)) {
             // Pointer-to-array. In this case, the resulting pointer is not of the same type
             // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.
             return try self.accessChainId(elem_ptr_ty_id, ptr_id, &.{index_id});
 @@ -4907,14 +4908,14 @@ const NavGen = struct {
     fn airPtrElemPtr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const src_ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = src_ptr_ty.childType(mod);
+        const elem_ty = src_ptr_ty.childType(zcu);
         const ptr_id = try self.resolve(bin_op.lhs);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             const dst_ptr_ty = self.typeOfIndex(inst);
             return try self.bitCast(dst_ptr_ty, src_ptr_ty, ptr_id);
         }
 @@ -4924,10 +4925,10 @@ const NavGen = struct {
     }
     fn airArrayElemVal(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const array_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = array_ty.childType(mod);
+        const elem_ty = array_ty.childType(zcu);
         const array_id = try self.resolve(bin_op.lhs);
         const index_id = try self.resolve(bin_op.rhs);
 @@ -4946,7 +4947,7 @@ const NavGen = struct {
         // For now, just generate a temporary and use that.
         // TODO: This backend probably also should use isByRef from llvm...
-        const is_vector = array_ty.isVector(mod);
+        const is_vector = array_ty.isVector(zcu);
         const elem_repr: Repr = if (is_vector) .direct else .indirect;
         const ptr_array_ty_id = try self.ptrType2(array_ty, .Function, .direct);
 @@ -4985,26 +4986,26 @@ const NavGen = struct {
     }
     fn airPtrElemVal(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
         const elem_ty = self.typeOfIndex(inst);
         const ptr_id = try self.resolve(bin_op.lhs);
         const index_id = try self.resolve(bin_op.rhs);
         const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
-        return try self.load(elem_ty, elem_ptr_id, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
+        return try self.load(elem_ty, elem_ptr_id, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) });
     }
     fn airVectorStoreElem(self: *NavGen, inst: Air.Inst.Index) !void {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const data = self.air.instructions.items(.data)[@intFromEnum(inst)].vector_store_elem;
         const extra = self.air.extraData(Air.Bin, data.payload).data;
         const vector_ptr_ty = self.typeOf(data.vector_ptr);
-        const vector_ty = vector_ptr_ty.childType(mod);
+        const vector_ty = vector_ptr_ty.childType(zcu);
-        const scalar_ty = vector_ty.scalarType(mod);
+        const scalar_ty = vector_ty.scalarType(zcu);
-        const storage_class = self.spvStorageClass(vector_ptr_ty.ptrAddressSpace(mod));
+        const storage_class = self.spvStorageClass(vector_ptr_ty.ptrAddressSpace(zcu));
         const scalar_ptr_ty_id = try self.ptrType(scalar_ty, storage_class);
         const vector_ptr = try self.resolve(data.vector_ptr);
 @@ -5013,30 +5014,30 @@ const NavGen = struct {
         const elem_ptr_id = try self.accessChainId(scalar_ptr_ty_id, vector_ptr, &.{index});
         try self.store(scalar_ty, elem_ptr_id, operand, .{
-            .is_volatile = vector_ptr_ty.isVolatilePtr(mod),
+            .is_volatile = vector_ptr_ty.isVolatilePtr(zcu),
         });
     }
     fn airSetUnionTag(self: *NavGen, inst: Air.Inst.Index) !void {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const un_ptr_ty = self.typeOf(bin_op.lhs);
-        const un_ty = un_ptr_ty.childType(mod);
+        const un_ty = un_ptr_ty.childType(zcu);
         const layout = self.unionLayout(un_ty);
         if (layout.tag_size == 0) return;
-        const tag_ty = un_ty.unionTagTypeSafety(mod).?;
+        const tag_ty = un_ty.unionTagTypeSafety(zcu).?;
-        const tag_ptr_ty_id = try self.ptrType(tag_ty, self.spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
+        const tag_ptr_ty_id = try self.ptrType(tag_ty, self.spvStorageClass(un_ptr_ty.ptrAddressSpace(zcu)));
         const union_ptr_id = try self.resolve(bin_op.lhs);
         const new_tag_id = try self.resolve(bin_op.rhs);
         if (!layout.has_payload) {
-            try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
+            try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(zcu) });
         } else {
             const ptr_id = try self.accessChain(tag_ptr_ty_id, union_ptr_id, &.{layout.tag_index});
-            try self.store(tag_ty, ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
+            try self.store(tag_ty, ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(zcu) });
         }
     }
 @@ -5044,14 +5045,14 @@ const NavGen = struct {
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const un_ty = self.typeOf(ty_op.operand);
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const layout = self.unionLayout(un_ty);
         if (layout.tag_size == 0) return null;
         const union_handle = try self.resolve(ty_op.operand);
         if (!layout.has_payload) return union_handle;
-        const tag_ty = un_ty.unionTagTypeSafety(mod).?;
+        const tag_ty = un_ty.unionTagTypeSafety(zcu).?;
         return try self.extractField(tag_ty, union_handle, layout.tag_index);
     }
 @@ -5068,9 +5069,9 @@ const NavGen = struct {
         // Note: The result here is not cached, because it generates runtime code.
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
-        const union_ty = mod.typeToUnion(ty).?;
+        const union_ty = zcu.typeToUnion(ty).?;
         const tag_ty = Type.fromInterned(union_ty.enum_tag_ty);
         if (union_ty.flagsUnordered(ip).layout == .@"packed") {
 @@ -5082,7 +5083,7 @@ const NavGen = struct {
         const tag_int = if (layout.tag_size != 0) blk: {
             const tag_val = try pt.enumValueFieldIndex(tag_ty, active_field);
             const tag_int_val = try tag_val.intFromEnum(tag_ty, pt);
-            break :blk tag_int_val.toUnsignedInt(pt);
+            break :blk tag_int_val.toUnsignedInt(zcu);
         } else 0;
         if (!layout.has_payload) {
 @@ -5099,7 +5100,7 @@ const NavGen = struct {
         }
         const payload_ty = Type.fromInterned(union_ty.field_types.get(ip)[active_field]);
-        if (payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             const pl_ptr_ty_id = try self.ptrType(layout.payload_ty, .Function);
             const pl_ptr_id = try self.accessChain(pl_ptr_ty_id, tmp_id, &.{layout.payload_index});
             const active_pl_ptr_ty_id = try self.ptrType(payload_ty, .Function);
 @@ -5123,15 +5124,15 @@ const NavGen = struct {
     fn airUnionInit(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
         const ty = self.typeOfIndex(inst);
-        const union_obj = mod.typeToUnion(ty).?;
+        const union_obj = zcu.typeToUnion(ty).?;
         const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[extra.field_index]);
-        const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(pt))
+        const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu))
             try self.resolve(extra.init)
         else
             null;
 @@ -5140,23 +5141,23 @@ const NavGen = struct {
     fn airStructFieldVal(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
         const object_ty = self.typeOf(struct_field.struct_operand);
         const object_id = try self.resolve(struct_field.struct_operand);
         const field_index = struct_field.field_index;
-        const field_ty = object_ty.structFieldType(field_index, mod);
+        const field_ty = object_ty.fieldType(field_index, zcu);
-        if (!field_ty.hasRuntimeBitsIgnoreComptime(pt)) return null;
+        if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
-        switch (object_ty.zigTypeTag(mod)) {
+        switch (object_ty.zigTypeTag(zcu)) {
-            .Struct => switch (object_ty.containerLayout(mod)) {
+            .Struct => switch (object_ty.containerLayout(zcu)) {
                 .@"packed" => unreachable, // TODO
                 else => return try self.extractField(field_ty, object_id, field_index),
             },
-            .Union => switch (object_ty.containerLayout(mod)) {
+            .Union => switch (object_ty.containerLayout(zcu)) {
                 .@"packed" => unreachable, // TODO
                 else => {
                     // Store, ptr-elem-ptr, pointer-cast, load
 @@ -5185,16 +5186,16 @@ const NavGen = struct {
     fn airFieldParentPtr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
-        const parent_ty = ty_pl.ty.toType().childType(mod);
+        const parent_ty = ty_pl.ty.toType().childType(zcu);
         const result_ty_id = try self.resolveType(ty_pl.ty.toType(), .indirect);
         const field_ptr = try self.resolve(extra.field_ptr);
         const field_ptr_int = try self.intFromPtr(field_ptr);
-        const field_offset = parent_ty.structFieldOffset(extra.field_index, pt);
+        const field_offset = parent_ty.structFieldOffset(extra.field_index, zcu);
         const base_ptr_int = base_ptr_int: {
             if (field_offset == 0) break :base_ptr_int field_ptr_int;
 @@ -5319,10 +5320,10 @@ const NavGen = struct {
     }
     fn airAlloc(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ptr_ty = self.typeOfIndex(inst);
-        assert(ptr_ty.ptrAddressSpace(mod) == .generic);
+        assert(ptr_ty.ptrAddressSpace(zcu) == .generic);
-        const child_ty = ptr_ty.childType(mod);
+        const child_ty = ptr_ty.childType(zcu);
         return try self.alloc(child_ty, .{});
     }
 @@ -5494,9 +5495,9 @@ const NavGen = struct {
         // ir.Block in a different SPIR-V block.
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty = self.typeOfIndex(inst);
-        const have_block_result = ty.isFnOrHasRuntimeBitsIgnoreComptime(pt);
+        const have_block_result = ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu);
         const cf = switch (self.control_flow) {
             .structured => |*cf| cf,
 @@ -5570,7 +5571,7 @@ const NavGen = struct {
         const sblock = cf.block_stack.getLast();
-        if (ty.isNoReturn(mod)) {
+        if (ty.isNoReturn(zcu)) {
             // If this block is noreturn, this instruction is the last of a block,
             // and we must simply jump to the block's merge unconditionally.
             try self.structuredBreak(next_block);
 @@ -5626,13 +5627,13 @@ const NavGen = struct {
     }
     fn airBr(self: *NavGen, inst: Air.Inst.Index) !void {
-        const pt = self.pt;
+        const zcu = self.pt.zcu;
         const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
         const operand_ty = self.typeOf(br.operand);
         switch (self.control_flow) {
             .structured => |*cf| {
-                if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+                if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
                     const operand_id = try self.resolve(br.operand);
                     const block_result_var_id = cf.block_results.get(br.block_inst).?;
                     try self.store(operand_ty, block_result_var_id, operand_id, .{});
 @@ -5643,7 +5644,7 @@ const NavGen = struct {
             },
             .unstructured => |cf| {
                 const block = cf.blocks.get(br.block_inst).?;
-                if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(pt)) {
+                if (operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
                     const operand_id = try self.resolve(br.operand);
                     // current_block_label should not be undefined here, lest there
                     // is a br or br_void in the function's body.
 @@ -5770,35 +5771,35 @@ const NavGen = struct {
     }
     fn airLoad(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const ptr_ty = self.typeOf(ty_op.operand);
         const elem_ty = self.typeOfIndex(inst);
         const operand = try self.resolve(ty_op.operand);
-        if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
+        if (!ptr_ty.isVolatilePtr(zcu) and self.liveness.isUnused(inst)) return null;
-        return try self.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
+        return try self.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) });
     }
     fn airStore(self: *NavGen, inst: Air.Inst.Index) !void {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType(mod);
+        const elem_ty = ptr_ty.childType(zcu);
         const ptr = try self.resolve(bin_op.lhs);
         const value = try self.resolve(bin_op.rhs);
-        try self.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
+        try self.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) });
     }
     fn airRet(self: *NavGen, inst: Air.Inst.Index) !void {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const operand = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const ret_ty = self.typeOf(operand);
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            const fn_info = mod.typeToFunc(mod.navValue(self.owner_nav).typeOf(mod)).?;
+            const fn_info = zcu.typeToFunc(zcu.navValue(self.owner_nav).typeOf(zcu)).?;
-            if (Type.fromInterned(fn_info.return_type).isError(mod)) {
+            if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
                 // to functions that return anyerror.
 @@ -5815,14 +5816,14 @@ const NavGen = struct {
     fn airRetLoad(self: *NavGen, inst: Air.Inst.Index) !void {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const ptr_ty = self.typeOf(un_op);
-        const ret_ty = ptr_ty.childType(mod);
+        const ret_ty = ptr_ty.childType(zcu);
-        if (!ret_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-            const fn_info = mod.typeToFunc(mod.navValue(self.owner_nav).typeOf(mod)).?;
+            const fn_info = zcu.typeToFunc(zcu.navValue(self.owner_nav).typeOf(zcu)).?;
-            if (Type.fromInterned(fn_info.return_type).isError(mod)) {
+            if (Type.fromInterned(fn_info.return_type).isError(zcu)) {
                 // Functions with an empty error set are emitted with an error code
                 // return type and return zero so they can be function pointers coerced
                 // to functions that return anyerror.
 @@ -5834,14 +5835,14 @@ const NavGen = struct {
         }
         const ptr = try self.resolve(un_op);
-        const value = try self.load(ret_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
+        const value = try self.load(ret_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) });
         try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{
             .value = value,
         });
     }
     fn airTry(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const err_union_id = try self.resolve(pl_op.operand);
         const extra = self.air.extraData(Air.Try, pl_op.payload);
 @@ -5854,7 +5855,7 @@ const NavGen = struct {
         const eu_layout = self.errorUnionLayout(payload_ty);
-        if (!err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (!err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             const err_id = if (eu_layout.payload_has_bits)
                 try self.extractField(Type.anyerror, err_union_id, eu_layout.errorFieldIndex())
             else
 @@ -5911,18 +5912,18 @@ const NavGen = struct {
     }
     fn airErrUnionErr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand_id = try self.resolve(ty_op.operand);
         const err_union_ty = self.typeOf(ty_op.operand);
         const err_ty_id = try self.resolveType(Type.anyerror, .direct);
-        if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             // No error possible, so just return undefined.
             return try self.spv.constUndef(err_ty_id);
         }
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
         const eu_layout = self.errorUnionLayout(payload_ty);
         if (!eu_layout.payload_has_bits) {
 @@ -5947,10 +5948,10 @@ const NavGen = struct {
     }
     fn airWrapErrUnionErr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const err_union_ty = self.typeOfIndex(inst);
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
         const operand_id = try self.resolve(ty_op.operand);
         const eu_layout = self.errorUnionLayout(payload_ty);
 @@ -5995,28 +5996,28 @@ const NavGen = struct {
     fn airIsNull(self: *NavGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum { is_null, is_non_null }) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const operand_id = try self.resolve(un_op);
         const operand_ty = self.typeOf(un_op);
-        const optional_ty = if (is_pointer) operand_ty.childType(mod) else operand_ty;
+        const optional_ty = if (is_pointer) operand_ty.childType(zcu) else operand_ty;
-        const payload_ty = optional_ty.optionalChild(mod);
+        const payload_ty = optional_ty.optionalChild(zcu);
         const bool_ty_id = try self.resolveType(Type.bool, .direct);
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             // Pointer payload represents nullability: pointer or slice.
             const loaded_id = if (is_pointer)
                 try self.load(optional_ty, operand_id, .{})
             else
                 operand_id;
-            const ptr_ty = if (payload_ty.isSlice(mod))
+            const ptr_ty = if (payload_ty.isSlice(zcu))
-                payload_ty.slicePtrFieldType(mod)
+                payload_ty.slicePtrFieldType(zcu)
             else
                 payload_ty;
-            const ptr_id = if (payload_ty.isSlice(mod))
+            const ptr_id = if (payload_ty.isSlice(zcu))
                 try self.extractField(ptr_ty, loaded_id, 0)
             else
                 loaded_id;
 @@ -6036,8 +6037,8 @@ const NavGen = struct {
         const is_non_null_id = blk: {
             if (is_pointer) {
-                if (payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+                if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const storage_class = self.spvStorageClass(operand_ty.ptrAddressSpace(mod));
+                    const storage_class = self.spvStorageClass(operand_ty.ptrAddressSpace(zcu));
                     const bool_ptr_ty_id = try self.ptrType(Type.bool, storage_class);
                     const tag_ptr_id = try self.accessChain(bool_ptr_ty_id, operand_id, &.{1});
                     break :blk try self.load(Type.bool, tag_ptr_id, .{});
 @@ -6046,7 +6047,7 @@ const NavGen = struct {
                 break :blk try self.load(Type.bool, operand_id, .{});
             }
-            break :blk if (payload_ty.hasRuntimeBitsIgnoreComptime(pt))
+            break :blk if (payload_ty.hasRuntimeBitsIgnoreComptime(zcu))
                 try self.extractField(Type.bool, operand_id, 1)
             else
                 // Optional representation is bool indicating whether the optional is set
 @@ -6071,16 +6072,16 @@ const NavGen = struct {
     }
     fn airIsErr(self: *NavGen, inst: Air.Inst.Index, pred: enum { is_err, is_non_err }) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
         const operand_id = try self.resolve(un_op);
         const err_union_ty = self.typeOf(un_op);
-        if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
+        if (err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) {
             return try self.constBool(pred == .is_non_err, .direct);
         }
-        const payload_ty = err_union_ty.errorUnionPayload(mod);
+        const payload_ty = err_union_ty.errorUnionPayload(zcu);
         const eu_layout = self.errorUnionLayout(payload_ty);
         const bool_ty_id = try self.resolveType(Type.bool, .direct);
 @@ -6105,15 +6106,15 @@ const NavGen = struct {
     fn airUnwrapOptional(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand_id = try self.resolve(ty_op.operand);
         const optional_ty = self.typeOf(ty_op.operand);
         const payload_ty = self.typeOfIndex(inst);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) return null;
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) return null;
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             return operand_id;
         }
 @@ -6122,22 +6123,22 @@ const NavGen = struct {
     fn airUnwrapOptionalPtr(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const operand_id = try self.resolve(ty_op.operand);
         const operand_ty = self.typeOf(ty_op.operand);
-        const optional_ty = operand_ty.childType(mod);
+        const optional_ty = operand_ty.childType(zcu);
-        const payload_ty = optional_ty.optionalChild(mod);
+        const payload_ty = optional_ty.optionalChild(zcu);
         const result_ty = self.typeOfIndex(inst);
         const result_ty_id = try self.resolveType(result_ty, .direct);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             // There is no payload, but we still need to return a valid pointer.
             // We can just return anything here, so just return a pointer to the operand.
             return try self.bitCast(result_ty, operand_ty, operand_id);
         }
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             // They are the same value.
             return try self.bitCast(result_ty, operand_ty, operand_id);
         }
 @@ -6147,18 +6148,18 @@ const NavGen = struct {
     fn airWrapOptional(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op;
         const payload_ty = self.typeOf(ty_op.operand);
-        if (!payload_ty.hasRuntimeBitsIgnoreComptime(pt)) {
+        if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
             return try self.constBool(true, .indirect);
         }
         const operand_id = try self.resolve(ty_op.operand);
         const optional_ty = self.typeOfIndex(inst);
-        if (optional_ty.optionalReprIsPayload(mod)) {
+        if (optional_ty.optionalReprIsPayload(zcu)) {
             return operand_id;
         }
 @@ -6170,7 +6171,7 @@ const NavGen = struct {
     fn airSwitchBr(self: *NavGen, inst: Air.Inst.Index) !void {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const target = self.getTarget();
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const cond_ty = self.typeOf(pl_op.operand);
 @@ -6178,18 +6179,18 @@ const NavGen = struct {
         var cond_indirect = try self.convertToIndirect(cond_ty, cond);
         const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
-        const cond_words: u32 = switch (cond_ty.zigTypeTag(mod)) {
+        const cond_words: u32 = switch (cond_ty.zigTypeTag(zcu)) {
             .Bool, .ErrorSet => 1,
             .Int => blk: {
-                const bits = cond_ty.intInfo(mod).bits;
+                const bits = cond_ty.intInfo(zcu).bits;
                 const backing_bits = self.backingIntBits(bits) orelse {
                     return self.todo("implement composite int switch", .{});
                 };
                 break :blk if (backing_bits <= 32) 1 else 2;
             },
             .Enum => blk: {
-                const int_ty = cond_ty.intTagType(mod);
+                const int_ty = cond_ty.intTagType(zcu);
-                const int_info = int_ty.intInfo(mod);
+                const int_info = int_ty.intInfo(zcu);
                 const backing_bits = self.backingIntBits(int_info.bits) orelse {
                     return self.todo("implement composite int switch", .{});
                 };
 @@ -6200,7 +6201,7 @@ const NavGen = struct {
                 break :blk target.ptrBitWidth() / 32;
             },
             // TODO: Figure out which types apply here, and work around them as we can only do integers.
-            else => return self.todo("implement switch for type {s}", .{@tagName(cond_ty.zigTypeTag(mod))}),
+            else => return self.todo("implement switch for type {s}", .{@tagName(cond_ty.zigTypeTag(zcu))}),
         };
         const num_cases = switch_br.data.cases_len;
 @@ -6255,14 +6256,14 @@ const NavGen = struct {
                 for (items) |item| {
                     const value = (try self.air.value(item, pt)) orelse unreachable;
-                    const int_val: u64 = switch (cond_ty.zigTypeTag(mod)) {
+                    const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) {
-                        .Bool, .Int => if (cond_ty.isSignedInt(mod)) @bitCast(value.toSignedInt(pt)) else value.toUnsignedInt(pt),
+                        .Bool, .Int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu),
                         .Enum => blk: {
                             // TODO: figure out of cond_ty is correct (something with enum literals)
-                            break :blk (try value.intFromEnum(cond_ty, pt)).toUnsignedInt(pt); // TODO: composite integer constants
+                            break :blk (try value.intFromEnum(cond_ty, pt)).toUnsignedInt(zcu); // TODO: composite integer constants
                         },
-                        .ErrorSet => value.getErrorInt(mod),
+                        .ErrorSet => value.getErrorInt(zcu),
-                        .Pointer => value.toUnsignedInt(pt),
+                        .Pointer => value.toUnsignedInt(zcu),
                         else => unreachable,
                     };
                     const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) {
 @@ -6343,9 +6344,9 @@ const NavGen = struct {
     fn airDbgStmt(self: *NavGen, inst: Air.Inst.Index) !void {
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
-        const path = mod.navFileScope(self.owner_nav).sub_file_path;
+        const path = zcu.navFileScope(self.owner_nav).sub_file_path;
         try self.func.body.emit(self.spv.gpa, .OpLine, .{
             .file = try self.spv.resolveString(path),
             .line = self.base_line + dbg_stmt.line + 1,
 @@ -6354,12 +6355,12 @@ const NavGen = struct {
     }
     fn airDbgInlineBlock(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const inst_datas = self.air.instructions.items(.data);
         const extra = self.air.extraData(Air.DbgInlineBlock, inst_datas[@intFromEnum(inst)].ty_pl.payload);
         const old_base_line = self.base_line;
         defer self.base_line = old_base_line;
-        self.base_line = mod.navSrcLine(mod.funcInfo(extra.data.func).owner_nav);
+        self.base_line = zcu.navSrcLine(zcu.funcInfo(extra.data.func).owner_nav);
         return self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len]));
     }
 @@ -6371,7 +6372,7 @@ const NavGen = struct {
     }
     fn airAssembly(self: *NavGen, inst: Air.Inst.Index) !?IdRef {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
         const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
         const extra = self.air.extraData(Air.Asm, ty_pl.payload);
 @@ -6453,20 +6454,20 @@ const NavGen = struct {
                 // TODO: Translate proper error locations.
                 assert(as.errors.items.len != 0);
                 assert(self.error_msg == null);
-                const src_loc = mod.navSrcLoc(self.owner_nav);
+                const src_loc = zcu.navSrcLoc(self.owner_nav);
-                self.error_msg = try Zcu.ErrorMsg.create(mod.gpa, src_loc, "failed to assemble SPIR-V inline assembly", .{});
+                self.error_msg = try Zcu.ErrorMsg.create(zcu.gpa, src_loc, "failed to assemble SPIR-V inline assembly", .{});
-                const notes = try mod.gpa.alloc(Zcu.ErrorMsg, as.errors.items.len);
+                const notes = try zcu.gpa.alloc(Zcu.ErrorMsg, as.errors.items.len);
                 // Sub-scope to prevent `return error.CodegenFail` from running the errdefers.
                 {
-                    errdefer mod.gpa.free(notes);
+                    errdefer zcu.gpa.free(notes);
                     var i: usize = 0;
                     errdefer for (notes[0..i]) |*note| {
-                        note.deinit(mod.gpa);
+                        note.deinit(zcu.gpa);
                     };
                     while (i < as.errors.items.len) : (i += 1) {
-                        notes[i] = try Zcu.ErrorMsg.init(mod.gpa, src_loc, "{s}", .{as.errors.items[i].msg});
+                        notes[i] = try Zcu.ErrorMsg.init(zcu.gpa, src_loc, "{s}", .{as.errors.items[i].msg});
                     }
                 }
                 self.error_msg.?.notes = notes;
 @@ -6503,17 +6504,17 @@ const NavGen = struct {
         _ = modifier;
         const pt = self.pt;
-        const mod = pt.zcu;
+        const zcu = pt.zcu;
         const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
         const extra = self.air.extraData(Air.Call, pl_op.payload);
         const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
         const callee_ty = self.typeOf(pl_op.operand);
-        const zig_fn_ty = switch (callee_ty.zigTypeTag(mod)) {
+        const zig_fn_ty = switch (callee_ty.zigTypeTag(zcu)) {
             .Fn => callee_ty,
             .Pointer => return self.fail("cannot call function pointers", .{}),
             else => unreachable,
         };
-        const fn_info = mod.typeToFunc(zig_fn_ty).?;
+        const fn_info = zcu.typeToFunc(zig_fn_ty).?;
         const return_type = fn_info.return_type;
         const result_type_id = try self.resolveFnReturnType(Type.fromInterned(return_type));
 @@ -6529,7 +6530,7 @@ const NavGen = struct {
             // before starting to emit OpFunctionCall instructions. Hence the
             // temporary params buffer.
             const arg_ty = self.typeOf(arg);
-            if (!arg_ty.hasRuntimeBitsIgnoreComptime(pt)) continue;
+            if (!arg_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
             const arg_id = try self.resolve(arg);
             params[n_params] = arg_id;
 @@ -6547,7 +6548,7 @@ const NavGen = struct {
             try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
         }
-        if (self.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBitsIgnoreComptime(pt)) {
+        if (self.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
             return null;
         }
 @@ -6604,12 +6605,12 @@ const NavGen = struct {
     }
     fn typeOf(self: *NavGen, inst: Air.Inst.Ref) Type {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        return self.air.typeOf(inst, &mod.intern_pool);
+        return self.air.typeOf(inst, &zcu.intern_pool);
     }
     fn typeOfIndex(self: *NavGen, inst: Air.Inst.Index) Type {
-        const mod = self.pt.zcu;
+        const zcu = self.pt.zcu;
-        return self.air.typeOfIndex(inst, &mod.intern_pool);
+        return self.air.typeOfIndex(inst, &zcu.intern_pool);
     }
 };

src/link.zig+1-1

...	@@ -755,7 +755,7 @@ pub const File = struct {	...	@@ -755,7 +755,7 @@ pub const File = struct {
755	const directory = base.emit.root_dir; // Just an alias to make it shorter to type.	755	const directory = base.emit.root_dir; // Just an alias to make it shorter to type.
756	const full_out_path = try directory.join(arena, &[_][]const u8{base.emit.sub_path});	756	const full_out_path = try directory.join(arena, &[_][]const u8{base.emit.sub_path});
757	const full_out_path_z = try arena.dupeZ(u8, full_out_path);	757	const full_out_path_z = try arena.dupeZ(u8, full_out_path);
758	const opt_zcu = comp.module;	758	const opt_zcu = comp.zcu;
759		759
760	// If there is no Zig code to compile, then we should skip flushing the output file	760	// If there is no Zig code to compile, then we should skip flushing the output file
761	// because it will not be part of the linker line anyway.	761	// because it will not be part of the linker line anyway.

src/link/C.zig+2-2

...	@@ -327,7 +327,7 @@ pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !	...	@@ -327,7 +327,7 @@ pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !
327	.variable => \|variable\| variable.init,	327	.variable => \|variable\| variable.init,
328	else => nav.status.resolved.val,	328	else => nav.status.resolved.val,
329	};	329	};
330	if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) return;	330	if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) return;
331		331
332	const gop = try self.navs.getOrPut(gpa, nav_index);	332	const gop = try self.navs.getOrPut(gpa, nav_index);
333	errdefer _ = self.navs.pop();	333	errdefer _ = self.navs.pop();
...	@@ -418,7 +418,7 @@ pub fn flushModule(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:	...	@@ -418,7 +418,7 @@ pub fn flushModule(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
418		418
419	const comp = self.base.comp;	419	const comp = self.base.comp;
420	const gpa = comp.gpa;	420	const gpa = comp.gpa;
421	const zcu = self.base.comp.module.?;	421	const zcu = self.base.comp.zcu.?;
422	const ip = &zcu.intern_pool;	422	const ip = &zcu.intern_pool;
423	const pt: Zcu.PerThread = .{ .zcu = zcu, .tid = tid };	423	const pt: Zcu.PerThread = .{ .zcu = zcu, .tid = tid };
424		424

src/link/Coff.zig+34-36

 @@ -1141,7 +1141,7 @@ pub fn updateFunc(self: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index,
 const LowerConstResult = union(enum) {
     ok: Atom.Index,
-    fail: *Module.ErrorMsg,
+    fail: *Zcu.ErrorMsg,
 };
 fn lowerConst(
 @@ -1151,7 +1151,7 @@ fn lowerConst(
     val: Value,
     required_alignment: InternPool.Alignment,
     sect_id: u16,
-    src_loc: Module.LazySrcLoc,
+    src_loc: Zcu.LazySrcLoc,
 ) !LowerConstResult {
     const gpa = self.base.comp.gpa;
 @@ -1221,7 +1221,7 @@ pub fn updateNav(
         else => nav_val,
     };
-    if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) {
+    if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) {
         const atom_index = try self.getOrCreateAtomForNav(nav_index);
         Atom.freeRelocations(self, atom_index);
         const atom = self.getAtom(atom_index);
 @@ -1259,8 +1259,8 @@ fn updateLazySymbolAtom(
     atom_index: Atom.Index,
     section_index: u16,
 ) !void {
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
     var required_alignment: InternPool.Alignment = .none;
     var code_buffer = std.ArrayList(u8).init(gpa);
 @@ -1275,7 +1275,7 @@ fn updateLazySymbolAtom(
     const atom = self.getAtomPtr(atom_index);
     const local_sym_index = atom.getSymbolIndex().?;
-    const src = Type.fromInterned(sym.ty).srcLocOrNull(mod) orelse Module.LazySrcLoc.unneeded;
+    const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
     const res = try codegen.generateLazySymbol(
         &self.base,
         pt,
 @@ -1354,7 +1354,7 @@ pub fn getOrCreateAtomForNav(self: *Coff, nav_index: InternPool.Nav.Index) !Atom
 }
 fn getNavOutputSection(self: *Coff, nav_index: InternPool.Nav.Index) u16 {
-    const zcu = self.base.comp.module.?;
+    const zcu = self.base.comp.zcu.?;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
     const ty = Type.fromInterned(nav.typeOf(ip));
 @@ -1462,15 +1462,15 @@ pub fn freeNav(self: *Coff, nav_index: InternPool.NavIndex) void {
 pub fn updateExports(
     self: *Coff,
     pt: Zcu.PerThread,
-    exported: Module.Exported,
+    exported: Zcu.Exported,
     export_indices: []const u32,
 ) link.File.UpdateExportsError!void {
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    const mod = pt.zcu;
+    const zcu = pt.zcu;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const comp = self.base.comp;
     const target = comp.root_mod.resolved_target.result;
 @@ -1478,7 +1478,7 @@ pub fn updateExports(
         // Even in the case of LLVM, we need to notice certain exported symbols in order to
         // detect the default subsystem.
         for (export_indices) |export_idx| {
-            const exp = mod.all_exports.items[export_idx];
+            const exp = zcu.all_exports.items[export_idx];
             const exported_nav_index = switch (exp.exported) {
                 .nav => |nav| nav,
                 .uav => continue,
 @@ -1490,20 +1490,20 @@ pub fn updateExports(
                 .x86 => .Stdcall,
                 else => .C,
             };
-            const exported_cc = Type.fromInterned(exported_ty).fnCallingConvention(mod);
+            const exported_cc = Type.fromInterned(exported_ty).fnCallingConvention(zcu);
             if (exported_cc == .C and exp.opts.name.eqlSlice("main", ip) and comp.config.link_libc) {
-                mod.stage1_flags.have_c_main = true;
+                zcu.stage1_flags.have_c_main = true;
             } else if (exported_cc == winapi_cc and target.os.tag == .windows) {
                 if (exp.opts.name.eqlSlice("WinMain", ip)) {
-                    mod.stage1_flags.have_winmain = true;
+                    zcu.stage1_flags.have_winmain = true;
                 } else if (exp.opts.name.eqlSlice("wWinMain", ip)) {
-                    mod.stage1_flags.have_wwinmain = true;
+                    zcu.stage1_flags.have_wwinmain = true;
                 } else if (exp.opts.name.eqlSlice("WinMainCRTStartup", ip)) {
-                    mod.stage1_flags.have_winmain_crt_startup = true;
+                    zcu.stage1_flags.have_winmain_crt_startup = true;
                 } else if (exp.opts.name.eqlSlice("wWinMainCRTStartup", ip)) {
-                    mod.stage1_flags.have_wwinmain_crt_startup = true;
+                    zcu.stage1_flags.have_wwinmain_crt_startup = true;
                 } else if (exp.opts.name.eqlSlice("DllMainCRTStartup", ip)) {
-                    mod.stage1_flags.have_dllmain_crt_startup = true;
+                    zcu.stage1_flags.have_dllmain_crt_startup = true;
                 }
             }
         }
 @@ -1519,15 +1519,15 @@ pub fn updateExports(
             break :blk self.navs.getPtr(nav).?;
         },
         .uav => |uav| self.uavs.getPtr(uav) orelse blk: {
-            const first_exp = mod.all_exports.items[export_indices[0]];
+            const first_exp = zcu.all_exports.items[export_indices[0]];
             const res = try self.lowerUav(pt, uav, .none, first_exp.src);
             switch (res) {
                 .mcv => {},
                 .fail => |em| {
                     // TODO maybe it's enough to return an error here and let Module.processExportsInner
                     // handle the error?
-                    try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);
+                    try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
-                    mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
+                    zcu.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
                     return;
                 },
             }
 @@ -1538,12 +1538,12 @@ pub fn updateExports(
     const atom = self.getAtom(atom_index);
     for (export_indices) |export_idx| {
-        const exp = mod.all_exports.items[export_idx];
+        const exp = zcu.all_exports.items[export_idx];
-        log.debug("adding new export '{}'", .{exp.opts.name.fmt(&mod.intern_pool)});
+        log.debug("adding new export '{}'", .{exp.opts.name.fmt(&zcu.intern_pool)});
-        if (exp.opts.section.toSlice(&mod.intern_pool)) |section_name| {
+        if (exp.opts.section.toSlice(&zcu.intern_pool)) |section_name| {
             if (!mem.eql(u8, section_name, ".text")) {
-                try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
+                try zcu.failed_exports.putNoClobber(gpa, export_idx, try Zcu.ErrorMsg.create(
                     gpa,
                     exp.src,
                     "Unimplemented: ExportOptions.section",
 @@ -1554,7 +1554,7 @@ pub fn updateExports(
         }
         if (exp.opts.linkage == .link_once) {
-            try mod.failed_exports.putNoClobber(gpa, export_idx, try Module.ErrorMsg.create(
+            try zcu.failed_exports.putNoClobber(gpa, export_idx, try Zcu.ErrorMsg.create(
                 gpa,
                 exp.src,
                 "Unimplemented: GlobalLinkage.link_once",
 @@ -1563,7 +1563,7 @@ pub fn updateExports(
             continue;
         }
-        const exp_name = exp.opts.name.toSlice(&mod.intern_pool);
+        const exp_name = exp.opts.name.toSlice(&zcu.intern_pool);
         const sym_index = metadata.getExport(self, exp_name) orelse blk: {
             const sym_index = if (self.getGlobalIndex(exp_name)) |global_index| ind: {
                 const global = self.globals.items[global_index];
 @@ -1609,14 +1609,14 @@ pub fn deleteExport(
         .nav => |nav| self.navs.getPtr(nav),
         .uav => |uav| self.uavs.getPtr(uav),
     } orelse return;
-    const mod = self.base.comp.module.?;
+    const zcu = self.base.comp.zcu.?;
-    const name_slice = name.toSlice(&mod.intern_pool);
+    const name_slice = name.toSlice(&zcu.intern_pool);
     const sym_index = metadata.getExportPtr(self, name_slice) orelse return;
     const gpa = self.base.comp.gpa;
     const sym_loc = SymbolWithLoc{ .sym_index = sym_index.*, .file = null };
     const sym = self.getSymbolPtr(sym_loc);
-    log.debug("deleting export '{}'", .{name.fmt(&mod.intern_pool)});
+    log.debug("deleting export '{}'", .{name.fmt(&zcu.intern_pool)});
     assert(sym.storage_class == .EXTERNAL and sym.section_number != .UNDEFINED);
     sym.* = .{
         .name = [_]u8{0} ** 8,
 @@ -1691,7 +1691,7 @@ pub fn flushModule(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     defer sub_prog_node.end();
     const pt: Zcu.PerThread = .{
-        .zcu = comp.module orelse return error.LinkingWithoutZigSourceUnimplemented,
+        .zcu = comp.zcu orelse return error.LinkingWithoutZigSourceUnimplemented,
         .tid = tid,
     };
 @@ -1843,13 +1843,13 @@ pub fn lowerUav(
     pt: Zcu.PerThread,
     uav: InternPool.Index,
     explicit_alignment: InternPool.Alignment,
-    src_loc: Module.LazySrcLoc,
+    src_loc: Zcu.LazySrcLoc,
 ) !codegen.GenResult {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const val = Value.fromInterned(uav);
     const uav_alignment = switch (explicit_alignment) {
-        .none => val.typeOf(zcu).abiAlignment(pt),
+        .none => val.typeOf(zcu).abiAlignment(zcu),
         else => explicit_alignment,
     };
     if (self.uavs.get(uav)) |metadata| {
 @@ -1872,7 +1872,7 @@ pub fn lowerUav(
         src_loc,
     ) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        else => |e| return .{ .fail = try Module.ErrorMsg.create(
+        else => |e| return .{ .fail = try Zcu.ErrorMsg.create(
             gpa,
             src_loc,
             "lowerAnonDecl failed with error: {s}",
 @@ -2730,8 +2730,6 @@ const ImportTable = @import("Coff/ImportTable.zig");
 const Liveness = @import("../Liveness.zig");
 const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Zcu = @import("../Zcu.zig");
-/// Deprecated.
-const Module = Zcu;
 const InternPool = @import("../InternPool.zig");
 const Object = @import("Coff/Object.zig");
 const Relocation = @import("Coff/Relocation.zig");

src/link/Coff/lld.zig+3-3

src/link/Dwarf.zig+43-43

src/link/Elf.zig+2-2

...	@@ -212,7 +212,7 @@ pub fn createEmpty(	...	@@ -212,7 +212,7 @@ pub fn createEmpty(
212		212
213	const use_lld = build_options.have_llvm and comp.config.use_lld;	213	const use_lld = build_options.have_llvm and comp.config.use_lld;
214	const use_llvm = comp.config.use_llvm;	214	const use_llvm = comp.config.use_llvm;
215	const opt_zcu = comp.module;	215	const opt_zcu = comp.zcu;
216	const output_mode = comp.config.output_mode;	216	const output_mode = comp.config.output_mode;
217	const link_mode = comp.config.link_mode;	217	const link_mode = comp.config.link_mode;
218	const optimize_mode = comp.root_mod.optimize_mode;	218	const optimize_mode = comp.root_mod.optimize_mode;
...	@@ -2084,7 +2084,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s	...	@@ -2084,7 +2084,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
2084		2084
2085	// If there is no Zig code to compile, then we should skip flushing the output file because it	2085	// If there is no Zig code to compile, then we should skip flushing the output file because it
2086	// will not be part of the linker line anyway.	2086	// will not be part of the linker line anyway.
2087	const module_obj_path: ?[]const u8 = if (comp.module != null) blk: {	2087	const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
2088	try self.flushModule(arena, tid, prog_node);	2088	try self.flushModule(arena, tid, prog_node);
2089		2089
2090	if (fs.path.dirname(full_out_path)) \|dirname\| {	2090	if (fs.path.dirname(full_out_path)) \|dirname\| {

src/link/Elf/ZigObject.zig+22-22

src/link/MachO.zig+3-5

...	@@ -164,7 +164,7 @@ pub fn createEmpty(	...	@@ -164,7 +164,7 @@ pub fn createEmpty(
164		164
165	const gpa = comp.gpa;	165	const gpa = comp.gpa;
166	const use_llvm = comp.config.use_llvm;	166	const use_llvm = comp.config.use_llvm;
167	const opt_zcu = comp.module;	167	const opt_zcu = comp.zcu;
168	const optimize_mode = comp.root_mod.optimize_mode;	168	const optimize_mode = comp.root_mod.optimize_mode;
169	const output_mode = comp.config.output_mode;	169	const output_mode = comp.config.output_mode;
170	const link_mode = comp.config.link_mode;	170	const link_mode = comp.config.link_mode;
...	@@ -3026,7 +3026,7 @@ pub fn updateNavLineNumber(self: *MachO, pt: Zcu.PerThread, nav: InternPool.NavI	...	@@ -3026,7 +3026,7 @@ pub fn updateNavLineNumber(self: *MachO, pt: Zcu.PerThread, nav: InternPool.NavI
3026	pub fn updateExports(	3026	pub fn updateExports(
3027	self: *MachO,	3027	self: *MachO,
3028	pt: Zcu.PerThread,	3028	pt: Zcu.PerThread,
3029	exported: Module.Exported,	3029	exported: Zcu.Exported,
3030	export_indices: []const u32,	3030	export_indices: []const u32,
3031	) link.File.UpdateExportsError!void {	3031	) link.File.UpdateExportsError!void {
3032	if (build_options.skip_non_native and builtin.object_format != .macho) {	3032	if (build_options.skip_non_native and builtin.object_format != .macho) {
...	@@ -3060,7 +3060,7 @@ pub fn lowerUav(	...	@@ -3060,7 +3060,7 @@ pub fn lowerUav(
3060	pt: Zcu.PerThread,	3060	pt: Zcu.PerThread,
3061	uav: InternPool.Index,	3061	uav: InternPool.Index,
3062	explicit_alignment: InternPool.Alignment,	3062	explicit_alignment: InternPool.Alignment,
3063	src_loc: Module.LazySrcLoc,	3063	src_loc: Zcu.LazySrcLoc,
3064	) !codegen.GenResult {	3064	) !codegen.GenResult {
3065	return self.getZigObject().?.lowerUav(self, pt, uav, explicit_alignment, src_loc);	3065	return self.getZigObject().?.lowerUav(self, pt, uav, explicit_alignment, src_loc);
3066	}	3066	}
...	@@ -4634,8 +4634,6 @@ const Liveness = @import("../Liveness.zig");	...	@@ -4634,8 +4634,6 @@ const Liveness = @import("../Liveness.zig");
4634	const LlvmObject = @import("../codegen/llvm.zig").Object;	4634	const LlvmObject = @import("../codegen/llvm.zig").Object;
4635	const Md5 = std.crypto.hash.Md5;	4635	const Md5 = std.crypto.hash.Md5;
4636	const Zcu = @import("../Zcu.zig");	4636	const Zcu = @import("../Zcu.zig");
4637	/// Deprecated.
4638	const Module = Zcu;
4639	const InternPool = @import("../InternPool.zig");	4637	const InternPool = @import("../InternPool.zig");
4640	const Rebase = @import("MachO/dyld_info/Rebase.zig");	4638	const Rebase = @import("MachO/dyld_info/Rebase.zig");
4641	pub const Relocation = @import("MachO/Relocation.zig");	4639	pub const Relocation = @import("MachO/Relocation.zig");

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

src/link/Plan9.zig+19-19

src/link/SpirV.zig+1-1

...	@@ -229,7 +229,7 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n	...	@@ -229,7 +229,7 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
229	defer error_info.deinit();	229	defer error_info.deinit();
230		230
231	try error_info.appendSlice("zig_errors:");	231	try error_info.appendSlice("zig_errors:");
232	const ip = &self.base.comp.module.?.intern_pool;	232	const ip = &self.base.comp.zcu.?.intern_pool;
233	for (ip.global_error_set.getNamesFromMainThread()) \|name\| {	233	for (ip.global_error_set.getNamesFromMainThread()) \|name\| {
234	// Errors can contain pretty much any character - to encode them in a string we must escape	234	// Errors can contain pretty much any character - to encode them in a string we must escape
235	// them somehow. Easiest here is to use some established scheme, one which also preseves the	235	// them somehow. Easiest here is to use some established scheme, one which also preseves the

src/link/Wasm.zig+2-2

...	@@ -556,7 +556,7 @@ pub fn createEmpty(	...	@@ -556,7 +556,7 @@ pub fn createEmpty(
556	}	556	}
557	}	557	}
558		558
559	if (comp.module) \|zcu\| {	559	if (comp.zcu) \|zcu\| {
560	if (!use_llvm) {	560	if (!use_llvm) {
561	const index: File.Index = @enumFromInt(wasm.files.len);	561	const index: File.Index = @enumFromInt(wasm.files.len);
562	var zig_object: ZigObject = .{	562	var zig_object: ZigObject = .{
...	@@ -3352,7 +3352,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:	...	@@ -3352,7 +3352,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
3352		3352
3353	// If there is no Zig code to compile, then we should skip flushing the output file because it	3353	// If there is no Zig code to compile, then we should skip flushing the output file because it
3354	// will not be part of the linker line anyway.	3354	// will not be part of the linker line anyway.
3355	const module_obj_path: ?[]const u8 = if (comp.module != null) blk: {	3355	const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
3356	try wasm.flushModule(arena, tid, prog_node);	3356	try wasm.flushModule(arena, tid, prog_node);
3357		3357
3358	if (fs.path.dirname(full_out_path)) \|dirname\| {	3358	if (fs.path.dirname(full_out_path)) \|dirname\| {

src/link/Wasm/ZigObject.zig+18-18

src/mutable_value.zig+5-5

src/print_air.zig+6-6

src/print_value.zig+7-7

src/target.zig+5-1

 @@ -526,7 +526,11 @@ pub fn zigBackend(target: std.Target, use_llvm: bool) std.builtin.CompilerBacken
 pub inline fn backendSupportsFeature(backend: std.builtin.CompilerBackend, comptime feature: Feature) bool {
     return switch (feature) {
         .panic_fn => switch (backend) {
-            .stage2_c, .stage2_llvm, .stage2_x86_64, .stage2_riscv64 => true,
+            .stage2_c,
+            .stage2_llvm,
+            .stage2_x86_64,
+            .stage2_riscv64,
+            => true,
             else => false,
         },
         .panic_unwrap_error => switch (backend) {

...	@@ -32,7 +32,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no	...	@@ -32,7 +32,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
32		32
33	// If there is no Zig code to compile, then we should skip flushing the output file because it	33	// If there is no Zig code to compile, then we should skip flushing the output file because it
34	// will not be part of the linker line anyway.	34	// will not be part of the linker line anyway.
35	const module_obj_path: ?[]const u8 = if (comp.module != null) blk: {	35	const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
36	try self.flushModule(arena, tid, prog_node);	36	try self.flushModule(arena, tid, prog_node);
37		37
38	if (fs.path.dirname(full_out_path)) \|dirname\| {	38	if (fs.path.dirname(full_out_path)) \|dirname\| {
...	@@ -296,7 +296,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no	...	@@ -296,7 +296,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
296	if (self.subsystem) \|explicit\| break :blk explicit;	296	if (self.subsystem) \|explicit\| break :blk explicit;
297	switch (target.os.tag) {	297	switch (target.os.tag) {
298	.windows => {	298	.windows => {
299	if (comp.module) \|module\| {	299	if (comp.zcu) \|module\| {
300	if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)	300	if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
301	break :blk null;	301	break :blk null;
302	if (module.stage1_flags.have_c_main or comp.config.is_test or	302	if (module.stage1_flags.have_c_main or comp.config.is_test or
...	@@ -440,7 +440,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no	...	@@ -440,7 +440,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
440	} else {	440	} else {
441	try argv.append("-NODEFAULTLIB");	441	try argv.append("-NODEFAULTLIB");
442	if (!is_lib and entry_name == null) {	442	if (!is_lib and entry_name == null) {
443	if (comp.module) \|module\| {	443	if (comp.zcu) \|module\| {
444	if (module.stage1_flags.have_winmain_crt_startup) {	444	if (module.stage1_flags.have_winmain_crt_startup) {
445	try argv.append("-ENTRY:WinMainCRTStartup");	445	try argv.append("-ENTRY:WinMainCRTStartup");
446	} else {	446	} else {

...	@@ -128,7 +128,7 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {	...	@@ -128,7 +128,7 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {
128	pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {	128	pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {
129	// Handle any lazy symbols that were emitted by incremental compilation.	129	// Handle any lazy symbols that were emitted by incremental compilation.
130	if (self.lazy_syms.getPtr(.anyerror_type)) \|metadata\| {	130	if (self.lazy_syms.getPtr(.anyerror_type)) \|metadata\| {
131	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.module.?, .tid = tid };	131	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid };
132		132
133	// Most lazy symbols can be updated on first use, but	133	// Most lazy symbols can be updated on first use, but
134	// anyerror needs to wait for everything to be flushed.	134	// anyerror needs to wait for everything to be flushed.
...	@@ -157,7 +157,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi	...	@@ -157,7 +157,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi
157	}	157	}
158		158
159	if (build_options.enable_logging) {	159	if (build_options.enable_logging) {
160	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.module.?, .tid = tid };	160	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid };
161	for (self.navs.keys(), self.navs.values()) \|nav_index, meta\| {	161	for (self.navs.keys(), self.navs.values()) \|nav_index, meta\| {
162	checkNavAllocated(pt, nav_index, meta);	162	checkNavAllocated(pt, nav_index, meta);
163	}	163	}
...	@@ -167,7 +167,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi	...	@@ -167,7 +167,7 @@ pub fn flushModule(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !voi
167	}	167	}
168		168
169	if (self.dwarf) \|*dwarf\| {	169	if (self.dwarf) \|*dwarf\| {
170	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.module.?, .tid = tid };	170	const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid };
171	try dwarf.flushModule(pt);	171	try dwarf.flushModule(pt);
172		172
173	const gpa = elf_file.base.comp.gpa;	173	const gpa = elf_file.base.comp.gpa;
...	@@ -849,7 +849,7 @@ pub fn lowerUav(	...	@@ -849,7 +849,7 @@ pub fn lowerUav(
849	const gpa = zcu.gpa;	849	const gpa = zcu.gpa;
850	const val = Value.fromInterned(uav);	850	const val = Value.fromInterned(uav);
851	const uav_alignment = switch (explicit_alignment) {	851	const uav_alignment = switch (explicit_alignment) {
852	.none => val.typeOf(zcu).abiAlignment(pt),	852	.none => val.typeOf(zcu).abiAlignment(zcu),
853	else => explicit_alignment,	853	else => explicit_alignment,
854	};	854	};
855	if (self.uavs.get(uav)) \|metadata\| {	855	if (self.uavs.get(uav)) \|metadata\| {
...	@@ -949,7 +949,7 @@ pub fn getOrCreateMetadataForNav(	...	@@ -949,7 +949,7 @@ pub fn getOrCreateMetadataForNav(
949	if (!gop.found_existing) {	949	if (!gop.found_existing) {
950	const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;	950	const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;
951	const symbol_index = try self.newSymbolWithAtom(gpa, 0);	951	const symbol_index = try self.newSymbolWithAtom(gpa, 0);
952	const zcu = elf_file.base.comp.module.?;	952	const zcu = elf_file.base.comp.zcu.?;
953	const nav_val = Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.resolved.val);	953	const nav_val = Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.resolved.val);
954	const sym = self.symbol(symbol_index);	954	const sym = self.symbol(symbol_index);
955	if (nav_val.getVariable(zcu)) \|variable\| {	955	if (nav_val.getVariable(zcu)) \|variable\| {
...	@@ -1306,7 +1306,7 @@ pub fn updateNav(	...	@@ -1306,7 +1306,7 @@ pub fn updateNav(
1306	else => nav.status.resolved.val,	1306	else => nav.status.resolved.val,
1307	};	1307	};
1308		1308
1309	if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) {	1309	if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) {
1310	const sym_index = try self.getOrCreateMetadataForNav(elf_file, nav_index);	1310	const sym_index = try self.getOrCreateMetadataForNav(elf_file, nav_index);
1311	self.symbol(sym_index).atom(elf_file).?.freeRelocs(self);	1311	self.symbol(sym_index).atom(elf_file).?.freeRelocs(self);
1312		1312
...	@@ -1382,8 +1382,8 @@ fn updateLazySymbol(	...	@@ -1382,8 +1382,8 @@ fn updateLazySymbol(
1382	sym: link.File.LazySymbol,	1382	sym: link.File.LazySymbol,
1383	symbol_index: Symbol.Index,	1383	symbol_index: Symbol.Index,
1384	) !void {	1384	) !void {
1385	const mod = pt.zcu;	1385	const zcu = pt.zcu;
1386	const gpa = mod.gpa;	1386	const gpa = zcu.gpa;
1387		1387
1388	var required_alignment: InternPool.Alignment = .none;	1388	var required_alignment: InternPool.Alignment = .none;
1389	var code_buffer = std.ArrayList(u8).init(gpa);	1389	var code_buffer = std.ArrayList(u8).init(gpa);
...	@@ -1398,7 +1398,7 @@ fn updateLazySymbol(	...	@@ -1398,7 +1398,7 @@ fn updateLazySymbol(
1398	break :blk try self.strtab.insert(gpa, name);	1398	break :blk try self.strtab.insert(gpa, name);
1399	};	1399	};
1400		1400
1401	const src = Type.fromInterned(sym.ty).srcLocOrNull(mod) orelse Zcu.LazySrcLoc.unneeded;	1401	const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
1402	const res = try codegen.generateLazySymbol(	1402	const res = try codegen.generateLazySymbol(
1403	&elf_file.base,	1403	&elf_file.base,
1404	pt,	1404	pt,
...	@@ -1513,7 +1513,7 @@ pub fn updateExports(	...	@@ -1513,7 +1513,7 @@ pub fn updateExports(
1513	const tracy = trace(@src());	1513	const tracy = trace(@src());
1514	defer tracy.end();	1514	defer tracy.end();
1515		1515
1516	const mod = pt.zcu;	1516	const zcu = pt.zcu;
1517	const gpa = elf_file.base.comp.gpa;	1517	const gpa = elf_file.base.comp.gpa;
1518	const metadata = switch (exported) {	1518	const metadata = switch (exported) {
1519	.nav => \|nav\| blk: {	1519	.nav => \|nav\| blk: {
...	@@ -1521,15 +1521,15 @@ pub fn updateExports(	...	@@ -1521,15 +1521,15 @@ pub fn updateExports(
1521	break :blk self.navs.getPtr(nav).?;	1521	break :blk self.navs.getPtr(nav).?;
1522	},	1522	},
1523	.uav => \|uav\| self.uavs.getPtr(uav) orelse blk: {	1523	.uav => \|uav\| self.uavs.getPtr(uav) orelse blk: {
1524	const first_exp = mod.all_exports.items[export_indices[0]];	1524	const first_exp = zcu.all_exports.items[export_indices[0]];
1525	const res = try self.lowerUav(elf_file, pt, uav, .none, first_exp.src);	1525	const res = try self.lowerUav(elf_file, pt, uav, .none, first_exp.src);
1526	switch (res) {	1526	switch (res) {
1527	.mcv => {},	1527	.mcv => {},
1528	.fail => \|em\| {	1528	.fail => \|em\| {
1529	// TODO maybe it's enough to return an error here and let Zcu.processExportsInner	1529	// TODO maybe it's enough to return an error here and let Zcu.processExportsInner
1530	// handle the error?	1530	// handle the error?
1531	try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);	1531	try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
1532	mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);	1532	zcu.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
1533	return;	1533	return;
1534	},	1534	},
1535	}	1535	}
...	@@ -1542,11 +1542,11 @@ pub fn updateExports(	...	@@ -1542,11 +1542,11 @@ pub fn updateExports(
1542	const esym_shndx = self.symtab.items(.shndx)[esym_index];	1542	const esym_shndx = self.symtab.items(.shndx)[esym_index];
1543		1543
1544	for (export_indices) \|export_idx\| {	1544	for (export_indices) \|export_idx\| {
1545	const exp = mod.all_exports.items[export_idx];	1545	const exp = zcu.all_exports.items[export_idx];
1546	if (exp.opts.section.unwrap()) \|section_name\| {	1546	if (exp.opts.section.unwrap()) \|section_name\| {
1547	if (!section_name.eqlSlice(".text", &mod.intern_pool)) {	1547	if (!section_name.eqlSlice(".text", &zcu.intern_pool)) {
1548	try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);	1548	try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
1549	mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(	1549	zcu.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(
1550	gpa,	1550	gpa,
1551	exp.src,	1551	exp.src,
1552	"Unimplemented: ExportOptions.section",	1552	"Unimplemented: ExportOptions.section",
...	@@ -1560,8 +1560,8 @@ pub fn updateExports(	...	@@ -1560,8 +1560,8 @@ pub fn updateExports(
1560	.strong => elf.STB_GLOBAL,	1560	.strong => elf.STB_GLOBAL,
1561	.weak => elf.STB_WEAK,	1561	.weak => elf.STB_WEAK,
1562	.link_once => {	1562	.link_once => {
1563	try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);	1563	try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
1564	mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(	1564	zcu.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(
1565	gpa,	1565	gpa,
1566	exp.src,	1566	exp.src,
1567	"Unimplemented: GlobalLinkage.LinkOnce",	1567	"Unimplemented: GlobalLinkage.LinkOnce",
...	@@ -1571,7 +1571,7 @@ pub fn updateExports(	...	@@ -1571,7 +1571,7 @@ pub fn updateExports(
1571	},	1571	},
1572	};	1572	};
1573	const stt_bits: u8 = @as(u4, @truncate(esym.st_info));	1573	const stt_bits: u8 = @as(u4, @truncate(esym.st_info));
1574	const exp_name = exp.opts.name.toSlice(&mod.intern_pool);	1574	const exp_name = exp.opts.name.toSlice(&zcu.intern_pool);
1575	const name_off = try self.strtab.insert(gpa, exp_name);	1575	const name_off = try self.strtab.insert(gpa, exp_name);
1576	const global_sym_index = if (metadata.@"export"(self, exp_name)) \|exp_index\|	1576	const global_sym_index = if (metadata.@"export"(self, exp_name)) \|exp_index\|
1577	exp_index.*	1577	exp_index.*
...	@@ -1626,8 +1626,8 @@ pub fn deleteExport(	...	@@ -1626,8 +1626,8 @@ pub fn deleteExport(
1626	.nav => \|nav\| self.navs.getPtr(nav),	1626	.nav => \|nav\| self.navs.getPtr(nav),
1627	.uav => \|uav\| self.uavs.getPtr(uav),	1627	.uav => \|uav\| self.uavs.getPtr(uav),
1628	} orelse return;	1628	} orelse return;
1629	const mod = elf_file.base.comp.module.?;	1629	const zcu = elf_file.base.comp.zcu.?;
1630	const exp_name = name.toSlice(&mod.intern_pool);	1630	const exp_name = name.toSlice(&zcu.intern_pool);
1631	const esym_index = metadata.@"export"(self, exp_name) orelse return;	1631	const esym_index = metadata.@"export"(self, exp_name) orelse return;
1632	log.debug("deleting export '{s}'", .{exp_name});	1632	log.debug("deleting export '{s}'", .{exp_name});
1633	const esym = &self.symtab.items(.elf_sym)[esym_index.*];	1633	const esym = &self.symtab.items(.elf_sym)[esym_index.*];

...	@@ -566,7 +566,7 @@ pub fn getInputSection(self: ZigObject, atom: Atom, macho_file: *MachO) macho.se	...	@@ -566,7 +566,7 @@ pub fn getInputSection(self: ZigObject, atom: Atom, macho_file: *MachO) macho.se
566	pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id) !void {	566	pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id) !void {
567	// Handle any lazy symbols that were emitted by incremental compilation.	567	// Handle any lazy symbols that were emitted by incremental compilation.
568	if (self.lazy_syms.getPtr(.anyerror_type)) \|metadata\| {	568	if (self.lazy_syms.getPtr(.anyerror_type)) \|metadata\| {
569	const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.module.?, .tid = tid };	569	const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.zcu.?, .tid = tid };
570		570
571	// Most lazy symbols can be updated on first use, but	571	// Most lazy symbols can be updated on first use, but
572	// anyerror needs to wait for everything to be flushed.	572	// anyerror needs to wait for everything to be flushed.
...	@@ -595,7 +595,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)	...	@@ -595,7 +595,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)
595	}	595	}
596		596
597	if (self.dwarf) \|*dwarf\| {	597	if (self.dwarf) \|*dwarf\| {
598	const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.module.?, .tid = tid };	598	const pt: Zcu.PerThread = .{ .zcu = macho_file.base.comp.zcu.?, .tid = tid };
599	try dwarf.flushModule(pt);	599	try dwarf.flushModule(pt);
600		600
601	self.debug_abbrev_dirty = false;	601	self.debug_abbrev_dirty = false;
...	@@ -688,7 +688,7 @@ pub fn lowerUav(	...	@@ -688,7 +688,7 @@ pub fn lowerUav(
688	const gpa = zcu.gpa;	688	const gpa = zcu.gpa;
689	const val = Value.fromInterned(uav);	689	const val = Value.fromInterned(uav);
690	const uav_alignment = switch (explicit_alignment) {	690	const uav_alignment = switch (explicit_alignment) {
691	.none => val.typeOf(zcu).abiAlignment(pt),	691	.none => val.typeOf(zcu).abiAlignment(zcu),
692	else => explicit_alignment,	692	else => explicit_alignment,
693	};	693	};
694	if (self.uavs.get(uav)) \|metadata\| {	694	if (self.uavs.get(uav)) \|metadata\| {
...	@@ -887,7 +887,7 @@ pub fn updateNav(	...	@@ -887,7 +887,7 @@ pub fn updateNav(
887	else => nav.status.resolved.val,	887	else => nav.status.resolved.val,
888	};	888	};
889		889
890	if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(pt)) {	890	if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) {
891	const sym_index = try self.getOrCreateMetadataForNav(macho_file, nav_index);	891	const sym_index = try self.getOrCreateMetadataForNav(macho_file, nav_index);
892	self.symbols.items[sym_index].getAtom(macho_file).?.freeRelocs(macho_file);	892	self.symbols.items[sym_index].getAtom(macho_file).?.freeRelocs(macho_file);
893		893
...	@@ -1256,7 +1256,7 @@ pub fn updateExports(	...	@@ -1256,7 +1256,7 @@ pub fn updateExports(
1256	const tracy = trace(@src());	1256	const tracy = trace(@src());
1257	defer tracy.end();	1257	defer tracy.end();
1258		1258
1259	const mod = pt.zcu;	1259	const zcu = pt.zcu;
1260	const gpa = macho_file.base.comp.gpa;	1260	const gpa = macho_file.base.comp.gpa;
1261	const metadata = switch (exported) {	1261	const metadata = switch (exported) {
1262	.nav => \|nav\| blk: {	1262	.nav => \|nav\| blk: {
...	@@ -1264,15 +1264,15 @@ pub fn updateExports(	...	@@ -1264,15 +1264,15 @@ pub fn updateExports(
1264	break :blk self.navs.getPtr(nav).?;	1264	break :blk self.navs.getPtr(nav).?;
1265	},	1265	},
1266	.uav => \|uav\| self.uavs.getPtr(uav) orelse blk: {	1266	.uav => \|uav\| self.uavs.getPtr(uav) orelse blk: {
1267	const first_exp = mod.all_exports.items[export_indices[0]];	1267	const first_exp = zcu.all_exports.items[export_indices[0]];
1268	const res = try self.lowerUav(macho_file, pt, uav, .none, first_exp.src);	1268	const res = try self.lowerUav(macho_file, pt, uav, .none, first_exp.src);
1269	switch (res) {	1269	switch (res) {
1270	.mcv => {},	1270	.mcv => {},
1271	.fail => \|em\| {	1271	.fail => \|em\| {
1272	// TODO maybe it's enough to return an error here and let Zcu.processExportsInner	1272	// TODO maybe it's enough to return an error here and let Zcu.processExportsInner
1273	// handle the error?	1273	// handle the error?
1274	try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);	1274	try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
1275	mod.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);	1275	zcu.failed_exports.putAssumeCapacityNoClobber(export_indices[0], em);
1276	return;	1276	return;
1277	},	1277	},
1278	}	1278	}
...	@@ -1284,11 +1284,11 @@ pub fn updateExports(	...	@@ -1284,11 +1284,11 @@ pub fn updateExports(
1284	const nlist = self.symtab.items(.nlist)[nlist_idx];	1284	const nlist = self.symtab.items(.nlist)[nlist_idx];
1285		1285
1286	for (export_indices) \|export_idx\| {	1286	for (export_indices) \|export_idx\| {
1287	const exp = mod.all_exports.items[export_idx];	1287	const exp = zcu.all_exports.items[export_idx];
1288	if (exp.opts.section.unwrap()) \|section_name\| {	1288	if (exp.opts.section.unwrap()) \|section_name\| {
1289	if (!section_name.eqlSlice("__text", &mod.intern_pool)) {	1289	if (!section_name.eqlSlice("__text", &zcu.intern_pool)) {
1290	try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);	1290	try zcu.failed_exports.ensureUnusedCapacity(zcu.gpa, 1);
1291	mod.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(	1291	zcu.failed_exports.putAssumeCapacityNoClobber(export_idx, try Zcu.ErrorMsg.create(
1292	gpa,	1292	gpa,
1293	exp.src,	1293	exp.src,
1294	"Unimplemented: ExportOptions.section",	1294	"Unimplemented: ExportOptions.section",
...	@@ -1298,7 +1298,7 @@ pub fn updateExports(	...	@@ -1298,7 +1298,7 @@ pub fn updateExports(
1298	}	1298	}
1299	}	1299	}
1300	if (exp.opts.linkage == .link_once) {	1300	if (exp.opts.linkage == .link_once) {
1301	try mod.failed_exports.putNoClobber(mod.gpa, export_idx, try Zcu.ErrorMsg.create(	1301	try zcu.failed_exports.putNoClobber(zcu.gpa, export_idx, try Zcu.ErrorMsg.create(
1302	gpa,	1302	gpa,
1303	exp.src,	1303	exp.src,
1304	"Unimplemented: GlobalLinkage.link_once",	1304	"Unimplemented: GlobalLinkage.link_once",
...	@@ -1307,7 +1307,7 @@ pub fn updateExports(	...	@@ -1307,7 +1307,7 @@ pub fn updateExports(
1307	continue;	1307	continue;
1308	}	1308	}
1309		1309
1310	const exp_name = exp.opts.name.toSlice(&mod.intern_pool);	1310	const exp_name = exp.opts.name.toSlice(&zcu.intern_pool);
1311	const global_nlist_index = if (metadata.@"export"(self, exp_name)) \|exp_index\|	1311	const global_nlist_index = if (metadata.@"export"(self, exp_name)) \|exp_index\|
1312	exp_index.*	1312	exp_index.*
1313	else blk: {	1313	else blk: {
...	@@ -1437,15 +1437,15 @@ pub fn deleteExport(	...	@@ -1437,15 +1437,15 @@ pub fn deleteExport(
1437	exported: Zcu.Exported,	1437	exported: Zcu.Exported,
1438	name: InternPool.NullTerminatedString,	1438	name: InternPool.NullTerminatedString,
1439	) void {	1439	) void {
1440	const mod = macho_file.base.comp.module.?;	1440	const zcu = macho_file.base.comp.zcu.?;
1441		1441
1442	const metadata = switch (exported) {	1442	const metadata = switch (exported) {
1443	.nav => \|nav\| self.navs.getPtr(nav),	1443	.nav => \|nav\| self.navs.getPtr(nav),
1444	.uav => \|uav\| self.uavs.getPtr(uav),	1444	.uav => \|uav\| self.uavs.getPtr(uav),
1445	} orelse return;	1445	} orelse return;
1446	const nlist_index = metadata.@"export"(self, name.toSlice(&mod.intern_pool)) orelse return;	1446	const nlist_index = metadata.@"export"(self, name.toSlice(&zcu.intern_pool)) orelse return;
1447		1447
1448	log.debug("deleting export '{}'", .{name.fmt(&mod.intern_pool)});	1448	log.debug("deleting export '{}'", .{name.fmt(&zcu.intern_pool)});
1449		1449
1450	const nlist = &self.symtab.items(.nlist)[nlist_index.*];	1450	const nlist = &self.symtab.items(.nlist)[nlist_index.*];
1451	self.symtab.items(.size)[nlist_index.*] = 0;	1451	self.symtab.items(.size)[nlist_index.*] = 0;
...	@@ -1545,7 +1545,7 @@ pub fn getOrCreateMetadataForLazySymbol(	...	@@ -1545,7 +1545,7 @@ pub fn getOrCreateMetadataForLazySymbol(
1545	fn isThreadlocal(macho_file: *MachO, nav_index: InternPool.Nav.Index) bool {	1545	fn isThreadlocal(macho_file: *MachO, nav_index: InternPool.Nav.Index) bool {
1546	if (!macho_file.base.comp.config.any_non_single_threaded)	1546	if (!macho_file.base.comp.config.any_non_single_threaded)
1547	return false;	1547	return false;
1548	const ip = &macho_file.base.comp.module.?.intern_pool;	1548	const ip = &macho_file.base.comp.zcu.?.intern_pool;
1549	return switch (ip.indexToKey(ip.getNav(nav_index).status.resolved.val)) {	1549	return switch (ip.indexToKey(ip.getNav(nav_index).status.resolved.val)) {
1550	.variable => \|variable\| variable.is_threadlocal,	1550	.variable => \|variable\| variable.is_threadlocal,
1551	.@"extern" => \|@"extern"\| @"extern".is_threadlocal,	1551	.@"extern" => \|@"extern"\| @"extern".is_threadlocal,

...	@@ -152,7 +152,7 @@ pub const Atom = struct {	...	@@ -152,7 +152,7 @@ pub const Atom = struct {
152	return .{ .code_ptr = slice.ptr, .other = .{ .code_len = slice.len } };	152	return .{ .code_ptr = slice.ptr, .other = .{ .code_len = slice.len } };
153	}	153	}
154	fn getCode(self: CodePtr, plan9: *const Plan9) []u8 {	154	fn getCode(self: CodePtr, plan9: *const Plan9) []u8 {
155	const zcu = plan9.base.comp.module.?;	155	const zcu = plan9.base.comp.zcu.?;
156	const ip = &zcu.intern_pool;	156	const ip = &zcu.intern_pool;
157	return if (self.code_ptr) \|p\| p[0..self.other.code_len] else blk: {	157	return if (self.code_ptr) \|p\| p[0..self.other.code_len] else blk: {
158	const nav_index = self.other.nav_index;	158	const nav_index = self.other.nav_index;
...	@@ -317,8 +317,8 @@ pub fn createEmpty(	...	@@ -317,8 +317,8 @@ pub fn createEmpty(
317		317
318	fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void {	318	fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void {
319	const gpa = self.base.comp.gpa;	319	const gpa = self.base.comp.gpa;
320	const mod = self.base.comp.module.?;	320	const zcu = self.base.comp.zcu.?;
321	const file_scope = mod.navFileScopeIndex(nav_index);	321	const file_scope = zcu.navFileScopeIndex(nav_index);
322	const fn_map_res = try self.fn_nav_table.getOrPut(gpa, file_scope);	322	const fn_map_res = try self.fn_nav_table.getOrPut(gpa, file_scope);
323	if (fn_map_res.found_existing) {	323	if (fn_map_res.found_existing) {
324	if (try fn_map_res.value_ptr.functions.fetchPut(gpa, nav_index, out)) \|old_entry\| {	324	if (try fn_map_res.value_ptr.functions.fetchPut(gpa, nav_index, out)) \|old_entry\| {
...	@@ -326,7 +326,7 @@ fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void	...	@@ -326,7 +326,7 @@ fn putFn(self: *Plan9, nav_index: InternPool.Nav.Index, out: FnNavOutput) !void
326	gpa.free(old_entry.value.lineinfo);	326	gpa.free(old_entry.value.lineinfo);
327	}	327	}
328	} else {	328	} else {
329	const file = mod.fileByIndex(file_scope);	329	const file = zcu.fileByIndex(file_scope);
330	const arena = self.path_arena.allocator();	330	const arena = self.path_arena.allocator();
331	// each file gets a symbol	331	// each file gets a symbol
332	fn_map_res.value_ptr.* = .{	332	fn_map_res.value_ptr.* = .{
...	@@ -391,10 +391,10 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,	...	@@ -391,10 +391,10 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,
391	@panic("Attempted to compile for object format that was disabled by build configuration");	391	@panic("Attempted to compile for object format that was disabled by build configuration");
392	}	392	}
393		393
394	const mod = pt.zcu;	394	const zcu = pt.zcu;
395	const gpa = mod.gpa;	395	const gpa = zcu.gpa;
396	const target = self.base.comp.root_mod.resolved_target.result;	396	const target = self.base.comp.root_mod.resolved_target.result;
397	const func = mod.funcInfo(func_index);	397	const func = zcu.funcInfo(func_index);
398		398
399	const atom_idx = try self.seeNav(pt, func.owner_nav);	399	const atom_idx = try self.seeNav(pt, func.owner_nav);
400		400
...	@@ -413,7 +413,7 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,	...	@@ -413,7 +413,7 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,
413	const res = try codegen.generateFunction(	413	const res = try codegen.generateFunction(
414	&self.base,	414	&self.base,
415	pt,	415	pt,
416	mod.navSrcLoc(func.owner_nav),	416	zcu.navSrcLoc(func.owner_nav),
417	func_index,	417	func_index,
418	air,	418	air,
419	liveness,	419	liveness,
...	@@ -423,7 +423,7 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,	...	@@ -423,7 +423,7 @@ pub fn updateFunc(self: *Plan9, pt: Zcu.PerThread, func_index: InternPool.Index,
423	const code = switch (res) {	423	const code = switch (res) {
424	.ok => try code_buffer.toOwnedSlice(),	424	.ok => try code_buffer.toOwnedSlice(),
425	.fail => \|em\| {	425	.fail => \|em\| {
426	try mod.failed_codegen.put(gpa, func.owner_nav, em);	426	try zcu.failed_codegen.put(gpa, func.owner_nav, em);
427	return;	427	return;
428	},	428	},
429	};	429	};
...	@@ -457,7 +457,7 @@ pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde	...	@@ -457,7 +457,7 @@ pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde
457	else => nav_val,	457	else => nav_val,
458	};	458	};
459		459
460	if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) {	460	if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) {
461	const atom_idx = try self.seeNav(pt, nav_index);	461	const atom_idx = try self.seeNav(pt, nav_index);
462		462
463	var code_buffer = std.ArrayList(u8).init(gpa);	463	var code_buffer = std.ArrayList(u8).init(gpa);
...	@@ -607,7 +607,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, tid: Zcu.PerThread.Id, prog_n	...	@@ -607,7 +607,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
607	defer assert(self.hdr.entry != 0x0);	607	defer assert(self.hdr.entry != 0x0);
608		608
609	const pt: Zcu.PerThread = .{	609	const pt: Zcu.PerThread = .{
610	.zcu = self.base.comp.module orelse return error.LinkingWithoutZigSourceUnimplemented,	610	.zcu = self.base.comp.zcu orelse return error.LinkingWithoutZigSourceUnimplemented,
611	.tid = tid,	611	.tid = tid,
612	};	612	};
613		613
...	@@ -952,11 +952,11 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {	...	@@ -952,11 +952,11 @@ pub fn freeDecl(self: *Plan9, decl_index: InternPool.DeclIndex) void {
952	const gpa = self.base.comp.gpa;	952	const gpa = self.base.comp.gpa;
953	// TODO audit the lifetimes of decls table entries. It's possible to get	953	// TODO audit the lifetimes of decls table entries. It's possible to get
954	// freeDecl without any updateDecl in between.	954	// freeDecl without any updateDecl in between.
955	const mod = self.base.comp.module.?;	955	const zcu = self.base.comp.zcu.?;
956	const decl = mod.declPtr(decl_index);	956	const decl = zcu.declPtr(decl_index);
957	const is_fn = decl.val.isFuncBody(mod);	957	const is_fn = decl.val.isFuncBody(zcu);
958	if (is_fn) {	958	if (is_fn) {
959	const symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(mod)).?;	959	const symidx_and_submap = self.fn_decl_table.get(decl.getFileScope(zcu)).?;
960	var submap = symidx_and_submap.functions;	960	var submap = symidx_and_submap.functions;
961	if (submap.fetchSwapRemove(decl_index)) \|removed_entry\| {	961	if (submap.fetchSwapRemove(decl_index)) \|removed_entry\| {
962	gpa.free(removed_entry.value.code);	962	gpa.free(removed_entry.value.code);
...	@@ -1256,8 +1256,8 @@ pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void {	...	@@ -1256,8 +1256,8 @@ pub fn writeSym(self: *Plan9, w: anytype, sym: aout.Sym) !void {
1256	}	1256	}
1257		1257
1258	pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {	1258	pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {
1259	const mod = self.base.comp.module.?;	1259	const zcu = self.base.comp.zcu.?;
1260	const ip = &mod.intern_pool;	1260	const ip = &zcu.intern_pool;
1261	const writer = buf.writer();	1261	const writer = buf.writer();
1262	// write __GOT	1262	// write __GOT
1263	try self.writeSym(writer, self.syms.items[0]);	1263	try self.writeSym(writer, self.syms.items[0]);
...	@@ -1284,7 +1284,7 @@ pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {	...	@@ -1284,7 +1284,7 @@ pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {
1284	try self.writeSym(writer, sym);	1284	try self.writeSym(writer, sym);
1285	if (self.nav_exports.get(nav_index)) \|export_indices\| {	1285	if (self.nav_exports.get(nav_index)) \|export_indices\| {
1286	for (export_indices) \|export_idx\| {	1286	for (export_indices) \|export_idx\| {
1287	const exp = mod.all_exports.items[export_idx];	1287	const exp = zcu.all_exports.items[export_idx];
1288	if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) \|exp_i\| {	1288	if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) \|exp_i\| {
1289	try self.writeSym(writer, self.syms.items[exp_i]);	1289	try self.writeSym(writer, self.syms.items[exp_i]);
1290	}	1290	}
...	@@ -1323,7 +1323,7 @@ pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {	...	@@ -1323,7 +1323,7 @@ pub fn writeSyms(self: Plan9, buf: std.ArrayList(u8)) !void {
1323	try self.writeSym(writer, sym);	1323	try self.writeSym(writer, sym);
1324	if (self.nav_exports.get(nav_index)) \|export_indices\| {	1324	if (self.nav_exports.get(nav_index)) \|export_indices\| {
1325	for (export_indices) \|export_idx\| {	1325	for (export_indices) \|export_idx\| {
1326	const exp = mod.all_exports.items[export_idx];	1326	const exp = zcu.all_exports.items[export_idx];
1327	if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) \|exp_i\| {	1327	if (nav_metadata.getExport(self, exp.opts.name.toSlice(ip))) \|exp_i\| {
1328	const s = self.syms.items[exp_i];	1328	const s = self.syms.items[exp_i];
1329	if (mem.eql(u8, s.name, "_start"))	1329	if (mem.eql(u8, s.name, "_start"))

...	@@ -259,7 +259,7 @@ pub fn updateNav(	...	@@ -259,7 +259,7 @@ pub fn updateNav(
259	else => .{ false, .none, nav_val },	259	else => .{ false, .none, nav_val },
260	};	260	};
261		261
262	if (nav_init.typeOf(zcu).hasRuntimeBits(pt)) {	262	if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) {
263	const gpa = wasm_file.base.comp.gpa;	263	const gpa = wasm_file.base.comp.gpa;
264	const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index);	264	const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index);
265	const atom = wasm_file.getAtomPtr(atom_index);	265	const atom = wasm_file.getAtomPtr(atom_index);
...	@@ -487,9 +487,9 @@ fn lowerConst(	...	@@ -487,9 +487,9 @@ fn lowerConst(
487	src_loc: Zcu.LazySrcLoc,	487	src_loc: Zcu.LazySrcLoc,
488	) !LowerConstResult {	488	) !LowerConstResult {
489	const gpa = wasm_file.base.comp.gpa;	489	const gpa = wasm_file.base.comp.gpa;
490	const mod = wasm_file.base.comp.module.?;	490	const zcu = wasm_file.base.comp.zcu.?;
491		491
492	const ty = val.typeOf(mod);	492	const ty = val.typeOf(zcu);
493		493
494	// Create and initialize a new local symbol and atom	494	// Create and initialize a new local symbol and atom
495	const sym_index = try zig_object.allocateSymbol(gpa);	495	const sym_index = try zig_object.allocateSymbol(gpa);
...	@@ -499,7 +499,7 @@ fn lowerConst(	...	@@ -499,7 +499,7 @@ fn lowerConst(
499		499
500	const code = code: {	500	const code = code: {
501	const atom = wasm_file.getAtomPtr(atom_index);	501	const atom = wasm_file.getAtomPtr(atom_index);
502	atom.alignment = ty.abiAlignment(pt);	502	atom.alignment = ty.abiAlignment(zcu);
503	const segment_name = try std.mem.concat(gpa, u8, &.{ ".rodata.", name });	503	const segment_name = try std.mem.concat(gpa, u8, &.{ ".rodata.", name });
504	errdefer gpa.free(segment_name);	504	errdefer gpa.free(segment_name);
505	zig_object.symbol(sym_index).* = .{	505	zig_object.symbol(sym_index).* = .{
...	@@ -509,7 +509,7 @@ fn lowerConst(	...	@@ -509,7 +509,7 @@ fn lowerConst(
509	.index = try zig_object.createDataSegment(	509	.index = try zig_object.createDataSegment(
510	gpa,	510	gpa,
511	segment_name,	511	segment_name,
512	ty.abiAlignment(pt),	512	ty.abiAlignment(zcu),
513	),	513	),
514	.virtual_address = undefined,	514	.virtual_address = undefined,
515	};	515	};
...	@@ -555,7 +555,7 @@ pub fn getErrorTableSymbol(zig_object: ZigObject, wasm_file: Wasm, pt: Zcu.Per	...	@@ -555,7 +555,7 @@ pub fn getErrorTableSymbol(zig_object: ZigObject, wasm_file: Wasm, pt: Zcu.Per
555	const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);	555	const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);
556	const atom = wasm_file.getAtomPtr(atom_index);	556	const atom = wasm_file.getAtomPtr(atom_index);
557	const slice_ty = Type.slice_const_u8_sentinel_0;	557	const slice_ty = Type.slice_const_u8_sentinel_0;
558	atom.alignment = slice_ty.abiAlignment(pt);	558	atom.alignment = slice_ty.abiAlignment(pt.zcu);
559		559
560	const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_name_table");	560	const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_name_table");
561	const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_name_table");	561	const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_name_table");
...	@@ -604,14 +604,14 @@ fn populateErrorNameTable(zig_object: ZigObject, wasm_file: Wasm, tid: Zcu.Per	...	@@ -604,14 +604,14 @@ fn populateErrorNameTable(zig_object: ZigObject, wasm_file: Wasm, tid: Zcu.Per
604		604
605	// Addend for each relocation to the table	605	// Addend for each relocation to the table
606	var addend: u32 = 0;	606	var addend: u32 = 0;
607	const pt: Zcu.PerThread = .{ .zcu = wasm_file.base.comp.module.?, .tid = tid };	607	const pt: Zcu.PerThread = .{ .zcu = wasm_file.base.comp.zcu.?, .tid = tid };
608	const slice_ty = Type.slice_const_u8_sentinel_0;	608	const slice_ty = Type.slice_const_u8_sentinel_0;
609	const atom = wasm_file.getAtomPtr(atom_index);	609	const atom = wasm_file.getAtomPtr(atom_index);
610	{	610	{
611	// TODO: remove this unreachable entry	611	// TODO: remove this unreachable entry
612	try atom.code.appendNTimes(gpa, 0, 4);	612	try atom.code.appendNTimes(gpa, 0, 4);
613	try atom.code.writer(gpa).writeInt(u32, 0, .little);	613	try atom.code.writer(gpa).writeInt(u32, 0, .little);
614	atom.size += @intCast(slice_ty.abiSize(pt));	614	atom.size += @intCast(slice_ty.abiSize(pt.zcu));
615	addend += 1;	615	addend += 1;
616		616
617	try names_atom.code.append(gpa, 0);	617	try names_atom.code.append(gpa, 0);
...	@@ -632,7 +632,7 @@ fn populateErrorNameTable(zig_object: ZigObject, wasm_file: Wasm, tid: Zcu.Per	...	@@ -632,7 +632,7 @@ fn populateErrorNameTable(zig_object: ZigObject, wasm_file: Wasm, tid: Zcu.Per
632	.offset = offset,	632	.offset = offset,
633	.addend = @intCast(addend),	633	.addend = @intCast(addend),
634	});	634	});
635	atom.size += @intCast(slice_ty.abiSize(pt));	635	atom.size += @intCast(slice_ty.abiSize(pt.zcu));
636	addend += len;	636	addend += len;
637		637
638	// as we updated the error name table, we now store the actual name within the names atom	638	// as we updated the error name table, we now store the actual name within the names atom
...	@@ -803,9 +803,9 @@ pub fn getUavVAddr(	...	@@ -803,9 +803,9 @@ pub fn getUavVAddr(
803	const parent_atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = @enumFromInt(reloc_info.parent_atom_index) }).?;	803	const parent_atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = @enumFromInt(reloc_info.parent_atom_index) }).?;
804	const parent_atom = wasm_file.getAtomPtr(parent_atom_index);	804	const parent_atom = wasm_file.getAtomPtr(parent_atom_index);
805	const is_wasm32 = target.cpu.arch == .wasm32;	805	const is_wasm32 = target.cpu.arch == .wasm32;
806	const mod = wasm_file.base.comp.module.?;	806	const zcu = wasm_file.base.comp.zcu.?;
807	const ty = Type.fromInterned(mod.intern_pool.typeOf(uav));	807	const ty = Type.fromInterned(zcu.intern_pool.typeOf(uav));
808	if (ty.zigTypeTag(mod) == .Fn) {	808	if (ty.zigTypeTag(zcu) == .Fn) {
809	std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations	809	std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations
810	try parent_atom.relocs.append(gpa, .{	810	try parent_atom.relocs.append(gpa, .{
811	.index = target_symbol_index,	811	.index = target_symbol_index,
...	@@ -834,13 +834,13 @@ pub fn deleteExport(	...	@@ -834,13 +834,13 @@ pub fn deleteExport(
834	exported: Zcu.Exported,	834	exported: Zcu.Exported,
835	name: InternPool.NullTerminatedString,	835	name: InternPool.NullTerminatedString,
836	) void {	836	) void {
837	const mod = wasm_file.base.comp.module.?;	837	const zcu = wasm_file.base.comp.zcu.?;
838	const nav_index = switch (exported) {	838	const nav_index = switch (exported) {
839	.nav => \|nav_index\| nav_index,	839	.nav => \|nav_index\| nav_index,
840	.uav => @panic("TODO: implement Wasm linker code for exporting a constant value"),	840	.uav => @panic("TODO: implement Wasm linker code for exporting a constant value"),
841	};	841	};
842	const nav_info = zig_object.navs.getPtr(nav_index) orelse return;	842	const nav_info = zig_object.navs.getPtr(nav_index) orelse return;
843	if (nav_info.@"export"(zig_object, name.toSlice(&mod.intern_pool))) \|sym_index\| {	843	if (nav_info.@"export"(zig_object, name.toSlice(&zcu.intern_pool))) \|sym_index\| {
844	const sym = zig_object.symbol(sym_index);	844	const sym = zig_object.symbol(sym_index);
845	nav_info.deleteExport(sym_index);	845	nav_info.deleteExport(sym_index);
846	std.debug.assert(zig_object.global_syms.remove(sym.name));	846	std.debug.assert(zig_object.global_syms.remove(sym.name));
...	@@ -930,8 +930,8 @@ pub fn updateExports(	...	@@ -930,8 +930,8 @@ pub fn updateExports(
930		930
931	pub fn freeNav(zig_object: ZigObject, wasm_file: Wasm, nav_index: InternPool.Nav.Index) void {	931	pub fn freeNav(zig_object: ZigObject, wasm_file: Wasm, nav_index: InternPool.Nav.Index) void {
932	const gpa = wasm_file.base.comp.gpa;	932	const gpa = wasm_file.base.comp.gpa;
933	const mod = wasm_file.base.comp.module.?;	933	const zcu = wasm_file.base.comp.zcu.?;
934	const ip = &mod.intern_pool;	934	const ip = &zcu.intern_pool;
935	const nav_info = zig_object.navs.getPtr(nav_index).?;	935	const nav_info = zig_object.navs.getPtr(nav_index).?;
936	const atom_index = nav_info.atom;	936	const atom_index = nav_info.atom;
937	const atom = wasm_file.getAtomPtr(atom_index);	937	const atom = wasm_file.getAtomPtr(atom_index);
...	@@ -956,7 +956,7 @@ pub fn freeNav(zig_object: ZigObject, wasm_file: Wasm, nav_index: InternPool.N	...	@@ -956,7 +956,7 @@ pub fn freeNav(zig_object: ZigObject, wasm_file: Wasm, nav_index: InternPool.N
956	segment.name = &.{}; // Ensure no accidental double free	956	segment.name = &.{}; // Ensure no accidental double free
957	}	957	}
958		958
959	const nav_val = mod.navValue(nav_index).toIntern();	959	const nav_val = zcu.navValue(nav_index).toIntern();
960	if (ip.indexToKey(nav_val) == .@"extern") {	960	if (ip.indexToKey(nav_val) == .@"extern") {
961	std.debug.assert(zig_object.imports.remove(atom.sym_index));	961	std.debug.assert(zig_object.imports.remove(atom.sym_index));
962	}	962	}
...	@@ -1016,7 +1016,7 @@ fn setupErrorsLen(zig_object: ZigObject, wasm_file: Wasm) !void {	...	@@ -1016,7 +1016,7 @@ fn setupErrorsLen(zig_object: ZigObject, wasm_file: Wasm) !void {
1016	const gpa = wasm_file.base.comp.gpa;	1016	const gpa = wasm_file.base.comp.gpa;
1017	const sym_index = zig_object.findGlobalSymbol("__zig_errors_len") orelse return;	1017	const sym_index = zig_object.findGlobalSymbol("__zig_errors_len") orelse return;
1018		1018
1019	const errors_len = 1 + wasm_file.base.comp.module.?.intern_pool.global_error_set.getNamesFromMainThread().len;	1019	const errors_len = 1 + wasm_file.base.comp.zcu.?.intern_pool.global_error_set.getNamesFromMainThread().len;
1020	// overwrite existing atom if it already exists (maybe the error set has increased)	1020	// overwrite existing atom if it already exists (maybe the error set has increased)
1021	// if not, allocate a new atom.	1021	// if not, allocate a new atom.
1022	const atom_index = if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index })) \|index\| blk: {	1022	const atom_index = if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index })) \|index\| blk: {

...	@@ -223,7 +223,7 @@ pub const MutableValue = union(enum) {	...	@@ -223,7 +223,7 @@ pub const MutableValue = union(enum) {
223	@memset(elems[0..@intCast(len_no_sent)], .{ .interned = undef_elem });	223	@memset(elems[0..@intCast(len_no_sent)], .{ .interned = undef_elem });
224	},	224	},
225	.Struct => for (elems[0..@intCast(len_no_sent)], 0..) \|*mut_elem, i\| {	225	.Struct => for (elems[0..@intCast(len_no_sent)], 0..) \|*mut_elem, i\| {
226	const field_ty = ty.structFieldType(i, zcu).toIntern();	226	const field_ty = ty.fieldType(i, zcu).toIntern();
227	mut_elem.* = .{ .interned = try pt.intern(.{ .undef = field_ty }) };	227	mut_elem.* = .{ .interned = try pt.intern(.{ .undef = field_ty }) };
228	},	228	},
229	else => unreachable,	229	else => unreachable,
...	@@ -369,7 +369,7 @@ pub const MutableValue = union(enum) {	...	@@ -369,7 +369,7 @@ pub const MutableValue = union(enum) {
369	.bytes => \|b\| {	369	.bytes => \|b\| {
370	assert(is_trivial_int);	370	assert(is_trivial_int);
371	assert(field_val.typeOf(zcu).toIntern() == .u8_type);	371	assert(field_val.typeOf(zcu).toIntern() == .u8_type);
372	b.data[field_idx] = @intCast(Value.fromInterned(field_val.interned).toUnsignedInt(pt));	372	b.data[field_idx] = @intCast(Value.fromInterned(field_val.interned).toUnsignedInt(zcu));
373	},	373	},
374	.repeated => \|r\| {	374	.repeated => \|r\| {
375	if (field_val.eqlTrivial(r.child.*)) return;	375	if (field_val.eqlTrivial(r.child.*)) return;
...	@@ -382,9 +382,9 @@ pub const MutableValue = union(enum) {	...	@@ -382,9 +382,9 @@ pub const MutableValue = union(enum) {
382	{	382	{
383	// We can use the `bytes` representation.	383	// We can use the `bytes` representation.
384	const bytes = try arena.alloc(u8, @intCast(len_inc_sent));	384	const bytes = try arena.alloc(u8, @intCast(len_inc_sent));
385	const repeated_byte = Value.fromInterned(r.child.interned).toUnsignedInt(pt);	385	const repeated_byte = Value.fromInterned(r.child.interned).toUnsignedInt(zcu);
386	@memset(bytes, @intCast(repeated_byte));	386	@memset(bytes, @intCast(repeated_byte));
387	bytes[field_idx] = @intCast(Value.fromInterned(field_val.interned).toUnsignedInt(pt));	387	bytes[field_idx] = @intCast(Value.fromInterned(field_val.interned).toUnsignedInt(zcu));
388	mv.* = .{ .bytes = .{	388	mv.* = .{ .bytes = .{
389	.ty = r.ty,	389	.ty = r.ty,
390	.data = bytes,	390	.data = bytes,
...	@@ -431,7 +431,7 @@ pub const MutableValue = union(enum) {	...	@@ -431,7 +431,7 @@ pub const MutableValue = union(enum) {
431	} else {	431	} else {
432	const bytes = try arena.alloc(u8, a.elems.len);	432	const bytes = try arena.alloc(u8, a.elems.len);
433	for (a.elems, bytes) \|elem_val, *b\| {	433	for (a.elems, bytes) \|elem_val, *b\| {
434	b.* = @intCast(Value.fromInterned(elem_val.interned).toUnsignedInt(pt));	434	b.* = @intCast(Value.fromInterned(elem_val.interned).toUnsignedInt(zcu));
435	}	435	}
436	mv.* = .{ .bytes = .{	436	mv.* = .{ .bytes = .{
437	.ty = a.ty,	437	.ty = a.ty,

...	@@ -428,10 +428,10 @@ const Writer = struct {	...	@@ -428,10 +428,10 @@ const Writer = struct {
428	}	428	}
429		429
430	fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {	430	fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
431	const mod = w.pt.zcu;	431	const zcu = w.pt.zcu;
432	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;	432	const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl;
433	const vector_ty = ty_pl.ty.toType();	433	const vector_ty = ty_pl.ty.toType();
434	const len = @as(usize, @intCast(vector_ty.arrayLen(mod)));	434	const len = @as(usize, @intCast(vector_ty.arrayLen(zcu)));
435	const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra[ty_pl.payload..][0..len]));	435	const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra[ty_pl.payload..][0..len]));
436		436
437	try w.writeType(s, vector_ty);	437	try w.writeType(s, vector_ty);
...	@@ -508,11 +508,11 @@ const Writer = struct {	...	@@ -508,11 +508,11 @@ const Writer = struct {
508	}	508	}
509		509
510	fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {	510	fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
511	const mod = w.pt.zcu;	511	const zcu = w.pt.zcu;
512	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;	512	const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
513	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;	513	const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
514		514
515	const elem_ty = w.typeOfIndex(inst).childType(mod);	515	const elem_ty = w.typeOfIndex(inst).childType(zcu);
516	try w.writeType(s, elem_ty);	516	try w.writeType(s, elem_ty);
517	try s.writeAll(", ");	517	try s.writeAll(", ");
518	try w.writeOperand(s, inst, 0, pl_op.operand);	518	try w.writeOperand(s, inst, 0, pl_op.operand);
...	@@ -974,7 +974,7 @@ const Writer = struct {	...	@@ -974,7 +974,7 @@ const Writer = struct {
974	}	974	}
975		975
976	fn typeOfIndex(w: *Writer, inst: Air.Inst.Index) Type {	976	fn typeOfIndex(w: *Writer, inst: Air.Inst.Index) Type {
977	const mod = w.pt.zcu;	977	const zcu = w.pt.zcu;
978	return w.air.typeOfIndex(inst, &mod.intern_pool);	978	return w.air.typeOfIndex(inst, &zcu.intern_pool);
979	}	979	}
980	};	980	};

...	@@ -62,8 +62,8 @@ pub fn print(	...	@@ -62,8 +62,8 @@ pub fn print(
62	comptime have_sema: bool,	62	comptime have_sema: bool,
63	sema: if (have_sema) *Sema else void,	63	sema: if (have_sema) *Sema else void,
64	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {	64	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {
65	const mod = pt.zcu;	65	const zcu = pt.zcu;
66	const ip = &mod.intern_pool;	66	const ip = &zcu.intern_pool;
67	switch (ip.indexToKey(val.toIntern())) {	67	switch (ip.indexToKey(val.toIntern())) {
68	.int_type,	68	.int_type,
69	.ptr_type,	69	.ptr_type,
...	@@ -95,11 +95,11 @@ pub fn print(	...	@@ -95,11 +95,11 @@ pub fn print(
95	.int => \|int\| switch (int.storage) {	95	.int => \|int\| switch (int.storage) {
96	inline .u64, .i64, .big_int => \|x\| try writer.print("{}", .{x}),	96	inline .u64, .i64, .big_int => \|x\| try writer.print("{}", .{x}),
97	.lazy_align => \|ty\| if (have_sema) {	97	.lazy_align => \|ty\| if (have_sema) {
98	const a = (try Type.fromInterned(ty).abiAlignmentAdvanced(pt, .sema)).scalar;	98	const a = try Type.fromInterned(ty).abiAlignmentSema(pt);
99	try writer.print("{}", .{a.toByteUnits() orelse 0});	99	try writer.print("{}", .{a.toByteUnits() orelse 0});
100	} else try writer.print("@alignOf({})", .{Type.fromInterned(ty).fmt(pt)}),	100	} else try writer.print("@alignOf({})", .{Type.fromInterned(ty).fmt(pt)}),
101	.lazy_size => \|ty\| if (have_sema) {	101	.lazy_size => \|ty\| if (have_sema) {
102	const s = (try Type.fromInterned(ty).abiSizeAdvanced(pt, .sema)).scalar;	102	const s = try Type.fromInterned(ty).abiSizeSema(pt);
103	try writer.print("{}", .{s});	103	try writer.print("{}", .{s});
104	} else try writer.print("@sizeOf({})", .{Type.fromInterned(ty).fmt(pt)}),	104	} else try writer.print("@sizeOf({})", .{Type.fromInterned(ty).fmt(pt)}),
105	},	105	},
...	@@ -116,7 +116,7 @@ pub fn print(	...	@@ -116,7 +116,7 @@ pub fn print(
116	enum_literal.fmt(ip),	116	enum_literal.fmt(ip),
117	}),	117	}),
118	.enum_tag => \|enum_tag\| {	118	.enum_tag => \|enum_tag\| {
119	const enum_type = ip.loadEnumType(val.typeOf(mod).toIntern());	119	const enum_type = ip.loadEnumType(val.typeOf(zcu).toIntern());
120	if (enum_type.tagValueIndex(ip, val.toIntern())) \|tag_index\| {	120	if (enum_type.tagValueIndex(ip, val.toIntern())) \|tag_index\| {
121	return writer.print(".{i}", .{enum_type.names.get(ip)[tag_index].fmt(ip)});	121	return writer.print(".{i}", .{enum_type.names.get(ip)[tag_index].fmt(ip)});
122	}	122	}
...	@@ -173,7 +173,7 @@ pub fn print(	...	@@ -173,7 +173,7 @@ pub fn print(
173	return;	173	return;
174	}	174	}
175	if (un.tag == .none) {	175	if (un.tag == .none) {
176	const backing_ty = try val.typeOf(mod).unionBackingType(pt);	176	const backing_ty = try val.typeOf(zcu).unionBackingType(pt);
177	try writer.print("@bitCast(@as({}, ", .{backing_ty.fmt(pt)});	177	try writer.print("@bitCast(@as({}, ", .{backing_ty.fmt(pt)});
178	try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);	178	try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);
179	try writer.writeAll("))");	179	try writer.writeAll("))");
...	@@ -245,7 +245,7 @@ fn printAggregate(	...	@@ -245,7 +245,7 @@ fn printAggregate(
245	if (ty.childType(zcu).toIntern() != .u8_type) break :one_byte_str;	245	if (ty.childType(zcu).toIntern() != .u8_type) break :one_byte_str;
246	const elem_val = Value.fromInterned(aggregate.storage.values()[0]);	246	const elem_val = Value.fromInterned(aggregate.storage.values()[0]);
247	if (elem_val.isUndef(zcu)) break :one_byte_str;	247	if (elem_val.isUndef(zcu)) break :one_byte_str;
248	const byte = elem_val.toUnsignedInt(pt);	248	const byte = elem_val.toUnsignedInt(zcu);
249	try writer.print("\"{}\"", .{std.zig.fmtEscapes(&.{@intCast(byte)})});	249	try writer.print("\"{}\"", .{std.zig.fmtEscapes(&.{@intCast(byte)})});
250	if (!is_ref) try writer.writeAll(".*");	250	if (!is_ref) try writer.writeAll(".*");
251	return;	251	return;