Commit 5e636643d2a36c777a607b65cfd1abbb1822ad1e | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-05-04 20:30:25-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-10 20:42:27-07:00
log	5e636643d2a36c777a607b65cfd1abbb1822ad1e
tree	500ec74bd5cc60bb8a4db95ab5f5e90fcfb222aa
parent	9d422bff18dbb92d3a6b8705c3dae7404a34bba6

stage2: move many Type encodings to InternPool

Notably, `vector`.

Additionally, all alternate encodings of `pointer`, `optional`, and
`array`.

25 files changed, 1834 insertions(+), 2771 deletions(-)

src
- Air.zig
- InternPool.zig
- Liveness.zig
- Liveness
  - Verify.zig
- Module.zig
- Sema.zig
- TypedValue.zig
- arch
  - aarch64
    CodeGen.zig
  - arm
    CodeGen.zig
  - riscv64
    CodeGen.zig
  - sparc64
    CodeGen.zig
  - wasm
    CodeGen.zig
  - x86_64
    CodeGen.zig
    abi.zig
- codegen.zig
- codegen
  - c.zig
  - c
    type.zig
  - llvm.zig
  - spirv.zig
  - spirv
    Module.zig
- link
  - Dwarf.zig
  - Wasm.zig
- print_air.zig
- type.zig
- value.zig

src/Air.zig+8-5

 @@ -1375,7 +1375,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index, ip: InternPool) Type {
         .bool_to_int => return Type.u1,
-        .tag_name, .error_name => return Type.initTag(.const_slice_u8_sentinel_0),
+        .tag_name, .error_name => return Type.const_slice_u8_sentinel_0,
         .call, .call_always_tail, .call_never_tail, .call_never_inline => {
             const callee_ty = air.typeOf(datas[inst].pl_op.operand, ip);
 @@ -1384,18 +1384,21 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index, ip: InternPool) Type {
         .slice_elem_val, .ptr_elem_val, .array_elem_val => {
             const ptr_ty = air.typeOf(datas[inst].bin_op.lhs, ip);
-            return ptr_ty.elemType();
+            return ptr_ty.childTypeIp(ip);
         },
         .atomic_load => {
             const ptr_ty = air.typeOf(datas[inst].atomic_load.ptr, ip);
-            return ptr_ty.elemType();
+            return ptr_ty.childTypeIp(ip);
         },
         .atomic_rmw => {
             const ptr_ty = air.typeOf(datas[inst].pl_op.operand, ip);
-            return ptr_ty.elemType();
+            return ptr_ty.childTypeIp(ip);
         },
-        .reduce, .reduce_optimized => return air.typeOf(datas[inst].reduce.operand, ip).childType(),
+        .reduce, .reduce_optimized => {
+            const operand_ty = air.typeOf(datas[inst].reduce.operand, ip);
+            return ip.indexToKey(operand_ty.ip_index).vector_type.child.toType();
+        },
         .mul_add => return air.typeOf(datas[inst].pl_op.operand, ip),
         .select => {

src/InternPool.zig+63-29

 @@ -31,28 +31,10 @@ const KeyAdapter = struct {
 pub const Key = union(enum) {
     int_type: IntType,
-    ptr_type: struct {
+    ptr_type: PtrType,
-        elem_type: Index,
+    array_type: ArrayType,
-        sentinel: Index = .none,
+    vector_type: VectorType,
-        alignment: u16 = 0,
+    opt_type: Index,
-        size: std.builtin.Type.Pointer.Size,
-        is_const: bool = false,
-        is_volatile: bool = false,
-        is_allowzero: bool = false,
-        address_space: std.builtin.AddressSpace = .generic,
-    },
-    array_type: struct {
-        len: u64,
-        child: Index,
-        sentinel: Index,
-    },
-    vector_type: struct {
-        len: u32,
-        child: Index,
-    },
-    optional_type: struct {
-        payload_type: Index,
-    },
     error_union_type: struct {
         error_set_type: Index,
         payload_type: Index,
 @@ -87,6 +69,47 @@ pub const Key = union(enum) {
     pub const IntType = std.builtin.Type.Int;
+    pub const PtrType = struct {
+        elem_type: Index,
+        sentinel: Index = .none,
+        /// If zero use pointee_type.abiAlignment()
+        /// When creating pointer types, if alignment is equal to pointee type
+        /// abi alignment, this value should be set to 0 instead.
+        alignment: u16 = 0,
+        /// If this is non-zero it means the pointer points to a sub-byte
+        /// range of data, which is backed by a "host integer" with this
+        /// number of bytes.
+        /// When host_size=pointee_abi_size and bit_offset=0, this must be
+        /// represented with host_size=0 instead.
+        host_size: u16 = 0,
+        bit_offset: u16 = 0,
+        vector_index: VectorIndex = .none,
+        size: std.builtin.Type.Pointer.Size = .One,
+        is_const: bool = false,
+        is_volatile: bool = false,
+        is_allowzero: bool = false,
+        /// See src/target.zig defaultAddressSpace function for how to obtain
+        /// an appropriate value for this field.
+        address_space: std.builtin.AddressSpace = .generic,
+        pub const VectorIndex = enum(u32) {
+            none = std.math.maxInt(u32),
+            runtime = std.math.maxInt(u32) - 1,
+            _,
+        };
+    };
+    pub const ArrayType = struct {
+        len: u64,
+        child: Index,
+        sentinel: Index,
+    };
+    pub const VectorType = struct {
+        len: u32,
+        child: Index,
+    };
     pub fn hash32(key: Key) u32 {
         return @truncate(u32, key.hash64());
     }
 @@ -106,7 +129,7 @@ pub const Key = union(enum) {
             .ptr_type,
             .array_type,
             .vector_type,
-            .optional_type,
+            .opt_type,
             .error_union_type,
             .simple_type,
             .simple_value,
 @@ -159,8 +182,8 @@ pub const Key = union(enum) {
                 const b_info = b.vector_type;
                 return std.meta.eql(a_info, b_info);
             },
-            .optional_type => |a_info| {
+            .opt_type => |a_info| {
-                const b_info = b.optional_type;
+                const b_info = b.opt_type;
                 return std.meta.eql(a_info, b_info);
             },
             .error_union_type => |a_info| {
 @@ -220,7 +243,7 @@ pub const Key = union(enum) {
             .ptr_type,
             .array_type,
             .vector_type,
-            .optional_type,
+            .opt_type,
             .error_union_type,
             .simple_type,
             .struct_type,
 @@ -630,6 +653,7 @@ pub const Tag = enum(u8) {
     /// data is payload to Vector.
     type_vector,
     /// A fully explicitly specified pointer type.
+    /// TODO actually this is missing some stuff like bit_offset
     /// data is payload to Pointer.
     type_pointer,
     /// An optional type.
 @@ -893,7 +917,7 @@ pub fn indexToKey(ip: InternPool, index: Index) Key {
             } };
         },
-        .type_optional => .{ .optional_type = .{ .payload_type = @intToEnum(Index, data) } },
+        .type_optional => .{ .opt_type = @intToEnum(Index, data) },
         .type_error_union => @panic("TODO"),
         .type_enum_simple => @panic("TODO"),
 @@ -971,10 +995,10 @@ pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index {
                 }),
             });
         },
-        .optional_type => |optional_type| {
+        .opt_type => |opt_type| {
             ip.items.appendAssumeCapacity(.{
                 .tag = .type_optional,
-                .data = @enumToInt(optional_type.payload_type),
+                .data = @enumToInt(opt_type),
             });
         },
         .error_union_type => |error_union_type| {
 @@ -1192,3 +1216,13 @@ test "basic usage" {
     } });
     try std.testing.expect(another_array_i32 == array_i32);
 }
+pub fn childType(ip: InternPool, i: Index) Index {
+    return switch (ip.indexToKey(i)) {
+        .ptr_type => |ptr_type| ptr_type.elem_type,
+        .vector_type => |vector_type| vector_type.child,
+        .array_type => |array_type| array_type.child,
+        .opt_type => |child| child,
+        else => unreachable,
+    };
+}

src/Liveness.zig+5-3

src/Liveness/Verify.zig+1-1

...	@@ -325,7 +325,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {	...	@@ -325,7 +325,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void {
325	.aggregate_init => {	325	.aggregate_init => {
326	const ty_pl = data[inst].ty_pl;	326	const ty_pl = data[inst].ty_pl;
327	const aggregate_ty = self.air.getRefType(ty_pl.ty);	327	const aggregate_ty = self.air.getRefType(ty_pl.ty);
328	const len = @intCast(usize, aggregate_ty.arrayLen());	328	const len = @intCast(usize, aggregate_ty.arrayLenIp(ip.*));
329	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);	329	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
330		330
331	var bt = self.liveness.iterateBigTomb(inst);	331	var bt = self.liveness.iterateBigTomb(inst);

src/Module.zig+37-4

...	@@ -5805,7 +5805,7 @@ pub fn analyzeFnBody(mod: Module, func: Fn, arena: Allocator) SemaError!Air {	...	@@ -5805,7 +5805,7 @@ pub fn analyzeFnBody(mod: Module, func: Fn, arena: Allocator) SemaError!Air {
5805	// is unused so it just has to be a no-op.	5805	// is unused so it just has to be a no-op.
5806	sema.air_instructions.set(ptr_inst.*, .{	5806	sema.air_instructions.set(ptr_inst.*, .{
5807	.tag = .alloc,	5807	.tag = .alloc,
5808	.data = .{ .ty = Type.initTag(.single_const_pointer_to_comptime_int) },	5808	.data = .{ .ty = Type.single_const_pointer_to_comptime_int },
5809	});	5809	});
5810	}	5810	}
5811	}	5811	}
...	@@ -6545,7 +6545,7 @@ pub fn populateTestFunctions(	...	@@ -6545,7 +6545,7 @@ pub fn populateTestFunctions(
6545	}	6545	}
6546	const decl = mod.declPtr(decl_index);	6546	const decl = mod.declPtr(decl_index);
6547	var buf: Type.SlicePtrFieldTypeBuffer = undefined;	6547	var buf: Type.SlicePtrFieldTypeBuffer = undefined;
6548	const tmp_test_fn_ty = decl.ty.slicePtrFieldType(&buf).elemType();	6548	const tmp_test_fn_ty = decl.ty.slicePtrFieldType(&buf).childType(mod);
6549		6549
6550	const array_decl_index = d: {	6550	const array_decl_index = d: {
6551	// Add mod.test_functions to an array decl then make the test_functions	6551	// Add mod.test_functions to an array decl then make the test_functions
...	@@ -6575,7 +6575,7 @@ pub fn populateTestFunctions(	...	@@ -6575,7 +6575,7 @@ pub fn populateTestFunctions(
6575	errdefer name_decl_arena.deinit();	6575	errdefer name_decl_arena.deinit();
6576	const bytes = try name_decl_arena.allocator().dupe(u8, test_name_slice);	6576	const bytes = try name_decl_arena.allocator().dupe(u8, test_name_slice);
6577	const test_name_decl_index = try mod.createAnonymousDeclFromDecl(array_decl, array_decl.src_namespace, null, .{	6577	const test_name_decl_index = try mod.createAnonymousDeclFromDecl(array_decl, array_decl.src_namespace, null, .{
6578	.ty = try Type.Tag.array_u8.create(name_decl_arena.allocator(), bytes.len),	6578	.ty = try Type.array(name_decl_arena.allocator(), bytes.len, null, Type.u8, mod),
6579	.val = try Value.Tag.bytes.create(name_decl_arena.allocator(), bytes),	6579	.val = try Value.Tag.bytes.create(name_decl_arena.allocator(), bytes),
6580	});	6580	});
6581	try mod.declPtr(test_name_decl_index).finalizeNewArena(&name_decl_arena);	6581	try mod.declPtr(test_name_decl_index).finalizeNewArena(&name_decl_arena);
...	@@ -6609,7 +6609,12 @@ pub fn populateTestFunctions(	...	@@ -6609,7 +6609,12 @@ pub fn populateTestFunctions(
6609		6609
6610	{	6610	{
6611	// This copy accesses the old Decl Type/Value so it must be done before `clearValues`.	6611	// This copy accesses the old Decl Type/Value so it must be done before `clearValues`.
6612	const new_ty = try Type.Tag.const_slice.create(arena, try tmp_test_fn_ty.copy(arena));	6612	const new_ty = try Type.ptr(arena, mod, .{
		6613	.size = .Slice,
		6614	.pointee_type = try tmp_test_fn_ty.copy(arena),
		6615	.mutable = false,
		6616	.@"addrspace" = .generic,
		6617	});
6613	const new_var = try gpa.create(Var);	6618	const new_var = try gpa.create(Var);
6614	errdefer gpa.destroy(new_var);	6619	errdefer gpa.destroy(new_var);
6615	new_var.* = decl.val.castTag(.variable).?.data.*;	6620	new_var.* = decl.val.castTag(.variable).?.data.*;
...	@@ -6819,6 +6824,34 @@ pub fn intType(mod: *Module, signedness: std.builtin.Signedness, bits: u16) Allo	...	@@ -6819,6 +6824,34 @@ pub fn intType(mod: *Module, signedness: std.builtin.Signedness, bits: u16) Allo
6819	return i.toType();	6824	return i.toType();
6820	}	6825	}
6821		6826
		6827	pub fn arrayType(mod: *Module, info: InternPool.Key.ArrayType) Allocator.Error!Type {
		6828	const i = try intern(mod, .{ .array_type = info });
		6829	return i.toType();
		6830	}
		6831
		6832	pub fn vectorType(mod: *Module, info: InternPool.Key.VectorType) Allocator.Error!Type {
		6833	const i = try intern(mod, .{ .vector_type = info });
		6834	return i.toType();
		6835	}
		6836
		6837	pub fn optionalType(mod: *Module, child_type: InternPool.Index) Allocator.Error!Type {
		6838	const i = try intern(mod, .{ .opt_type = child_type });
		6839	return i.toType();
		6840	}
		6841
		6842	pub fn ptrType(mod: *Module, info: InternPool.Key.PtrType) Allocator.Error!Type {
		6843	const i = try intern(mod, .{ .ptr_type = info });
		6844	return i.toType();
		6845	}
		6846
		6847	pub fn singleMutPtrType(mod: *Module, child_type: Type) Allocator.Error!Type {
		6848	return ptrType(mod, .{ .elem_type = child_type.ip_index });
		6849	}
		6850
		6851	pub fn singleConstPtrType(mod: *Module, child_type: Type) Allocator.Error!Type {
		6852	return ptrType(mod, .{ .elem_type = child_type.ip_index, .is_const = true });
		6853	}
		6854
6822	pub fn smallestUnsignedInt(mod: *Module, max: u64) Allocator.Error!Type {	6855	pub fn smallestUnsignedInt(mod: *Module, max: u64) Allocator.Error!Type {
6823	return intType(mod, .unsigned, Type.smallestUnsignedBits(max));	6856	return intType(mod, .unsigned, Type.smallestUnsignedBits(max));
6824	}	6857	}

src/Sema.zig+519-556

 @@ -585,13 +585,18 @@ 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 mod = sema.mod;
         return block.addInst(.{
             .tag = if (block.float_mode == .Optimized) .cmp_vector_optimized else .cmp_vector,
             .data = .{ .ty_pl = .{
-                .ty = try block.sema.addType(
+                .ty = try sema.addType(
-                    try Type.vector(block.sema.arena, block.sema.typeOf(lhs).vectorLen(), Type.bool),
+                    try mod.vectorType(.{
+                        .len = sema.typeOf(lhs).vectorLen(mod),
+                        .child = .bool_type,
+                    }),
                 ),
-                .payload = try block.sema.addExtra(Air.VectorCmp{
+                .payload = try sema.addExtra(Air.VectorCmp{
                     .lhs = lhs,
                     .rhs = rhs,
                     .op = Air.VectorCmp.encodeOp(cmp_op),
 @@ -1760,7 +1765,7 @@ pub fn resolveConstString(
     reason: []const u8,
 ) ![]u8 {
     const air_inst = try sema.resolveInst(zir_ref);
-    const wanted_type = Type.initTag(.const_slice_u8);
+    const wanted_type = Type.const_slice_u8;
     const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
     const val = try sema.resolveConstValue(block, src, coerced_inst, reason);
     return val.toAllocatedBytes(wanted_type, sema.arena, sema.mod);
 @@ -1788,7 +1793,8 @@ fn analyzeAsType(
 }
 pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) !void {
-    if (!sema.mod.backendSupportsFeature(.error_return_trace)) return;
+    const mod = sema.mod;
+    if (!mod.backendSupportsFeature(.error_return_trace)) return;
     assert(!block.is_comptime);
     var err_trace_block = block.makeSubBlock();
 @@ -1798,13 +1804,13 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
     // var addrs: [err_return_trace_addr_count]usize = undefined;
     const err_return_trace_addr_count = 32;
-    const addr_arr_ty = try Type.array(sema.arena, err_return_trace_addr_count, null, Type.usize, sema.mod);
+    const addr_arr_ty = try Type.array(sema.arena, err_return_trace_addr_count, null, Type.usize, mod);
-    const addrs_ptr = try err_trace_block.addTy(.alloc, try Type.Tag.single_mut_pointer.create(sema.arena, addr_arr_ty));
+    const addrs_ptr = try err_trace_block.addTy(.alloc, try mod.singleMutPtrType(addr_arr_ty));
     // var st: StackTrace = undefined;
     const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
     const stack_trace_ty = try sema.resolveTypeFields(unresolved_stack_trace_ty);
-    const st_ptr = try err_trace_block.addTy(.alloc, try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty));
+    const st_ptr = try err_trace_block.addTy(.alloc, try mod.singleMutPtrType(stack_trace_ty));
     // st.instruction_addresses = &addrs;
     const addr_field_ptr = try sema.fieldPtr(&err_trace_block, src, st_ptr, "instruction_addresses", src, true);
 @@ -2101,11 +2107,10 @@ fn failWithUseOfAsync(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError
 fn failWithInvalidFieldAccess(sema: *Sema, block: *Block, src: LazySrcLoc, object_ty: Type, field_name: []const u8) CompileError {
     const mod = sema.mod;
-    const inner_ty = if (object_ty.isSinglePointer(mod)) object_ty.childType() else object_ty;
+    const inner_ty = if (object_ty.isSinglePointer(mod)) object_ty.childType(mod) else object_ty;
     if (inner_ty.zigTypeTag(mod) == .Optional) opt: {
-        var buf: Type.Payload.ElemType = undefined;
+        const child_ty = inner_ty.optionalChild(mod);
-        const child_ty = inner_ty.optionalChild(&buf);
         if (!typeSupportsFieldAccess(mod, child_ty, field_name)) break :opt;
         const msg = msg: {
             const msg = try sema.errMsg(block, src, "optional type '{}' does not support field access", .{object_ty.fmt(sema.mod)});
 @@ -2132,7 +2137,7 @@ fn typeSupportsFieldAccess(mod: *const Module, ty: Type, field_name: []const u8)
     switch (ty.zigTypeTag(mod)) {
         .Array => return mem.eql(u8, field_name, "len"),
         .Pointer => {
-            const ptr_info = ty.ptrInfo().data;
+            const ptr_info = ty.ptrInfo(mod);
             if (ptr_info.size == .Slice) {
                 return mem.eql(u8, field_name, "ptr") or mem.eql(u8, field_name, "len");
             } else if (ptr_info.pointee_type.zigTypeTag(mod) == .Array) {
 @@ -2504,6 +2509,7 @@ fn coerceResultPtr(
     dummy_operand: Air.Inst.Ref,
     trash_block: *Block,
 ) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const target = sema.mod.getTarget();
     const addr_space = target_util.defaultAddressSpace(target, .local);
     const pointee_ty = sema.typeOf(dummy_operand);
 @@ -2547,7 +2553,7 @@ fn coerceResultPtr(
                 return sema.addConstant(ptr_ty, ptr_val);
             }
             if (pointee_ty.eql(Type.null, sema.mod)) {
-                const opt_ty = sema.typeOf(new_ptr).childType();
+                const opt_ty = sema.typeOf(new_ptr).childType(mod);
                 const null_inst = try sema.addConstant(opt_ty, Value.null);
                 _ = try block.addBinOp(.store, new_ptr, null_inst);
                 return Air.Inst.Ref.void_value;
 @@ -3394,7 +3400,7 @@ fn zirEnsureErrUnionPayloadVoid(sema: *Sema, block: *Block, inst: Zir.Inst.Index
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const err_union_ty = if (operand_ty.zigTypeTag(mod) == .Pointer)
-        operand_ty.childType()
+        operand_ty.childType(mod)
     else
         operand_ty;
     if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) return;
 @@ -3430,7 +3436,7 @@ fn indexablePtrLen(
     const mod = sema.mod;
     const object_ty = sema.typeOf(object);
     const is_pointer_to = object_ty.isSinglePointer(mod);
-    const indexable_ty = if (is_pointer_to) object_ty.childType() else object_ty;
+    const indexable_ty = if (is_pointer_to) object_ty.childType(mod) else object_ty;
     try checkIndexable(sema, block, src, indexable_ty);
     return sema.fieldVal(block, src, object, "len", src);
 }
 @@ -3441,9 +3447,10 @@ fn indexablePtrLenOrNone(
     src: LazySrcLoc,
     operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const operand_ty = sema.typeOf(operand);
     try checkMemOperand(sema, block, src, operand_ty);
-    if (operand_ty.ptrSize() == .Many) return .none;
+    if (operand_ty.ptrSize(mod) == .Many) return .none;
     return sema.fieldVal(block, src, operand, "len", src);
 }
 @@ -3529,11 +3536,12 @@ 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 mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const alloc = try sema.resolveInst(inst_data.operand);
     const alloc_ty = sema.typeOf(alloc);
-    var ptr_info = alloc_ty.ptrInfo().data;
+    var ptr_info = alloc_ty.ptrInfo(mod);
     const elem_ty = ptr_info.pointee_type;
     // Detect if all stores to an `.alloc` were comptime-known.
 @@ -3589,9 +3597,10 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 }
 fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const alloc_ty = sema.typeOf(alloc);
-    var ptr_info = alloc_ty.ptrInfo().data;
+    var ptr_info = alloc_ty.ptrInfo(mod);
     ptr_info.mutable = false;
     const const_ptr_ty = try Type.ptr(sema.arena, sema.mod, ptr_info);
 @@ -3947,13 +3956,13 @@ fn zirArrayBasePtr(
     const start_ptr = try sema.resolveInst(inst_data.operand);
     var base_ptr = start_ptr;
-    while (true) switch (sema.typeOf(base_ptr).childType().zigTypeTag(mod)) {
+    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
         .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,
     };
-    const elem_ty = sema.typeOf(base_ptr).childType();
+    const elem_ty = sema.typeOf(base_ptr).childType(mod);
     switch (elem_ty.zigTypeTag(mod)) {
         .Array, .Vector => return base_ptr,
         .Struct => if (elem_ty.isTuple()) {
 @@ -3962,7 +3971,7 @@ fn zirArrayBasePtr(
         },
         else => {},
     }
-    return sema.failWithArrayInitNotSupported(block, src, sema.typeOf(start_ptr).childType());
+    return sema.failWithArrayInitNotSupported(block, src, sema.typeOf(start_ptr).childType(mod));
 }
 fn zirFieldBasePtr(
 @@ -3976,18 +3985,18 @@ fn zirFieldBasePtr(
     const start_ptr = try sema.resolveInst(inst_data.operand);
     var base_ptr = start_ptr;
-    while (true) switch (sema.typeOf(base_ptr).childType().zigTypeTag(mod)) {
+    while (true) switch (sema.typeOf(base_ptr).childType(mod).zigTypeTag(mod)) {
         .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,
     };
-    const elem_ty = sema.typeOf(base_ptr).childType();
+    const elem_ty = sema.typeOf(base_ptr).childType(mod);
     switch (elem_ty.zigTypeTag(mod)) {
         .Struct, .Union => return base_ptr,
         else => {},
     }
-    return sema.failWithStructInitNotSupported(block, src, sema.typeOf(start_ptr).childType());
+    return sema.failWithStructInitNotSupported(block, src, sema.typeOf(start_ptr).childType(mod));
 }
 fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -4129,7 +4138,7 @@ fn validateArrayInitTy(
     switch (ty.zigTypeTag(mod)) {
         .Array => {
-            const array_len = ty.arrayLen();
+            const array_len = ty.arrayLen(mod);
             if (extra.init_count != array_len) {
                 return sema.fail(block, src, "expected {d} array elements; found {d}", .{
                     array_len, extra.init_count,
 @@ -4138,7 +4147,7 @@ fn validateArrayInitTy(
             return;
         },
         .Vector => {
-            const array_len = ty.arrayLen();
+            const array_len = ty.arrayLen(mod);
             if (extra.init_count != array_len) {
                 return sema.fail(block, src, "expected {d} vector elements; found {d}", .{
                     array_len, extra.init_count,
 @@ -4148,7 +4157,7 @@ fn validateArrayInitTy(
         },
         .Struct => if (ty.isTuple()) {
             _ = try sema.resolveTypeFields(ty);
-            const array_len = ty.arrayLen();
+            const array_len = ty.arrayLen(mod);
             if (extra.init_count > array_len) {
                 return sema.fail(block, src, "expected at most {d} tuple fields; found {d}", .{
                     array_len, extra.init_count,
 @@ -4194,7 +4203,7 @@ fn zirValidateStructInit(
     const field_ptr_data = sema.code.instructions.items(.data)[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();
+    const agg_ty = sema.typeOf(object_ptr).childType(mod);
     switch (agg_ty.zigTypeTag(mod)) {
         .Struct => return sema.validateStructInit(
             block,
 @@ -4350,6 +4359,7 @@ fn validateStructInit(
     init_src: LazySrcLoc,
     instrs: []const Zir.Inst.Index,
 ) CompileError!void {
+    const mod = sema.mod;
     const gpa = sema.gpa;
     // Maps field index to field_ptr index of where it was already initialized.
 @@ -4425,14 +4435,13 @@ fn validateStructInit(
                 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(u32, i), true)
             else
                 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(u32, i), field_src, struct_ty, true);
-            const field_ty = sema.typeOf(default_field_ptr).childType();
+            const field_ty = sema.typeOf(default_field_ptr).childType(mod);
             const init = try sema.addConstant(field_ty, default_val);
             try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
         }
         if (root_msg) |msg| {
             if (struct_ty.castTag(.@"struct")) |struct_obj| {
-                const mod = sema.mod;
                 const fqn = try struct_obj.data.getFullyQualifiedName(mod);
                 defer gpa.free(fqn);
                 try mod.errNoteNonLazy(
 @@ -4605,7 +4614,7 @@ fn validateStructInit(
             try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(u32, i), true)
         else
             try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(u32, i), field_src, struct_ty, true);
-        const field_ty = sema.typeOf(default_field_ptr).childType();
+        const field_ty = sema.typeOf(default_field_ptr).childType(mod);
         const init = try sema.addConstant(field_ty, field_values[i]);
         try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
     }
 @@ -4624,8 +4633,8 @@ fn zirValidateArrayInit(
     const first_elem_ptr_data = sema.code.instructions.items(.data)[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();
+    const array_ty = sema.typeOf(array_ptr).childType(mod);
-    const array_len = array_ty.arrayLen();
+    const array_len = array_ty.arrayLen(mod);
     if (instrs.len != array_len) switch (array_ty.zigTypeTag(mod)) {
         .Struct => {
 @@ -4670,10 +4679,10 @@ fn zirValidateArrayInit(
         // 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()) |sentinel_val| {
+        if (array_ty.sentinel(mod)) |sentinel_val| {
             const array_len_ref = try sema.addIntUnsigned(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 = try sema.addConstant(array_ty.childType(), sentinel_val);
+            const sentinel = try sema.addConstant(array_ty.childType(mod), sentinel_val);
             try sema.storePtr2(block, init_src, sentinel_ptr, init_src, sentinel, init_src, .store);
         }
         return;
 @@ -4685,7 +4694,7 @@ fn zirValidateArrayInit(
     // Collect the comptime element values in case the array literal ends up
     // being comptime-known.
-    const array_len_s = try sema.usizeCast(block, init_src, array_ty.arrayLenIncludingSentinel());
+    const array_len_s = try sema.usizeCast(block, init_src, array_ty.arrayLenIncludingSentinel(mod));
     const element_vals = try sema.arena.alloc(Value, array_len_s);
     const opt_opv = try sema.typeHasOnePossibleValue(array_ty);
     const air_tags = sema.air_instructions.items(.tag);
 @@ -4784,7 +4793,7 @@ fn zirValidateArrayInit(
         // Our task is to delete all the `elem_ptr` and `store` instructions, and insert
         // instead a single `store` to the array_ptr with a comptime struct value.
         // Also to populate the sentinel value, if any.
-        if (array_ty.sentinel()) |sentinel_val| {
+        if (array_ty.sentinel(mod)) |sentinel_val| {
             element_vals[instrs.len] = sentinel_val;
         }
 @@ -4806,13 +4815,13 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     if (operand_ty.zigTypeTag(mod) != .Pointer) {
         return sema.fail(block, src, "cannot dereference non-pointer type '{}'", .{operand_ty.fmt(sema.mod)});
-    } else switch (operand_ty.ptrSize()) {
+    } else switch (operand_ty.ptrSize(mod)) {
         .One, .C => {},
         .Many => return sema.fail(block, src, "index syntax required for unknown-length pointer type '{}'", .{operand_ty.fmt(sema.mod)}),
         .Slice => return sema.fail(block, src, "index syntax required for slice type '{}'", .{operand_ty.fmt(sema.mod)}),
     }
-    if ((try sema.typeHasOnePossibleValue(operand_ty.childType())) != null) {
+    if ((try sema.typeHasOnePossibleValue(operand_ty.childType(mod))) != null) {
         // No need to validate the actual pointer value, we don't need it!
         return;
     }
 @@ -5132,7 +5141,7 @@ fn addStrLit(sema: *Sema, block: *Block, zir_bytes: []const u8) CompileError!Air
         defer anon_decl.deinit();
         const decl_index = try anon_decl.finish(
-            try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), gop.key_ptr.len),
+            try Type.array(anon_decl.arena(), gop.key_ptr.len, Value.zero, Type.u8, mod),
             try Value.Tag.str_lit.create(anon_decl.arena(), gop.key_ptr.*),
             0, // default alignment
         );
 @@ -6003,10 +6012,11 @@ fn addDbgVar(
     air_tag: Air.Inst.Tag,
     name: []const u8,
 ) CompileError!void {
+    const mod = sema.mod;
     const operand_ty = sema.typeOf(operand);
     switch (air_tag) {
         .dbg_var_ptr => {
-            if (!(try sema.typeHasRuntimeBits(operand_ty.childType()))) return;
+            if (!(try sema.typeHasRuntimeBits(operand_ty.childType(mod)))) return;
         },
         .dbg_var_val => {
             if (!(try sema.typeHasRuntimeBits(operand_ty))) return;
 @@ -6238,7 +6248,7 @@ fn popErrorReturnTrace(
         const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
         const stack_trace_ty = try sema.resolveTypeFields(unresolved_stack_trace_ty);
-        const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
+        const ptr_stack_trace_ty = try mod.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, "index", src, stack_trace_ty, true);
         try sema.storePtr2(block, src, field_ptr, src, saved_error_trace_index, src, .store);
 @@ -6263,7 +6273,7 @@ fn popErrorReturnTrace(
         // If non-error, then pop the error return trace by restoring the index.
         const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
         const stack_trace_ty = try sema.resolveTypeFields(unresolved_stack_trace_ty);
-        const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
+        const ptr_stack_trace_ty = try mod.singleMutPtrType(stack_trace_ty);
         const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty);
         const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, "index", src, stack_trace_ty, true);
         try sema.storePtr2(&then_block, src, field_ptr, src, saved_error_trace_index, src, .store);
 @@ -6456,16 +6466,15 @@ fn checkCallArgumentCount(
         switch (callee_ty.zigTypeTag(mod)) {
             .Fn => break :func_ty callee_ty,
             .Pointer => {
-                const ptr_info = callee_ty.ptrInfo().data;
+                const ptr_info = callee_ty.ptrInfo(mod);
                 if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag(mod) == .Fn) {
                     break :func_ty ptr_info.pointee_type;
                 }
             },
             .Optional => {
-                var buf: Type.Payload.ElemType = undefined;
+                const opt_child = callee_ty.optionalChild(mod);
-                const opt_child = callee_ty.optionalChild(&buf);
                 if (opt_child.zigTypeTag(mod) == .Fn or (opt_child.isSinglePointer(mod) and
-                    opt_child.childType().zigTypeTag(mod) == .Fn))
+                    opt_child.childType(mod).zigTypeTag(mod) == .Fn))
                 {
                     const msg = msg: {
                         const msg = try sema.errMsg(block, func_src, "cannot call optional type '{}'", .{
 @@ -6529,7 +6538,7 @@ fn callBuiltin(
         switch (callee_ty.zigTypeTag(mod)) {
             .Fn => break :func_ty callee_ty,
             .Pointer => {
-                const ptr_info = callee_ty.ptrInfo().data;
+                const ptr_info = callee_ty.ptrInfo(mod);
                 if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag(mod) == .Fn) {
                     break :func_ty ptr_info.pointee_type;
                 }
 @@ -7929,7 +7938,7 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     } else if (child_type.zigTypeTag(mod) == .Null) {
         return sema.fail(block, operand_src, "type '{}' cannot be optional", .{child_type.fmt(sema.mod)});
     }
-    const opt_type = try Type.optional(sema.arena, child_type);
+    const opt_type = try Type.optional(sema.arena, child_type, mod);
     return sema.addType(opt_type);
 }
 @@ -7949,16 +7958,17 @@ fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
 }
 fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const elem_type_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const len_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
-    const len = try sema.resolveInt(block, len_src, extra.lhs, Type.u32, "vector length must be comptime-known");
+    const len = @intCast(u32, try sema.resolveInt(block, len_src, extra.lhs, Type.u32, "vector length must be comptime-known"));
     const elem_type = try sema.resolveType(block, elem_type_src, extra.rhs);
     try sema.checkVectorElemType(block, elem_type_src, elem_type);
-    const vector_type = try Type.Tag.vector.create(sema.arena, .{
+    const vector_type = try mod.vectorType(.{
-        .len = @intCast(u32, len),
+        .len = len,
-        .elem_type = elem_type,
+        .child = elem_type.ip_index,
     });
     return sema.addType(vector_type);
 }
 @@ -8377,16 +8387,16 @@ fn analyzeOptionalPayloadPtr(
     const optional_ptr_ty = sema.typeOf(optional_ptr);
     assert(optional_ptr_ty.zigTypeTag(mod) == .Pointer);
-    const opt_type = optional_ptr_ty.elemType();
+    const opt_type = optional_ptr_ty.childType(mod);
     if (opt_type.zigTypeTag(mod) != .Optional) {
         return sema.fail(block, src, "expected optional type, found '{}'", .{opt_type.fmt(sema.mod)});
     }
-    const child_type = try opt_type.optionalChildAlloc(sema.arena);
+    const child_type = opt_type.optionalChild(mod);
     const child_pointer = try Type.ptr(sema.arena, sema.mod, .{
         .pointee_type = child_type,
         .mutable = !optional_ptr_ty.isConstPtr(),
-        .@"addrspace" = optional_ptr_ty.ptrAddressSpace(),
+        .@"addrspace" = optional_ptr_ty.ptrAddressSpace(mod),
     });
     if (try sema.resolveDefinedValue(block, src, optional_ptr)) |ptr_val| {
 @@ -8401,7 +8411,7 @@ fn analyzeOptionalPayloadPtr(
                 child_pointer,
                 try Value.Tag.opt_payload_ptr.create(sema.arena, .{
                     .container_ptr = ptr_val,
-                    .container_ty = optional_ptr_ty.childType(),
+                    .container_ty = optional_ptr_ty.childType(mod),
                 }),
             );
         }
 @@ -8414,7 +8424,7 @@ fn analyzeOptionalPayloadPtr(
                 child_pointer,
                 try Value.Tag.opt_payload_ptr.create(sema.arena, .{
                     .container_ptr = ptr_val,
-                    .container_ty = optional_ptr_ty.childType(),
+                    .container_ty = optional_ptr_ty.childType(mod),
                 }),
             );
         }
 @@ -8448,14 +8458,14 @@ fn zirOptionalPayload(
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     const result_ty = switch (operand_ty.zigTypeTag(mod)) {
-        .Optional => try operand_ty.optionalChildAlloc(sema.arena),
+        .Optional => operand_ty.optionalChild(mod),
         .Pointer => t: {
-            if (operand_ty.ptrSize() != .C) {
+            if (operand_ty.ptrSize(mod) != .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().data;
+            const ptr_info = operand_ty.ptrInfo(mod);
             break :t try Type.ptr(sema.arena, sema.mod, .{
                 .pointee_type = try ptr_info.pointee_type.copy(sema.arena),
                 .@"align" = ptr_info.@"align",
 @@ -8569,18 +8579,18 @@ fn analyzeErrUnionPayloadPtr(
     const operand_ty = sema.typeOf(operand);
     assert(operand_ty.zigTypeTag(mod) == .Pointer);
-    if (operand_ty.elemType().zigTypeTag(mod) != .ErrorUnion) {
+    if (operand_ty.childType(mod).zigTypeTag(mod) != .ErrorUnion) {
         return sema.fail(block, src, "expected error union type, found '{}'", .{
-            operand_ty.elemType().fmt(sema.mod),
+            operand_ty.childType(mod).fmt(sema.mod),
         });
     }
-    const err_union_ty = operand_ty.elemType();
+    const err_union_ty = operand_ty.childType(mod);
     const payload_ty = err_union_ty.errorUnionPayload();
     const operand_pointer_ty = try Type.ptr(sema.arena, sema.mod, .{
         .pointee_type = payload_ty,
         .mutable = !operand_ty.isConstPtr(),
-        .@"addrspace" = operand_ty.ptrAddressSpace(),
+        .@"addrspace" = operand_ty.ptrAddressSpace(mod),
     });
     if (try sema.resolveDefinedValue(block, src, operand)) |ptr_val| {
 @@ -8596,7 +8606,7 @@ fn analyzeErrUnionPayloadPtr(
                 operand_pointer_ty,
                 try Value.Tag.eu_payload_ptr.create(sema.arena, .{
                     .container_ptr = ptr_val,
-                    .container_ty = operand_ty.elemType(),
+                    .container_ty = operand_ty.childType(mod),
                 }),
             );
         }
 @@ -8609,7 +8619,7 @@ fn analyzeErrUnionPayloadPtr(
                 operand_pointer_ty,
                 try Value.Tag.eu_payload_ptr.create(sema.arena, .{
                     .container_ptr = ptr_val,
-                    .container_ty = operand_ty.elemType(),
+                    .container_ty = operand_ty.childType(mod),
                 }),
             );
         }
 @@ -8674,13 +8684,13 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     const operand_ty = sema.typeOf(operand);
     assert(operand_ty.zigTypeTag(mod) == .Pointer);
-    if (operand_ty.elemType().zigTypeTag(mod) != .ErrorUnion) {
+    if (operand_ty.childType(mod).zigTypeTag(mod) != .ErrorUnion) {
         return sema.fail(block, src, "expected error union type, found '{}'", .{
-            operand_ty.elemType().fmt(sema.mod),
+            operand_ty.childType(mod).fmt(sema.mod),
         });
     }
-    const result_ty = operand_ty.elemType().errorUnionSet();
+    const result_ty = operand_ty.childType(mod).errorUnionSet();
     if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
         if (try sema.pointerDeref(block, src, pointer_val, operand_ty)) |val| {
 @@ -10119,7 +10129,7 @@ fn zirSwitchCapture(
     const operand_is_ref = cond_tag == .switch_cond_ref;
     const operand_ptr = try sema.resolveInst(cond_info.operand);
     const operand_ptr_ty = sema.typeOf(operand_ptr);
-    const operand_ty = if (operand_is_ref) operand_ptr_ty.childType() else operand_ptr_ty;
+    const operand_ty = if (operand_is_ref) operand_ptr_ty.childType(mod) else operand_ptr_ty;
     if (block.inline_case_capture != .none) {
         const item_val = sema.resolveConstValue(block, .unneeded, block.inline_case_capture, undefined) catch unreachable;
 @@ -10131,9 +10141,9 @@ fn zirSwitchCapture(
                 if (is_ref) {
                     const ptr_field_ty = try Type.ptr(sema.arena, sema.mod, .{
                         .pointee_type = field_ty,
-                        .mutable = operand_ptr_ty.ptrIsMutable(),
+                        .mutable = operand_ptr_ty.ptrIsMutable(mod),
                         .@"volatile" = operand_ptr_ty.isVolatilePtr(),
-                        .@"addrspace" = operand_ptr_ty.ptrAddressSpace(),
+                        .@"addrspace" = operand_ptr_ty.ptrAddressSpace(mod),
                     });
                     return sema.addConstant(
                         ptr_field_ty,
 @@ -10150,9 +10160,9 @@ fn zirSwitchCapture(
             if (is_ref) {
                 const ptr_field_ty = try Type.ptr(sema.arena, sema.mod, .{
                     .pointee_type = field_ty,
-                    .mutable = operand_ptr_ty.ptrIsMutable(),
+                    .mutable = operand_ptr_ty.ptrIsMutable(mod),
                     .@"volatile" = operand_ptr_ty.isVolatilePtr(),
-                    .@"addrspace" = operand_ptr_ty.ptrAddressSpace(),
+                    .@"addrspace" = operand_ptr_ty.ptrAddressSpace(mod),
                 });
                 return block.addStructFieldPtr(operand_ptr, field_index, ptr_field_ty);
             } else {
 @@ -10235,7 +10245,7 @@ fn zirSwitchCapture(
                 const field_ty_ptr = try Type.ptr(sema.arena, sema.mod, .{
                     .pointee_type = first_field.ty,
                     .@"addrspace" = .generic,
-                    .mutable = operand_ptr_ty.ptrIsMutable(),
+                    .mutable = operand_ptr_ty.ptrIsMutable(mod),
                 });
                 if (try sema.resolveDefinedValue(block, operand_src, operand_ptr)) |op_ptr_val| {
 @@ -10311,7 +10321,7 @@ fn zirSwitchCaptureTag(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile
     const cond_data = zir_datas[Zir.refToIndex(inst_data.operand).?].un_node;
     const operand_ptr = try sema.resolveInst(cond_data.operand);
     const operand_ptr_ty = sema.typeOf(operand_ptr);
-    const operand_ty = if (is_ref) operand_ptr_ty.childType() else operand_ptr_ty;
+    const operand_ty = if (is_ref) operand_ptr_ty.childType(mod) else operand_ptr_ty;
     if (operand_ty.zigTypeTag(mod) != .Union) {
         const msg = msg: {
 @@ -10448,7 +10458,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         const cond_index = Zir.refToIndex(extra.data.operand).?;
         const raw_operand = sema.resolveInst(zir_data[cond_index].un_node.operand) catch unreachable;
         const target_ty = sema.typeOf(raw_operand);
-        break :blk if (zir_tags[cond_index] == .switch_cond_ref) target_ty.elemType() else target_ty;
+        break :blk if (zir_tags[cond_index] == .switch_cond_ref) target_ty.childType(mod) else target_ty;
     };
     const union_originally = maybe_union_ty.zigTypeTag(mod) == .Union;
 @@ -12132,7 +12142,7 @@ fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     //   into the final binary, and never loads the data into memory.
     // - When a Decl is destroyed, it can free the `*Module.EmbedFile`.
     embed_file.owner_decl = try anon_decl.finish(
-        try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), embed_file.bytes.len),
+        try Type.array(anon_decl.arena(), embed_file.bytes.len, Value.zero, Type.u8, mod),
         try Value.Tag.bytes.create(anon_decl.arena(), bytes_including_null),
         0, // default alignment
     );
 @@ -12200,7 +12210,7 @@ fn zirShl(
             const bit_value = Value.initPayload(&bits_payload.base);
             if (rhs_ty.zigTypeTag(mod) == .Vector) {
                 var i: usize = 0;
-                while (i < rhs_ty.vectorLen()) : (i += 1) {
+                while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
                     var elem_value_buf: Value.ElemValueBuffer = undefined;
                     const rhs_elem = rhs_val.elemValueBuffer(sema.mod, i, &elem_value_buf);
                     if (rhs_elem.compareHetero(.gte, bit_value, mod)) {
 @@ -12220,7 +12230,7 @@ fn zirShl(
         }
         if (rhs_ty.zigTypeTag(mod) == .Vector) {
             var i: usize = 0;
-            while (i < rhs_ty.vectorLen()) : (i += 1) {
+            while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
                 var elem_value_buf: Value.ElemValueBuffer = undefined;
                 const rhs_elem = rhs_val.elemValueBuffer(sema.mod, i, &elem_value_buf);
                 if (rhs_elem.compareHetero(.lt, Value.zero, mod)) {
 @@ -12388,7 +12398,7 @@ fn zirShr(
             const bit_value = Value.initPayload(&bits_payload.base);
             if (rhs_ty.zigTypeTag(mod) == .Vector) {
                 var i: usize = 0;
-                while (i < rhs_ty.vectorLen()) : (i += 1) {
+                while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
                     var elem_value_buf: Value.ElemValueBuffer = undefined;
                     const rhs_elem = rhs_val.elemValueBuffer(sema.mod, i, &elem_value_buf);
                     if (rhs_elem.compareHetero(.gte, bit_value, mod)) {
 @@ -12408,7 +12418,7 @@ fn zirShr(
         }
         if (rhs_ty.zigTypeTag(mod) == .Vector) {
             var i: usize = 0;
-            while (i < rhs_ty.vectorLen()) : (i += 1) {
+            while (i < rhs_ty.vectorLen(mod)) : (i += 1) {
                 var elem_value_buf: Value.ElemValueBuffer = undefined;
                 const rhs_elem = rhs_val.elemValueBuffer(sema.mod, i, &elem_value_buf);
                 if (rhs_elem.compareHetero(.lt, Value.zero, mod)) {
 @@ -12571,7 +12581,7 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         if (val.isUndef()) {
             return sema.addConstUndef(operand_type);
         } else if (operand_type.zigTypeTag(mod) == .Vector) {
-            const vec_len = try sema.usizeCast(block, operand_src, operand_type.vectorLen());
+            const vec_len = try sema.usizeCast(block, operand_src, operand_type.vectorLen(mod));
             var elem_val_buf: Value.ElemValueBuffer = undefined;
             const elems = try sema.arena.alloc(Value, vec_len);
             for (elems, 0..) |*elem, i| {
 @@ -12768,8 +12778,8 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const result_ty = try Type.array(sema.arena, result_len, res_sent_val, resolved_elem_ty, sema.mod);
     const mod = sema.mod;
     const ptr_addrspace = p: {
-        if (lhs_ty.zigTypeTag(mod) == .Pointer) break :p lhs_ty.ptrAddressSpace();
+        if (lhs_ty.zigTypeTag(mod) == .Pointer) break :p lhs_ty.ptrAddressSpace(mod);
-        if (rhs_ty.zigTypeTag(mod) == .Pointer) break :p rhs_ty.ptrAddressSpace();
+        if (rhs_ty.zigTypeTag(mod) == .Pointer) break :p rhs_ty.ptrAddressSpace(mod);
         break :p null;
     };
 @@ -12883,9 +12893,9 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
     const mod = sema.mod;
     const operand_ty = sema.typeOf(operand);
     switch (operand_ty.zigTypeTag(mod)) {
-        .Array => return operand_ty.arrayInfo(),
+        .Array => return operand_ty.arrayInfo(mod),
         .Pointer => {
-            const ptr_info = operand_ty.ptrInfo().data;
+            const ptr_info = operand_ty.ptrInfo(mod);
             switch (ptr_info.size) {
                 // TODO: in the Many case here this should only work if the type
                 // has a sentinel, and this code should compute the length based
 @@ -12900,7 +12910,7 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
                 },
                 .One => {
                     if (ptr_info.pointee_type.zigTypeTag(mod) == .Array) {
-                        return ptr_info.pointee_type.arrayInfo();
+                        return ptr_info.pointee_type.arrayInfo(mod);
                     }
                 },
                 .C => {},
 @@ -12912,7 +12922,7 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
                 return .{
                     .elem_type = peer_ty.elemType2(mod),
                     .sentinel = null,
-                    .len = operand_ty.arrayLen(),
+                    .len = operand_ty.arrayLen(mod),
                 };
             }
         },
 @@ -13035,7 +13045,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const result_ty = try Type.array(sema.arena, result_len, lhs_info.sentinel, lhs_info.elem_type, sema.mod);
-    const ptr_addrspace = if (lhs_ty.zigTypeTag(mod) == .Pointer) lhs_ty.ptrAddressSpace() else null;
+    const ptr_addrspace = if (lhs_ty.zigTypeTag(mod) == .Pointer) lhs_ty.ptrAddressSpace(mod) else null;
     const lhs_len = try sema.usizeCast(block, lhs_src, lhs_info.len);
     if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val| {
 @@ -14022,7 +14032,7 @@ fn intRem(
 ) CompileError!Value {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
-        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -14484,7 +14494,10 @@ fn maybeRepeated(sema: *Sema, ty: Type, val: Value) !Value {
 fn overflowArithmeticTupleType(sema: *Sema, ty: Type) !Type {
     const mod = sema.mod;
-    const ov_ty = if (ty.zigTypeTag(mod) == .Vector) try Type.vector(sema.arena, ty.vectorLen(), Type.u1) else Type.u1;
+    const ov_ty = if (ty.zigTypeTag(mod) == .Vector) try mod.vectorType(.{
+        .len = ty.vectorLen(mod),
+        .child = .u1_type,
+    }) else Type.u1;
     const types = try sema.arena.alloc(Type, 2);
     const values = try sema.arena.alloc(Value, 2);
 @@ -14520,7 +14533,7 @@ fn analyzeArithmetic(
     const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
-    if (lhs_zig_ty_tag == .Pointer) switch (lhs_ty.ptrSize()) {
+    if (lhs_zig_ty_tag == .Pointer) switch (lhs_ty.ptrSize(mod)) {
         .One, .Slice => {},
         .Many, .C => {
             const air_tag: Air.Inst.Tag = switch (zir_tag) {
 @@ -14993,9 +15006,9 @@ fn analyzePtrArithmetic(
     const opt_ptr_val = try sema.resolveMaybeUndefVal(ptr);
     const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);
     const ptr_ty = sema.typeOf(ptr);
-    const ptr_info = ptr_ty.ptrInfo().data;
+    const ptr_info = ptr_ty.ptrInfo(mod);
     const elem_ty = if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag(mod) == .Array)
-        ptr_info.pointee_type.childType()
+        ptr_info.pointee_type.childType(mod)
     else
         ptr_info.pointee_type;
 @@ -15466,7 +15479,10 @@ fn cmpSelf(
                 if (rhs_val.isUndef()) return sema.addConstUndef(Type.bool);
                 if (resolved_type.zigTypeTag(mod) == .Vector) {
-                    const result_ty = try Type.vector(sema.arena, resolved_type.vectorLen(), Type.bool);
+                    const result_ty = try mod.vectorType(.{
+                        .len = resolved_type.vectorLen(mod),
+                        .child = .bool_type,
+                    });
                     const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_type);
                     return sema.addConstant(result_ty, cmp_val);
                 }
 @@ -15767,6 +15783,7 @@ fn zirBuiltinSrc(
     const tracy = trace(@src());
     defer tracy.end();
+    const mod = sema.mod;
     const extra = sema.code.extraData(Zir.Inst.Src, extended.operand).data;
     const src = LazySrcLoc.nodeOffset(extra.node);
     const func = sema.func orelse return sema.fail(block, src, "@src outside function", .{});
 @@ -15778,7 +15795,7 @@ fn zirBuiltinSrc(
         const name = std.mem.span(fn_owner_decl.name);
         const bytes = try anon_decl.arena().dupe(u8, name[0 .. name.len + 1]);
         const new_decl = try anon_decl.finish(
-            try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len - 1),
+            try Type.array(anon_decl.arena(), bytes.len - 1, Value.zero, Type.u8, mod),
             try Value.Tag.bytes.create(anon_decl.arena(), bytes),
             0, // default alignment
         );
 @@ -15791,7 +15808,7 @@ fn zirBuiltinSrc(
         // The compiler must not call realpath anywhere.
         const name = try fn_owner_decl.getFileScope().fullPathZ(anon_decl.arena());
         const new_decl = try anon_decl.finish(
-            try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), name.len),
+            try Type.array(anon_decl.arena(), name.len, Value.zero, Type.u8, mod),
             try Value.Tag.bytes.create(anon_decl.arena(), name[0 .. name.len + 1]),
             0, // default alignment
         );
 @@ -16024,7 +16041,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             );
         },
         .Pointer => {
-            const info = ty.ptrInfo().data;
+            const info = ty.ptrInfo(mod);
             const alignment = if (info.@"align" != 0)
                 try Value.Tag.int_u64.create(sema.arena, info.@"align")
             else
 @@ -16059,7 +16076,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             );
         },
         .Array => {
-            const info = ty.arrayInfo();
+            const info = ty.arrayInfo(mod);
             const field_values = try sema.arena.alloc(Value, 3);
             // len: comptime_int,
             field_values[0] = try Value.Tag.int_u64.create(sema.arena, info.len);
 @@ -16077,7 +16094,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             );
         },
         .Vector => {
-            const info = ty.arrayInfo();
+            const info = ty.arrayInfo(mod);
             const field_values = try sema.arena.alloc(Value, 2);
             // len: comptime_int,
             field_values[0] = try Value.Tag.int_u64.create(sema.arena, info.len);
 @@ -16095,7 +16112,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         .Optional => {
             const field_values = try sema.arena.alloc(Value, 1);
             // child: type,
-            field_values[0] = try Value.Tag.ty.create(sema.arena, try ty.optionalChildAlloc(sema.arena));
+            field_values[0] = try Value.Tag.ty.create(sema.arena, ty.optionalChild(mod));
             return sema.addConstant(
                 type_info_ty,
 @@ -16141,7 +16158,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         defer anon_decl.deinit();
                         const bytes = try anon_decl.arena().dupeZ(u8, name);
                         const new_decl = try anon_decl.finish(
-                            try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                            try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                             try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                             0, // default alignment
                         );
 @@ -16250,7 +16267,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     defer anon_decl.deinit();
                     const bytes = try anon_decl.arena().dupeZ(u8, name);
                     const new_decl = try anon_decl.finish(
-                        try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                        try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                         try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                         0, // default alignment
                     );
 @@ -16338,7 +16355,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     defer anon_decl.deinit();
                     const bytes = try anon_decl.arena().dupeZ(u8, name);
                     const new_decl = try anon_decl.finish(
-                        try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                        try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                         try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                         0, // default alignment
                     );
 @@ -16448,7 +16465,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                             else
                                 try std.fmt.allocPrintZ(anon_decl.arena(), "{d}", .{i});
                             const new_decl = try anon_decl.finish(
-                                try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                                try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                                 try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                                 0, // default alignment
                             );
 @@ -16490,7 +16507,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                         defer anon_decl.deinit();
                         const bytes = try anon_decl.arena().dupeZ(u8, name);
                         const new_decl = try anon_decl.finish(
-                            try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                            try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                             try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                             0, // default alignment
                         );
 @@ -16666,14 +16683,15 @@ fn typeInfoNamespaceDecls(
     decl_vals: *std.ArrayList(Value),
     seen_namespaces: *std.AutoHashMap(*Namespace, void),
 ) !void {
+    const mod = sema.mod;
     const gop = try seen_namespaces.getOrPut(namespace);
     if (gop.found_existing) return;
     const decls = namespace.decls.keys();
     for (decls) |decl_index| {
-        const decl = sema.mod.declPtr(decl_index);
+        const decl = mod.declPtr(decl_index);
         if (decl.kind == .@"usingnamespace") {
             if (decl.analysis == .in_progress) continue;
-            try sema.mod.ensureDeclAnalyzed(decl_index);
+            try mod.ensureDeclAnalyzed(decl_index);
             const new_ns = decl.val.toType().getNamespace().?;
             try sema.typeInfoNamespaceDecls(block, decls_anon_decl, new_ns, decl_vals, seen_namespaces);
             continue;
 @@ -16684,7 +16702,7 @@ fn typeInfoNamespaceDecls(
             defer anon_decl.deinit();
             const bytes = try anon_decl.arena().dupeZ(u8, mem.sliceTo(decl.name, 0));
             const new_decl = try anon_decl.finish(
-                try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+                try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
                 try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
                 0, // default alignment
             );
 @@ -16770,9 +16788,9 @@ fn log2IntType(sema: *Sema, block: *Block, operand: Type, src: LazySrcLoc) Compi
         .Vector => {
             const elem_ty = operand.elemType2(mod);
             const log2_elem_ty = try sema.log2IntType(block, elem_ty, src);
-            return Type.Tag.vector.create(sema.arena, .{
+            return mod.vectorType(.{
-                .len = operand.vectorLen(),
+                .len = operand.vectorLen(mod),
-                .elem_type = log2_elem_ty,
+                .child = log2_elem_ty.ip_index,
             });
         },
         else => {},
 @@ -17207,7 +17225,7 @@ 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().data;
+    const ptr_info = operand_ty.ptrInfo(mod);
     const res_ty = try Type.ptr(sema.arena, sema.mod, .{
         .pointee_type = err_union_ty.errorUnionPayload(),
         .@"addrspace" = ptr_info.@"addrspace",
 @@ -17398,6 +17416,7 @@ fn retWithErrTracing(
     ret_tag: Air.Inst.Tag,
     operand: Air.Inst.Ref,
 ) CompileError!Zir.Inst.Index {
+    const mod = sema.mod;
     const need_check = switch (is_non_err) {
         .bool_true => {
             _ = try block.addUnOp(ret_tag, operand);
 @@ -17409,7 +17428,7 @@ fn retWithErrTracing(
     const gpa = sema.gpa;
     const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
     const stack_trace_ty = try sema.resolveTypeFields(unresolved_stack_trace_ty);
-    const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
+    const ptr_stack_trace_ty = try mod.singleMutPtrType(stack_trace_ty);
     const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
     const return_err_fn = try sema.getBuiltin("returnError");
     const args: [1]Air.Inst.Ref = .{err_return_trace};
 @@ -17755,7 +17774,7 @@ fn structInitEmpty(
 fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
-    const arr_len = obj_ty.arrayLen();
+    const arr_len = obj_ty.arrayLen(mod);
     if (arr_len != 0) {
         if (obj_ty.zigTypeTag(mod) == .Array) {
             return sema.fail(block, src, "expected {d} array elements; found 0", .{arr_len});
 @@ -17763,7 +17782,7 @@ fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) Com
             return sema.fail(block, src, "expected {d} vector elements; found 0", .{arr_len});
         }
     }
-    if (obj_ty.sentinel()) |sentinel| {
+    if (obj_ty.sentinel(mod)) |sentinel| {
         const val = try Value.Tag.empty_array_sentinel.create(sema.arena, sentinel);
         return sema.addConstant(obj_ty, val);
     } else {
 @@ -18199,6 +18218,7 @@ fn zirArrayInit(
     inst: Zir.Inst.Index,
     is_ref: bool,
 ) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const gpa = sema.gpa;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
 @@ -18208,8 +18228,7 @@ fn zirArrayInit(
     assert(args.len >= 2); // array_ty + at least one element
     const array_ty = try sema.resolveType(block, src, args[0]);
-    const sentinel_val = array_ty.sentinel();
+    const sentinel_val = array_ty.sentinel(mod);
-    const mod = sema.mod;
     const resolved_args = try gpa.alloc(Air.Inst.Ref, args.len - 1 + @boolToInt(sentinel_val != null));
     defer gpa.free(resolved_args);
 @@ -18489,14 +18508,16 @@ fn zirErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
 }
 fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const unresolved_stack_trace_ty = try sema.getBuiltinType("StackTrace");
     const stack_trace_ty = try sema.resolveTypeFields(unresolved_stack_trace_ty);
-    const opt_ptr_stack_trace_ty = try Type.Tag.optional_single_mut_pointer.create(sema.arena, stack_trace_ty);
+    const ptr_stack_trace_ty = try mod.singleMutPtrType(stack_trace_ty);
+    const opt_ptr_stack_trace_ty = try Type.optional(sema.arena, ptr_stack_trace_ty, mod);
     if (sema.owner_func != null and
         sema.owner_func.?.calls_or_awaits_errorable_fn and
-        sema.mod.comp.bin_file.options.error_return_tracing and
+        mod.comp.bin_file.options.error_return_tracing and
-        sema.mod.backendSupportsFeature(.error_return_trace))
+        mod.backendSupportsFeature(.error_return_trace))
     {
         return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
     }
 @@ -18585,8 +18606,11 @@ fn zirUnaryMath(
     switch (operand_ty.zigTypeTag(mod)) {
         .Vector => {
             const scalar_ty = operand_ty.scalarType(mod);
-            const vec_len = operand_ty.vectorLen();
+            const vec_len = operand_ty.vectorLen(mod);
-            const result_ty = try Type.vector(sema.arena, vec_len, scalar_ty);
+            const result_ty = try mod.vectorType(.{
+                .len = vec_len,
+                .child = scalar_ty.ip_index,
+            });
             if (try sema.resolveMaybeUndefVal(operand)) |val| {
                 if (val.isUndef())
                     return sema.addConstUndef(result_ty);
 @@ -18730,12 +18754,15 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             const len_val = struct_val[0];
             const child_val = struct_val[1];
-            const len = len_val.toUnsignedInt(mod);
+            const len = @intCast(u32, len_val.toUnsignedInt(mod));
             const child_ty = child_val.toType();
             try sema.checkVectorElemType(block, src, child_ty);
-            const ty = try Type.vector(sema.arena, len, try child_ty.copy(sema.arena));
+            const ty = try mod.vectorType(.{
+                .len = len,
+                .child = child_ty.ip_index,
+            });
             return sema.addType(ty);
         },
         .Float => {
 @@ -18872,7 +18899,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             const child_ty = try child_val.toType().copy(sema.arena);
-            const ty = try Type.optional(sema.arena, child_ty);
+            const ty = try Type.optional(sema.arena, child_ty, mod);
             return sema.addType(ty);
         },
         .ErrorUnion => {
 @@ -18912,7 +18939,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 // TODO use reflection instead of magic numbers here
                 // error_set: type,
                 const name_val = struct_val[0];
-                const name_str = try name_val.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, sema.mod);
+                const name_str = try name_val.toAllocatedBytes(Type.const_slice_u8, sema.arena, sema.mod);
                 const kv = try mod.getErrorValue(name_str);
                 const gop = names.getOrPutAssumeCapacity(kv.key);
 @@ -19038,7 +19065,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 const value_val = field_struct_val[1];
                 const field_name = try name_val.toAllocatedBytes(
-                    Type.initTag(.const_slice_u8),
+                    Type.const_slice_u8,
                     new_decl_arena_allocator,
                     sema.mod,
                 );
 @@ -19215,7 +19242,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 const alignment_val = field_struct_val[2];
                 const field_name = try name_val.toAllocatedBytes(
-                    Type.initTag(.const_slice_u8),
+                    Type.const_slice_u8,
                     new_decl_arena_allocator,
                     sema.mod,
                 );
 @@ -19482,7 +19509,7 @@ fn reifyStruct(
         }
         const field_name = try name_val.toAllocatedBytes(
-            Type.initTag(.const_slice_u8),
+            Type.const_slice_u8,
             new_decl_arena_allocator,
             mod,
         );
 @@ -19626,7 +19653,7 @@ fn zirAddrSpaceCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
     try sema.checkPtrOperand(block, ptr_src, ptr_ty);
-    var ptr_info = ptr_ty.ptrInfo().data;
+    var ptr_info = ptr_ty.ptrInfo(mod);
     const src_addrspace = ptr_info.@"addrspace";
     if (!target_util.addrSpaceCastIsValid(sema.mod.getTarget(), src_addrspace, dest_addrspace)) {
         const msg = msg: {
 @@ -19641,7 +19668,7 @@ fn zirAddrSpaceCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
     ptr_info.@"addrspace" = dest_addrspace;
     const dest_ptr_ty = try Type.ptr(sema.arena, sema.mod, ptr_info);
     const dest_ty = if (ptr_ty.zigTypeTag(mod) == .Optional)
-        try Type.optional(sema.arena, dest_ptr_ty)
+        try Type.optional(sema.arena, dest_ptr_ty, mod)
     else
         dest_ptr_ty;
 @@ -19731,6 +19758,7 @@ 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 mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const ty = try sema.resolveType(block, ty_src, inst_data.operand);
 @@ -19738,10 +19766,10 @@ fn zirTypeName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     var anon_decl = try block.startAnonDecl();
     defer anon_decl.deinit();
-    const bytes = try ty.nameAllocArena(anon_decl.arena(), sema.mod);
+    const bytes = try ty.nameAllocArena(anon_decl.arena(), mod);
     const new_decl = try anon_decl.finish(
-        try Type.Tag.array_u8_sentinel_0.create(anon_decl.arena(), bytes.len),
+        try Type.array(anon_decl.arena(), bytes.len, Value.zero, Type.u8, mod),
         try Value.Tag.bytes.create(anon_decl.arena(), bytes[0 .. bytes.len + 1]),
         0, // default alignment
     );
 @@ -19842,7 +19870,7 @@ fn zirIntToPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const elem_ty = ptr_ty.elemType2(mod);
     const ptr_align = try ptr_ty.ptrAlignmentAdvanced(mod, sema);
-    if (ptr_ty.isSlice()) {
+    if (ptr_ty.isSlice(mod)) {
         const msg = msg: {
             const msg = try sema.errMsg(block, type_src, "integer cannot be converted to slice type '{}'", .{ptr_ty.fmt(sema.mod)});
             errdefer msg.destroy(sema.gpa);
 @@ -19987,8 +20015,8 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     try sema.checkPtrType(block, dest_ty_src, dest_ty);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
-    const operand_info = operand_ty.ptrInfo().data;
+    const operand_info = operand_ty.ptrInfo(mod);
-    const dest_info = dest_ty.ptrInfo().data;
+    const dest_info = dest_ty.ptrInfo(mod);
     if (!operand_info.mutable and dest_info.mutable) {
         const msg = msg: {
             const msg = try sema.errMsg(block, src, "cast discards const qualifier", .{});
 @@ -20042,12 +20070,11 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     const aligned_dest_ty = if (operand_align <= dest_align) dest_ty else blk: {
         // Unwrap the pointer (or pointer-like optional) type, set alignment, and re-wrap into result
         if (dest_ty.zigTypeTag(mod) == .Optional) {
-            var buf: Type.Payload.ElemType = undefined;
+            var dest_ptr_info = dest_ty.optionalChild(mod).ptrInfo(mod);
-            var dest_ptr_info = dest_ty.optionalChild(&buf).ptrInfo().data;
             dest_ptr_info.@"align" = operand_align;
-            break :blk try Type.optional(sema.arena, try Type.ptr(sema.arena, sema.mod, dest_ptr_info));
+            break :blk try Type.optional(sema.arena, try Type.ptr(sema.arena, sema.mod, dest_ptr_info), mod);
         } else {
-            var dest_ptr_info = dest_ty.ptrInfo().data;
+            var dest_ptr_info = dest_ty.ptrInfo(mod);
             dest_ptr_info.@"align" = operand_align;
             break :blk try Type.ptr(sema.arena, sema.mod, dest_ptr_info);
         }
 @@ -20110,6 +20137,7 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
 }
 fn zirConstCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = LazySrcLoc.nodeOffset(extra.node);
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
 @@ -20117,7 +20145,7 @@ fn zirConstCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
     const operand_ty = sema.typeOf(operand);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
-    var ptr_info = operand_ty.ptrInfo().data;
+    var ptr_info = operand_ty.ptrInfo(mod);
     ptr_info.mutable = true;
     const dest_ty = try Type.ptr(sema.arena, sema.mod, ptr_info);
 @@ -20130,6 +20158,7 @@ fn zirConstCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
 }
 fn zirVolatileCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = LazySrcLoc.nodeOffset(extra.node);
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
 @@ -20137,7 +20166,7 @@ fn zirVolatileCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const operand_ty = sema.typeOf(operand);
     try sema.checkPtrOperand(block, operand_src, operand_ty);
-    var ptr_info = operand_ty.ptrInfo().data;
+    var ptr_info = operand_ty.ptrInfo(mod);
     ptr_info.@"volatile" = false;
     const dest_ty = try Type.ptr(sema.arena, sema.mod, ptr_info);
 @@ -20163,7 +20192,10 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const operand_scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
     const is_vector = operand_ty.zigTypeTag(mod) == .Vector;
     const dest_ty = if (is_vector)
-        try Type.vector(sema.arena, operand_ty.vectorLen(), dest_scalar_ty)
+        try mod.vectorType(.{
+            .len = operand_ty.vectorLen(mod),
+            .child = dest_scalar_ty.ip_index,
+        })
     else
         dest_scalar_ty;
 @@ -20218,7 +20250,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             );
         }
         var elem_buf: Value.ElemValueBuffer = undefined;
-        const elems = try sema.arena.alloc(Value, operand_ty.vectorLen());
+        const elems = try sema.arena.alloc(Value, operand_ty.vectorLen(mod));
         for (elems, 0..) |*elem, i| {
             const elem_val = val.elemValueBuffer(sema.mod, i, &elem_buf);
             elem.* = try elem_val.intTrunc(operand_scalar_ty, sema.arena, dest_info.signedness, dest_info.bits, sema.mod);
 @@ -20245,7 +20277,7 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     try sema.checkPtrOperand(block, ptr_src, ptr_ty);
-    var ptr_info = ptr_ty.ptrInfo().data;
+    var ptr_info = ptr_ty.ptrInfo(mod);
     ptr_info.@"align" = dest_align;
     var dest_ty = try Type.ptr(sema.arena, sema.mod, ptr_info);
     if (ptr_ty.zigTypeTag(mod) == .Optional) {
 @@ -20314,8 +20346,11 @@ fn zirBitCount(
     const result_scalar_ty = try mod.smallestUnsignedInt(bits);
     switch (operand_ty.zigTypeTag(mod)) {
         .Vector => {
-            const vec_len = operand_ty.vectorLen();
+            const vec_len = operand_ty.vectorLen(mod);
-            const result_ty = try Type.vector(sema.arena, vec_len, result_scalar_ty);
+            const result_ty = try mod.vectorType(.{
+                .len = vec_len,
+                .child = result_scalar_ty.ip_index,
+            });
             if (try sema.resolveMaybeUndefVal(operand)) |val| {
                 if (val.isUndef()) return sema.addConstUndef(result_ty);
 @@ -20388,7 +20423,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 if (val.isUndef())
                     return sema.addConstUndef(operand_ty);
-                const vec_len = operand_ty.vectorLen();
+                const vec_len = operand_ty.vectorLen(mod);
                 var elem_buf: Value.ElemValueBuffer = undefined;
                 const elems = try sema.arena.alloc(Value, vec_len);
                 for (elems, 0..) |*elem, i| {
 @@ -20437,7 +20472,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
                 if (val.isUndef())
                     return sema.addConstUndef(operand_ty);
-                const vec_len = operand_ty.vectorLen();
+                const vec_len = operand_ty.vectorLen(mod);
                 var elem_buf: Value.ElemValueBuffer = undefined;
                 const elems = try sema.arena.alloc(Value, vec_len);
                 for (elems, 0..) |*elem, i| {
 @@ -20546,7 +20581,7 @@ fn checkInvalidPtrArithmetic(
 ) CompileError!void {
     const mod = sema.mod;
     switch (try ty.zigTypeTagOrPoison(mod)) {
-        .Pointer => switch (ty.ptrSize()) {
+        .Pointer => switch (ty.ptrSize(mod)) {
             .One, .Slice => return,
             .Many, .C => return sema.fail(
                 block,
 @@ -20676,7 +20711,7 @@ fn checkNumericType(
     const mod = sema.mod;
     switch (ty.zigTypeTag(mod)) {
         .ComptimeFloat, .Float, .ComptimeInt, .Int => {},
-        .Vector => switch (ty.childType().zigTypeTag(mod)) {
+        .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
             .ComptimeFloat, .Float, .ComptimeInt, .Int => {},
             else => |t| return sema.fail(block, ty_src, "expected number, found '{}'", .{t}),
         },
 @@ -20726,7 +20761,7 @@ fn checkAtomicPtrOperand(
     const ptr_ty = sema.typeOf(ptr);
     const ptr_data = switch (try ptr_ty.zigTypeTagOrPoison(mod)) {
-        .Pointer => ptr_ty.ptrInfo().data,
+        .Pointer => ptr_ty.ptrInfo(mod),
         else => {
             const wanted_ptr_ty = try Type.ptr(sema.arena, sema.mod, wanted_ptr_data);
             _ = try sema.coerce(block, wanted_ptr_ty, ptr, ptr_src);
 @@ -20797,7 +20832,7 @@ fn checkIntOrVector(
     switch (try operand_ty.zigTypeTagOrPoison(mod)) {
         .Int => return operand_ty,
         .Vector => {
-            const elem_ty = operand_ty.childType();
+            const elem_ty = operand_ty.childType(mod);
             switch (try elem_ty.zigTypeTagOrPoison(mod)) {
                 .Int => return elem_ty,
                 else => return sema.fail(block, operand_src, "expected vector of integers; found vector of '{}'", .{
 @@ -20821,7 +20856,7 @@ fn checkIntOrVectorAllowComptime(
     switch (try operand_ty.zigTypeTagOrPoison(mod)) {
         .Int, .ComptimeInt => return operand_ty,
         .Vector => {
-            const elem_ty = operand_ty.childType();
+            const elem_ty = operand_ty.childType(mod);
             switch (try elem_ty.zigTypeTagOrPoison(mod)) {
                 .Int, .ComptimeInt => return elem_ty,
                 else => return sema.fail(block, operand_src, "expected vector of integers; found vector of '{}'", .{
 @@ -20870,7 +20905,7 @@ fn checkSimdBinOp(
     const rhs_ty = sema.typeOf(uncasted_rhs);
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
-    var vec_len: ?usize = if (lhs_ty.zigTypeTag(mod) == .Vector) lhs_ty.vectorLen() else null;
+    var vec_len: ?usize = if (lhs_ty.zigTypeTag(mod) == .Vector) lhs_ty.vectorLen(mod) else null;
     const result_ty = try sema.resolvePeerTypes(block, src, &.{ uncasted_lhs, uncasted_rhs }, .{
         .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
     });
 @@ -20912,8 +20947,8 @@ fn checkVectorizableBinaryOperands(
     };
     if (lhs_is_vector and rhs_is_vector) {
-        const lhs_len = lhs_ty.arrayLen();
+        const lhs_len = lhs_ty.arrayLen(mod);
-        const rhs_len = rhs_ty.arrayLen();
+        const rhs_len = rhs_ty.arrayLen(mod);
         if (lhs_len != rhs_len) {
             const msg = msg: {
                 const msg = try sema.errMsg(block, src, "vector length mismatch", .{});
 @@ -20966,7 +21001,7 @@ fn resolveExportOptions(
     const name_operand = try sema.fieldVal(block, src, options, "name", name_src);
     const name_val = try sema.resolveConstValue(block, name_src, name_operand, "name of exported value must be comptime-known");
-    const name_ty = Type.initTag(.const_slice_u8);
+    const name_ty = Type.const_slice_u8;
     const name = try name_val.toAllocatedBytes(name_ty, sema.arena, mod);
     const linkage_operand = try sema.fieldVal(block, src, options, "linkage", linkage_src);
 @@ -20975,7 +21010,7 @@ fn resolveExportOptions(
     const section_operand = try sema.fieldVal(block, src, options, "section", section_src);
     const section_opt_val = try sema.resolveConstValue(block, section_src, section_operand, "linksection of exported value must be comptime-known");
-    const section_ty = Type.initTag(.const_slice_u8);
+    const section_ty = Type.const_slice_u8;
     const section = if (section_opt_val.optionalValue(mod)) |section_val|
         try section_val.toAllocatedBytes(section_ty, sema.arena, mod)
     else
 @@ -21087,7 +21122,7 @@ fn zirCmpxchg(
         return sema.fail(block, failure_order_src, "failure atomic ordering must not be Release or AcqRel", .{});
     }
-    const result_ty = try Type.optional(sema.arena, elem_ty);
+    const result_ty = try Type.optional(sema.arena, elem_ty, mod);
     // special case zero bit types
     if ((try sema.typeHasOnePossibleValue(elem_ty)) != null) {
 @@ -21133,6 +21168,7 @@ fn zirCmpxchg(
 }
 fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
     const len_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
 @@ -21141,9 +21177,9 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const scalar = try sema.resolveInst(extra.rhs);
     const scalar_ty = sema.typeOf(scalar);
     try sema.checkVectorElemType(block, scalar_src, scalar_ty);
-    const vector_ty = try Type.Tag.vector.create(sema.arena, .{
+    const vector_ty = try mod.vectorType(.{
         .len = len,
-        .elem_type = scalar_ty,
+        .child = scalar_ty.ip_index,
     });
     if (try sema.resolveMaybeUndefVal(scalar)) |scalar_val| {
         if (scalar_val.isUndef()) return sema.addConstUndef(vector_ty);
 @@ -21172,7 +21208,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         return sema.fail(block, operand_src, "expected vector, found '{}'", .{operand_ty.fmt(mod)});
     }
-    const scalar_ty = operand_ty.childType();
+    const scalar_ty = operand_ty.childType(mod);
     // Type-check depending on operation.
     switch (operation) {
 @@ -21190,7 +21226,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
         },
     }
-    const vec_len = operand_ty.vectorLen();
+    const vec_len = operand_ty.vectorLen(mod);
     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.
 @@ -21243,12 +21279,12 @@ fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     var mask_ty = sema.typeOf(mask);
     const mask_len = switch (sema.typeOf(mask).zigTypeTag(mod)) {
-        .Array, .Vector => sema.typeOf(mask).arrayLen(),
+        .Array, .Vector => sema.typeOf(mask).arrayLen(mod),
         else => return sema.fail(block, mask_src, "expected vector or array, found '{}'", .{sema.typeOf(mask).fmt(sema.mod)}),
     };
-    mask_ty = try Type.Tag.vector.create(sema.arena, .{
+    mask_ty = try mod.vectorType(.{
-        .len = mask_len,
+        .len = @intCast(u32, mask_len),
-        .elem_type = Type.i32,
+        .child = .i32_type,
     });
     mask = try sema.coerce(block, mask_ty, mask, mask_src);
     const mask_val = try sema.resolveConstMaybeUndefVal(block, mask_src, mask, "shuffle mask must be comptime-known");
 @@ -21272,13 +21308,13 @@ fn analyzeShuffle(
     var a = a_arg;
     var b = b_arg;
-    const res_ty = try Type.Tag.vector.create(sema.arena, .{
+    const res_ty = try mod.vectorType(.{
         .len = mask_len,
-        .elem_type = elem_ty,
+        .child = elem_ty.ip_index,
     });
     var maybe_a_len = switch (sema.typeOf(a).zigTypeTag(mod)) {
-        .Array, .Vector => sema.typeOf(a).arrayLen(),
+        .Array, .Vector => sema.typeOf(a).arrayLen(mod),
         .Undefined => null,
         else => return sema.fail(block, a_src, "expected vector or array with element type '{}', found '{}'", .{
             elem_ty.fmt(sema.mod),
 @@ -21286,7 +21322,7 @@ fn analyzeShuffle(
         }),
     };
     var maybe_b_len = switch (sema.typeOf(b).zigTypeTag(mod)) {
-        .Array, .Vector => sema.typeOf(b).arrayLen(),
+        .Array, .Vector => sema.typeOf(b).arrayLen(mod),
         .Undefined => null,
         else => return sema.fail(block, b_src, "expected vector or array with element type '{}', found '{}'", .{
             elem_ty.fmt(sema.mod),
 @@ -21296,16 +21332,16 @@ fn analyzeShuffle(
     if (maybe_a_len == null and maybe_b_len == null) {
         return sema.addConstUndef(res_ty);
     }
-    const a_len = maybe_a_len orelse maybe_b_len.?;
+    const a_len = @intCast(u32, maybe_a_len orelse maybe_b_len.?);
-    const b_len = maybe_b_len orelse a_len;
+    const b_len = @intCast(u32, maybe_b_len orelse a_len);
-    const a_ty = try Type.Tag.vector.create(sema.arena, .{
+    const a_ty = try mod.vectorType(.{
         .len = a_len,
-        .elem_type = elem_ty,
+        .child = elem_ty.ip_index,
     });
-    const b_ty = try Type.Tag.vector.create(sema.arena, .{
+    const b_ty = try mod.vectorType(.{
         .len = b_len,
-        .elem_type = elem_ty,
+        .child = elem_ty.ip_index,
     });
     if (maybe_a_len == null) a = try sema.addConstUndef(a_ty) else a = try sema.coerce(block, a_ty, a, a_src);
 @@ -21437,15 +21473,21 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
     const pred_ty = sema.typeOf(pred_uncoerced);
     const vec_len_u64 = switch (try pred_ty.zigTypeTagOrPoison(mod)) {
-        .Vector, .Array => pred_ty.arrayLen(),
+        .Vector, .Array => pred_ty.arrayLen(mod),
         else => return sema.fail(block, pred_src, "expected vector or array, found '{}'", .{pred_ty.fmt(sema.mod)}),
     };
-    const vec_len = try sema.usizeCast(block, pred_src, vec_len_u64);
+    const vec_len = @intCast(u32, try sema.usizeCast(block, pred_src, vec_len_u64));
-    const bool_vec_ty = try Type.vector(sema.arena, vec_len, Type.bool);
+    const bool_vec_ty = try mod.vectorType(.{
+        .len = vec_len,
+        .child = .bool_type,
+    });
     const pred = try sema.coerce(block, bool_vec_ty, pred_uncoerced, pred_src);
-    const vec_ty = try Type.vector(sema.arena, vec_len, elem_ty);
+    const vec_ty = try mod.vectorType(.{
+        .len = vec_len,
+        .child = elem_ty.ip_index,
+    });
     const a = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.a), a_src);
     const b = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.b), b_src);
 @@ -21854,7 +21896,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
     }
     try sema.checkPtrOperand(block, ptr_src, field_ptr_ty);
-    const field_ptr_ty_info = field_ptr_ty.ptrInfo().data;
+    const field_ptr_ty_info = field_ptr_ty.ptrInfo(mod);
     var ptr_ty_data: Type.Payload.Pointer.Data = .{
         .pointee_type = parent_ty.structFieldType(field_index),
 @@ -22052,8 +22094,8 @@ fn analyzeMinMax(
         }
         const refined_ty = if (orig_ty.zigTypeTag(mod) == .Vector) blk: {
-            const elem_ty = orig_ty.childType();
+            const elem_ty = orig_ty.childType(mod);
-            const len = orig_ty.vectorLen();
+            const len = orig_ty.vectorLen(mod);
             if (len == 0) break :blk orig_ty;
             if (elem_ty.isAnyFloat()) break :blk orig_ty; // can't refine floats
 @@ -22068,7 +22110,10 @@ fn analyzeMinMax(
             }
             const refined_elem_ty = try mod.intFittingRange(cur_min, cur_max);
-            break :blk try Type.vector(sema.arena, len, refined_elem_ty);
+            break :blk try mod.vectorType(.{
+                .len = len,
+                .child = refined_elem_ty.ip_index,
+            });
         } else blk: {
             if (orig_ty.isAnyFloat()) break :blk orig_ty; // can't refine floats
             if (val.isUndef()) break :blk orig_ty; // can't refine undef
 @@ -22129,8 +22174,8 @@ fn analyzeMinMax(
         if (known_undef) break :refine; // can't refine undef
         const unrefined_ty = sema.typeOf(cur_minmax.?);
         const is_vector = unrefined_ty.zigTypeTag(mod) == .Vector;
-        const comptime_elem_ty = if (is_vector) comptime_ty.childType() else comptime_ty;
+        const comptime_elem_ty = if (is_vector) comptime_ty.childType(mod) else comptime_ty;
-        const unrefined_elem_ty = if (is_vector) unrefined_ty.childType() else unrefined_ty;
+        const unrefined_elem_ty = if (is_vector) unrefined_ty.childType(mod) else unrefined_ty;
         if (unrefined_elem_ty.isAnyFloat()) break :refine; // we can't refine floats
 @@ -22150,7 +22195,10 @@ fn analyzeMinMax(
         const final_elem_ty = try mod.intFittingRange(min_val, max_val);
         const final_ty = if (is_vector)
-            try Type.vector(sema.arena, unrefined_ty.vectorLen(), final_elem_ty)
+            try mod.vectorType(.{
+                .len = unrefined_ty.vectorLen(mod),
+                .child = final_elem_ty.ip_index,
+            })
         else
             final_elem_ty;
 @@ -22165,7 +22213,7 @@ fn analyzeMinMax(
 fn upgradeToArrayPtr(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, len: u64) !Air.Inst.Ref {
     const mod = sema.mod;
-    const info = sema.typeOf(ptr).ptrInfo().data;
+    const info = sema.typeOf(ptr).ptrInfo(mod);
     if (info.size == .One) {
         // Already an array pointer.
         return ptr;
 @@ -22659,7 +22707,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const body = sema.code.extra[extra_index..][0..body_len];
         extra_index += body.len;
-        const ty = Type.initTag(.const_slice_u8);
+        const ty = Type.const_slice_u8;
         const val = try sema.resolveGenericBody(block, section_src, body, inst, ty, "linksection must be comptime-known");
         if (val.isGenericPoison()) {
             break :blk FuncLinkSection{ .generic = {} };
 @@ -22943,7 +22991,7 @@ fn resolveExternOptions(
     const name_ref = try sema.fieldVal(block, src, options, "name", name_src);
     const name_val = try sema.resolveConstValue(block, name_src, name_ref, "name of the extern symbol must be comptime-known");
-    const name = try name_val.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod);
+    const name = try name_val.toAllocatedBytes(Type.const_slice_u8, sema.arena, mod);
     const library_name_inst = try sema.fieldVal(block, src, options, "library_name", library_src);
     const library_name_val = try sema.resolveConstValue(block, library_src, library_name_inst, "library in which extern symbol is must be comptime-known");
 @@ -22957,7 +23005,7 @@ fn resolveExternOptions(
     const library_name = if (!library_name_val.isNull(mod)) blk: {
         const payload = library_name_val.castTag(.opt_payload).?.data;
-        const library_name = try payload.toAllocatedBytes(Type.initTag(.const_slice_u8), sema.arena, mod);
+        const library_name = try payload.toAllocatedBytes(Type.const_slice_u8, sema.arena, mod);
         if (library_name.len == 0) {
             return sema.fail(block, library_src, "library name cannot be empty", .{});
         }
 @@ -22994,7 +23042,7 @@ fn zirBuiltinExtern(
     if (!ty.isPtrAtRuntime(mod)) {
         return sema.fail(block, ty_src, "expected (optional) pointer", .{});
     }
-    if (!try sema.validateExternType(ty.childType(), .other)) {
+    if (!try sema.validateExternType(ty.childType(mod), .other)) {
         const msg = msg: {
             const msg = try sema.errMsg(block, ty_src, "extern symbol cannot have type '{}'", .{ty.fmt(mod)});
             errdefer msg.destroy(sema.gpa);
 @@ -23014,7 +23062,7 @@ fn zirBuiltinExtern(
     };
     if (options.linkage == .Weak and !ty.ptrAllowsZero(mod)) {
-        ty = try Type.optional(sema.arena, ty);
+        ty = try Type.optional(sema.arena, ty, mod);
     }
     // TODO check duplicate extern
 @@ -23194,7 +23242,7 @@ fn validateRunTimeType(
         => return false,
         .Pointer => {
-            const elem_ty = ty.childType();
+            const elem_ty = ty.childType(mod);
             switch (elem_ty.zigTypeTag(mod)) {
                 .Opaque => return true,
                 .Fn => return elem_ty.isFnOrHasRuntimeBits(mod),
 @@ -23204,11 +23252,10 @@ fn validateRunTimeType(
         .Opaque => return is_extern,
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            const child_ty = ty.optionalChild(mod);
-            const child_ty = ty.optionalChild(&buf);
             return sema.validateRunTimeType(child_ty, is_extern);
         },
-        .Array, .Vector => ty = ty.elemType(),
+        .Array, .Vector => ty = ty.childType(mod),
         .ErrorUnion => ty = ty.errorUnionPayload(),
 @@ -23277,7 +23324,7 @@ fn explainWhyTypeIsComptimeInner(
         },
         .Array, .Vector => {
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.elemType(), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(mod), type_set);
         },
         .Pointer => {
             const elem_ty = ty.elemType2(mod);
 @@ -23295,12 +23342,11 @@ fn explainWhyTypeIsComptimeInner(
                 }
                 return;
             }
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.elemType(), type_set);
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.childType(mod), type_set);
         },
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.optionalChild(mod), type_set);
-            try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.optionalChild(&buf), type_set);
         },
         .ErrorUnion => {
             try sema.explainWhyTypeIsComptimeInner(msg, src_loc, ty.errorUnionPayload(), type_set);
 @@ -23451,7 +23497,7 @@ fn explainWhyTypeIsNotExtern(
             if (ty.isSlice(mod)) {
                 try mod.errNoteNonLazy(src_loc, msg, "slices have no guaranteed in-memory representation", .{});
             } else {
-                const pointee_ty = ty.childType();
+                const pointee_ty = ty.childType(mod);
                 try mod.errNoteNonLazy(src_loc, msg, "pointer to comptime-only type '{}'", .{pointee_ty.fmt(sema.mod)});
                 try sema.explainWhyTypeIsComptime(msg, src_loc, pointee_ty);
             }
 @@ -23698,7 +23744,7 @@ fn panicWithMsg(
         .@"addrspace" = target_util.defaultAddressSpace(target, .global_constant), // TODO might need a place that is more dynamic
     });
     const null_stack_trace = try sema.addConstant(
-        try Type.optional(arena, ptr_stack_trace_ty),
+        try Type.optional(arena, ptr_stack_trace_ty, mod),
         Value.null,
     );
     const args: [3]Air.Inst.Ref = .{ msg_inst, null_stack_trace, .null_value };
 @@ -23927,7 +23973,7 @@ fn fieldVal(
     const is_pointer_to = object_ty.isSinglePointer(mod);
     const inner_ty = if (is_pointer_to)
-        object_ty.childType()
+        object_ty.childType(mod)
     else
         object_ty;
 @@ -23936,12 +23982,12 @@ fn fieldVal(
             if (mem.eql(u8, field_name, "len")) {
                 return sema.addConstant(
                     Type.usize,
-                    try Value.Tag.int_u64.create(arena, inner_ty.arrayLen()),
+                    try Value.Tag.int_u64.create(arena, inner_ty.arrayLen(mod)),
                 );
             } else if (mem.eql(u8, field_name, "ptr") and is_pointer_to) {
-                const ptr_info = object_ty.ptrInfo().data;
+                const ptr_info = object_ty.ptrInfo(mod);
                 const result_ty = try Type.ptr(sema.arena, sema.mod, .{
-                    .pointee_type = ptr_info.pointee_type.childType(),
+                    .pointee_type = ptr_info.pointee_type.childType(mod),
                     .sentinel = ptr_info.sentinel,
                     .@"align" = ptr_info.@"align",
                     .@"addrspace" = ptr_info.@"addrspace",
 @@ -23964,7 +24010,7 @@ fn fieldVal(
             }
         },
         .Pointer => {
-            const ptr_info = inner_ty.ptrInfo().data;
+            const ptr_info = inner_ty.ptrInfo(mod);
             if (ptr_info.size == .Slice) {
                 if (mem.eql(u8, field_name, "ptr")) {
                     const slice = if (is_pointer_to)
 @@ -24107,7 +24153,7 @@ fn fieldPtr(
     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)) {
-        .Pointer => object_ptr_ty.elemType(),
+        .Pointer => object_ptr_ty.childType(mod),
         else => return sema.fail(block, object_ptr_src, "expected pointer, found '{}'", .{object_ptr_ty.fmt(sema.mod)}),
     };
 @@ -24117,7 +24163,7 @@ fn fieldPtr(
     const is_pointer_to = object_ty.isSinglePointer(mod);
     const inner_ty = if (is_pointer_to)
-        object_ty.childType()
+        object_ty.childType(mod)
     else
         object_ty;
 @@ -24128,7 +24174,7 @@ fn fieldPtr(
                 defer anon_decl.deinit();
                 return sema.analyzeDeclRef(try anon_decl.finish(
                     Type.usize,
-                    try Value.Tag.int_u64.create(anon_decl.arena(), inner_ty.arrayLen()),
+                    try Value.Tag.int_u64.create(anon_decl.arena(), inner_ty.arrayLen(mod)),
                     0, // default alignment
                 ));
             } else {
 @@ -24154,9 +24200,9 @@ fn fieldPtr(
                 const result_ty = try Type.ptr(sema.arena, sema.mod, .{
                     .pointee_type = slice_ptr_ty,
-                    .mutable = attr_ptr_ty.ptrIsMutable(),
+                    .mutable = attr_ptr_ty.ptrIsMutable(mod),
                     .@"volatile" = attr_ptr_ty.isVolatilePtr(),
-                    .@"addrspace" = attr_ptr_ty.ptrAddressSpace(),
+                    .@"addrspace" = attr_ptr_ty.ptrAddressSpace(mod),
                 });
                 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
 @@ -24175,9 +24221,9 @@ fn fieldPtr(
             } else if (mem.eql(u8, field_name, "len")) {
                 const result_ty = try Type.ptr(sema.arena, sema.mod, .{
                     .pointee_type = Type.usize,
-                    .mutable = attr_ptr_ty.ptrIsMutable(),
+                    .mutable = attr_ptr_ty.ptrIsMutable(mod),
                     .@"volatile" = attr_ptr_ty.isVolatilePtr(),
-                    .@"addrspace" = attr_ptr_ty.ptrAddressSpace(),
+                    .@"addrspace" = attr_ptr_ty.ptrAddressSpace(mod),
                 });
                 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
 @@ -24329,14 +24375,14 @@ fn fieldCallBind(
     const mod = sema.mod;
     const raw_ptr_src = src; // TODO better source location
     const raw_ptr_ty = sema.typeOf(raw_ptr);
-    const inner_ty = if (raw_ptr_ty.zigTypeTag(mod) == .Pointer and (raw_ptr_ty.ptrSize() == .One or raw_ptr_ty.ptrSize() == .C))
+    const inner_ty = if (raw_ptr_ty.zigTypeTag(mod) == .Pointer and (raw_ptr_ty.ptrSize(mod) == .One or raw_ptr_ty.ptrSize(mod) == .C))
-        raw_ptr_ty.childType()
+        raw_ptr_ty.childType(mod)
     else
         return sema.fail(block, raw_ptr_src, "expected single pointer, found '{}'", .{raw_ptr_ty.fmt(sema.mod)});
     // Optionally dereference a second pointer to get the concrete type.
-    const is_double_ptr = inner_ty.zigTypeTag(mod) == .Pointer and inner_ty.ptrSize() == .One;
+    const is_double_ptr = inner_ty.zigTypeTag(mod) == .Pointer and inner_ty.ptrSize(mod) == .One;
-    const concrete_ty = if (is_double_ptr) inner_ty.childType() else inner_ty;
+    const concrete_ty = if (is_double_ptr) inner_ty.childType(mod) else inner_ty;
     const ptr_ty = if (is_double_ptr) inner_ty else raw_ptr_ty;
     const object_ptr = if (is_double_ptr)
         try sema.analyzeLoad(block, src, raw_ptr, src)
 @@ -24404,9 +24450,9 @@ fn fieldCallBind(
                         // zig fmt: off
                         if (first_param_type.isGenericPoison() or (
                                 first_param_type.zigTypeTag(mod) == .Pointer and
-                                (first_param_type.ptrSize() == .One or
+                                (first_param_type.ptrSize(mod) == .One or
-                                first_param_type.ptrSize() == .C) and
+                                first_param_type.ptrSize(mod) == .C) and
-                                first_param_type.childType().eql(concrete_ty, sema.mod)))
+                                first_param_type.childType(mod).eql(concrete_ty, sema.mod)))
                         {
                         // zig fmt: on
                             // Note that if the param type is generic poison, we know that it must
 @@ -24425,8 +24471,7 @@ fn fieldCallBind(
                                 .arg0_inst = deref,
                             } };
                         } else if (first_param_type.zigTypeTag(mod) == .Optional) {
-                            var opt_buf: Type.Payload.ElemType = undefined;
+                            const child = first_param_type.optionalChild(mod);
-                            const child = first_param_type.optionalChild(&opt_buf);
                             if (child.eql(concrete_ty, sema.mod)) {
                                 const deref = try sema.analyzeLoad(block, src, object_ptr, src);
                                 return .{ .method = .{
 @@ -24434,8 +24479,8 @@ fn fieldCallBind(
                                     .arg0_inst = deref,
                                 } };
                             } else if (child.zigTypeTag(mod) == .Pointer and
-                                child.ptrSize() == .One and
+                                child.ptrSize(mod) == .One and
-                                child.childType().eql(concrete_ty, sema.mod))
+                                child.childType(mod).eql(concrete_ty, sema.mod))
                             {
                                 return .{ .method = .{
                                     .func_inst = decl_val,
 @@ -24482,15 +24527,15 @@ fn finishFieldCallBind(
     field_index: u32,
     object_ptr: Air.Inst.Ref,
 ) CompileError!ResolvedFieldCallee {
+    const mod = sema.mod;
     const arena = sema.arena;
     const ptr_field_ty = try Type.ptr(arena, sema.mod, .{
         .pointee_type = field_ty,
-        .mutable = ptr_ty.ptrIsMutable(),
+        .mutable = ptr_ty.ptrIsMutable(mod),
-        .@"addrspace" = ptr_ty.ptrAddressSpace(),
+        .@"addrspace" = ptr_ty.ptrAddressSpace(mod),
     });
-    const mod = sema.mod;
+    const container_ty = ptr_ty.childType(mod);
-    const container_ty = ptr_ty.childType();
     if (container_ty.zigTypeTag(mod) == .Struct) {
         if (container_ty.structFieldValueComptime(mod, field_index)) |default_val| {
             return .{ .direct = try sema.addConstant(field_ty, default_val) };
 @@ -24618,7 +24663,7 @@ fn structFieldPtrByIndex(
     const struct_obj = struct_ty.castTag(.@"struct").?.data;
     const field = struct_obj.fields.values()[field_index];
     const struct_ptr_ty = sema.typeOf(struct_ptr);
-    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo().data;
+    const struct_ptr_ty_info = struct_ptr_ty.ptrInfo(mod);
     var ptr_ty_data: Type.Payload.Pointer.Data = .{
         .pointee_type = field.ty,
 @@ -24696,7 +24741,7 @@ fn structFieldPtrByIndex(
             ptr_field_ty,
             try Value.Tag.field_ptr.create(sema.arena, .{
                 .container_ptr = struct_ptr_val,
-                .container_ty = struct_ptr_ty.childType(),
+                .container_ty = struct_ptr_ty.childType(mod),
                 .field_index = field_index,
             }),
         );
 @@ -24846,9 +24891,9 @@ fn unionFieldPtr(
     const field = union_obj.fields.values()[field_index];
     const ptr_field_ty = try Type.ptr(arena, sema.mod, .{
         .pointee_type = field.ty,
-        .mutable = union_ptr_ty.ptrIsMutable(),
+        .mutable = union_ptr_ty.ptrIsMutable(mod),
         .@"volatile" = union_ptr_ty.isVolatilePtr(),
-        .@"addrspace" = union_ptr_ty.ptrAddressSpace(),
+        .@"addrspace" = union_ptr_ty.ptrAddressSpace(mod),
     });
     const enum_field_index = @intCast(u32, union_obj.tag_ty.enumFieldIndex(field_name).?);
 @@ -25009,7 +25054,7 @@ fn elemPtr(
     const indexable_ptr_ty = sema.typeOf(indexable_ptr);
     const indexable_ty = switch (indexable_ptr_ty.zigTypeTag(mod)) {
-        .Pointer => indexable_ptr_ty.elemType(),
+        .Pointer => indexable_ptr_ty.childType(mod),
         else => return sema.fail(block, indexable_ptr_src, "expected pointer, found '{}'", .{indexable_ptr_ty.fmt(sema.mod)}),
     };
     try checkIndexable(sema, block, src, indexable_ty);
 @@ -25046,7 +25091,7 @@ fn elemPtrOneLayerOnly(
     try checkIndexable(sema, block, src, indexable_ty);
-    switch (indexable_ty.ptrSize()) {
+    switch (indexable_ty.ptrSize(mod)) {
         .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);
 @@ -25065,7 +25110,7 @@ fn elemPtrOneLayerOnly(
             return block.addPtrElemPtr(indexable, elem_index, result_ty);
         },
         .One => {
-            assert(indexable_ty.childType().zigTypeTag(mod) == .Array); // Guaranteed by checkIndexable
+            assert(indexable_ty.childType(mod).zigTypeTag(mod) == .Array); // Guaranteed by checkIndexable
             return sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety);
         },
     }
 @@ -25091,7 +25136,7 @@ fn elemVal(
     const elem_index = try sema.coerce(block, Type.usize, elem_index_uncasted, elem_index_src);
     switch (indexable_ty.zigTypeTag(mod)) {
-        .Pointer => switch (indexable_ty.ptrSize()) {
+        .Pointer => switch (indexable_ty.ptrSize(mod)) {
             .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);
 @@ -25112,7 +25157,7 @@ fn elemVal(
                 return block.addBinOp(.ptr_elem_val, indexable, elem_index);
             },
             .One => {
-                assert(indexable_ty.childType().zigTypeTag(mod) == .Array); // Guaranteed by checkIndexable
+                assert(indexable_ty.childType(mod).zigTypeTag(mod) == .Array); // Guaranteed by checkIndexable
                 const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
                 return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
             },
 @@ -25171,7 +25216,7 @@ fn tupleFieldPtr(
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const tuple_ptr_ty = sema.typeOf(tuple_ptr);
-    const tuple_ty = tuple_ptr_ty.childType();
+    const tuple_ty = tuple_ptr_ty.childType(mod);
     _ = try sema.resolveTypeFields(tuple_ty);
     const field_count = tuple_ty.structFieldCount();
 @@ -25188,9 +25233,9 @@ fn tupleFieldPtr(
     const field_ty = tuple_ty.structFieldType(field_index);
     const ptr_field_ty = try Type.ptr(sema.arena, sema.mod, .{
         .pointee_type = field_ty,
-        .mutable = tuple_ptr_ty.ptrIsMutable(),
+        .mutable = tuple_ptr_ty.ptrIsMutable(mod),
         .@"volatile" = tuple_ptr_ty.isVolatilePtr(),
-        .@"addrspace" = tuple_ptr_ty.ptrAddressSpace(),
+        .@"addrspace" = tuple_ptr_ty.ptrAddressSpace(mod),
     });
     if (tuple_ty.structFieldValueComptime(mod, field_index)) |default_val| {
 @@ -25271,10 +25316,10 @@ fn elemValArray(
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const array_ty = sema.typeOf(array);
-    const array_sent = array_ty.sentinel();
+    const array_sent = array_ty.sentinel(mod);
-    const array_len = array_ty.arrayLen();
+    const array_len = array_ty.arrayLen(mod);
     const array_len_s = array_len + @boolToInt(array_sent != null);
-    const elem_ty = array_ty.childType();
+    const elem_ty = array_ty.childType(mod);
     if (array_len_s == 0) {
         return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});
 @@ -25335,9 +25380,9 @@ fn elemPtrArray(
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const array_ptr_ty = sema.typeOf(array_ptr);
-    const array_ty = array_ptr_ty.childType();
+    const array_ty = array_ptr_ty.childType(mod);
-    const array_sent = array_ty.sentinel() != null;
+    const array_sent = array_ty.sentinel(mod) != null;
-    const array_len = array_ty.arrayLen();
+    const array_len = array_ty.arrayLen(mod);
     const array_len_s = array_len + @boolToInt(array_sent);
     if (array_len_s == 0) {
 @@ -25396,7 +25441,7 @@ fn elemValSlice(
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const slice_ty = sema.typeOf(slice);
-    const slice_sent = slice_ty.sentinel() != null;
+    const slice_sent = slice_ty.sentinel(mod) != null;
     const elem_ty = slice_ty.elemType2(mod);
     var runtime_src = slice_src;
 @@ -25453,7 +25498,7 @@ fn elemPtrSlice(
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
     const slice_ty = sema.typeOf(slice);
-    const slice_sent = slice_ty.sentinel() != null;
+    const slice_sent = slice_ty.sentinel(mod) != null;
     const maybe_undef_slice_val = try sema.resolveMaybeUndefVal(slice);
     // The index must not be undefined since it can be out of bounds.
 @@ -25614,7 +25659,7 @@ fn coerceExtra(
             }
             // T to ?T
-            const child_type = try dest_ty.optionalChildAlloc(sema.arena);
+            const child_type = dest_ty.optionalChild(mod);
             const intermediate = sema.coerceExtra(block, child_type, inst, inst_src, .{ .report_err = false }) catch |err| switch (err) {
                 error.NotCoercible => {
                     if (in_memory_result == .no_match) {
 @@ -25628,7 +25673,7 @@ fn coerceExtra(
             return try sema.wrapOptional(block, dest_ty, intermediate, inst_src);
         },
         .Pointer => pointer: {
-            const dest_info = dest_ty.ptrInfo().data;
+            const dest_info = dest_ty.ptrInfo(mod);
             // Function body to function pointer.
             if (inst_ty.zigTypeTag(mod) == .Fn) {
 @@ -25643,11 +25688,11 @@ fn coerceExtra(
                 if (dest_info.size != .One) break :single_item;
                 if (!inst_ty.isSinglePointer(mod)) break :single_item;
                 if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :pointer;
-                const ptr_elem_ty = inst_ty.childType();
+                const ptr_elem_ty = inst_ty.childType(mod);
                 const array_ty = dest_info.pointee_type;
                 if (array_ty.zigTypeTag(mod) != .Array) break :single_item;
-                const array_elem_ty = array_ty.childType();
+                const array_elem_ty = array_ty.childType(mod);
-                if (array_ty.arrayLen() != 1) break :single_item;
+                if (array_ty.arrayLen(mod) != 1) break :single_item;
                 const dest_is_mut = dest_info.mutable;
                 switch (try sema.coerceInMemoryAllowed(block, array_elem_ty, ptr_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {
                     .ok => {},
 @@ -25660,9 +25705,9 @@ fn coerceExtra(
             src_array_ptr: {
                 if (!inst_ty.isSinglePointer(mod)) break :src_array_ptr;
                 if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :pointer;
-                const array_ty = inst_ty.childType();
+                const array_ty = inst_ty.childType(mod);
                 if (array_ty.zigTypeTag(mod) != .Array) break :src_array_ptr;
-                const array_elem_type = array_ty.childType();
+                const array_elem_type = array_ty.childType(mod);
                 const dest_is_mut = dest_info.mutable;
                 const dst_elem_type = dest_info.pointee_type;
 @@ -25680,7 +25725,7 @@ fn coerceExtra(
                 }
                 if (dest_info.sentinel) |dest_sent| {
-                    if (array_ty.sentinel()) |inst_sent| {
+                    if (array_ty.sentinel(mod)) |inst_sent| {
                         if (!dest_sent.eql(inst_sent, dst_elem_type, sema.mod)) {
                             in_memory_result = .{ .ptr_sentinel = .{
                                 .actual = inst_sent,
 @@ -25721,7 +25766,7 @@ fn coerceExtra(
                 if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :src_c_ptr;
                 // In this case we must add a safety check because the C pointer
                 // could be null.
-                const src_elem_ty = inst_ty.childType();
+                const src_elem_ty = inst_ty.childType(mod);
                 const dest_is_mut = dest_info.mutable;
                 const dst_elem_type = dest_info.pointee_type;
                 switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, src_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {
 @@ -25784,7 +25829,7 @@ fn coerceExtra(
                     },
                     .Pointer => p: {
                         if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :p;
-                        const inst_info = inst_ty.ptrInfo().data;
+                        const inst_info = inst_ty.ptrInfo(mod);
                         switch (try sema.coerceInMemoryAllowed(
                             block,
                             dest_info.pointee_type,
 @@ -25814,7 +25859,7 @@ fn coerceExtra(
                     .Union => {
                         // pointer to anonymous struct to pointer to union
                         if (inst_ty.isSinglePointer(mod) and
-                            inst_ty.childType().isAnonStruct() and
+                            inst_ty.childType(mod).isAnonStruct() and
                             sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
                         {
                             return sema.coerceAnonStructToUnionPtrs(block, dest_ty, dest_ty_src, inst, inst_src);
 @@ -25823,7 +25868,7 @@ fn coerceExtra(
                     .Struct => {
                         // pointer to anonymous struct to pointer to struct
                         if (inst_ty.isSinglePointer(mod) and
-                            inst_ty.childType().isAnonStruct() and
+                            inst_ty.childType(mod).isAnonStruct() and
                             sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
                         {
                             return sema.coerceAnonStructToStructPtrs(block, dest_ty, dest_ty_src, inst, inst_src) catch |err| switch (err) {
 @@ -25835,7 +25880,7 @@ fn coerceExtra(
                     .Array => {
                         // pointer to tuple to pointer to array
                         if (inst_ty.isSinglePointer(mod) and
-                            inst_ty.childType().isTuple() and
+                            inst_ty.childType(mod).isTuple() and
                             sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
                         {
                             return sema.coerceTupleToArrayPtrs(block, dest_ty, dest_ty_src, inst, inst_src);
 @@ -25854,7 +25899,7 @@ fn coerceExtra(
                     }
                     if (!inst_ty.isSinglePointer(mod)) break :to_slice;
-                    const inst_child_ty = inst_ty.childType();
+                    const inst_child_ty = inst_ty.childType(mod);
                     if (!inst_child_ty.isTuple()) break :to_slice;
                     // empty tuple to zero-length slice
 @@ -25887,7 +25932,7 @@ fn coerceExtra(
                 .Many => p: {
                     if (!inst_ty.isSlice(mod)) break :p;
                     if (!sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result)) break :p;
-                    const inst_info = inst_ty.ptrInfo().data;
+                    const inst_info = inst_ty.ptrInfo(mod);
                     switch (try sema.coerceInMemoryAllowed(
                         block,
 @@ -26196,9 +26241,8 @@ fn coerceExtra(
         }
         // ?T to T
-        var buf: Type.Payload.ElemType = undefined;
         if (inst_ty.zigTypeTag(mod) == .Optional and
-            (try sema.coerceInMemoryAllowed(block, inst_ty.optionalChild(&buf), dest_ty, false, target, dest_ty_src, inst_src)) == .ok)
+            (try sema.coerceInMemoryAllowed(block, inst_ty.optionalChild(mod), dest_ty, false, target, dest_ty_src, inst_src)) == .ok)
         {
             try sema.errNote(block, inst_src, msg, "cannot convert optional to payload type", .{});
             try sema.errNote(block, inst_src, msg, "consider using '.?', 'orelse', or 'if'", .{});
 @@ -26399,10 +26443,8 @@ const InMemoryCoercionResult = union(enum) {
                 cur = pair.child;
             },
             .optional_shape => |pair| {
-                var buf_actual: Type.Payload.ElemType = undefined;
-                var buf_wanted: Type.Payload.ElemType = undefined;
                 try sema.errNote(block, src, msg, "optional type child '{}' cannot cast into optional type child '{}'", .{
-                    pair.actual.optionalChild(&buf_actual).fmt(sema.mod), pair.wanted.optionalChild(&buf_wanted).fmt(sema.mod),
+                    pair.actual.optionalChild(mod).fmt(sema.mod), pair.wanted.optionalChild(mod).fmt(sema.mod),
                 });
                 break;
             },
 @@ -26640,10 +26682,8 @@ fn coerceInMemoryAllowed(
     }
     // Pointers / Pointer-like Optionals
-    var dest_buf: Type.Payload.ElemType = undefined;
+    const maybe_dest_ptr_ty = try sema.typePtrOrOptionalPtrTy(dest_ty);
-    var src_buf: Type.Payload.ElemType = undefined;
+    const maybe_src_ptr_ty = try sema.typePtrOrOptionalPtrTy(src_ty);
-    const maybe_dest_ptr_ty = try sema.typePtrOrOptionalPtrTy(dest_ty, &dest_buf);
-    const maybe_src_ptr_ty = try sema.typePtrOrOptionalPtrTy(src_ty, &src_buf);
     if (maybe_dest_ptr_ty) |dest_ptr_ty| {
         if (maybe_src_ptr_ty) |src_ptr_ty| {
             return try sema.coerceInMemoryAllowedPtrs(block, dest_ty, src_ty, dest_ptr_ty, src_ptr_ty, dest_is_mut, target, dest_src, src_src);
 @@ -26685,8 +26725,8 @@ fn coerceInMemoryAllowed(
     // Arrays
     if (dest_tag == .Array and src_tag == .Array) {
-        const dest_info = dest_ty.arrayInfo();
+        const dest_info = dest_ty.arrayInfo(mod);
-        const src_info = src_ty.arrayInfo();
+        const src_info = src_ty.arrayInfo(mod);
         if (dest_info.len != src_info.len) {
             return InMemoryCoercionResult{ .array_len = .{
                 .actual = src_info.len,
 @@ -26717,8 +26757,8 @@ fn coerceInMemoryAllowed(
     // Vectors
     if (dest_tag == .Vector and src_tag == .Vector) {
-        const dest_len = dest_ty.vectorLen();
+        const dest_len = dest_ty.vectorLen(mod);
-        const src_len = src_ty.vectorLen();
+        const src_len = src_ty.vectorLen(mod);
         if (dest_len != src_len) {
             return InMemoryCoercionResult{ .vector_len = .{
                 .actual = src_len,
 @@ -26748,8 +26788,8 @@ fn coerceInMemoryAllowed(
                 .wanted = dest_ty,
             } };
         }
-        const dest_child_type = dest_ty.optionalChild(&dest_buf);
+        const dest_child_type = dest_ty.optionalChild(mod);
-        const src_child_type = src_ty.optionalChild(&src_buf);
+        const src_child_type = src_ty.optionalChild(mod);
         const child = try sema.coerceInMemoryAllowed(block, dest_child_type, src_child_type, dest_is_mut, target, dest_src, src_src);
         if (child != .ok) {
 @@ -27019,8 +27059,8 @@ fn coerceInMemoryAllowedPtrs(
     src_src: LazySrcLoc,
 ) !InMemoryCoercionResult {
     const mod = sema.mod;
-    const dest_info = dest_ptr_ty.ptrInfo().data;
+    const dest_info = dest_ptr_ty.ptrInfo(mod);
-    const src_info = src_ptr_ty.ptrInfo().data;
+    const src_info = src_ptr_ty.ptrInfo(mod);
     const ok_ptr_size = src_info.size == dest_info.size or
         src_info.size == .C or dest_info.size == .C;
 @@ -27206,11 +27246,12 @@ fn storePtr2(
     operand_src: LazySrcLoc,
     air_tag: Air.Inst.Tag,
 ) CompileError!void {
+    const mod = sema.mod;
     const ptr_ty = sema.typeOf(ptr);
     if (ptr_ty.isConstPtr())
         return sema.fail(block, ptr_src, "cannot assign to constant", .{});
-    const elem_ty = ptr_ty.childType();
+    const elem_ty = ptr_ty.childType(mod);
     // 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
 @@ -27221,7 +27262,6 @@ fn storePtr2(
     // this code does not handle tuple-to-struct coercion which requires dealing with missing
     // fields.
     const operand_ty = sema.typeOf(uncasted_operand);
-    const mod = sema.mod;
     if (operand_ty.isTuple() and elem_ty.zigTypeTag(mod) == .Array) {
         const field_count = operand_ty.structFieldCount();
         var i: u32 = 0;
 @@ -27247,7 +27287,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();
+        const vector_ty = sema.typeOf(vector_ptr).childType(mod);
         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,
 @@ -27288,7 +27328,7 @@ fn storePtr2(
     try sema.requireRuntimeBlock(block, src, runtime_src);
     try sema.queueFullTypeResolution(elem_ty);
-    if (ptr_ty.ptrInfo().data.vector_index == .runtime) {
+    if (ptr_ty.ptrInfo(mod).vector_index == .runtime) {
         const ptr_inst = Air.refToIndex(ptr).?;
         const air_tags = sema.air_instructions.items(.tag);
         if (air_tags[ptr_inst] == .ptr_elem_ptr) {
 @@ -27322,8 +27362,8 @@ fn storePtr2(
 /// pointer. Only if the final element type matches the vector element type, and the
 /// lengths match.
 fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
-    const array_ty = sema.typeOf(ptr).childType();
     const mod = sema.mod;
+    const array_ty = sema.typeOf(ptr).childType(mod);
     if (array_ty.zigTypeTag(mod) != .Array) return null;
     var ptr_inst = Air.refToIndex(ptr) orelse return null;
     const air_datas = sema.air_instructions.items(.data);
 @@ -27332,7 +27372,6 @@ fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
         const prev_ptr = air_datas[ptr_inst].ty_op.operand;
         const prev_ptr_ty = sema.typeOf(prev_ptr);
         const prev_ptr_child_ty = switch (prev_ptr_ty.tag()) {
-            .single_mut_pointer => prev_ptr_ty.castTag(.single_mut_pointer).?.data,
             .pointer => prev_ptr_ty.castTag(.pointer).?.data.pointee_type,
             else => return null,
         };
 @@ -27342,9 +27381,9 @@ fn obtainBitCastedVectorPtr(sema: *Sema, ptr: Air.Inst.Ref) ?Air.Inst.Ref {
     // We have a pointer-to-array and a pointer-to-vector. If the elements and
     // lengths match, return the result.
-    const vector_ty = sema.typeOf(prev_ptr).childType();
+    const vector_ty = sema.typeOf(prev_ptr).childType(mod);
-    if (array_ty.childType().eql(vector_ty.childType(), sema.mod) and
+    if (array_ty.childType(mod).eql(vector_ty.childType(mod), sema.mod) and
-        array_ty.arrayLen() == vector_ty.vectorLen())
+        array_ty.arrayLen(mod) == vector_ty.vectorLen(mod))
     {
         return prev_ptr;
     } else {
 @@ -27476,14 +27515,14 @@ fn beginComptimePtrMutation(
             switch (parent.pointee) {
                 .direct => |val_ptr| switch (parent.ty.zigTypeTag(mod)) {
                     .Array, .Vector => {
-                        const check_len = parent.ty.arrayLenIncludingSentinel();
+                        const check_len = parent.ty.arrayLenIncludingSentinel(mod);
                         if (elem_ptr.index >= check_len) {
                             // TODO have the parent include the decl so we can say "declared here"
                             return sema.fail(block, src, "comptime store of index {d} out of bounds of array length {d}", .{
                                 elem_ptr.index, check_len,
                             });
                         }
-                        const elem_ty = parent.ty.childType();
+                        const elem_ty = parent.ty.childType(mod);
                         // We might have a pointer to multiple elements of the array (e.g. a pointer
                         // to a sub-array). In this case, we just have to reinterpret the relevant
 @@ -27510,7 +27549,7 @@ fn beginComptimePtrMutation(
                                 defer parent.finishArena(sema.mod);
                                 const array_len_including_sentinel =
-                                    try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
+                                    try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel(mod));
                                 const elems = try arena.alloc(Value, array_len_including_sentinel);
                                 @memset(elems, Value.undef);
 @@ -27536,7 +27575,7 @@ fn beginComptimePtrMutation(
                                 defer parent.finishArena(sema.mod);
                                 const bytes = val_ptr.castTag(.bytes).?.data;
-                                const dest_len = parent.ty.arrayLenIncludingSentinel();
+                                const dest_len = parent.ty.arrayLenIncludingSentinel(mod);
                                 // bytes.len may be one greater than dest_len because of the case when
                                 // assigning `[N:S]T` to `[N]T`. This is allowed; the sentinel is omitted.
                                 assert(bytes.len >= dest_len);
 @@ -27567,13 +27606,13 @@ fn beginComptimePtrMutation(
                                 defer parent.finishArena(sema.mod);
                                 const str_lit = val_ptr.castTag(.str_lit).?.data;
-                                const dest_len = parent.ty.arrayLenIncludingSentinel();
+                                const dest_len = parent.ty.arrayLenIncludingSentinel(mod);
                                 const bytes = sema.mod.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
                                 const elems = try arena.alloc(Value, @intCast(usize, dest_len));
                                 for (bytes, 0..) |byte, i| {
                                     elems[i] = try Value.Tag.int_u64.create(arena, byte);
                                 }
-                                if (parent.ty.sentinel()) |sent_val| {
+                                if (parent.ty.sentinel(mod)) |sent_val| {
                                     assert(elems.len == bytes.len + 1);
                                     elems[bytes.len] = sent_val;
                                 }
 @@ -27603,7 +27642,7 @@ fn beginComptimePtrMutation(
                                 const repeated_val = try val_ptr.castTag(.repeated).?.data.copy(arena);
                                 const array_len_including_sentinel =
-                                    try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
+                                    try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel(mod));
                                 const elems = try arena.alloc(Value, array_len_including_sentinel);
                                 if (elems.len > 0) elems[0] = repeated_val;
                                 for (elems[1..]) |*elem| {
 @@ -27906,12 +27945,12 @@ fn beginComptimePtrMutation(
         },
         .opt_payload_ptr => {
             const opt_ptr = if (ptr_val.castTag(.opt_payload_ptr)) |some| some.data else {
-                return sema.beginComptimePtrMutation(block, src, ptr_val, try ptr_elem_ty.optionalChildAlloc(sema.arena));
+                return sema.beginComptimePtrMutation(block, src, ptr_val, ptr_elem_ty.optionalChild(mod));
             };
             var parent = try sema.beginComptimePtrMutation(block, src, opt_ptr.container_ptr, opt_ptr.container_ty);
             switch (parent.pointee) {
                 .direct => |val_ptr| {
-                    const payload_ty = try parent.ty.optionalChildAlloc(sema.arena);
+                    const payload_ty = parent.ty.optionalChild(mod);
                     switch (val_ptr.tag()) {
                         .undef, .null_value => {
                             // An optional has been initialized to undefined at comptime and now we
 @@ -27984,7 +28023,7 @@ fn beginComptimePtrMutationInner(
     // Handle the case that the decl is an array and we're actually trying to point to an element.
     if (decl_ty.isArrayOrVector(mod)) {
-        const decl_elem_ty = decl_ty.childType();
+        const decl_elem_ty = decl_ty.childType(mod);
         if ((try sema.coerceInMemoryAllowed(block, ptr_elem_ty, decl_elem_ty, true, target, src, src)) == .ok) {
             return ComptimePtrMutationKit{
                 .decl_ref_mut = decl_ref_mut,
 @@ -28105,7 +28144,7 @@ fn beginComptimePtrLoad(
             // If we're loading an elem_ptr that was derived from a different type
             // than the true type of the underlying decl, we cannot deref directly
             const ty_matches = if (deref.pointee != null and deref.pointee.?.ty.isArrayOrVector(mod)) x: {
-                const deref_elem_ty = deref.pointee.?.ty.childType();
+                const deref_elem_ty = deref.pointee.?.ty.childType(mod);
                 break :x (try sema.coerceInMemoryAllowed(block, deref_elem_ty, elem_ty, false, target, src, src)) == .ok or
                     (try sema.coerceInMemoryAllowed(block, elem_ty, deref_elem_ty, false, target, src, src)) == .ok;
             } else false;
 @@ -28115,12 +28154,12 @@ fn beginComptimePtrLoad(
             }
             var array_tv = deref.pointee.?;
-            const check_len = array_tv.ty.arrayLenIncludingSentinel();
+            const check_len = array_tv.ty.arrayLenIncludingSentinel(mod);
             if (maybe_array_ty) |load_ty| {
                 // It's possible that we're loading a [N]T, in which case we'd like to slice
                 // the pointee array directly from our parent array.
-                if (load_ty.isArrayOrVector(mod) and load_ty.childType().eql(elem_ty, sema.mod)) {
+                if (load_ty.isArrayOrVector(mod) and load_ty.childType(mod).eql(elem_ty, sema.mod)) {
-                    const N = try sema.usizeCast(block, src, load_ty.arrayLenIncludingSentinel());
+                    const N = try sema.usizeCast(block, src, load_ty.arrayLenIncludingSentinel(mod));
                     deref.pointee = if (elem_ptr.index + N <= check_len) TypedValue{
                         .ty = try Type.array(sema.arena, N, null, elem_ty, sema.mod),
                         .val = try array_tv.val.sliceArray(sema.mod, sema.arena, elem_ptr.index, elem_ptr.index + N),
 @@ -28134,7 +28173,7 @@ fn beginComptimePtrLoad(
                 break :blk deref;
             }
             if (elem_ptr.index == check_len - 1) {
-                if (array_tv.ty.sentinel()) |sent| {
+                if (array_tv.ty.sentinel(mod)) |sent| {
                     deref.pointee = TypedValue{
                         .ty = elem_ty,
                         .val = sent,
 @@ -28226,7 +28265,7 @@ fn beginComptimePtrLoad(
             const payload_ptr = ptr_val.cast(Value.Payload.PayloadPtr).?.data;
             const payload_ty = switch (ptr_val.tag()) {
                 .eu_payload_ptr => payload_ptr.container_ty.errorUnionPayload(),
-                .opt_payload_ptr => try payload_ptr.container_ty.optionalChildAlloc(sema.arena),
+                .opt_payload_ptr => payload_ptr.container_ty.optionalChild(mod),
                 else => unreachable,
             };
             var deref = try sema.beginComptimePtrLoad(block, src, payload_ptr.container_ptr, payload_ptr.container_ty);
 @@ -28357,12 +28396,13 @@ fn coerceArrayPtrToSlice(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
+    const mod = sema.mod;
     if (try sema.resolveMaybeUndefVal(inst)) |val| {
         const ptr_array_ty = sema.typeOf(inst);
-        const array_ty = ptr_array_ty.childType();
+        const array_ty = ptr_array_ty.childType(mod);
         const slice_val = try Value.Tag.slice.create(sema.arena, .{
             .ptr = val,
-            .len = try Value.Tag.int_u64.create(sema.arena, array_ty.arrayLen()),
+            .len = try Value.Tag.int_u64.create(sema.arena, array_ty.arrayLen(mod)),
         });
         return sema.addConstant(dest_ty, slice_val);
     }
 @@ -28371,11 +28411,11 @@ fn coerceArrayPtrToSlice(
 }
 fn checkPtrAttributes(sema: *Sema, dest_ty: Type, inst_ty: Type, in_memory_result: *InMemoryCoercionResult) bool {
-    const dest_info = dest_ty.ptrInfo().data;
-    const inst_info = inst_ty.ptrInfo().data;
     const mod = sema.mod;
-    const len0 = (inst_info.pointee_type.zigTypeTag(mod) == .Array and (inst_info.pointee_type.arrayLenIncludingSentinel() == 0 or
+    const dest_info = dest_ty.ptrInfo(mod);
-        (inst_info.pointee_type.arrayLen() == 0 and dest_info.sentinel == null and dest_info.size != .C and dest_info.size != .Many))) or
+    const inst_info = inst_ty.ptrInfo(mod);
+    const len0 = (inst_info.pointee_type.zigTypeTag(mod) == .Array and (inst_info.pointee_type.arrayLenIncludingSentinel(mod) == 0 or
+        (inst_info.pointee_type.arrayLen(mod) == 0 and dest_info.sentinel == null and dest_info.size != .C and dest_info.size != .Many))) or
         (inst_info.pointee_type.isTuple() and inst_info.pointee_type.structFieldCount() == 0);
     const ok_cv_qualifiers =
 @@ -28647,7 +28687,8 @@ fn coerceAnonStructToUnionPtrs(
     ptr_anon_struct: Air.Inst.Ref,
     anon_struct_src: LazySrcLoc,
 ) !Air.Inst.Ref {
-    const union_ty = ptr_union_ty.childType();
+    const mod = sema.mod;
+    const union_ty = ptr_union_ty.childType(mod);
     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);
 @@ -28661,7 +28702,8 @@ fn coerceAnonStructToStructPtrs(
     ptr_anon_struct: Air.Inst.Ref,
     anon_struct_src: LazySrcLoc,
 ) !Air.Inst.Ref {
-    const struct_ty = ptr_struct_ty.childType();
+    const mod = sema.mod;
+    const struct_ty = ptr_struct_ty.childType(mod);
     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);
 @@ -28676,15 +28718,16 @@ fn coerceArrayLike(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
+    const mod = sema.mod;
     const inst_ty = sema.typeOf(inst);
-    const inst_len = inst_ty.arrayLen();
+    const inst_len = inst_ty.arrayLen(mod);
-    const dest_len = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLen());
+    const dest_len = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLen(mod));
-    const target = sema.mod.getTarget();
+    const target = mod.getTarget();
     if (dest_len != inst_len) {
         const msg = msg: {
             const msg = try sema.errMsg(block, inst_src, "expected type '{}', found '{}'", .{
-                dest_ty.fmt(sema.mod), inst_ty.fmt(sema.mod),
+                dest_ty.fmt(mod), inst_ty.fmt(mod),
             });
             errdefer msg.destroy(sema.gpa);
             try sema.errNote(block, dest_ty_src, msg, "destination has length {d}", .{dest_len});
 @@ -28694,8 +28737,8 @@ fn coerceArrayLike(
         return sema.failWithOwnedErrorMsg(msg);
     }
-    const dest_elem_ty = dest_ty.childType();
+    const dest_elem_ty = dest_ty.childType(mod);
-    const inst_elem_ty = inst_ty.childType();
+    const inst_elem_ty = inst_ty.childType(mod);
     const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_elem_ty, inst_elem_ty, false, target, dest_ty_src, inst_src);
     if (in_memory_result == .ok) {
         if (try sema.resolveMaybeUndefVal(inst)) |inst_val| {
 @@ -28749,9 +28792,10 @@ fn coerceTupleToArray(
     inst: Air.Inst.Ref,
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
+    const mod = sema.mod;
     const inst_ty = sema.typeOf(inst);
-    const inst_len = inst_ty.arrayLen();
+    const inst_len = inst_ty.arrayLen(mod);
-    const dest_len = dest_ty.arrayLen();
+    const dest_len = dest_ty.arrayLen(mod);
     if (dest_len != inst_len) {
         const msg = msg: {
 @@ -28766,16 +28810,16 @@ fn coerceTupleToArray(
         return sema.failWithOwnedErrorMsg(msg);
     }
-    const dest_elems = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLenIncludingSentinel());
+    const dest_elems = try sema.usizeCast(block, dest_ty_src, dest_ty.arrayLenIncludingSentinel(mod));
     const element_vals = try sema.arena.alloc(Value, dest_elems);
     const element_refs = try sema.arena.alloc(Air.Inst.Ref, dest_elems);
-    const dest_elem_ty = dest_ty.childType();
+    const dest_elem_ty = dest_ty.childType(mod);
     var runtime_src: ?LazySrcLoc = null;
     for (element_vals, 0..) |*elem, i_usize| {
         const i = @intCast(u32, i_usize);
         if (i_usize == inst_len) {
-            elem.* = dest_ty.sentinel().?;
+            elem.* = dest_ty.sentinel(mod).?;
             element_refs[i] = try sema.addConstant(dest_elem_ty, elem.*);
             break;
         }
 @@ -28812,9 +28856,10 @@ fn coerceTupleToSlicePtrs(
     ptr_tuple: Air.Inst.Ref,
     tuple_src: LazySrcLoc,
 ) !Air.Inst.Ref {
-    const tuple_ty = sema.typeOf(ptr_tuple).childType();
+    const mod = sema.mod;
+    const tuple_ty = sema.typeOf(ptr_tuple).childType(mod);
     const tuple = try sema.analyzeLoad(block, tuple_src, ptr_tuple, tuple_src);
-    const slice_info = slice_ty.ptrInfo().data;
+    const slice_info = slice_ty.ptrInfo(mod);
     const array_ty = try Type.array(sema.arena, tuple_ty.structFieldCount(), slice_info.sentinel, slice_info.pointee_type, sema.mod);
     const array_inst = try sema.coerceTupleToArray(block, array_ty, slice_ty_src, tuple, tuple_src);
     if (slice_info.@"align" != 0) {
 @@ -28833,8 +28878,9 @@ fn coerceTupleToArrayPtrs(
     ptr_tuple: Air.Inst.Ref,
     tuple_src: LazySrcLoc,
 ) !Air.Inst.Ref {
+    const mod = sema.mod;
     const tuple = try sema.analyzeLoad(block, tuple_src, ptr_tuple, tuple_src);
-    const ptr_info = ptr_array_ty.ptrInfo().data;
+    const ptr_info = ptr_array_ty.ptrInfo(mod);
     const array_ty = ptr_info.pointee_type;
     const array_inst = try sema.coerceTupleToArray(block, array_ty, array_ty_src, tuple, tuple_src);
     if (ptr_info.@"align" != 0) {
 @@ -29231,7 +29277,7 @@ fn analyzeLoad(
     const mod = sema.mod;
     const ptr_ty = sema.typeOf(ptr);
     const elem_ty = switch (ptr_ty.zigTypeTag(mod)) {
-        .Pointer => ptr_ty.childType(),
+        .Pointer => ptr_ty.childType(mod),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ty.fmt(sema.mod)}),
     };
 @@ -29245,7 +29291,7 @@ fn analyzeLoad(
         }
     }
-    if (ptr_ty.ptrInfo().data.vector_index == .runtime) {
+    if (ptr_ty.ptrInfo(mod).vector_index == .runtime) {
         const ptr_inst = Air.refToIndex(ptr).?;
         const air_tags = sema.air_instructions.items(.tag);
         if (air_tags[ptr_inst] == .ptr_elem_ptr) {
 @@ -29318,8 +29364,7 @@ fn analyzeIsNull(
     const inverted_non_null_res = if (invert_logic) Air.Inst.Ref.bool_true else Air.Inst.Ref.bool_false;
     const operand_ty = sema.typeOf(operand);
-    var buf: Type.Payload.ElemType = undefined;
+    if (operand_ty.zigTypeTag(mod) == .Optional and operand_ty.optionalChild(mod).zigTypeTag(mod) == .NoReturn) {
-    if (operand_ty.zigTypeTag(mod) == .Optional and operand_ty.optionalChild(&buf).zigTypeTag(mod) == .NoReturn) {
         return inverted_non_null_res;
     }
     if (operand_ty.zigTypeTag(mod) != .Optional and !operand_ty.isPtrLikeOptional(mod)) {
 @@ -29339,7 +29384,7 @@ fn analyzePtrIsNonErrComptimeOnly(
     const mod = sema.mod;
     const ptr_ty = sema.typeOf(operand);
     assert(ptr_ty.zigTypeTag(mod) == .Pointer);
-    const child_ty = ptr_ty.childType();
+    const child_ty = ptr_ty.childType(mod);
     const child_tag = child_ty.zigTypeTag(mod);
     if (child_tag != .ErrorSet and child_tag != .ErrorUnion) return Air.Inst.Ref.bool_true;
 @@ -29495,7 +29540,7 @@ fn analyzeSlice(
     // 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)) {
-        .Pointer => ptr_ptr_ty.elemType(),
+        .Pointer => ptr_ptr_ty.childType(mod),
         else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ptr_ty.fmt(sema.mod)}),
     };
 @@ -29506,30 +29551,30 @@ fn analyzeSlice(
     var ptr_sentinel: ?Value = null;
     switch (ptr_ptr_child_ty.zigTypeTag(mod)) {
         .Array => {
-            ptr_sentinel = ptr_ptr_child_ty.sentinel();
+            ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
-            elem_ty = ptr_ptr_child_ty.childType();
+            elem_ty = ptr_ptr_child_ty.childType(mod);
         },
-        .Pointer => switch (ptr_ptr_child_ty.ptrSize()) {
+        .Pointer => switch (ptr_ptr_child_ty.ptrSize(mod)) {
             .One => {
-                const double_child_ty = ptr_ptr_child_ty.childType();
+                const double_child_ty = ptr_ptr_child_ty.childType(mod);
                 if (double_child_ty.zigTypeTag(mod) == .Array) {
-                    ptr_sentinel = double_child_ty.sentinel();
+                    ptr_sentinel = double_child_ty.sentinel(mod);
                     ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src);
                     slice_ty = ptr_ptr_child_ty;
                     array_ty = double_child_ty;
-                    elem_ty = double_child_ty.childType();
+                    elem_ty = double_child_ty.childType(mod);
                 } else {
                     return sema.fail(block, src, "slice of single-item pointer", .{});
                 }
             },
             .Many, .C => {
-                ptr_sentinel = ptr_ptr_child_ty.sentinel();
+                ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
                 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();
+                elem_ty = ptr_ptr_child_ty.childType(mod);
-                if (ptr_ptr_child_ty.ptrSize() == .C) {
+                if (ptr_ptr_child_ty.ptrSize(mod) == .C) {
                     if (try sema.resolveDefinedValue(block, ptr_src, ptr_or_slice)) |ptr_val| {
                         if (ptr_val.isNull(mod)) {
                             return sema.fail(block, src, "slice of null pointer", .{});
 @@ -29538,11 +29583,11 @@ fn analyzeSlice(
                 }
             },
             .Slice => {
-                ptr_sentinel = ptr_ptr_child_ty.sentinel();
+                ptr_sentinel = ptr_ptr_child_ty.sentinel(mod);
                 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();
+                elem_ty = ptr_ptr_child_ty.childType(mod);
             },
         },
         else => return sema.fail(block, src, "slice of non-array type '{}'", .{ptr_ptr_child_ty.fmt(mod)}),
 @@ -29563,7 +29608,7 @@ fn analyzeSlice(
     var end_is_len = uncasted_end_opt == .none;
     const end = e: {
         if (array_ty.zigTypeTag(mod) == .Array) {
-            const len_val = try Value.Tag.int_u64.create(sema.arena, array_ty.arrayLen());
+            const len_val = try Value.Tag.int_u64.create(sema.arena, array_ty.arrayLen(mod));
             if (!end_is_len) {
                 const end = if (by_length) end: {
 @@ -29574,10 +29619,10 @@ fn analyzeSlice(
                 if (try sema.resolveMaybeUndefVal(end)) |end_val| {
                     const len_s_val = try Value.Tag.int_u64.create(
                         sema.arena,
-                        array_ty.arrayLenIncludingSentinel(),
+                        array_ty.arrayLenIncludingSentinel(mod),
                     );
                     if (!(try sema.compareAll(end_val, .lte, len_s_val, Type.usize))) {
-                        const sentinel_label: []const u8 = if (array_ty.sentinel() != null)
+                        const sentinel_label: []const u8 = if (array_ty.sentinel(mod) != null)
                             " +1 (sentinel)"
                         else
                             "";
 @@ -29617,7 +29662,7 @@ fn analyzeSlice(
                         if (slice_val.isUndef()) {
                             return sema.fail(block, src, "slice of undefined", .{});
                         }
-                        const has_sentinel = slice_ty.sentinel() != null;
+                        const has_sentinel = slice_ty.sentinel(mod) != null;
                         var int_payload: Value.Payload.U64 = .{
                             .base = .{ .tag = .int_u64 },
                             .data = slice_val.sliceLen(mod) + @boolToInt(has_sentinel),
 @@ -29751,8 +29796,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 = sema.typeOf(new_ptr).ptrInfo().data;
+    const new_ptr_ty_info = sema.typeOf(new_ptr).ptrInfo(mod);
-    const new_allowzero = new_ptr_ty_info.@"allowzero" and sema.typeOf(ptr).ptrSize() != .C;
+    const new_allowzero = new_ptr_ty_info.@"allowzero" and sema.typeOf(ptr).ptrSize(mod) != .C;
     if (opt_new_len_val) |new_len_val| {
         const new_len_int = new_len_val.toUnsignedInt(mod);
 @@ -29780,7 +29825,7 @@ fn analyzeSlice(
                 if (slice_ty.isSlice(mod)) {
                     const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
-                    const actual_len = if (slice_ty.sentinel() == null)
+                    const actual_len = if (slice_ty.sentinel(mod) == null)
                         slice_len_inst
                     else
                         try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src, true);
 @@ -29839,7 +29884,7 @@ fn analyzeSlice(
         // requirement: end <= len
         const opt_len_inst = if (array_ty.zigTypeTag(mod) == .Array)
-            try sema.addIntUnsigned(Type.usize, array_ty.arrayLenIncludingSentinel())
+            try sema.addIntUnsigned(Type.usize, array_ty.arrayLenIncludingSentinel(mod))
         else if (slice_ty.isSlice(mod)) blk: {
             if (try sema.resolveDefinedValue(block, src, ptr_or_slice)) |slice_val| {
                 // we don't need to add one for sentinels because the
 @@ -29848,7 +29893,7 @@ fn analyzeSlice(
             }
             const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
-            if (slice_ty.sentinel() == null) break :blk slice_len_inst;
+            if (slice_ty.sentinel(mod) == 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);
 @@ -30284,7 +30329,10 @@ fn cmpVector(
     const casted_lhs = try sema.coerce(block, resolved_ty, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_ty, rhs, rhs_src);
-    const result_ty = try Type.vector(sema.arena, lhs_ty.vectorLen(), Type.bool);
+    const result_ty = try mod.vectorType(.{
+        .len = lhs_ty.vectorLen(mod),
+        .child = .bool_type,
+    });
     const runtime_src: LazySrcLoc = src: {
         if (try sema.resolveMaybeUndefVal(casted_lhs)) |lhs_val| {
 @@ -30484,12 +30532,12 @@ fn resolvePeerTypes(
                     }
                     continue;
                 },
-                .Pointer => if (chosen_ty.ptrSize() == .C) continue,
+                .Pointer => if (chosen_ty.ptrSize(mod) == .C) continue,
                 else => {},
             },
             .ComptimeInt => switch (chosen_ty_tag) {
                 .Int, .Float, .ComptimeFloat => continue,
-                .Pointer => if (chosen_ty.ptrSize() == .C) continue,
+                .Pointer => if (chosen_ty.ptrSize(mod) == .C) continue,
                 else => {},
             },
             .Float => switch (chosen_ty_tag) {
 @@ -30654,10 +30702,10 @@ fn resolvePeerTypes(
                 },
             },
             .Pointer => {
-                const cand_info = candidate_ty.ptrInfo().data;
+                const cand_info = candidate_ty.ptrInfo(mod);
                 switch (chosen_ty_tag) {
                     .Pointer => {
-                        const chosen_info = chosen_ty.ptrInfo().data;
+                        const chosen_info = chosen_ty.ptrInfo(mod);
                         seen_const = seen_const or !chosen_info.mutable or !cand_info.mutable;
 @@ -30690,8 +30738,8 @@ fn resolvePeerTypes(
                             chosen_info.pointee_type.zigTypeTag(mod) == .Array and
                             cand_info.pointee_type.zigTypeTag(mod) == .Array)
                         {
-                            const chosen_elem_ty = chosen_info.pointee_type.childType();
+                            const chosen_elem_ty = chosen_info.pointee_type.childType(mod);
-                            const cand_elem_ty = cand_info.pointee_type.childType();
+                            const cand_elem_ty = cand_info.pointee_type.childType(mod);
                             const chosen_ok = .ok == try sema.coerceInMemoryAllowed(block, chosen_elem_ty, cand_elem_ty, chosen_info.mutable, target, src, src);
                             if (chosen_ok) {
 @@ -30757,10 +30805,9 @@ fn resolvePeerTypes(
                         }
                     },
                     .Optional => {
-                        var opt_child_buf: Type.Payload.ElemType = undefined;
+                        const chosen_ptr_ty = chosen_ty.optionalChild(mod);
-                        const chosen_ptr_ty = chosen_ty.optionalChild(&opt_child_buf);
                         if (chosen_ptr_ty.zigTypeTag(mod) == .Pointer) {
-                            const chosen_info = chosen_ptr_ty.ptrInfo().data;
+                            const chosen_info = chosen_ptr_ty.ptrInfo(mod);
                             seen_const = seen_const or !chosen_info.mutable or !cand_info.mutable;
 @@ -30777,7 +30824,7 @@ fn resolvePeerTypes(
                     .ErrorUnion => {
                         const chosen_ptr_ty = chosen_ty.errorUnionPayload();
                         if (chosen_ptr_ty.zigTypeTag(mod) == .Pointer) {
-                            const chosen_info = chosen_ptr_ty.ptrInfo().data;
+                            const chosen_info = chosen_ptr_ty.ptrInfo(mod);
                             seen_const = seen_const or !chosen_info.mutable or !cand_info.mutable;
 @@ -30802,8 +30849,7 @@ fn resolvePeerTypes(
                 }
             },
             .Optional => {
-                var opt_child_buf: Type.Payload.ElemType = undefined;
+                const opt_child_ty = candidate_ty.optionalChild(mod);
-                const opt_child_ty = candidate_ty.optionalChild(&opt_child_buf);
                 if ((try sema.coerceInMemoryAllowed(block, chosen_ty, opt_child_ty, false, target, src, src)) == .ok) {
                     seen_const = seen_const or opt_child_ty.isConstPtr();
                     any_are_null = true;
 @@ -30818,13 +30864,13 @@ fn resolvePeerTypes(
             },
             .Vector => switch (chosen_ty_tag) {
                 .Vector => {
-                    const chosen_len = chosen_ty.vectorLen();
+                    const chosen_len = chosen_ty.vectorLen(mod);
-                    const candidate_len = candidate_ty.vectorLen();
+                    const candidate_len = candidate_ty.vectorLen(mod);
                     if (chosen_len != candidate_len)
                         continue;
-                    const chosen_child_ty = chosen_ty.childType();
+                    const chosen_child_ty = chosen_ty.childType(mod);
-                    const candidate_child_ty = candidate_ty.childType();
+                    const candidate_child_ty = candidate_ty.childType(mod);
                     if (chosen_child_ty.zigTypeTag(mod) == .Int and candidate_child_ty.zigTypeTag(mod) == .Int) {
                         const chosen_info = chosen_child_ty.intInfo(mod);
                         const candidate_info = candidate_child_ty.intInfo(mod);
 @@ -30853,8 +30899,8 @@ fn resolvePeerTypes(
                 .Vector => continue,
                 else => {},
             },
-            .Fn => if (chosen_ty.isSinglePointer(mod) and chosen_ty.isConstPtr() and chosen_ty.childType().zigTypeTag(mod) == .Fn) {
+            .Fn => if (chosen_ty.isSinglePointer(mod) and chosen_ty.isConstPtr() and chosen_ty.childType(mod).zigTypeTag(mod) == .Fn) {
-                if (.ok == try sema.coerceInMemoryAllowedFns(block, chosen_ty.childType(), candidate_ty, target, src, src)) {
+                if (.ok == try sema.coerceInMemoryAllowedFns(block, chosen_ty.childType(mod), candidate_ty, target, src, src)) {
                     continue;
                 }
             },
 @@ -30874,8 +30920,7 @@ fn resolvePeerTypes(
                 continue;
             },
             .Optional => {
-                var opt_child_buf: Type.Payload.ElemType = undefined;
+                const opt_child_ty = chosen_ty.optionalChild(mod);
-                const opt_child_ty = chosen_ty.optionalChild(&opt_child_buf);
                 if ((try sema.coerceInMemoryAllowed(block, opt_child_ty, candidate_ty, false, target, src, src)) == .ok) {
                     continue;
                 }
 @@ -30949,16 +30994,16 @@ fn resolvePeerTypes(
     if (convert_to_slice) {
         // turn *[N]T => []T
-        const chosen_child_ty = chosen_ty.childType();
+        const chosen_child_ty = chosen_ty.childType(mod);
-        var info = chosen_ty.ptrInfo();
+        var info = chosen_ty.ptrInfo(mod);
-        info.data.sentinel = chosen_child_ty.sentinel();
+        info.sentinel = chosen_child_ty.sentinel(mod);
-        info.data.size = .Slice;
+        info.size = .Slice;
-        info.data.mutable = !(seen_const or chosen_child_ty.isConstPtr());
+        info.mutable = !(seen_const or chosen_child_ty.isConstPtr());
-        info.data.pointee_type = chosen_child_ty.elemType2(mod);
+        info.pointee_type = chosen_child_ty.elemType2(mod);
-        const new_ptr_ty = try Type.ptr(sema.arena, mod, info.data);
+        const new_ptr_ty = try Type.ptr(sema.arena, mod, info);
         const opt_ptr_ty = if (any_are_null)
-            try Type.optional(sema.arena, new_ptr_ty)
+            try Type.optional(sema.arena, new_ptr_ty, mod)
         else
             new_ptr_ty;
         const set_ty = err_set_ty orelse return opt_ptr_ty;
 @@ -30970,22 +31015,22 @@ fn resolvePeerTypes(
         switch (chosen_ty.zigTypeTag(mod)) {
             .ErrorUnion => {
                 const ptr_ty = chosen_ty.errorUnionPayload();
-                var info = ptr_ty.ptrInfo();
+                var info = ptr_ty.ptrInfo(mod);
-                info.data.mutable = false;
+                info.mutable = false;
-                const new_ptr_ty = try Type.ptr(sema.arena, mod, info.data);
+                const new_ptr_ty = try Type.ptr(sema.arena, mod, info);
                 const opt_ptr_ty = if (any_are_null)
-                    try Type.optional(sema.arena, new_ptr_ty)
+                    try Type.optional(sema.arena, new_ptr_ty, mod)
                 else
                     new_ptr_ty;
                 const set_ty = err_set_ty orelse chosen_ty.errorUnionSet();
                 return try Type.errorUnion(sema.arena, set_ty, opt_ptr_ty, mod);
             },
             .Pointer => {
-                var info = chosen_ty.ptrInfo();
+                var info = chosen_ty.ptrInfo(mod);
-                info.data.mutable = false;
+                info.mutable = false;
-                const new_ptr_ty = try Type.ptr(sema.arena, mod, info.data);
+                const new_ptr_ty = try Type.ptr(sema.arena, mod, info);
                 const opt_ptr_ty = if (any_are_null)
-                    try Type.optional(sema.arena, new_ptr_ty)
+                    try Type.optional(sema.arena, new_ptr_ty, mod)
                 else
                     new_ptr_ty;
                 const set_ty = err_set_ty orelse return opt_ptr_ty;
 @@ -30998,7 +31043,7 @@ fn resolvePeerTypes(
     if (any_are_null) {
         const opt_ty = switch (chosen_ty.zigTypeTag(mod)) {
             .Null, .Optional => chosen_ty,
-            else => try Type.optional(sema.arena, chosen_ty),
+            else => try Type.optional(sema.arena, chosen_ty, mod),
         };
         const set_ty = err_set_ty orelse return opt_ty;
         return try Type.errorUnion(sema.arena, set_ty, opt_ty, mod);
 @@ -31077,13 +31122,12 @@ pub fn resolveTypeLayout(sema: *Sema, ty: Type) CompileError!void {
         .Struct => return sema.resolveStructLayout(ty),
         .Union => return sema.resolveUnionLayout(ty),
         .Array => {
-            if (ty.arrayLenIncludingSentinel() == 0) return;
+            if (ty.arrayLenIncludingSentinel(mod) == 0) return;
-            const elem_ty = ty.childType();
+            const elem_ty = ty.childType(mod);
             return sema.resolveTypeLayout(elem_ty);
         },
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            const payload_ty = ty.optionalChild(mod);
-            const payload_ty = ty.optionalChild(&buf);
             // In case of querying the ABI alignment of this optional, we will ask
             // for hasRuntimeBits() of the payload type, so we need "requires comptime"
             // to be known already before this function returns.
 @@ -31343,10 +31387,10 @@ fn checkIndexable(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
 fn checkMemOperand(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Pointer) {
-        switch (ty.ptrSize()) {
+        switch (ty.ptrSize(mod)) {
             .Slice, .Many, .C => return,
             .One => {
-                const elem_ty = ty.childType();
+                const elem_ty = ty.childType(mod);
                 if (elem_ty.zigTypeTag(mod) == .Array) return;
                 // TODO https://github.com/ziglang/zig/issues/15479
                 // if (elem_ty.isTuple()) return;
 @@ -31418,8 +31462,8 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
         .int_type => false,
         .ptr_type => @panic("TODO"),
         .array_type => @panic("TODO"),
-        .vector_type => @panic("TODO"),
+        .vector_type => |vector_type| return sema.resolveTypeRequiresComptime(vector_type.child.toType()),
-        .optional_type => @panic("TODO"),
+        .opt_type => @panic("TODO"),
         .error_union_type => @panic("TODO"),
         .simple_type => |t| switch (t) {
             .f16,
 @@ -31478,12 +31522,6 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
     };
     return switch (ty.tag()) {
-        .manyptr_u8,
-        .manyptr_const_u8,
-        .manyptr_const_u8_sentinel_0,
-        .const_slice_u8,
-        .const_slice_u8_sentinel_0,
-        .anyerror_void_error_union,
         .empty_struct_literal,
         .empty_struct,
         .error_set,
 @@ -31491,34 +31529,20 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
         .error_set_inferred,
         .error_set_merged,
         .@"opaque",
-        .array_u8,
-        .array_u8_sentinel_0,
         .enum_simple,
         => false,
-        .single_const_pointer_to_comptime_int,
+        .function => true,
-        .function,
-        => true,
         .inferred_alloc_mut => unreachable,
         .inferred_alloc_const => unreachable,
         .array,
         .array_sentinel,
-        .vector,
+        => return sema.resolveTypeRequiresComptime(ty.childType(mod)),
-        => return sema.resolveTypeRequiresComptime(ty.childType()),
-        .pointer,
+        .pointer => {
-        .single_const_pointer,
+            const child_ty = ty.childType(mod);
-        .single_mut_pointer,
-        .many_const_pointer,
-        .many_mut_pointer,
-        .c_const_pointer,
-        .c_mut_pointer,
-        .const_slice,
-        .mut_slice,
-        => {
-            const child_ty = ty.childType();
             if (child_ty.zigTypeTag(mod) == .Fn) {
                 return child_ty.fnInfo().is_generic;
             } else {
 @@ -31526,12 +31550,8 @@ pub fn resolveTypeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
             }
         },
-        .optional,
+        .optional => {
-        .optional_single_mut_pointer,
+            return sema.resolveTypeRequiresComptime(ty.optionalChild(mod));
-        .optional_single_const_pointer,
-        => {
-            var buf: Type.Payload.ElemType = undefined;
-            return sema.resolveTypeRequiresComptime(ty.optionalChild(&buf));
         },
         .tuple, .anon_struct => {
 @@ -31609,7 +31629,7 @@ pub fn resolveTypeFully(sema: *Sema, ty: Type) CompileError!void {
     const mod = sema.mod;
     switch (ty.zigTypeTag(mod)) {
         .Pointer => {
-            const child_ty = try sema.resolveTypeFields(ty.childType());
+            const child_ty = try sema.resolveTypeFields(ty.childType(mod));
             return sema.resolveTypeFully(child_ty);
         },
         .Struct => switch (ty.tag()) {
 @@ -31624,10 +31644,9 @@ pub fn resolveTypeFully(sema: *Sema, ty: Type) CompileError!void {
             else => {},
         },
         .Union => return sema.resolveUnionFully(ty),
-        .Array => return sema.resolveTypeFully(ty.childType()),
+        .Array => return sema.resolveTypeFully(ty.childType(mod)),
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            return sema.resolveTypeFully(ty.optionalChild(mod));
-            return sema.resolveTypeFully(ty.optionalChild(&buf));
         },
         .ErrorUnion => return sema.resolveTypeFully(ty.errorUnionPayload()),
         .Fn => {
 @@ -32897,10 +32916,14 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
                 return null;
             }
         },
-        .ptr_type => @panic("TODO"),
+        .ptr_type => return null,
         .array_type => @panic("TODO"),
-        .vector_type => @panic("TODO"),
+        .vector_type => |vector_type| {
-        .optional_type => @panic("TODO"),
+            if (vector_type.len == 0) return Value.initTag(.empty_array);
+            if (try sema.typeHasOnePossibleValue(vector_type.child.toType())) |v| return v;
+            return null;
+        },
+        .opt_type => @panic("TODO"),
         .error_union_type => @panic("TODO"),
         .simple_type => |t| switch (t) {
             .f16,
 @@ -32963,34 +32986,15 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .error_set_merged,
         .error_union,
         .function,
-        .single_const_pointer_to_comptime_int,
         .array_sentinel,
-        .array_u8_sentinel_0,
-        .const_slice_u8,
-        .const_slice_u8_sentinel_0,
-        .const_slice,
-        .mut_slice,
-        .optional_single_mut_pointer,
-        .optional_single_const_pointer,
-        .anyerror_void_error_union,
         .error_set_inferred,
         .@"opaque",
-        .manyptr_u8,
-        .manyptr_const_u8,
-        .manyptr_const_u8_sentinel_0,
         .anyframe_T,
-        .many_const_pointer,
-        .many_mut_pointer,
-        .c_const_pointer,
-        .c_mut_pointer,
-        .single_const_pointer,
-        .single_mut_pointer,
         .pointer,
         => return null,
         .optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            const child_ty = ty.optionalChild(mod);
-            const child_ty = ty.optionalChild(&buf);
             if (child_ty.isNoReturn()) {
                 return Value.null;
             } else {
 @@ -33111,10 +33115,10 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .empty_struct, .empty_struct_literal => return Value.initTag(.empty_struct_value),
-        .vector, .array, .array_u8 => {
+        .array => {
-            if (ty.arrayLen() == 0)
+            if (ty.arrayLen(mod) == 0)
                 return Value.initTag(.empty_array);
-            if ((try sema.typeHasOnePossibleValue(ty.elemType())) != null) {
+            if ((try sema.typeHasOnePossibleValue(ty.childType(mod))) != null) {
                 return Value.initTag(.the_only_possible_value);
             }
             return null;
 @@ -33147,20 +33151,13 @@ pub fn addType(sema: *Sema, ty: Type) !Air.Inst.Ref {
             .data = .{ .interned = ty.ip_index },
         });
         return Air.indexToRef(@intCast(u32, sema.air_instructions.len - 1));
+    } else {
+        try sema.air_instructions.append(sema.gpa, .{
+            .tag = .const_ty,
+            .data = .{ .ty = ty },
+        });
+        return Air.indexToRef(@intCast(u32, sema.air_instructions.len - 1));
     }
-    switch (ty.tag()) {
-        .manyptr_u8 => return .manyptr_u8_type,
-        .manyptr_const_u8 => return .manyptr_const_u8_type,
-        .single_const_pointer_to_comptime_int => return .single_const_pointer_to_comptime_int_type,
-        .const_slice_u8 => return .const_slice_u8_type,
-        .anyerror_void_error_union => return .anyerror_void_error_union_type,
-        else => {},
-    }
-    try sema.air_instructions.append(sema.gpa, .{
-        .tag = .const_ty,
-        .data = .{ .ty = ty },
-    });
-    return Air.indexToRef(@intCast(u32, sema.air_instructions.len - 1));
 }
 fn addIntUnsigned(sema: *Sema, ty: Type, int: u64) CompileError!Air.Inst.Ref {
 @@ -33173,6 +33170,15 @@ fn addConstUndef(sema: *Sema, ty: Type) CompileError!Air.Inst.Ref {
 pub fn addConstant(sema: *Sema, ty: Type, val: Value) SemaError!Air.Inst.Ref {
     const gpa = sema.gpa;
+    if (val.ip_index != .none) {
+        if (@enumToInt(val.ip_index) < Air.ref_start_index)
+            return @intToEnum(Air.Inst.Ref, @enumToInt(val.ip_index));
+        try sema.air_instructions.append(gpa, .{
+            .tag = .interned,
+            .data = .{ .interned = val.ip_index },
+        });
+        return Air.indexToRef(@intCast(u32, sema.air_instructions.len - 1));
+    }
     const ty_inst = try sema.addType(ty);
     try sema.air_values.append(gpa, val);
     try sema.air_instructions.append(gpa, .{
 @@ -33331,7 +33337,8 @@ pub fn analyzeAddressSpace(
 /// Asserts the value is a pointer and dereferences it.
 /// Returns `null` if the pointer contents cannot be loaded at comptime.
 fn pointerDeref(sema: *Sema, block: *Block, src: LazySrcLoc, ptr_val: Value, ptr_ty: Type) CompileError!?Value {
-    const load_ty = ptr_ty.childType();
+    const mod = sema.mod;
+    const load_ty = ptr_ty.childType(mod);
     const res = try sema.pointerDerefExtra(block, src, ptr_val, load_ty, true);
     switch (res) {
         .runtime_load => return null,
 @@ -33422,11 +33429,7 @@ fn usizeCast(sema: *Sema, block: *Block, src: LazySrcLoc, int: u64) CompileError
 /// This can return `error.AnalysisFail` because it sometimes requires resolving whether
 /// a type has zero bits, which can cause a "foo depends on itself" compile error.
 /// This logic must be kept in sync with `Type.isPtrLikeOptional`.
-fn typePtrOrOptionalPtrTy(
+fn typePtrOrOptionalPtrTy(sema: *Sema, ty: Type) !?Type {
-    sema: *Sema,
-    ty: Type,
-    buf: *Type.Payload.ElemType,
-) !?Type {
     const mod = sema.mod;
     if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {
 @@ -33435,14 +33438,14 @@ fn typePtrOrOptionalPtrTy(
             .C => return ptr_type.elem_type.toType(),
             .One, .Many => return ty,
         },
-        .optional_type => |o| switch (mod.intern_pool.indexToKey(o.payload_type)) {
+        .opt_type => |opt_child| switch (mod.intern_pool.indexToKey(opt_child)) {
             .ptr_type => |ptr_type| switch (ptr_type.size) {
                 .Slice, .C => return null,
                 .Many, .One => {
                     if (ptr_type.is_allowzero) return null;
                     // optionals of zero sized types behave like bools, not pointers
-                    const payload_ty = o.payload_type.toType();
+                    const payload_ty = opt_child.toType();
                     if ((try sema.typeHasOnePossibleValue(payload_ty)) != null) {
                         return null;
                     }
 @@ -33456,25 +33459,9 @@ fn typePtrOrOptionalPtrTy(
     };
     switch (ty.tag()) {
-        .optional_single_const_pointer,
+        .pointer => switch (ty.ptrSize(mod)) {
-        .optional_single_mut_pointer,
-        .c_const_pointer,
-        .c_mut_pointer,
-        => return ty.optionalChild(buf),
-        .single_const_pointer_to_comptime_int,
-        .single_const_pointer,
-        .single_mut_pointer,
-        .many_const_pointer,
-        .many_mut_pointer,
-        .manyptr_u8,
-        .manyptr_const_u8,
-        .manyptr_const_u8_sentinel_0,
-        => return ty,
-        .pointer => switch (ty.ptrSize()) {
             .Slice => return null,
-            .C => return ty.optionalChild(buf),
+            .C => return ty.optionalChild(mod),
             else => return ty,
         },
 @@ -33482,10 +33469,10 @@ fn typePtrOrOptionalPtrTy(
         .inferred_alloc_mut => unreachable,
         .optional => {
-            const child_type = ty.optionalChild(buf);
+            const child_type = ty.optionalChild(mod);
             if (child_type.zigTypeTag(mod) != .Pointer) return null;
-            const info = child_type.ptrInfo().data;
+            const info = child_type.ptrInfo(mod);
             switch (info.size) {
                 .Slice, .C => return null,
                 .Many, .One => {
 @@ -33518,8 +33505,8 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
             .int_type => return false,
             .ptr_type => @panic("TODO"),
             .array_type => @panic("TODO"),
-            .vector_type => @panic("TODO"),
+            .vector_type => |vector_type| return sema.typeRequiresComptime(vector_type.child.toType()),
-            .optional_type => @panic("TODO"),
+            .opt_type => @panic("TODO"),
             .error_union_type => @panic("TODO"),
             .simple_type => |t| return switch (t) {
                 .f16,
 @@ -33578,12 +33565,6 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
         }
     }
     return switch (ty.tag()) {
-        .manyptr_u8,
-        .manyptr_const_u8,
-        .manyptr_const_u8_sentinel_0,
-        .const_slice_u8,
-        .const_slice_u8_sentinel_0,
-        .anyerror_void_error_union,
         .empty_struct_literal,
         .empty_struct,
         .error_set,
 @@ -33591,34 +33572,20 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
         .error_set_inferred,
         .error_set_merged,
         .@"opaque",
-        .array_u8,
-        .array_u8_sentinel_0,
         .enum_simple,
         => false,
-        .single_const_pointer_to_comptime_int,
+        .function => true,
-        .function,
-        => true,
         .inferred_alloc_mut => unreachable,
         .inferred_alloc_const => unreachable,
         .array,
         .array_sentinel,
-        .vector,
+        => return sema.typeRequiresComptime(ty.childType(mod)),
-        => return sema.typeRequiresComptime(ty.childType()),
-        .pointer,
+        .pointer => {
-        .single_const_pointer,
+            const child_ty = ty.childType(mod);
-        .single_mut_pointer,
-        .many_const_pointer,
-        .many_mut_pointer,
-        .c_const_pointer,
-        .c_mut_pointer,
-        .const_slice,
-        .mut_slice,
-        => {
-            const child_ty = ty.childType();
             if (child_ty.zigTypeTag(mod) == .Fn) {
                 return child_ty.fnInfo().is_generic;
             } else {
 @@ -33626,12 +33593,8 @@ pub fn typeRequiresComptime(sema: *Sema, ty: Type) CompileError!bool {
             }
         },
-        .optional,
+        .optional => {
-        .optional_single_mut_pointer,
+            return sema.typeRequiresComptime(ty.optionalChild(mod));
-        .optional_single_const_pointer,
-        => {
-            var buf: Type.Payload.ElemType = undefined;
-            return sema.typeRequiresComptime(ty.optionalChild(&buf));
         },
         .tuple, .anon_struct => {
 @@ -33814,7 +33777,7 @@ fn queueFullTypeResolution(sema: *Sema, ty: Type) !void {
 fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
-        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -33874,7 +33837,7 @@ fn intSub(
 ) !Value {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
-        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -33934,7 +33897,7 @@ fn floatAdd(
 ) !Value {
     const mod = sema.mod;
     if (float_type.zigTypeTag(mod) == .Vector) {
-        const result_data = try sema.arena.alloc(Value, float_type.vectorLen());
+        const result_data = try sema.arena.alloc(Value, float_type.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -33992,7 +33955,7 @@ fn floatSub(
 ) !Value {
     const mod = sema.mod;
     if (float_type.zigTypeTag(mod) == .Vector) {
-        const result_data = try sema.arena.alloc(Value, float_type.vectorLen());
+        const result_data = try sema.arena.alloc(Value, float_type.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -34050,8 +34013,8 @@ fn intSubWithOverflow(
 ) !Value.OverflowArithmeticResult {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
-        const overflowed_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const overflowed_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
-        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -34105,8 +34068,8 @@ fn floatToInt(
 ) CompileError!Value {
     const mod = sema.mod;
     if (float_ty.zigTypeTag(mod) == .Vector) {
-        const elem_ty = float_ty.childType();
+        const elem_ty = float_ty.childType(mod);
-        const result_data = try sema.arena.alloc(Value, float_ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, float_ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var buf: Value.ElemValueBuffer = undefined;
             const elem_val = val.elemValueBuffer(sema.mod, i, &buf);
 @@ -34383,8 +34346,8 @@ fn intAddWithOverflow(
 ) !Value.OverflowArithmeticResult {
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
-        const overflowed_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const overflowed_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
-        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
         for (result_data, 0..) |*scalar, i| {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -34442,7 +34405,7 @@ fn compareAll(
     const mod = sema.mod;
     if (ty.zigTypeTag(mod) == .Vector) {
         var i: usize = 0;
-        while (i < ty.vectorLen()) : (i += 1) {
+        while (i < ty.vectorLen(mod)) : (i += 1) {
             var lhs_buf: Value.ElemValueBuffer = undefined;
             var rhs_buf: Value.ElemValueBuffer = undefined;
             const lhs_elem = lhs.elemValueBuffer(sema.mod, i, &lhs_buf);
 @@ -34490,7 +34453,7 @@ fn compareVector(
 ) !Value {
     const mod = sema.mod;
     assert(ty.zigTypeTag(mod) == .Vector);
-    const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+    const result_data = try sema.arena.alloc(Value, ty.vectorLen(mod));
     for (result_data, 0..) |*scalar, i| {
         var lhs_buf: Value.ElemValueBuffer = undefined;
         var rhs_buf: Value.ElemValueBuffer = undefined;
 @@ -34511,10 +34474,10 @@ fn compareVector(
 /// This code is duplicated in `analyzePtrArithmetic`.
 fn elemPtrType(sema: *Sema, ptr_ty: Type, offset: ?usize) !Type {
     const mod = sema.mod;
-    const ptr_info = ptr_ty.ptrInfo().data;
+    const ptr_info = ptr_ty.ptrInfo(mod);
     const elem_ty = ptr_ty.elemType2(mod);
     const allow_zero = ptr_info.@"allowzero" and (offset orelse 0) == 0;
-    const parent_ty = ptr_ty.childType();
+    const parent_ty = ptr_ty.childType(mod);
     const VI = Type.Payload.Pointer.Data.VectorIndex;
 @@ -34522,14 +34485,14 @@ fn elemPtrType(sema: *Sema, ptr_ty: Type, offset: ?usize) !Type {
         host_size: u16 = 0,
         alignment: u32 = 0,
         vector_index: VI = .none,
-    } = if (parent_ty.tag() == .vector and ptr_info.size == .One) blk: {
+    } = if (parent_ty.isVector(mod) and ptr_info.size == .One) blk: {
         const elem_bits = elem_ty.bitSize(mod);
         if (elem_bits == 0) break :blk .{};
         const is_packed = elem_bits < 8 or !std.math.isPowerOfTwo(elem_bits);
         if (!is_packed) break :blk .{};
         break :blk .{
-            .host_size = @intCast(u16, parent_ty.arrayLen()),
+            .host_size = @intCast(u16, parent_ty.arrayLen(mod)),
             .alignment = @intCast(u16, parent_ty.abiAlignment(mod)),
             .vector_index = if (offset) |some| @intToEnum(VI, some) else .runtime,
         };

src/TypedValue.zig+6-26

 @@ -77,15 +77,6 @@ pub fn print(
         return writer.writeAll("(variable)");
     while (true) switch (val.tag()) {
-        .single_const_pointer_to_comptime_int_type => return writer.writeAll("*const comptime_int"),
-        .const_slice_u8_type => return writer.writeAll("[]const u8"),
-        .const_slice_u8_sentinel_0_type => return writer.writeAll("[:0]const u8"),
-        .anyerror_void_error_union_type => return writer.writeAll("anyerror!void"),
-        .manyptr_u8_type => return writer.writeAll("[*]u8"),
-        .manyptr_const_u8_type => return writer.writeAll("[*]const u8"),
-        .manyptr_const_u8_sentinel_0_type => return writer.writeAll("[*:0]const u8"),
         .empty_struct_value, .aggregate => {
             if (level == 0) {
                 return writer.writeAll(".{ ... }");
 @@ -112,7 +103,7 @@ pub fn print(
                 return writer.writeAll("}");
             } else {
                 const elem_ty = ty.elemType2(mod);
-                const len = ty.arrayLen();
+                const len = ty.arrayLen(mod);
                 if (elem_ty.eql(Type.u8, mod)) str: {
                     const max_len = @intCast(usize, std.math.min(len, max_string_len));
 @@ -288,7 +279,7 @@ pub fn print(
                 .ty = ty.elemType2(mod),
                 .val = val.castTag(.repeated).?.data,
             };
-            const len = ty.arrayLen();
+            const len = ty.arrayLen(mod);
             const max_len = std.math.min(len, max_aggregate_items);
             while (i < max_len) : (i += 1) {
                 if (i != 0) try writer.writeAll(", ");
 @@ -306,7 +297,7 @@ pub fn print(
             try writer.writeAll(".{ ");
             try print(.{
                 .ty = ty.elemType2(mod),
-                .val = ty.sentinel().?,
+                .val = ty.sentinel(mod).?,
             }, writer, level - 1, mod);
             return writer.writeAll(" }");
         },
 @@ -364,8 +355,7 @@ pub fn print(
         },
         .opt_payload => {
             val = val.castTag(.opt_payload).?.data;
-            var buf: Type.Payload.ElemType = undefined;
+            ty = ty.optionalChild(mod);
-            ty = ty.optionalChild(&buf);
             return print(.{ .ty = ty, .val = val }, writer, level, mod);
         },
         .eu_payload_ptr => {
 @@ -386,13 +376,8 @@ pub fn print(
             try writer.writeAll(", &(payload of ");
-            var ptr_ty: Type.Payload.ElemType = .{
-                .base = .{ .tag = .single_mut_pointer },
-                .data = data.container_ty,
-            };
             try print(.{
-                .ty = Type.initPayload(&ptr_ty.base),
+                .ty = mod.singleMutPtrType(data.container_ty) catch @panic("OOM"),
                 .val = data.container_ptr,
             }, writer, level - 1, mod);
 @@ -415,13 +400,8 @@ pub fn print(
             try writer.writeAll(", &(payload of ");
-            var ptr_ty: Type.Payload.ElemType = .{
-                .base = .{ .tag = .single_mut_pointer },
-                .data = data.container_ty,
-            };
             try print(.{
-                .ty = Type.initPayload(&ptr_ty.base),
+                .ty = mod.singleMutPtrType(data.container_ty) catch @panic("OOM"),
                 .val = data.container_ptr,
             }, writer, level - 1, mod);

src/arch/aarch64/CodeGen.zig+32-48

 @@ -1030,7 +1030,7 @@ fn allocMem(
 /// Use a pointer instruction as the basis for allocating stack memory.
 fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
     const mod = self.bin_file.options.module.?;
-    const elem_ty = self.typeOfIndex(inst).elemType();
+    const elem_ty = self.typeOfIndex(inst).childType(mod);
     if (!elem_ty.hasRuntimeBits(mod)) {
         // return the stack offset 0. Stack offset 0 will be where all
 @@ -1140,17 +1140,14 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     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();
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(ret_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = ret_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             // addr_reg will contain the address of where to store the
             // result into
 @@ -2406,9 +2403,9 @@ fn ptrArithmetic(
             assert(rhs_ty.eql(Type.usize, mod));
             const ptr_ty = lhs_ty;
-            const elem_ty = switch (ptr_ty.ptrSize()) {
+            const elem_ty = switch (ptr_ty.ptrSize(mod)) {
-                .One => ptr_ty.childType().childType(), // ptr to array, so get array element type
+                .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
-                else => ptr_ty.childType(),
+                else => ptr_ty.childType(mod),
             };
             const elem_size = elem_ty.abiSize(mod);
 @@ -3024,8 +3021,7 @@ fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void {
 fn optionalPayload(self: *Self, inst: Air.Inst.Index, mcv: MCValue, optional_ty: Type) !MCValue {
     const mod = self.bin_file.options.module.?;
-    var opt_buf: Type.Payload.ElemType = undefined;
+    const payload_ty = optional_ty.optionalChild(mod);
-    const payload_ty = optional_ty.optionalChild(&opt_buf);
     if (!payload_ty.hasRuntimeBits(mod)) return MCValue.none;
     if (optional_ty.isPtrLikeOptional(mod)) {
         // TODO should we reuse the operand here?
 @@ -3459,7 +3455,7 @@ fn ptrElemVal(
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
     const mod = self.bin_file.options.module.?;
-    const elem_ty = ptr_ty.childType();
+    const elem_ty = ptr_ty.childType(mod);
     const elem_size = @intCast(u32, elem_ty.abiSize(mod));
     // TODO optimize for elem_sizes of 1, 2, 4, 8
 @@ -3617,7 +3613,7 @@ fn reuseOperand(
 fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
     const mod = self.bin_file.options.module.?;
-    const elem_ty = ptr_ty.elemType();
+    const elem_ty = ptr_ty.childType(mod);
     const elem_size = elem_ty.abiSize(mod);
     switch (ptr) {
 @@ -3773,7 +3769,7 @@ fn genInlineMemset(
 ) !void {
     const dst_reg = switch (dst) {
         .register => |r| r,
-        else => try self.copyToTmpRegister(Type.initTag(.manyptr_u8), dst),
+        else => try self.copyToTmpRegister(Type.manyptr_u8, dst),
     };
     const dst_reg_lock = self.register_manager.lockReg(dst_reg);
     defer if (dst_reg_lock) |lock| self.register_manager.unlockReg(lock);
 @@ -4096,7 +4092,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
         const mod = self.bin_file.options.module.?;
         const mcv = try self.resolveInst(operand);
         const ptr_ty = self.typeOf(operand);
-        const struct_ty = ptr_ty.childType();
+        const struct_ty = ptr_ty.childType(mod);
         const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, mod));
         switch (mcv) {
             .ptr_stack_offset => |off| {
 @@ -4173,7 +4169,7 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
     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 = self.air.getRefType(ty_pl.ty).childType();
+        const struct_ty = self.air.getRefType(ty_pl.ty).childType(mod);
         const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(extra.field_index, mod));
         switch (field_ptr) {
             .ptr_stack_offset => |off| {
 @@ -4254,7 +4250,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     const fn_ty = switch (ty.zigTypeTag(mod)) {
         .Fn => ty,
-        .Pointer => ty.childType(),
+        .Pointer => ty.childType(mod),
         else => unreachable,
     };
 @@ -4280,11 +4276,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
         const ret_ptr_reg = self.registerAlias(.x0, Type.usize);
-        var ptr_ty_payload: Type.Payload.ElemType = .{
+        const ptr_ty = try mod.singleMutPtrType(ret_ty);
-            .base = .{ .tag = .single_mut_pointer },
-            .data = ret_ty,
-        };
-        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
         try self.register_manager.getReg(ret_ptr_reg, null);
         try self.genSetReg(ptr_ty, ret_ptr_reg, .{ .ptr_stack_offset = stack_offset });
 @@ -4453,11 +4445,7 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
             //
             // self.ret_mcv is an address to where this function
             // should store its result into
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(ret_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = ret_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try self.store(self.ret_mcv, operand, ptr_ty, ret_ty);
         },
         else => unreachable,
 @@ -4533,8 +4521,7 @@ fn cmp(
     const mod = self.bin_file.options.module.?;
     const int_ty = switch (lhs_ty.zigTypeTag(mod)) {
         .Optional => blk: {
-            var opt_buffer: Type.Payload.ElemType = undefined;
+            const payload_ty = lhs_ty.optionalChild(mod);
-            const payload_ty = lhs_ty.optionalChild(&opt_buffer);
             if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                 break :blk Type.u1;
             } else if (lhs_ty.isPtrLikeOptional(mod)) {
 @@ -4850,8 +4837,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
 fn isNull(self: *Self, operand_bind: ReadArg.Bind, operand_ty: Type) !MCValue {
     const mod = self.bin_file.options.module.?;
     const sentinel: struct { ty: Type, bind: ReadArg.Bind } = if (!operand_ty.isPtrLikeOptional(mod)) blk: {
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = operand_ty.optionalChild(mod);
-        const payload_ty = operand_ty.optionalChild(&buf);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod))
             break :blk .{ .ty = operand_ty, .bind = operand_bind };
 @@ -4947,11 +4933,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4973,11 +4960,12 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4999,11 +4987,12 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -5025,11 +5014,12 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -5511,11 +5501,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
                 const reg = try self.copyToTmpRegister(ty, mcv);
                 return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
             } else {
-                var ptr_ty_payload: Type.Payload.ElemType = .{
+                const ptr_ty = try mod.singleMutPtrType(ty);
-                    .base = .{ .tag = .single_mut_pointer },
-                    .data = ty,
-                };
-                const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                 // TODO call extern memcpy
                 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null }, gp);
 @@ -5833,11 +5819,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                 const reg = try self.copyToTmpRegister(ty, mcv);
                 return self.genSetStackArgument(ty, stack_offset, MCValue{ .register = reg });
             } else {
-                var ptr_ty_payload: Type.Payload.ElemType = .{
+                const ptr_ty = try mod.singleMutPtrType(ty);
-                    .base = .{ .tag = .single_mut_pointer },
-                    .data = ty,
-                };
-                const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                 // TODO call extern memcpy
                 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null }, gp);
 @@ -5957,12 +5939,13 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const ty_op = self.air.instructions.items(.data)[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();
+        const array_ty = ptr_ty.childType(mod);
-        const array_len = @intCast(u32, array_ty.arrayLen());
+        const array_len = @intCast(u32, array_ty.arrayLen(mod));
         const ptr_bits = self.target.ptrBitWidth();
         const ptr_bytes = @divExact(ptr_bits, 8);
 @@ -6079,8 +6062,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const vector_ty = self.typeOfIndex(inst);
-    const len = vector_ty.vectorLen();
+    const len = vector_ty.vectorLen(mod);
     const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
     const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
     const result: MCValue = res: {

src/arch/arm/CodeGen.zig+33-50

 @@ -1010,7 +1010,7 @@ fn allocMem(
 /// Use a pointer instruction as the basis for allocating stack memory.
 fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
     const mod = self.bin_file.options.module.?;
-    const elem_ty = self.typeOfIndex(inst).elemType();
+    const elem_ty = self.typeOfIndex(inst).childType(mod);
     if (!elem_ty.hasRuntimeBits(mod)) {
         // As this stack item will never be dereferenced at runtime,
 @@ -1117,17 +1117,14 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     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();
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(ret_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = ret_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             // addr_reg will contain the address of where to store the
             // result into
 @@ -2372,8 +2369,8 @@ fn ptrElemVal(
     ptr_ty: Type,
     maybe_inst: ?Air.Inst.Index,
 ) !MCValue {
-    const elem_ty = ptr_ty.childType();
     const mod = self.bin_file.options.module.?;
+    const elem_ty = ptr_ty.childType(mod);
     const elem_size = @intCast(u32, elem_ty.abiSize(mod));
     switch (elem_size) {
 @@ -2474,7 +2471,8 @@ fn arrayElemVal(
     array_ty: Type,
     maybe_inst: ?Air.Inst.Index,
 ) InnerError!MCValue {
-    const elem_ty = array_ty.childType();
+    const mod = self.bin_file.options.module.?;
+    const elem_ty = array_ty.childType(mod);
     const mcv = try array_bind.resolveToMcv(self);
     switch (mcv) {
 @@ -2508,11 +2506,7 @@ fn arrayElemVal(
             const base_bind: ReadArg.Bind = .{ .mcv = ptr_to_mcv };
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(elem_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = elem_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             return try self.ptrElemVal(base_bind, index_bind, ptr_ty, maybe_inst);
         },
 @@ -2659,8 +2653,8 @@ fn reuseOperand(
 }
 fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
-    const elem_ty = ptr_ty.elemType();
     const mod = self.bin_file.options.module.?;
+    const elem_ty = ptr_ty.childType(mod);
     const elem_size = @intCast(u32, elem_ty.abiSize(mod));
     switch (ptr) {
 @@ -2888,7 +2882,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
         const mod = self.bin_file.options.module.?;
         const mcv = try self.resolveInst(operand);
         const ptr_ty = self.typeOf(operand);
-        const struct_ty = ptr_ty.childType();
+        const struct_ty = ptr_ty.childType(mod);
         const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, mod));
         switch (mcv) {
             .ptr_stack_offset => |off| {
 @@ -3004,7 +2998,7 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
     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 = self.air.getRefType(ty_pl.ty).childType();
+        const struct_ty = self.air.getRefType(ty_pl.ty).childType(mod);
         if (struct_ty.zigTypeTag(mod) == .Union) {
             return self.fail("TODO implement @fieldParentPtr codegen for unions", .{});
 @@ -3898,9 +3892,9 @@ fn ptrArithmetic(
             assert(rhs_ty.eql(Type.usize, mod));
             const ptr_ty = lhs_ty;
-            const elem_ty = switch (ptr_ty.ptrSize()) {
+            const elem_ty = switch (ptr_ty.ptrSize(mod)) {
-                .One => ptr_ty.childType().childType(), // ptr to array, so get array element type
+                .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
-                else => ptr_ty.childType(),
+                else => ptr_ty.childType(mod),
             };
             const elem_size = @intCast(u32, elem_ty.abiSize(mod));
 @@ -4079,7 +4073,7 @@ fn genInlineMemset(
 ) !void {
     const dst_reg = switch (dst) {
         .register => |r| r,
-        else => try self.copyToTmpRegister(Type.initTag(.manyptr_u8), dst),
+        else => try self.copyToTmpRegister(Type.manyptr_u8, dst),
     };
     const dst_reg_lock = self.register_manager.lockReg(dst_reg);
     defer if (dst_reg_lock) |lock| self.register_manager.unlockReg(lock);
 @@ -4229,7 +4223,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
     const fn_ty = switch (ty.zigTypeTag(mod)) {
         .Fn => ty,
-        .Pointer => ty.childType(),
+        .Pointer => ty.childType(mod),
         else => unreachable,
     };
 @@ -4259,11 +4253,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
         const ret_abi_align = @intCast(u32, ret_ty.abiAlignment(mod));
         const stack_offset = try self.allocMem(ret_abi_size, ret_abi_align, inst);
-        var ptr_ty_payload: Type.Payload.ElemType = .{
+        const ptr_ty = try mod.singleMutPtrType(ret_ty);
-            .base = .{ .tag = .single_mut_pointer },
-            .data = ret_ty,
-        };
-        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
         try self.register_manager.getReg(.r0, null);
         try self.genSetReg(ptr_ty, .r0, .{ .ptr_stack_offset = stack_offset });
 @@ -4401,11 +4391,7 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
             //
             // self.ret_mcv is an address to where this function
             // should store its result into
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(ret_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = ret_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try self.store(self.ret_mcv, operand, ptr_ty, ret_ty);
         },
         else => unreachable, // invalid return result
 @@ -4482,8 +4468,7 @@ fn cmp(
     const mod = self.bin_file.options.module.?;
     const int_ty = switch (lhs_ty.zigTypeTag(mod)) {
         .Optional => blk: {
-            var opt_buffer: Type.Payload.ElemType = undefined;
+            const payload_ty = lhs_ty.optionalChild(mod);
-            const payload_ty = lhs_ty.optionalChild(&opt_buffer);
             if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                 break :blk Type.u1;
             } else if (lhs_ty.isPtrLikeOptional(mod)) {
 @@ -4837,11 +4822,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4863,11 +4849,12 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4924,11 +4911,12 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -4950,11 +4938,12 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const un_op = self.air.instructions.items(.data)[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.elemType();
+        const elem_ty = ptr_ty.childType(mod);
         const operand = try self.allocRegOrMem(elem_ty, true, null);
         try self.load(operand, operand_ptr, ptr_ty);
 @@ -5455,11 +5444,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
                 const reg = try self.copyToTmpRegister(ty, mcv);
                 return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
             } else {
-                var ptr_ty_payload: Type.Payload.ElemType = .{
+                const ptr_ty = try mod.singleMutPtrType(ty);
-                    .base = .{ .tag = .single_mut_pointer },
-                    .data = ty,
-                };
-                const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                 // TODO call extern memcpy
                 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null }, gp);
 @@ -5816,11 +5801,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                 const reg = try self.copyToTmpRegister(ty, mcv);
                 return self.genSetStackArgument(ty, stack_offset, MCValue{ .register = reg });
             } else {
-                var ptr_ty_payload: Type.Payload.ElemType = .{
+                const ptr_ty = try mod.singleMutPtrType(ty);
-                    .base = .{ .tag = .single_mut_pointer },
-                    .data = ty,
-                };
-                const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                 // TODO call extern memcpy
                 const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null }, gp);
 @@ -5908,12 +5889,13 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const ty_op = self.air.instructions.items(.data)[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();
+        const array_ty = ptr_ty.childType(mod);
-        const array_len = @intCast(u32, array_ty.arrayLen());
+        const array_len = @intCast(u32, array_ty.arrayLen(mod));
         const stack_offset = try self.allocMem(8, 8, inst);
         try self.genSetStack(ptr_ty, stack_offset, ptr);
 @@ -6026,8 +6008,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
 }
 fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
+    const mod = self.bin_file.options.module.?;
     const vector_ty = self.typeOfIndex(inst);
-    const len = vector_ty.vectorLen();
+    const len = vector_ty.vectorLen(mod);
     const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
     const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
     const result: MCValue = res: {

src/arch/riscv64/CodeGen.zig+8-6

src/arch/sparc64/CodeGen.zig+17-20

src/arch/wasm/CodeGen.zig+80-88

 @@ -1542,7 +1542,7 @@ fn allocStack(func: *CodeGen, ty: Type) !WValue {
 fn allocStackPtr(func: *CodeGen, inst: Air.Inst.Index) !WValue {
     const mod = func.bin_file.base.options.module.?;
     const ptr_ty = func.typeOfIndex(inst);
-    const pointee_ty = ptr_ty.childType();
+    const pointee_ty = ptr_ty.childType(mod);
     if (func.initial_stack_value == .none) {
         try func.initializeStack();
 @@ -1766,8 +1766,7 @@ fn isByRef(ty: Type, mod: *const Module) bool {
         },
         .Optional => {
             if (ty.isPtrLikeOptional(mod)) return false;
-            var buf: Type.Payload.ElemType = undefined;
+            const pl_type = ty.optionalChild(mod);
-            const pl_type = ty.optionalChild(&buf);
             if (pl_type.zigTypeTag(mod) == .ErrorSet) return false;
             return pl_type.hasRuntimeBitsIgnoreComptime(mod);
         },
 @@ -2139,7 +2138,7 @@ fn airRet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 fn airRetPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mod = func.bin_file.base.options.module.?;
-    const child_type = func.typeOfIndex(inst).childType();
+    const child_type = func.typeOfIndex(inst).childType(mod);
     var result = result: {
         if (!child_type.isFnOrHasRuntimeBitsIgnoreComptime(mod)) {
 @@ -2161,7 +2160,7 @@ fn airRetLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mod = func.bin_file.base.options.module.?;
     const un_op = func.air.instructions.items(.data)[inst].un_op;
     const operand = try func.resolveInst(un_op);
-    const ret_ty = func.typeOf(un_op).childType();
+    const ret_ty = func.typeOf(un_op).childType(mod);
     const fn_info = func.decl.ty.fnInfo();
     if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
 @@ -2188,7 +2187,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     const mod = func.bin_file.base.options.module.?;
     const fn_ty = switch (ty.zigTypeTag(mod)) {
         .Fn => ty,
-        .Pointer => ty.childType(),
+        .Pointer => ty.childType(mod),
         else => unreachable,
     };
     const ret_ty = fn_ty.fnReturnType();
 @@ -2301,8 +2300,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().data;
+    const ptr_info = ptr_ty.ptrInfo(mod);
-    const ty = ptr_ty.childType();
+    const ty = ptr_ty.childType(mod);
     if (ptr_info.host_size == 0) {
         try func.store(lhs, rhs, ty, 0);
 @@ -2360,8 +2359,7 @@ fn store(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerE
             if (ty.isPtrLikeOptional(mod)) {
                 return func.store(lhs, rhs, Type.usize, 0);
             }
-            var buf: Type.Payload.ElemType = undefined;
+            const pl_ty = ty.optionalChild(mod);
-            const pl_ty = ty.optionalChild(&buf);
             if (!pl_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                 return func.store(lhs, rhs, Type.u8, 0);
             }
 @@ -2454,7 +2452,7 @@ fn airLoad(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const operand = try func.resolveInst(ty_op.operand);
     const ty = func.air.getRefType(ty_op.ty);
     const ptr_ty = func.typeOf(ty_op.operand);
-    const ptr_info = ptr_ty.ptrInfo().data;
+    const ptr_info = ptr_ty.ptrInfo(mod);
     if (!ty.hasRuntimeBitsIgnoreComptime(mod)) return func.finishAir(inst, .none, &.{ty_op.operand});
 @@ -2971,7 +2969,7 @@ fn lowerParentPtr(func: *CodeGen, ptr_val: Value, offset: u32) InnerError!WValue
                         break :blk field_offset;
                     },
                 },
-                .Pointer => switch (parent_ty.ptrSize()) {
+                .Pointer => switch (parent_ty.ptrSize(mod)) {
                     .Slice => switch (field_ptr.field_index) {
                         0 => 0,
                         1 => func.ptrSize(),
 @@ -3001,11 +2999,7 @@ fn lowerParentPtrDecl(func: *CodeGen, ptr_val: Value, decl_index: Module.Decl.In
     const mod = func.bin_file.base.options.module.?;
     const decl = mod.declPtr(decl_index);
     mod.markDeclAlive(decl);
-    var ptr_ty_payload: Type.Payload.ElemType = .{
+    const ptr_ty = try mod.singleMutPtrType(decl.ty);
-        .base = .{ .tag = .single_mut_pointer },
-        .data = decl.ty,
-    };
-    const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
     return func.lowerDeclRefValue(.{ .ty = ptr_ty, .val = ptr_val }, decl_index, offset);
 }
 @@ -3145,8 +3139,7 @@ fn lowerConstant(func: *CodeGen, arg_val: Value, ty: Type) InnerError!WValue {
             return func.fail("Wasm TODO: lowerConstant error union with non-zero-bit payload type", .{});
         },
         .Optional => if (ty.optionalReprIsPayload(mod)) {
-            var buf: Type.Payload.ElemType = undefined;
+            const pl_ty = ty.optionalChild(mod);
-            const pl_ty = ty.optionalChild(&buf);
             if (val.castTag(.opt_payload)) |payload| {
                 return func.lowerConstant(payload.data, pl_ty);
             } else if (val.isNull(mod)) {
 @@ -3217,8 +3210,7 @@ fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
             else => unreachable,
         },
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            const pl_ty = ty.optionalChild(mod);
-            const pl_ty = ty.optionalChild(&buf);
             if (ty.optionalReprIsPayload(mod)) {
                 return func.emitUndefined(pl_ty);
             }
 @@ -3403,8 +3395,7 @@ fn cmp(func: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareO
     assert(!(lhs != .stack and rhs == .stack));
     const mod = func.bin_file.base.options.module.?;
     if (ty.zigTypeTag(mod) == .Optional and !ty.optionalReprIsPayload(mod)) {
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = ty.optionalChild(mod);
-        const payload_ty = ty.optionalChild(&buf);
         if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             // When we hit this case, we must check the value of optionals
             // that are not pointers. This means first checking against non-null for
 @@ -3609,19 +3600,21 @@ fn bitcast(func: *CodeGen, wanted_ty: Type, given_ty: Type, operand: WValue) Inn
 }
 fn airStructFieldPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_pl = func.air.instructions.items(.data)[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_ty = func.typeOf(extra.data.struct_operand).childType();
+    const struct_ty = func.typeOf(extra.data.struct_operand).childType(mod);
     const result = try func.structFieldPtr(inst, extra.data.struct_operand, struct_ptr, struct_ty, extra.data.field_index);
     func.finishAir(inst, result, &.{extra.data.struct_operand});
 }
 fn airStructFieldPtrIndex(func: *CodeGen, inst: Air.Inst.Index, index: u32) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
     const struct_ptr = try func.resolveInst(ty_op.operand);
-    const struct_ty = func.typeOf(ty_op.operand).childType();
+    const struct_ty = func.typeOf(ty_op.operand).childType(mod);
     const result = try func.structFieldPtr(inst, ty_op.operand, struct_ptr, struct_ty, index);
     func.finishAir(inst, result, &.{ty_op.operand});
 @@ -3640,7 +3633,7 @@ fn structFieldPtr(
     const offset = switch (struct_ty.containerLayout()) {
         .Packed => switch (struct_ty.zigTypeTag(mod)) {
             .Struct => offset: {
-                if (result_ty.ptrInfo().data.host_size != 0) {
+                if (result_ty.ptrInfo(mod).host_size != 0) {
                     break :offset @as(u32, 0);
                 }
                 break :offset struct_ty.packedStructFieldByteOffset(index, mod);
 @@ -3981,7 +3974,7 @@ fn airUnwrapErrUnionPayload(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: boo
     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() else op_ty;
+    const err_ty = if (op_is_ptr) op_ty.childType(mod) else op_ty;
     const payload_ty = err_ty.errorUnionPayload();
     const result = result: {
 @@ -4009,7 +4002,7 @@ fn airUnwrapErrUnionError(func: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool)
     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() else op_ty;
+    const err_ty = if (op_is_ptr) op_ty.childType(mod) else op_ty;
     const payload_ty = err_ty.errorUnionPayload();
     const result = result: {
 @@ -4156,11 +4149,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 mod = func.bin_file.base.options.module.?;
     const un_op = func.air.instructions.items(.data)[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() else op_ty;
+    const optional_ty = if (op_kind == .ptr) op_ty.childType(mod) else op_ty;
     const is_null = try func.isNull(operand, optional_ty, opcode);
     const result = try is_null.toLocal(func, optional_ty);
     func.finishAir(inst, result, &.{un_op});
 @@ -4171,8 +4165,7 @@ fn airIsNull(func: *CodeGen, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind:
 fn isNull(func: *CodeGen, operand: WValue, optional_ty: Type, opcode: wasm.Opcode) InnerError!WValue {
     const mod = func.bin_file.base.options.module.?;
     try func.emitWValue(operand);
-    var buf: Type.Payload.ElemType = undefined;
+    const payload_ty = optional_ty.optionalChild(mod);
-    const payload_ty = optional_ty.optionalChild(&buf);
     if (!optional_ty.optionalReprIsPayload(mod)) {
         // When payload is zero-bits, we can treat operand as a value, rather than
         // a pointer to the stack value
 @@ -4221,14 +4214,13 @@ fn airOptionalPayload(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airOptionalPayloadPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const opt_ty = func.typeOf(ty_op.operand).childType();
+    const opt_ty = func.typeOf(ty_op.operand).childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const result = result: {
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = opt_ty.optionalChild(mod);
-        const payload_ty = opt_ty.optionalChild(&buf);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod) or opt_ty.optionalReprIsPayload(mod)) {
             break :result func.reuseOperand(ty_op.operand, operand);
         }
 @@ -4242,9 +4234,8 @@ fn airOptionalPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!voi
     const mod = func.bin_file.base.options.module.?;
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const opt_ty = func.typeOf(ty_op.operand).childType();
+    const opt_ty = func.typeOf(ty_op.operand).childType(mod);
-    var buf: Type.Payload.ElemType = undefined;
+    const payload_ty = opt_ty.optionalChild(mod);
-    const payload_ty = opt_ty.optionalChild(&buf);
     if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
         return func.fail("TODO: Implement OptionalPayloadPtrSet for optional with zero-sized type {}", .{payload_ty.fmtDebug()});
     }
 @@ -4325,13 +4316,13 @@ fn airSliceLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const bin_op = func.air.instructions.items(.data)[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();
+    const elem_ty = slice_ty.childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const elem_size = elem_ty.abiSize(mod);
     // load pointer onto stack
 @@ -4355,11 +4346,11 @@ fn airSliceElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airSliceElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
     const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data;
-    const elem_ty = func.air.getRefType(ty_pl.ty).childType();
+    const elem_ty = func.air.getRefType(ty_pl.ty).childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const elem_size = elem_ty.abiSize(mod);
     const slice = try func.resolveInst(bin_op.lhs);
 @@ -4436,7 +4427,7 @@ fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
-    const array_ty = func.typeOf(ty_op.operand).childType();
+    const array_ty = func.typeOf(ty_op.operand).childType(mod);
     const slice_ty = func.air.getRefType(ty_op.ty);
     // create a slice on the stack
 @@ -4448,7 +4439,7 @@ fn airArrayToSlice(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     }
     // store the length of the array in the slice
-    const len = WValue{ .imm32 = @intCast(u32, array_ty.arrayLen()) };
+    const len = WValue{ .imm32 = @intCast(u32, array_ty.arrayLen(mod)) };
     try func.store(slice_local, len, Type.usize, func.ptrSize());
     func.finishAir(inst, slice_local, &.{ty_op.operand});
 @@ -4470,13 +4461,13 @@ fn airPtrToInt(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const bin_op = func.air.instructions.items(.data)[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();
+    const elem_ty = ptr_ty.childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const elem_size = elem_ty.abiSize(mod);
     // load pointer onto the stack
 @@ -4507,12 +4498,12 @@ fn airPtrElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airPtrElemPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_pl = func.air.instructions.items(.data)[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 = func.air.getRefType(ty_pl.ty).childType();
+    const elem_ty = func.air.getRefType(ty_pl.ty).childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const elem_size = elem_ty.abiSize(mod);
     const ptr = try func.resolveInst(bin_op.lhs);
 @@ -4544,9 +4535,9 @@ fn airPtrBinOp(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
     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()) {
+    const pointee_ty = switch (ptr_ty.ptrSize(mod)) {
-        .One => ptr_ty.childType().childType(), // ptr to array, so get array element type
+        .One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
-        else => ptr_ty.childType(),
+        else => ptr_ty.childType(mod),
     };
     const valtype = typeToValtype(Type.usize, mod);
 @@ -4565,6 +4556,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 mod = func.bin_file.base.options.module.?;
     if (safety) {
         // TODO if the value is undef, write 0xaa bytes to dest
     } else {
 @@ -4575,16 +4567,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()) {
+    const len = switch (ptr_ty.ptrSize(mod)) {
         .Slice => try func.sliceLen(ptr),
-        .One => @as(WValue, .{ .imm32 = @intCast(u32, ptr_ty.childType().arrayLen()) }),
+        .One => @as(WValue, .{ .imm32 = @intCast(u32, ptr_ty.childType(mod).arrayLen(mod)) }),
         .C, .Many => unreachable,
     };
-    const elem_ty = if (ptr_ty.ptrSize() == .One)
+    const elem_ty = if (ptr_ty.ptrSize(mod) == .One)
-        ptr_ty.childType().childType()
+        ptr_ty.childType(mod).childType(mod)
     else
-        ptr_ty.childType();
+        ptr_ty.childType(mod);
     const dst_ptr = try func.sliceOrArrayPtr(ptr, ptr_ty);
     try func.memset(elem_ty, dst_ptr, len, value);
 @@ -4686,13 +4678,13 @@ fn memset(func: *CodeGen, elem_ty: Type, ptr: WValue, len: WValue, value: WValue
 }
 fn airArrayElemVal(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const bin_op = func.air.instructions.items(.data)[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();
+    const elem_ty = array_ty.childType(mod);
-    const mod = func.bin_file.base.options.module.?;
     const elem_size = elem_ty.abiSize(mod);
     if (isByRef(array_ty, mod)) {
 @@ -4810,7 +4802,7 @@ fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
     const operand = try func.resolveInst(ty_op.operand);
     const ty = func.typeOfIndex(inst);
-    const elem_ty = ty.childType();
+    const elem_ty = ty.childType(mod);
     if (determineSimdStoreStrategy(ty, mod) == .direct) blk: {
         switch (operand) {
 @@ -4859,7 +4851,7 @@ fn airSplat(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         }
     }
     const elem_size = elem_ty.bitSize(mod);
-    const vector_len = @intCast(usize, ty.vectorLen());
+    const vector_len = @intCast(usize, ty.vectorLen(mod));
     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});
     }
 @@ -4895,7 +4887,7 @@ fn airShuffle(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mask = func.air.values[extra.mask];
     const mask_len = extra.mask_len;
-    const child_ty = inst_ty.childType();
+    const child_ty = inst_ty.childType(mod);
     const elem_size = child_ty.abiSize(mod);
     // TODO: One of them could be by ref; handle in loop
 @@ -4959,16 +4951,16 @@ fn airAggregateInit(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mod = func.bin_file.base.options.module.?;
     const ty_pl = func.air.instructions.items(.data)[inst].ty_pl;
     const result_ty = func.typeOfIndex(inst);
-    const len = @intCast(usize, result_ty.arrayLen());
+    const len = @intCast(usize, result_ty.arrayLen(mod));
     const elements = @ptrCast([]const Air.Inst.Ref, func.air.extra[ty_pl.payload..][0..len]);
     const result: WValue = result_value: {
         switch (result_ty.zigTypeTag(mod)) {
             .Array => {
                 const result = try func.allocStack(result_ty);
-                const elem_ty = result_ty.childType();
+                const elem_ty = result_ty.childType(mod);
                 const elem_size = @intCast(u32, elem_ty.abiSize(mod));
-                const sentinel = if (result_ty.sentinel()) |sent| blk: {
+                const sentinel = if (result_ty.sentinel(mod)) |sent| blk: {
                     break :blk try func.lowerConstant(sent, elem_ty);
                 } else null;
 @@ -5190,8 +5182,7 @@ fn cmpOptionals(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op:
     const mod = func.bin_file.base.options.module.?;
     assert(operand_ty.hasRuntimeBitsIgnoreComptime(mod));
     assert(op == .eq or op == .neq);
-    var buf: Type.Payload.ElemType = undefined;
+    const payload_ty = operand_ty.optionalChild(mod);
-    const payload_ty = operand_ty.optionalChild(&buf);
     // We store the final result in here that will be validated
     // if the optional is truly equal.
 @@ -5268,7 +5259,7 @@ fn cmpBigInt(func: *CodeGen, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
 fn airSetUnionTag(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const mod = func.bin_file.base.options.module.?;
     const bin_op = func.air.instructions.items(.data)[inst].bin_op;
-    const un_ty = func.typeOf(bin_op.lhs).childType();
+    const un_ty = func.typeOf(bin_op.lhs).childType(mod);
     const tag_ty = func.typeOf(bin_op.rhs);
     const layout = un_ty.unionGetLayout(mod);
     if (layout.tag_size == 0) return func.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs });
 @@ -5398,7 +5389,7 @@ fn airErrUnionPayloadPtrSet(func: *CodeGen, inst: Air.Inst.Index) InnerError!voi
     const mod = func.bin_file.base.options.module.?;
     const ty_op = func.air.instructions.items(.data)[inst].ty_op;
-    const err_set_ty = func.typeOf(ty_op.operand).childType();
+    const err_set_ty = func.typeOf(ty_op.operand).childType(mod);
     const payload_ty = err_set_ty.errorUnionPayload();
     const operand = try func.resolveInst(ty_op.operand);
 @@ -5426,7 +5417,7 @@ fn airFieldParentPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const extra = func.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
     const field_ptr = try func.resolveInst(extra.field_ptr);
-    const parent_ty = func.air.getRefType(ty_pl.ty).childType();
+    const parent_ty = func.air.getRefType(ty_pl.ty).childType(mod);
     const field_offset = parent_ty.structFieldOffset(extra.field_index, mod);
     const result = if (field_offset != 0) result: {
 @@ -5455,10 +5446,10 @@ fn airMemcpy(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const bin_op = func.air.instructions.items(.data)[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();
+    const ptr_elem_ty = dst_ty.childType(mod);
     const src = try func.resolveInst(bin_op.rhs);
     const src_ty = func.typeOf(bin_op.rhs);
-    const len = switch (dst_ty.ptrSize()) {
+    const len = switch (dst_ty.ptrSize(mod)) {
         .Slice => blk: {
             const slice_len = try func.sliceLen(dst);
             if (ptr_elem_ty.abiSize(mod) != 1) {
 @@ -5470,7 +5461,7 @@ fn airMemcpy(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
             break :blk slice_len;
         },
         .One => @as(WValue, .{
-            .imm32 = @intCast(u32, ptr_elem_ty.arrayLen() * ptr_elem_ty.childType().abiSize(mod)),
+            .imm32 = @intCast(u32, ptr_elem_ty.arrayLen(mod) * ptr_elem_ty.childType(mod).abiSize(mod)),
         }),
         .C, .Many => unreachable,
     };
 @@ -5551,7 +5542,7 @@ fn airErrorName(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     // As the names are global and the slice elements are constant, we do not have
     // to make a copy of the ptr+value but can point towards them directly.
     const error_table_symbol = try func.bin_file.getErrorTableSymbol();
-    const name_ty = Type.initTag(.const_slice_u8_sentinel_0);
+    const name_ty = Type.const_slice_u8_sentinel_0;
     const mod = func.bin_file.base.options.module.?;
     const abi_size = name_ty.abiSize(mod);
 @@ -5857,7 +5848,7 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         try func.addLabel(.local_set, overflow_bit.local.value);
         break :blk try func.wrapOperand(bin_op, lhs_ty);
     } else if (int_info.bits == 64 and int_info.signedness == .unsigned) blk: {
-        const new_ty = Type.initTag(.u128);
+        const new_ty = Type.u128;
         var lhs_upcast = try (try func.intcast(lhs, lhs_ty, new_ty)).toLocal(func, lhs_ty);
         defer lhs_upcast.free(func);
         var rhs_upcast = try (try func.intcast(rhs, lhs_ty, new_ty)).toLocal(func, lhs_ty);
 @@ -5878,7 +5869,7 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         const bin_op = try func.callIntrinsic(
             "__multi3",
             &[_]Type{Type.i64} ** 4,
-            Type.initTag(.i128),
+            Type.i128,
             &.{ lhs, lhs_shifted, rhs, rhs_shifted },
         );
         const res = try func.allocLocal(lhs_ty);
 @@ -5902,19 +5893,19 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         const mul1 = try func.callIntrinsic(
             "__multi3",
             &[_]Type{Type.i64} ** 4,
-            Type.initTag(.i128),
+            Type.i128,
             &.{ lhs_lsb, zero, rhs_msb, zero },
         );
         const mul2 = try func.callIntrinsic(
             "__multi3",
             &[_]Type{Type.i64} ** 4,
-            Type.initTag(.i128),
+            Type.i128,
             &.{ rhs_lsb, zero, lhs_msb, zero },
         );
         const mul3 = try func.callIntrinsic(
             "__multi3",
             &[_]Type{Type.i64} ** 4,
-            Type.initTag(.i128),
+            Type.i128,
             &.{ lhs_msb, zero, rhs_msb, zero },
         );
 @@ -5942,7 +5933,7 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         _ = try func.binOp(lsb_or, mul_add_lt, Type.bool, .@"or");
         try func.addLabel(.local_set, overflow_bit.local.value);
-        const tmp_result = try func.allocStack(Type.initTag(.u128));
+        const tmp_result = try func.allocStack(Type.u128);
         try func.emitWValue(tmp_result);
         const mul3_msb = try func.load(mul3, Type.u64, 0);
         try func.store(.stack, mul3_msb, Type.u64, tmp_result.offset());
 @@ -6191,11 +6182,12 @@ fn airTry(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
 }
 fn airTryPtr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
+    const mod = func.bin_file.base.options.module.?;
     const ty_pl = func.air.instructions.items(.data)[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 = func.air.extra[extra.end..][0..extra.data.body_len];
-    const err_union_ty = func.typeOf(extra.data.ptr).childType();
+    const err_union_ty = func.typeOf(extra.data.ptr).childType(mod);
     const result = try lowerTry(func, inst, err_union_ptr, body, err_union_ty, true);
     func.finishAir(inst, result, &.{extra.data.ptr});
 }
 @@ -6845,11 +6837,11 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
     for (enum_ty.enumFields().keys(), 0..) |tag_name, field_index| {
         // for each tag name, create an unnamed const,
         // and then get a pointer to its value.
-        var name_ty_payload: Type.Payload.Len = .{
+        const name_ty = try mod.arrayType(.{
-            .base = .{ .tag = .array_u8_sentinel_0 },
+            .len = tag_name.len,
-            .data = @intCast(u64, tag_name.len),
+            .child = .u8_type,
-        };
+            .sentinel = .zero_u8,
-        const name_ty = Type.initPayload(&name_ty_payload.base);
+        });
         const string_bytes = &mod.string_literal_bytes;
         try string_bytes.ensureUnusedCapacity(mod.gpa, tag_name.len);
         const gop = try mod.string_literal_table.getOrPutContextAdapted(mod.gpa, tag_name, Module.StringLiteralAdapter{
 @@ -6972,7 +6964,7 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
     // finish function body
     try writer.writeByte(std.wasm.opcode(.end));
-    const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+    const slice_ty = Type.const_slice_u8_sentinel_0;
     const func_type = try genFunctype(arena, .Unspecified, &.{int_tag_ty}, slice_ty, mod);
     return func.bin_file.createFunction(func_name, func_type, &body_list, &relocs);
 }
 @@ -7068,7 +7060,7 @@ fn airCmpxchg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const extra = func.air.extraData(Air.Cmpxchg, ty_pl.payload).data;
     const ptr_ty = func.typeOf(extra.ptr);
-    const ty = ptr_ty.childType();
+    const ty = ptr_ty.childType(mod);
     const result_ty = func.typeOfIndex(inst);
     const ptr_operand = try func.resolveInst(extra.ptr);
 @@ -7355,7 +7347,7 @@ fn airAtomicStore(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     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();
+    const ty = ptr_ty.childType(mod);
     if (func.useAtomicFeature()) {
         const tag: wasm.AtomicsOpcode = switch (ty.abiSize(mod)) {

src/arch/x86_64/CodeGen.zig+153-161

...	@@ -2259,7 +2259,7 @@ fn allocFrameIndex(self: *Self, alloc: FrameAlloc) !FrameIndex {	...	@@ -2259,7 +2259,7 @@ fn allocFrameIndex(self: *Self, alloc: FrameAlloc) !FrameIndex {
2259	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !FrameIndex {	2259	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !FrameIndex {
2260	const mod = self.bin_file.options.module.?;	2260	const mod = self.bin_file.options.module.?;
2261	const ptr_ty = self.typeOfIndex(inst);	2261	const ptr_ty = self.typeOfIndex(inst);
2262	const val_ty = ptr_ty.childType();	2262	const val_ty = ptr_ty.childType(mod);
2263	return self.allocFrameIndex(FrameAlloc.init(.{	2263	return self.allocFrameIndex(FrameAlloc.init(.{
2264	.size = math.cast(u32, val_ty.abiSize(mod)) orelse {	2264	.size = math.cast(u32, val_ty.abiSize(mod)) orelse {
2265	return self.fail("type '{}' too big to fit into stack frame", .{val_ty.fmt(mod)});	2265	return self.fail("type '{}' too big to fit into stack frame", .{val_ty.fmt(mod)});
...	@@ -2289,8 +2289,8 @@ fn allocRegOrMemAdvanced(self: *Self, ty: Type, inst: ?Air.Inst.Index, reg_ok: b	...	@@ -2289,8 +2289,8 @@ fn allocRegOrMemAdvanced(self: *Self, ty: Type, inst: ?Air.Inst.Index, reg_ok: b
2289	80 => break :need_mem,	2289	80 => break :need_mem,
2290	else => unreachable,	2290	else => unreachable,
2291	},	2291	},
2292	.Vector => switch (ty.childType().zigTypeTag(mod)) {	2292	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
2293	.Float => switch (ty.childType().floatBits(self.target.*)) {	2293	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
2294	16, 32, 64, 128 => if (self.hasFeature(.avx)) 32 else 16,	2294	16, 32, 64, 128 => if (self.hasFeature(.avx)) 32 else 16,
2295	80 => break :need_mem,	2295	80 => break :need_mem,
2296	else => unreachable,	2296	else => unreachable,
...	@@ -2727,12 +2727,12 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2727,12 +2727,12 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
2727	try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);	2727	try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
2728		2728
2729	if (dst_ty.zigTypeTag(mod) == .Vector) {	2729	if (dst_ty.zigTypeTag(mod) == .Vector) {
2730	assert(src_ty.zigTypeTag(mod) == .Vector and dst_ty.vectorLen() == src_ty.vectorLen());	2730	assert(src_ty.zigTypeTag(mod) == .Vector and dst_ty.vectorLen(mod) == src_ty.vectorLen(mod));
2731	const dst_info = dst_ty.childType().intInfo(mod);	2731	const dst_info = dst_ty.childType(mod).intInfo(mod);
2732	const src_info = src_ty.childType().intInfo(mod);	2732	const src_info = src_ty.childType(mod).intInfo(mod);
2733	const mir_tag = if (@as(?Mir.Inst.FixedTag, switch (dst_info.bits) {	2733	const mir_tag = if (@as(?Mir.Inst.FixedTag, switch (dst_info.bits) {
2734	8 => switch (src_info.bits) {	2734	8 => switch (src_info.bits) {
2735	16 => switch (dst_ty.vectorLen()) {	2735	16 => switch (dst_ty.vectorLen(mod)) {
2736	1...8 => if (self.hasFeature(.avx)) .{ .vp_b, .ackusw } else .{ .p_b, .ackusw },	2736	1...8 => if (self.hasFeature(.avx)) .{ .vp_b, .ackusw } else .{ .p_b, .ackusw },
2737	9...16 => if (self.hasFeature(.avx2)) .{ .vp_b, .ackusw } else null,	2737	9...16 => if (self.hasFeature(.avx2)) .{ .vp_b, .ackusw } else null,
2738	else => null,	2738	else => null,
...	@@ -2740,7 +2740,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2740,7 +2740,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
2740	else => null,	2740	else => null,
2741	},	2741	},
2742	16 => switch (src_info.bits) {	2742	16 => switch (src_info.bits) {
2743	32 => switch (dst_ty.vectorLen()) {	2743	32 => switch (dst_ty.vectorLen(mod)) {
2744	1...4 => if (self.hasFeature(.avx))	2744	1...4 => if (self.hasFeature(.avx))
2745	.{ .vp_w, .ackusd }	2745	.{ .vp_w, .ackusd }
2746	else if (self.hasFeature(.sse4_1))	2746	else if (self.hasFeature(.sse4_1))
...	@@ -2769,14 +2769,10 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2769,14 +2769,10 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
2769	};	2769	};
2770	const splat_val = Value.initPayload(&splat_pl.base);	2770	const splat_val = Value.initPayload(&splat_pl.base);
2771		2771
2772	var full_pl = Type.Payload.Array{	2772	const full_ty = try mod.vectorType(.{
2773	.base = .{ .tag = .vector },	2773	.len = @intCast(u32, @divExact(@as(u64, if (src_abi_size > 16) 256 else 128), src_info.bits)),
2774	.data = .{	2774	.child = src_ty.childType(mod).ip_index,
2775	.len = @divExact(@as(u64, if (src_abi_size > 16) 256 else 128), src_info.bits),	2775	});
2776	.elem_type = src_ty.childType(),
2777	},
2778	};
2779	const full_ty = Type.initPayload(&full_pl.base);
2780	const full_abi_size = @intCast(u32, full_ty.abiSize(mod));	2776	const full_abi_size = @intCast(u32, full_ty.abiSize(mod));
2781		2777
2782	const splat_mcv = try self.genTypedValue(.{ .ty = full_ty, .val = splat_val });	2778	const splat_mcv = try self.genTypedValue(.{ .ty = full_ty, .val = splat_val });
...	@@ -3587,7 +3583,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3587,7 +3583,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
3587	const result = result: {	3583	const result = result: {
3588	const dst_ty = self.typeOfIndex(inst);	3584	const dst_ty = self.typeOfIndex(inst);
3589	const src_ty = self.typeOf(ty_op.operand);	3585	const src_ty = self.typeOf(ty_op.operand);
3590	const opt_ty = src_ty.childType();	3586	const opt_ty = src_ty.childType(mod);
3591	const src_mcv = try self.resolveInst(ty_op.operand);	3587	const src_mcv = try self.resolveInst(ty_op.operand);
3592		3588
3593	if (opt_ty.optionalReprIsPayload(mod)) {	3589	if (opt_ty.optionalReprIsPayload(mod)) {
...	@@ -3607,7 +3603,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3607,7 +3603,7 @@ fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
3607	else	3603	else
3608	try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);	3604	try self.copyToRegisterWithInstTracking(inst, dst_ty, src_mcv);
3609		3605
3610	const pl_ty = dst_ty.childType();	3606	const pl_ty = dst_ty.childType(mod);
3611	const pl_abi_size = @intCast(i32, pl_ty.abiSize(mod));	3607	const pl_abi_size = @intCast(i32, pl_ty.abiSize(mod));
3612	try self.genSetMem(.{ .reg = dst_mcv.getReg().? }, pl_abi_size, Type.bool, .{ .immediate = 1 });	3608	try self.genSetMem(.{ .reg = dst_mcv.getReg().? }, pl_abi_size, Type.bool, .{ .immediate = 1 });
3613	break :result if (self.liveness.isUnused(inst)) .unreach else dst_mcv;	3609	break :result if (self.liveness.isUnused(inst)) .unreach else dst_mcv;
...	@@ -3737,7 +3733,7 @@ fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3737,7 +3733,7 @@ fn airUnwrapErrUnionErrPtr(self: *Self, inst: Air.Inst.Index) !void {
3737	const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);	3733	const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg);
3738	defer self.register_manager.unlockReg(dst_lock);	3734	defer self.register_manager.unlockReg(dst_lock);
3739		3735
3740	const eu_ty = src_ty.childType();	3736	const eu_ty = src_ty.childType(mod);
3741	const pl_ty = eu_ty.errorUnionPayload();	3737	const pl_ty = eu_ty.errorUnionPayload();
3742	const err_ty = eu_ty.errorUnionSet();	3738	const err_ty = eu_ty.errorUnionSet();
3743	const err_off = @intCast(i32, errUnionErrorOffset(pl_ty, mod));	3739	const err_off = @intCast(i32, errUnionErrorOffset(pl_ty, mod));
...	@@ -3777,7 +3773,7 @@ fn airUnwrapErrUnionPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3777,7 +3773,7 @@ fn airUnwrapErrUnionPayloadPtr(self: *Self, inst: Air.Inst.Index) !void {
3777	const dst_lock = self.register_manager.lockReg(dst_reg);	3773	const dst_lock = self.register_manager.lockReg(dst_reg);
3778	defer if (dst_lock) \|lock\| self.register_manager.unlockReg(lock);	3774	defer if (dst_lock) \|lock\| self.register_manager.unlockReg(lock);
3779		3775
3780	const eu_ty = src_ty.childType();	3776	const eu_ty = src_ty.childType(mod);
3781	const pl_ty = eu_ty.errorUnionPayload();	3777	const pl_ty = eu_ty.errorUnionPayload();
3782	const pl_off = @intCast(i32, errUnionPayloadOffset(pl_ty, mod));	3778	const pl_off = @intCast(i32, errUnionPayloadOffset(pl_ty, mod));
3783	const dst_abi_size = @intCast(u32, dst_ty.abiSize(mod));	3779	const dst_abi_size = @intCast(u32, dst_ty.abiSize(mod));
...	@@ -3803,7 +3799,7 @@ fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -3803,7 +3799,7 @@ fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
3803	const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);	3799	const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
3804	defer self.register_manager.unlockReg(src_lock);	3800	defer self.register_manager.unlockReg(src_lock);
3805		3801
3806	const eu_ty = src_ty.childType();	3802	const eu_ty = src_ty.childType(mod);
3807	const pl_ty = eu_ty.errorUnionPayload();	3803	const pl_ty = eu_ty.errorUnionPayload();
3808	const err_ty = eu_ty.errorUnionSet();	3804	const err_ty = eu_ty.errorUnionSet();
3809	const err_off = @intCast(i32, errUnionErrorOffset(pl_ty, mod));	3805	const err_off = @intCast(i32, errUnionErrorOffset(pl_ty, mod));
...	@@ -4057,7 +4053,7 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {	...	@@ -4057,7 +4053,7 @@ fn genSliceElemPtr(self: *Self, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue {
4057	};	4053	};
4058	defer if (slice_mcv_lock) \|lock\| self.register_manager.unlockReg(lock);	4054	defer if (slice_mcv_lock) \|lock\| self.register_manager.unlockReg(lock);
4059		4055
4060	const elem_ty = slice_ty.childType();	4056	const elem_ty = slice_ty.childType(mod);
4061	const elem_size = elem_ty.abiSize(mod);	4057	const elem_size = elem_ty.abiSize(mod);
4062	var buf: Type.SlicePtrFieldTypeBuffer = undefined;	4058	var buf: Type.SlicePtrFieldTypeBuffer = undefined;
4063	const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);	4059	const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
...	@@ -4116,7 +4112,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4116,7 +4112,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
4116	};	4112	};
4117	defer if (array_lock) \|lock\| self.register_manager.unlockReg(lock);	4113	defer if (array_lock) \|lock\| self.register_manager.unlockReg(lock);
4118		4114
4119	const elem_ty = array_ty.childType();	4115	const elem_ty = array_ty.childType(mod);
4120	const elem_abi_size = elem_ty.abiSize(mod);	4116	const elem_abi_size = elem_ty.abiSize(mod);
4121		4117
4122	const index_ty = self.typeOf(bin_op.rhs);	4118	const index_ty = self.typeOf(bin_op.rhs);
...	@@ -4253,7 +4249,7 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4253,7 +4249,7 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
4253	const mod = self.bin_file.options.module.?;	4249	const mod = self.bin_file.options.module.?;
4254	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	4250	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
4255	const ptr_union_ty = self.typeOf(bin_op.lhs);	4251	const ptr_union_ty = self.typeOf(bin_op.lhs);
4256	const union_ty = ptr_union_ty.childType();	4252	const union_ty = ptr_union_ty.childType(mod);
4257	const tag_ty = self.typeOf(bin_op.rhs);	4253	const tag_ty = self.typeOf(bin_op.rhs);
4258	const layout = union_ty.unionGetLayout(mod);	4254	const layout = union_ty.unionGetLayout(mod);
4259		4255
...	@@ -4287,7 +4283,9 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4287,7 +4283,9 @@ fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
4287	break :blk MCValue{ .register = reg };	4283	break :blk MCValue{ .register = reg };
4288	} else ptr;	4284	} else ptr;
4289		4285
4290	var ptr_tag_pl = ptr_union_ty.ptrInfo();	4286	var ptr_tag_pl: Type.Payload.Pointer = .{
		4287	.data = ptr_union_ty.ptrInfo(mod),
		4288	};
4291	ptr_tag_pl.data.pointee_type = tag_ty;	4289	ptr_tag_pl.data.pointee_type = tag_ty;
4292	const ptr_tag_ty = Type.initPayload(&ptr_tag_pl.base);	4290	const ptr_tag_ty = Type.initPayload(&ptr_tag_pl.base);
4293	try self.store(ptr_tag_ty, adjusted_ptr, tag);	4291	try self.store(ptr_tag_ty, adjusted_ptr, tag);
...	@@ -4924,14 +4922,11 @@ fn airFloatSign(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -4924,14 +4922,11 @@ fn airFloatSign(self: *Self, inst: Air.Inst.Index) !void {
4924	var stack align(@alignOf(ExpectedContents)) =	4922	var stack align(@alignOf(ExpectedContents)) =
4925	std.heap.stackFallback(@sizeOf(ExpectedContents), arena.allocator());	4923	std.heap.stackFallback(@sizeOf(ExpectedContents), arena.allocator());
4926		4924
4927	var vec_pl = Type.Payload.Array{	4925	const vec_ty = try mod.vectorType(.{
4928	.base = .{ .tag = .vector },	4926	.len = @divExact(abi_size * 8, scalar_bits),
4929	.data = .{	4927	.child = (try mod.intType(.signed, scalar_bits)).ip_index,
4930	.len = @divExact(abi_size * 8, scalar_bits),	4928	});
4931	.elem_type = try mod.intType(.signed, scalar_bits),	4929
4932	},
4933	};
4934	const vec_ty = Type.initPayload(&vec_pl.base);
4935	const sign_val = switch (tag) {	4930	const sign_val = switch (tag) {
4936	.neg => try vec_ty.minInt(stack.get(), mod),	4931	.neg => try vec_ty.minInt(stack.get(), mod),
4937	.fabs => try vec_ty.maxInt(stack.get(), mod),	4932	.fabs => try vec_ty.maxInt(stack.get(), mod),
...	@@ -5034,15 +5029,15 @@ fn genRound(self: *Self, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: u4	...	@@ -5034,15 +5029,15 @@ fn genRound(self: *Self, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: u4
5034	16, 80, 128 => null,	5029	16, 80, 128 => null,
5035	else => unreachable,	5030	else => unreachable,
5036	},	5031	},
5037	.Vector => switch (ty.childType().zigTypeTag(mod)) {	5032	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
5038	.Float => switch (ty.childType().floatBits(self.target.*)) {	5033	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
5039	32 => switch (ty.vectorLen()) {	5034	32 => switch (ty.vectorLen(mod)) {
5040	1 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },	5035	1 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round },
5041	2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else .{ ._ps, .round },	5036	2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else .{ ._ps, .round },
5042	5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else null,	5037	5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else null,
5043	else => null,	5038	else => null,
5044	},	5039	},
5045	64 => switch (ty.vectorLen()) {	5040	64 => switch (ty.vectorLen(mod)) {
5046	1 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round },	5041	1 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round },
5047	2 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else .{ ._pd, .round },	5042	2 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else .{ ._pd, .round },
5048	3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else null,	5043	3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .round } else null,
...	@@ -5131,9 +5126,9 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5131,9 +5126,9 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
5131	80, 128 => null,	5126	80, 128 => null,
5132	else => unreachable,	5127	else => unreachable,
5133	},	5128	},
5134	.Vector => switch (ty.childType().zigTypeTag(mod)) {	5129	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
5135	.Float => switch (ty.childType().floatBits(self.target.*)) {	5130	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
5136	16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen()) {	5131	16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen(mod)) {
5137	1 => {	5132	1 => {
5138	try self.asmRegisterRegister(	5133	try self.asmRegisterRegister(
5139	.{ .v_ps, .cvtph2 },	5134	.{ .v_ps, .cvtph2 },
...	@@ -5184,13 +5179,13 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5184,13 +5179,13 @@ fn airSqrt(self: *Self, inst: Air.Inst.Index) !void {
5184	},	5179	},
5185	else => null,	5180	else => null,
5186	} else null,	5181	} else null,
5187	32 => switch (ty.vectorLen()) {	5182	32 => switch (ty.vectorLen(mod)) {
5188	1 => if (self.hasFeature(.avx)) .{ .v_ss, .sqrt } else .{ ._ss, .sqrt },	5183	1 => if (self.hasFeature(.avx)) .{ .v_ss, .sqrt } else .{ ._ss, .sqrt },
5189	2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else .{ ._ps, .sqrt },	5184	2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else .{ ._ps, .sqrt },
5190	5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else null,	5185	5...8 => if (self.hasFeature(.avx)) .{ .v_ps, .sqrt } else null,
5191	else => null,	5186	else => null,
5192	},	5187	},
5193	64 => switch (ty.vectorLen()) {	5188	64 => switch (ty.vectorLen(mod)) {
5194	1 => if (self.hasFeature(.avx)) .{ .v_sd, .sqrt } else .{ ._sd, .sqrt },	5189	1 => if (self.hasFeature(.avx)) .{ .v_sd, .sqrt } else .{ ._sd, .sqrt },
5195	2 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else .{ ._pd, .sqrt },	5190	2 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else .{ ._pd, .sqrt },
5196	3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else null,	5191	3...4 => if (self.hasFeature(.avx)) .{ .v_pd, .sqrt } else null,
...	@@ -5292,7 +5287,7 @@ fn reuseOperandAdvanced(	...	@@ -5292,7 +5287,7 @@ fn reuseOperandAdvanced(
5292		5287
5293	fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {	5288	fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
5294	const mod = self.bin_file.options.module.?;	5289	const mod = self.bin_file.options.module.?;
5295	const ptr_info = ptr_ty.ptrInfo().data;	5290	const ptr_info = ptr_ty.ptrInfo(mod);
5296		5291
5297	const val_ty = ptr_info.pointee_type;	5292	const val_ty = ptr_info.pointee_type;
5298	const val_abi_size = @intCast(u32, val_ty.abiSize(mod));	5293	const val_abi_size = @intCast(u32, val_ty.abiSize(mod));
...	@@ -5365,7 +5360,8 @@ fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) Inn	...	@@ -5365,7 +5360,8 @@ fn packedLoad(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) Inn
5365	}	5360	}
5366		5361
5367	fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {	5362	fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerError!void {
5368	const dst_ty = ptr_ty.childType();	5363	const mod = self.bin_file.options.module.?;
		5364	const dst_ty = ptr_ty.childType(mod);
5369	switch (ptr_mcv) {	5365	switch (ptr_mcv) {
5370	.none,	5366	.none,
5371	.unreach,	5367	.unreach,
...	@@ -5424,7 +5420,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5424,7 +5420,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
5424	else	5420	else
5425	try self.allocRegOrMem(inst, true);	5421	try self.allocRegOrMem(inst, true);
5426		5422
5427	if (ptr_ty.ptrInfo().data.host_size > 0) {	5423	if (ptr_ty.ptrInfo(mod).host_size > 0) {
5428	try self.packedLoad(dst_mcv, ptr_ty, ptr_mcv);	5424	try self.packedLoad(dst_mcv, ptr_ty, ptr_mcv);
5429	} else {	5425	} else {
5430	try self.load(dst_mcv, ptr_ty, ptr_mcv);	5426	try self.load(dst_mcv, ptr_ty, ptr_mcv);
...	@@ -5436,8 +5432,8 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5436,8 +5432,8 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
5436		5432
5437	fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {	5433	fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {
5438	const mod = self.bin_file.options.module.?;	5434	const mod = self.bin_file.options.module.?;
5439	const ptr_info = ptr_ty.ptrInfo().data;	5435	const ptr_info = ptr_ty.ptrInfo(mod);
5440	const src_ty = ptr_ty.childType();	5436	const src_ty = ptr_ty.childType(mod);
5441		5437
5442	const limb_abi_size: u16 = @min(ptr_info.host_size, 8);	5438	const limb_abi_size: u16 = @min(ptr_info.host_size, 8);
5443	const limb_abi_bits = limb_abi_size * 8;	5439	const limb_abi_bits = limb_abi_size * 8;
...	@@ -5509,7 +5505,8 @@ fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) In	...	@@ -5509,7 +5505,8 @@ fn packedStore(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) In
5509	}	5505	}
5510		5506
5511	fn store(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {	5507	fn store(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerError!void {
5512	const src_ty = ptr_ty.childType();	5508	const mod = self.bin_file.options.module.?;
		5509	const src_ty = ptr_ty.childType(mod);
5513	switch (ptr_mcv) {	5510	switch (ptr_mcv) {
5514	.none,	5511	.none,
5515	.unreach,	5512	.unreach,
...	@@ -5544,6 +5541,7 @@ fn store(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerErr	...	@@ -5544,6 +5541,7 @@ fn store(self: *Self, ptr_ty: Type, ptr_mcv: MCValue, src_mcv: MCValue) InnerErr
5544	}	5541	}
5545		5542
5546	fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	5543	fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
		5544	const mod = self.bin_file.options.module.?;
5547	if (safety) {	5545	if (safety) {
5548	// TODO if the value is undef, write 0xaa bytes to dest	5546	// TODO if the value is undef, write 0xaa bytes to dest
5549	} else {	5547	} else {
...	@@ -5553,7 +5551,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -5553,7 +5551,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
5553	const ptr_mcv = try self.resolveInst(bin_op.lhs);	5551	const ptr_mcv = try self.resolveInst(bin_op.lhs);
5554	const ptr_ty = self.typeOf(bin_op.lhs);	5552	const ptr_ty = self.typeOf(bin_op.lhs);
5555	const src_mcv = try self.resolveInst(bin_op.rhs);	5553	const src_mcv = try self.resolveInst(bin_op.rhs);
5556	if (ptr_ty.ptrInfo().data.host_size > 0) {	5554	if (ptr_ty.ptrInfo(mod).host_size > 0) {
5557	try self.packedStore(ptr_ty, ptr_mcv, src_mcv);	5555	try self.packedStore(ptr_ty, ptr_mcv, src_mcv);
5558	} else {	5556	} else {
5559	try self.store(ptr_ty, ptr_mcv, src_mcv);	5557	try self.store(ptr_ty, ptr_mcv, src_mcv);
...	@@ -5578,11 +5576,11 @@ fn fieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32	...	@@ -5578,11 +5576,11 @@ fn fieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, index: u32
5578	const mod = self.bin_file.options.module.?;	5576	const mod = self.bin_file.options.module.?;
5579	const ptr_field_ty = self.typeOfIndex(inst);	5577	const ptr_field_ty = self.typeOfIndex(inst);
5580	const ptr_container_ty = self.typeOf(operand);	5578	const ptr_container_ty = self.typeOf(operand);
5581	const container_ty = ptr_container_ty.childType();	5579	const container_ty = ptr_container_ty.childType(mod);
5582	const field_offset = @intCast(i32, switch (container_ty.containerLayout()) {	5580	const field_offset = @intCast(i32, switch (container_ty.containerLayout()) {
5583	.Auto, .Extern => container_ty.structFieldOffset(index, mod),	5581	.Auto, .Extern => container_ty.structFieldOffset(index, mod),
5584	.Packed => if (container_ty.zigTypeTag(mod) == .Struct and	5582	.Packed => if (container_ty.zigTypeTag(mod) == .Struct and
5585	ptr_field_ty.ptrInfo().data.host_size == 0)	5583	ptr_field_ty.ptrInfo(mod).host_size == 0)
5586	container_ty.packedStructFieldByteOffset(index, mod)	5584	container_ty.packedStructFieldByteOffset(index, mod)
5587	else	5585	else
5588	0,	5586	0,
...	@@ -5760,7 +5758,7 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -5760,7 +5758,7 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
5760	const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;	5758	const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;
5761		5759
5762	const inst_ty = self.typeOfIndex(inst);	5760	const inst_ty = self.typeOfIndex(inst);
5763	const parent_ty = inst_ty.childType();	5761	const parent_ty = inst_ty.childType(mod);
5764	const field_offset = @intCast(i32, parent_ty.structFieldOffset(extra.field_index, mod));	5762	const field_offset = @intCast(i32, parent_ty.structFieldOffset(extra.field_index, mod));
5765		5763
5766	const src_mcv = try self.resolveInst(extra.field_ptr);	5764	const src_mcv = try self.resolveInst(extra.field_ptr);
...	@@ -6680,10 +6678,10 @@ fn genBinOp(	...	@@ -6680,10 +6678,10 @@ fn genBinOp(
6680	80, 128 => null,	6678	80, 128 => null,
6681	else => unreachable,	6679	else => unreachable,
6682	},	6680	},
6683	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	6681	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
6684	else => null,	6682	else => null,
6685	.Int => switch (lhs_ty.childType().intInfo(mod).bits) {	6683	.Int => switch (lhs_ty.childType(mod).intInfo(mod).bits) {
6686	8 => switch (lhs_ty.vectorLen()) {	6684	8 => switch (lhs_ty.vectorLen(mod)) {
6687	1...16 => switch (air_tag) {	6685	1...16 => switch (air_tag) {
6688	.add,	6686	.add,
6689	.addwrap,	6687	.addwrap,
...	@@ -6694,7 +6692,7 @@ fn genBinOp(	...	@@ -6694,7 +6692,7 @@ fn genBinOp(
6694	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },	6692	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },
6695	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },	6693	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
6696	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },	6694	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
6697	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6695	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6698	.signed => if (self.hasFeature(.avx))	6696	.signed => if (self.hasFeature(.avx))
6699	.{ .vp_b, .mins }	6697	.{ .vp_b, .mins }
6700	else if (self.hasFeature(.sse4_1))	6698	else if (self.hasFeature(.sse4_1))
...	@@ -6708,7 +6706,7 @@ fn genBinOp(	...	@@ -6708,7 +6706,7 @@ fn genBinOp(
6708	else	6706	else
6709	null,	6707	null,
6710	},	6708	},
6711	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6709	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6712	.signed => if (self.hasFeature(.avx))	6710	.signed => if (self.hasFeature(.avx))
6713	.{ .vp_b, .maxs }	6711	.{ .vp_b, .maxs }
6714	else if (self.hasFeature(.sse4_1))	6712	else if (self.hasFeature(.sse4_1))
...	@@ -6734,11 +6732,11 @@ fn genBinOp(	...	@@ -6734,11 +6732,11 @@ fn genBinOp(
6734	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,	6732	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
6735	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,	6733	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
6736	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,	6734	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
6737	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6735	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6738	.signed => if (self.hasFeature(.avx2)) .{ .vp_b, .mins } else null,	6736	.signed => if (self.hasFeature(.avx2)) .{ .vp_b, .mins } else null,
6739	.unsigned => if (self.hasFeature(.avx)) .{ .vp_b, .minu } else null,	6737	.unsigned => if (self.hasFeature(.avx)) .{ .vp_b, .minu } else null,
6740	},	6738	},
6741	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6739	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6742	.signed => if (self.hasFeature(.avx2)) .{ .vp_b, .maxs } else null,	6740	.signed => if (self.hasFeature(.avx2)) .{ .vp_b, .maxs } else null,
6743	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_b, .maxu } else null,	6741	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_b, .maxu } else null,
6744	},	6742	},
...	@@ -6746,7 +6744,7 @@ fn genBinOp(	...	@@ -6746,7 +6744,7 @@ fn genBinOp(
6746	},	6744	},
6747	else => null,	6745	else => null,
6748	},	6746	},
6749	16 => switch (lhs_ty.vectorLen()) {	6747	16 => switch (lhs_ty.vectorLen(mod)) {
6750	1...8 => switch (air_tag) {	6748	1...8 => switch (air_tag) {
6751	.add,	6749	.add,
6752	.addwrap,	6750	.addwrap,
...	@@ -6760,7 +6758,7 @@ fn genBinOp(	...	@@ -6760,7 +6758,7 @@ fn genBinOp(
6760	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },	6758	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },
6761	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },	6759	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
6762	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },	6760	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
6763	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6761	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6764	.signed => if (self.hasFeature(.avx))	6762	.signed => if (self.hasFeature(.avx))
6765	.{ .vp_w, .mins }	6763	.{ .vp_w, .mins }
6766	else	6764	else
...	@@ -6770,7 +6768,7 @@ fn genBinOp(	...	@@ -6770,7 +6768,7 @@ fn genBinOp(
6770	else	6768	else
6771	.{ .p_w, .minu },	6769	.{ .p_w, .minu },
6772	},	6770	},
6773	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6771	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6774	.signed => if (self.hasFeature(.avx))	6772	.signed => if (self.hasFeature(.avx))
6775	.{ .vp_w, .maxs }	6773	.{ .vp_w, .maxs }
6776	else	6774	else
...	@@ -6795,11 +6793,11 @@ fn genBinOp(	...	@@ -6795,11 +6793,11 @@ fn genBinOp(
6795	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,	6793	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
6796	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,	6794	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
6797	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,	6795	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
6798	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6796	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6799	.signed => if (self.hasFeature(.avx2)) .{ .vp_w, .mins } else null,	6797	.signed => if (self.hasFeature(.avx2)) .{ .vp_w, .mins } else null,
6800	.unsigned => if (self.hasFeature(.avx)) .{ .vp_w, .minu } else null,	6798	.unsigned => if (self.hasFeature(.avx)) .{ .vp_w, .minu } else null,
6801	},	6799	},
6802	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6800	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6803	.signed => if (self.hasFeature(.avx2)) .{ .vp_w, .maxs } else null,	6801	.signed => if (self.hasFeature(.avx2)) .{ .vp_w, .maxs } else null,
6804	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_w, .maxu } else null,	6802	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_w, .maxu } else null,
6805	},	6803	},
...	@@ -6807,7 +6805,7 @@ fn genBinOp(	...	@@ -6807,7 +6805,7 @@ fn genBinOp(
6807	},	6805	},
6808	else => null,	6806	else => null,
6809	},	6807	},
6810	32 => switch (lhs_ty.vectorLen()) {	6808	32 => switch (lhs_ty.vectorLen(mod)) {
6811	1...4 => switch (air_tag) {	6809	1...4 => switch (air_tag) {
6812	.add,	6810	.add,
6813	.addwrap,	6811	.addwrap,
...	@@ -6826,7 +6824,7 @@ fn genBinOp(	...	@@ -6826,7 +6824,7 @@ fn genBinOp(
6826	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },	6824	.bit_and => if (self.hasFeature(.avx)) .{ .vp_, .@"and" } else .{ .p_, .@"and" },
6827	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },	6825	.bit_or => if (self.hasFeature(.avx)) .{ .vp_, .@"or" } else .{ .p_, .@"or" },
6828	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },	6826	.xor => if (self.hasFeature(.avx)) .{ .vp_, .xor } else .{ .p_, .xor },
6829	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6827	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6830	.signed => if (self.hasFeature(.avx))	6828	.signed => if (self.hasFeature(.avx))
6831	.{ .vp_d, .mins }	6829	.{ .vp_d, .mins }
6832	else if (self.hasFeature(.sse4_1))	6830	else if (self.hasFeature(.sse4_1))
...	@@ -6840,7 +6838,7 @@ fn genBinOp(	...	@@ -6840,7 +6838,7 @@ fn genBinOp(
6840	else	6838	else
6841	null,	6839	null,
6842	},	6840	},
6843	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6841	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6844	.signed => if (self.hasFeature(.avx))	6842	.signed => if (self.hasFeature(.avx))
6845	.{ .vp_d, .maxs }	6843	.{ .vp_d, .maxs }
6846	else if (self.hasFeature(.sse4_1))	6844	else if (self.hasFeature(.sse4_1))
...	@@ -6869,11 +6867,11 @@ fn genBinOp(	...	@@ -6869,11 +6867,11 @@ fn genBinOp(
6869	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,	6867	.bit_and => if (self.hasFeature(.avx2)) .{ .vp_, .@"and" } else null,
6870	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,	6868	.bit_or => if (self.hasFeature(.avx2)) .{ .vp_, .@"or" } else null,
6871	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,	6869	.xor => if (self.hasFeature(.avx2)) .{ .vp_, .xor } else null,
6872	.min => switch (lhs_ty.childType().intInfo(mod).signedness) {	6870	.min => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6873	.signed => if (self.hasFeature(.avx2)) .{ .vp_d, .mins } else null,	6871	.signed => if (self.hasFeature(.avx2)) .{ .vp_d, .mins } else null,
6874	.unsigned => if (self.hasFeature(.avx)) .{ .vp_d, .minu } else null,	6872	.unsigned => if (self.hasFeature(.avx)) .{ .vp_d, .minu } else null,
6875	},	6873	},
6876	.max => switch (lhs_ty.childType().intInfo(mod).signedness) {	6874	.max => switch (lhs_ty.childType(mod).intInfo(mod).signedness) {
6877	.signed => if (self.hasFeature(.avx2)) .{ .vp_d, .maxs } else null,	6875	.signed => if (self.hasFeature(.avx2)) .{ .vp_d, .maxs } else null,
6878	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_d, .maxu } else null,	6876	.unsigned => if (self.hasFeature(.avx2)) .{ .vp_d, .maxu } else null,
6879	},	6877	},
...	@@ -6881,7 +6879,7 @@ fn genBinOp(	...	@@ -6881,7 +6879,7 @@ fn genBinOp(
6881	},	6879	},
6882	else => null,	6880	else => null,
6883	},	6881	},
6884	64 => switch (lhs_ty.vectorLen()) {	6882	64 => switch (lhs_ty.vectorLen(mod)) {
6885	1...2 => switch (air_tag) {	6883	1...2 => switch (air_tag) {
6886	.add,	6884	.add,
6887	.addwrap,	6885	.addwrap,
...	@@ -6910,8 +6908,8 @@ fn genBinOp(	...	@@ -6910,8 +6908,8 @@ fn genBinOp(
6910	},	6908	},
6911	else => null,	6909	else => null,
6912	},	6910	},
6913	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	6911	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
6914	16 => if (self.hasFeature(.f16c)) switch (lhs_ty.vectorLen()) {	6912	16 => if (self.hasFeature(.f16c)) switch (lhs_ty.vectorLen(mod)) {
6915	1 => {	6913	1 => {
6916	const tmp_reg = (try self.register_manager.allocReg(null, sse)).to128();	6914	const tmp_reg = (try self.register_manager.allocReg(null, sse)).to128();
6917	const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);	6915	const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
...	@@ -7086,7 +7084,7 @@ fn genBinOp(	...	@@ -7086,7 +7084,7 @@ fn genBinOp(
7086	},	7084	},
7087	else => null,	7085	else => null,
7088	} else null,	7086	} else null,
7089	32 => switch (lhs_ty.vectorLen()) {	7087	32 => switch (lhs_ty.vectorLen(mod)) {
7090	1 => switch (air_tag) {	7088	1 => switch (air_tag) {
7091	.add => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add },	7089	.add => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add },
7092	.sub => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub },	7090	.sub => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub },
...	@@ -7124,7 +7122,7 @@ fn genBinOp(	...	@@ -7124,7 +7122,7 @@ fn genBinOp(
7124	} else null,	7122	} else null,
7125	else => null,	7123	else => null,
7126	},	7124	},
7127	64 => switch (lhs_ty.vectorLen()) {	7125	64 => switch (lhs_ty.vectorLen(mod)) {
7128	1 => switch (air_tag) {	7126	1 => switch (air_tag) {
7129	.add => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add },	7127	.add => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add },
7130	.sub => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub },	7128	.sub => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub },
...	@@ -7236,14 +7234,14 @@ fn genBinOp(	...	@@ -7236,14 +7234,14 @@ fn genBinOp(
7236	16, 80, 128 => null,	7234	16, 80, 128 => null,
7237	else => unreachable,	7235	else => unreachable,
7238	},	7236	},
7239	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7237	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7240	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7238	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7241	32 => switch (lhs_ty.vectorLen()) {	7239	32 => switch (lhs_ty.vectorLen(mod)) {
7242	1 => .{ .v_ss, .cmp },	7240	1 => .{ .v_ss, .cmp },
7243	2...8 => .{ .v_ps, .cmp },	7241	2...8 => .{ .v_ps, .cmp },
7244	else => null,	7242	else => null,
7245	},	7243	},
7246	64 => switch (lhs_ty.vectorLen()) {	7244	64 => switch (lhs_ty.vectorLen(mod)) {
7247	1 => .{ .v_sd, .cmp },	7245	1 => .{ .v_sd, .cmp },
7248	2...4 => .{ .v_pd, .cmp },	7246	2...4 => .{ .v_pd, .cmp },
7249	else => null,	7247	else => null,
...	@@ -7270,13 +7268,13 @@ fn genBinOp(	...	@@ -7270,13 +7268,13 @@ fn genBinOp(
7270	16, 80, 128 => null,	7268	16, 80, 128 => null,
7271	else => unreachable,	7269	else => unreachable,
7272	},	7270	},
7273	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7271	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7274	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7272	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7275	32 => switch (lhs_ty.vectorLen()) {	7273	32 => switch (lhs_ty.vectorLen(mod)) {
7276	1...8 => .{ .v_ps, .blendv },	7274	1...8 => .{ .v_ps, .blendv },
7277	else => null,	7275	else => null,
7278	},	7276	},
7279	64 => switch (lhs_ty.vectorLen()) {	7277	64 => switch (lhs_ty.vectorLen(mod)) {
7280	1...4 => .{ .v_pd, .blendv },	7278	1...4 => .{ .v_pd, .blendv },
7281	else => null,	7279	else => null,
7282	},	7280	},
...	@@ -7304,14 +7302,14 @@ fn genBinOp(	...	@@ -7304,14 +7302,14 @@ fn genBinOp(
7304	16, 80, 128 => null,	7302	16, 80, 128 => null,
7305	else => unreachable,	7303	else => unreachable,
7306	},	7304	},
7307	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7305	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7308	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7306	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7309	32 => switch (lhs_ty.vectorLen()) {	7307	32 => switch (lhs_ty.vectorLen(mod)) {
7310	1 => .{ ._ss, .cmp },	7308	1 => .{ ._ss, .cmp },
7311	2...4 => .{ ._ps, .cmp },	7309	2...4 => .{ ._ps, .cmp },
7312	else => null,	7310	else => null,
7313	},	7311	},
7314	64 => switch (lhs_ty.vectorLen()) {	7312	64 => switch (lhs_ty.vectorLen(mod)) {
7315	1 => .{ ._sd, .cmp },	7313	1 => .{ ._sd, .cmp },
7316	2 => .{ ._pd, .cmp },	7314	2 => .{ ._pd, .cmp },
7317	else => null,	7315	else => null,
...	@@ -7337,13 +7335,13 @@ fn genBinOp(	...	@@ -7337,13 +7335,13 @@ fn genBinOp(
7337	16, 80, 128 => null,	7335	16, 80, 128 => null,
7338	else => unreachable,	7336	else => unreachable,
7339	},	7337	},
7340	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7338	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7341	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7339	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7342	32 => switch (lhs_ty.vectorLen()) {	7340	32 => switch (lhs_ty.vectorLen(mod)) {
7343	1...4 => .{ ._ps, .blendv },	7341	1...4 => .{ ._ps, .blendv },
7344	else => null,	7342	else => null,
7345	},	7343	},
7346	64 => switch (lhs_ty.vectorLen()) {	7344	64 => switch (lhs_ty.vectorLen(mod)) {
7347	1...2 => .{ ._pd, .blendv },	7345	1...2 => .{ ._pd, .blendv },
7348	else => null,	7346	else => null,
7349	},	7347	},
...	@@ -7368,13 +7366,13 @@ fn genBinOp(	...	@@ -7368,13 +7366,13 @@ fn genBinOp(
7368	16, 80, 128 => null,	7366	16, 80, 128 => null,
7369	else => unreachable,	7367	else => unreachable,
7370	},	7368	},
7371	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7369	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7372	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7370	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7373	32 => switch (lhs_ty.vectorLen()) {	7371	32 => switch (lhs_ty.vectorLen(mod)) {
7374	1...4 => .{ ._ps, .@"and" },	7372	1...4 => .{ ._ps, .@"and" },
7375	else => null,	7373	else => null,
7376	},	7374	},
7377	64 => switch (lhs_ty.vectorLen()) {	7375	64 => switch (lhs_ty.vectorLen(mod)) {
7378	1...2 => .{ ._pd, .@"and" },	7376	1...2 => .{ ._pd, .@"and" },
7379	else => null,	7377	else => null,
7380	},	7378	},
...	@@ -7398,13 +7396,13 @@ fn genBinOp(	...	@@ -7398,13 +7396,13 @@ fn genBinOp(
7398	16, 80, 128 => null,	7396	16, 80, 128 => null,
7399	else => unreachable,	7397	else => unreachable,
7400	},	7398	},
7401	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7399	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7402	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7400	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7403	32 => switch (lhs_ty.vectorLen()) {	7401	32 => switch (lhs_ty.vectorLen(mod)) {
7404	1...4 => .{ ._ps, .andn },	7402	1...4 => .{ ._ps, .andn },
7405	else => null,	7403	else => null,
7406	},	7404	},
7407	64 => switch (lhs_ty.vectorLen()) {	7405	64 => switch (lhs_ty.vectorLen(mod)) {
7408	1...2 => .{ ._pd, .andn },	7406	1...2 => .{ ._pd, .andn },
7409	else => null,	7407	else => null,
7410	},	7408	},
...	@@ -7428,13 +7426,13 @@ fn genBinOp(	...	@@ -7428,13 +7426,13 @@ fn genBinOp(
7428	16, 80, 128 => null,	7426	16, 80, 128 => null,
7429	else => unreachable,	7427	else => unreachable,
7430	},	7428	},
7431	.Vector => switch (lhs_ty.childType().zigTypeTag(mod)) {	7429	.Vector => switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
7432	.Float => switch (lhs_ty.childType().floatBits(self.target.*)) {	7430	.Float => switch (lhs_ty.childType(mod).floatBits(self.target.*)) {
7433	32 => switch (lhs_ty.vectorLen()) {	7431	32 => switch (lhs_ty.vectorLen(mod)) {
7434	1...4 => .{ ._ps, .@"or" },	7432	1...4 => .{ ._ps, .@"or" },
7435	else => null,	7433	else => null,
7436	},	7434	},
7437	64 => switch (lhs_ty.vectorLen()) {	7435	64 => switch (lhs_ty.vectorLen(mod)) {
7438	1...2 => .{ ._pd, .@"or" },	7436	1...2 => .{ ._pd, .@"or" },
7439	else => null,	7437	else => null,
7440	},	7438	},
...	@@ -7586,11 +7584,7 @@ fn genBinOpMir(	...	@@ -7586,11 +7584,7 @@ fn genBinOpMir(
7586	.load_got,	7584	.load_got,
7587	.load_tlv,	7585	.load_tlv,
7588	=> {	7586	=> {
7589	var ptr_pl = Type.Payload.ElemType{	7587	const ptr_ty = try mod.singleConstPtrType(ty);
7590	.base = .{ .tag = .single_const_pointer },
7591	.data = ty,
7592	};
7593	const ptr_ty = Type.initPayload(&ptr_pl.base);
7594	const addr_reg = try self.copyToTmpRegister(ptr_ty, src_mcv.address());	7588	const addr_reg = try self.copyToTmpRegister(ptr_ty, src_mcv.address());
7595	return self.genBinOpMir(mir_tag, ty, dst_mcv, .{	7589	return self.genBinOpMir(mir_tag, ty, dst_mcv, .{
7596	.indirect = .{ .reg = addr_reg },	7590	.indirect = .{ .reg = addr_reg },
...	@@ -8058,7 +8052,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -8058,7 +8052,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
8058		8052
8059	const fn_ty = switch (ty.zigTypeTag(mod)) {	8053	const fn_ty = switch (ty.zigTypeTag(mod)) {
8060	.Fn => ty,	8054	.Fn => ty,
8061	.Pointer => ty.childType(),	8055	.Pointer => ty.childType(mod),
8062	else => unreachable,	8056	else => unreachable,
8063	};	8057	};
8064		8058
...	@@ -8506,10 +8500,11 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -8506,10 +8500,11 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void {
8506	}	8500	}
8507		8501
8508	fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {	8502	fn airTryPtr(self: *Self, inst: Air.Inst.Index) !void {
		8503	const mod = self.bin_file.options.module.?;
8509	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	8504	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
8510	const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);	8505	const extra = self.air.extraData(Air.TryPtr, ty_pl.payload);
8511	const body = self.air.extra[extra.end..][0..extra.data.body_len];	8506	const body = self.air.extra[extra.end..][0..extra.data.body_len];
8512	const err_union_ty = self.typeOf(extra.data.ptr).childType();	8507	const err_union_ty = self.typeOf(extra.data.ptr).childType(mod);
8513	const result = try self.genTry(inst, extra.data.ptr, body, err_union_ty, true);	8508	const result = try self.genTry(inst, extra.data.ptr, body, err_union_ty, true);
8514	return self.finishAir(inst, result, .{ .none, .none, .none });	8509	return self.finishAir(inst, result, .{ .none, .none, .none });
8515	}	8510	}
...	@@ -8683,8 +8678,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC	...	@@ -8683,8 +8678,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
8683	try self.spillEflagsIfOccupied();	8678	try self.spillEflagsIfOccupied();
8684	self.eflags_inst = inst;	8679	self.eflags_inst = inst;
8685		8680
8686	var pl_buf: Type.Payload.ElemType = undefined;	8681	const pl_ty = opt_ty.optionalChild(mod);
8687	const pl_ty = opt_ty.optionalChild(&pl_buf);
8688		8682
8689	var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;	8683	var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
8690	const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))	8684	const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))
...	@@ -8775,9 +8769,8 @@ fn isNullPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue)	...	@@ -8775,9 +8769,8 @@ fn isNullPtr(self: *Self, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue)
8775	try self.spillEflagsIfOccupied();	8769	try self.spillEflagsIfOccupied();
8776	self.eflags_inst = inst;	8770	self.eflags_inst = inst;
8777		8771
8778	const opt_ty = ptr_ty.childType();	8772	const opt_ty = ptr_ty.childType(mod);
8779	var pl_buf: Type.Payload.ElemType = undefined;	8773	const pl_ty = opt_ty.optionalChild(mod);
8780	const pl_ty = opt_ty.optionalChild(&pl_buf);
8781		8774
8782	var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;	8775	var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
8783	const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))	8776	const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(mod))
...	@@ -8919,6 +8912,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -8919,6 +8912,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void {
8919	}	8912	}
8920		8913
8921	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {	8914	fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
		8915	const mod = self.bin_file.options.module.?;
8922	const un_op = self.air.instructions.items(.data)[inst].un_op;	8916	const un_op = self.air.instructions.items(.data)[inst].un_op;
8923		8917
8924	const operand_ptr = try self.resolveInst(un_op);	8918	const operand_ptr = try self.resolveInst(un_op);
...	@@ -8939,7 +8933,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -8939,7 +8933,7 @@ fn airIsErrPtr(self: *Self, inst: Air.Inst.Index) !void {
8939	const ptr_ty = self.typeOf(un_op);	8933	const ptr_ty = self.typeOf(un_op);
8940	try self.load(operand, ptr_ty, operand_ptr);	8934	try self.load(operand, ptr_ty, operand_ptr);
8941		8935
8942	const result = try self.isErr(inst, ptr_ty.childType(), operand);	8936	const result = try self.isErr(inst, ptr_ty.childType(mod), operand);
8943		8937
8944	return self.finishAir(inst, result, .{ un_op, .none, .none });	8938	return self.finishAir(inst, result, .{ un_op, .none, .none });
8945	}	8939	}
...	@@ -8953,6 +8947,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -8953,6 +8947,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void {
8953	}	8947	}
8954		8948
8955	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {	8949	fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
		8950	const mod = self.bin_file.options.module.?;
8956	const un_op = self.air.instructions.items(.data)[inst].un_op;	8951	const un_op = self.air.instructions.items(.data)[inst].un_op;
8957		8952
8958	const operand_ptr = try self.resolveInst(un_op);	8953	const operand_ptr = try self.resolveInst(un_op);
...	@@ -8973,7 +8968,7 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -8973,7 +8968,7 @@ fn airIsNonErrPtr(self: *Self, inst: Air.Inst.Index) !void {
8973	const ptr_ty = self.typeOf(un_op);	8968	const ptr_ty = self.typeOf(un_op);
8974	try self.load(operand, ptr_ty, operand_ptr);	8969	try self.load(operand, ptr_ty, operand_ptr);
8975		8970
8976	const result = try self.isNonErr(inst, ptr_ty.childType(), operand);	8971	const result = try self.isNonErr(inst, ptr_ty.childType(mod), operand);
8977		8972
8978	return self.finishAir(inst, result, .{ un_op, .none, .none });	8973	return self.finishAir(inst, result, .{ un_op, .none, .none });
8979	}	8974	}
...	@@ -9452,9 +9447,9 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9452,9 +9447,9 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9452	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },	9447	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
9453	else => {},	9448	else => {},
9454	},	9449	},
9455	.Vector => switch (ty.childType().zigTypeTag(mod)) {	9450	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
9456	.Int => switch (ty.childType().intInfo(mod).bits) {	9451	.Int => switch (ty.childType(mod).intInfo(mod).bits) {
9457	8 => switch (ty.vectorLen()) {	9452	8 => switch (ty.vectorLen(mod)) {
9458	1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{	9453	1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{
9459	.insert = .{ .vp_b, .insr },	9454	.insert = .{ .vp_b, .insr },
9460	.extract = .{ .vp_b, .extr },	9455	.extract = .{ .vp_b, .extr },
...	@@ -9484,7 +9479,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9484,7 +9479,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9484	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9479	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9485	else => {},	9480	else => {},
9486	},	9481	},
9487	16 => switch (ty.vectorLen()) {	9482	16 => switch (ty.vectorLen(mod)) {
9488	1 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{	9483	1 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{
9489	.insert = .{ .vp_w, .insr },	9484	.insert = .{ .vp_w, .insr },
9490	.extract = .{ .vp_w, .extr },	9485	.extract = .{ .vp_w, .extr },
...	@@ -9507,7 +9502,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9507,7 +9502,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9507	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9502	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9508	else => {},	9503	else => {},
9509	},	9504	},
9510	32 => switch (ty.vectorLen()) {	9505	32 => switch (ty.vectorLen(mod)) {
9511	1 => return .{ .move = if (self.hasFeature(.avx))	9506	1 => return .{ .move = if (self.hasFeature(.avx))
9512	.{ .v_d, .mov }	9507	.{ .v_d, .mov }
9513	else	9508	else
...	@@ -9523,7 +9518,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9523,7 +9518,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9523	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9518	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9524	else => {},	9519	else => {},
9525	},	9520	},
9526	64 => switch (ty.vectorLen()) {	9521	64 => switch (ty.vectorLen(mod)) {
9527	1 => return .{ .move = if (self.hasFeature(.avx))	9522	1 => return .{ .move = if (self.hasFeature(.avx))
9528	.{ .v_q, .mov }	9523	.{ .v_q, .mov }
9529	else	9524	else
...	@@ -9535,7 +9530,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9535,7 +9530,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9535	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9530	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9536	else => {},	9531	else => {},
9537	},	9532	},
9538	128 => switch (ty.vectorLen()) {	9533	128 => switch (ty.vectorLen(mod)) {
9539	1 => return .{ .move = if (self.hasFeature(.avx))	9534	1 => return .{ .move = if (self.hasFeature(.avx))
9540	if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }	9535	if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
9541	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },	9536	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
...	@@ -9543,15 +9538,15 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9543,15 +9538,15 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9543	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9538	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9544	else => {},	9539	else => {},
9545	},	9540	},
9546	256 => switch (ty.vectorLen()) {	9541	256 => switch (ty.vectorLen(mod)) {
9547	1 => if (self.hasFeature(.avx))	9542	1 => if (self.hasFeature(.avx))
9548	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9543	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9549	else => {},	9544	else => {},
9550	},	9545	},
9551	else => {},	9546	else => {},
9552	},	9547	},
9553	.Float => switch (ty.childType().floatBits(self.target.*)) {	9548	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
9554	16 => switch (ty.vectorLen()) {	9549	16 => switch (ty.vectorLen(mod)) {
9555	1 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{	9550	1 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{
9556	.insert = .{ .vp_w, .insr },	9551	.insert = .{ .vp_w, .insr },
9557	.extract = .{ .vp_w, .extr },	9552	.extract = .{ .vp_w, .extr },
...	@@ -9574,7 +9569,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9574,7 +9569,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9574	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },	9569	return .{ .move = if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu } },
9575	else => {},	9570	else => {},
9576	},	9571	},
9577	32 => switch (ty.vectorLen()) {	9572	32 => switch (ty.vectorLen(mod)) {
9578	1 => return .{ .move = if (self.hasFeature(.avx))	9573	1 => return .{ .move = if (self.hasFeature(.avx))
9579	.{ .v_ss, .mov }	9574	.{ .v_ss, .mov }
9580	else	9575	else
...	@@ -9590,7 +9585,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9590,7 +9585,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9590	return .{ .move = if (aligned) .{ .v_ps, .mova } else .{ .v_ps, .movu } },	9585	return .{ .move = if (aligned) .{ .v_ps, .mova } else .{ .v_ps, .movu } },
9591	else => {},	9586	else => {},
9592	},	9587	},
9593	64 => switch (ty.vectorLen()) {	9588	64 => switch (ty.vectorLen(mod)) {
9594	1 => return .{ .move = if (self.hasFeature(.avx))	9589	1 => return .{ .move = if (self.hasFeature(.avx))
9595	.{ .v_sd, .mov }	9590	.{ .v_sd, .mov }
9596	else	9591	else
...	@@ -9602,7 +9597,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {	...	@@ -9602,7 +9597,7 @@ fn moveStrategy(self: *Self, ty: Type, aligned: bool) !MoveStrategy {
9602	return .{ .move = if (aligned) .{ .v_pd, .mova } else .{ .v_pd, .movu } },	9597	return .{ .move = if (aligned) .{ .v_pd, .mova } else .{ .v_pd, .movu } },
9603	else => {},	9598	else => {},
9604	},	9599	},
9605	128 => switch (ty.vectorLen()) {	9600	128 => switch (ty.vectorLen(mod)) {
9606	1 => return .{ .move = if (self.hasFeature(.avx))	9601	1 => return .{ .move = if (self.hasFeature(.avx))
9607	if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }	9602	if (aligned) .{ .v_, .movdqa } else .{ .v_, .movdqu }
9608	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },	9603	else if (aligned) .{ ._, .movdqa } else .{ ._, .movdqu } },
...	@@ -10248,8 +10243,8 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -10248,8 +10243,8 @@ fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
10248	const slice_ty = self.typeOfIndex(inst);	10243	const slice_ty = self.typeOfIndex(inst);
10249	const ptr_ty = self.typeOf(ty_op.operand);	10244	const ptr_ty = self.typeOf(ty_op.operand);
10250	const ptr = try self.resolveInst(ty_op.operand);	10245	const ptr = try self.resolveInst(ty_op.operand);
10251	const array_ty = ptr_ty.childType();	10246	const array_ty = ptr_ty.childType(mod);
10252	const array_len = array_ty.arrayLen();	10247	const array_len = array_ty.arrayLen(mod);
10253		10248
10254	const frame_index = try self.allocFrameIndex(FrameAlloc.initType(slice_ty, mod));	10249	const frame_index = try self.allocFrameIndex(FrameAlloc.initType(slice_ty, mod));
10255	try self.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, ptr);	10250	try self.genSetMem(.{ .frame = frame_index }, 0, ptr_ty, ptr);
...	@@ -10790,16 +10785,16 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -10790,16 +10785,16 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
10790	const elem_abi_size = @intCast(u31, elem_ty.abiSize(mod));	10785	const elem_abi_size = @intCast(u31, elem_ty.abiSize(mod));
10791		10786
10792	if (elem_abi_size == 1) {	10787	if (elem_abi_size == 1) {
10793	const ptr: MCValue = switch (dst_ptr_ty.ptrSize()) {	10788	const ptr: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
10794	// TODO: this only handles slices stored in the stack	10789	// TODO: this only handles slices stored in the stack
10795	.Slice => dst_ptr,	10790	.Slice => dst_ptr,
10796	.One => dst_ptr,	10791	.One => dst_ptr,
10797	.C, .Many => unreachable,	10792	.C, .Many => unreachable,
10798	};	10793	};
10799	const len: MCValue = switch (dst_ptr_ty.ptrSize()) {	10794	const len: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
10800	// TODO: this only handles slices stored in the stack	10795	// TODO: this only handles slices stored in the stack
10801	.Slice => dst_ptr.address().offset(8).deref(),	10796	.Slice => dst_ptr.address().offset(8).deref(),
10802	.One => .{ .immediate = dst_ptr_ty.childType().arrayLen() },	10797	.One => .{ .immediate = dst_ptr_ty.childType(mod).arrayLen(mod) },
10803	.C, .Many => unreachable,	10798	.C, .Many => unreachable,
10804	};	10799	};
10805	const len_lock: ?RegisterLock = switch (len) {	10800	const len_lock: ?RegisterLock = switch (len) {
...	@@ -10815,7 +10810,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -10815,7 +10810,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
10815	// Store the first element, and then rely on memcpy copying forwards.	10810	// Store the first element, and then rely on memcpy copying forwards.
10816	// Length zero requires a runtime check - so we handle arrays specially	10811	// Length zero requires a runtime check - so we handle arrays specially
10817	// here to elide it.	10812	// here to elide it.
10818	switch (dst_ptr_ty.ptrSize()) {	10813	switch (dst_ptr_ty.ptrSize(mod)) {
10819	.Slice => {	10814	.Slice => {
10820	var buf: Type.SlicePtrFieldTypeBuffer = undefined;	10815	var buf: Type.SlicePtrFieldTypeBuffer = undefined;
10821	const slice_ptr_ty = dst_ptr_ty.slicePtrFieldType(&buf);	10816	const slice_ptr_ty = dst_ptr_ty.slicePtrFieldType(&buf);
...	@@ -10858,13 +10853,9 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -10858,13 +10853,9 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
10858	try self.performReloc(skip_reloc);	10853	try self.performReloc(skip_reloc);
10859	},	10854	},
10860	.One => {	10855	.One => {
10861	var elem_ptr_pl = Type.Payload.ElemType{	10856	const elem_ptr_ty = try mod.singleMutPtrType(elem_ty);
10862	.base = .{ .tag = .single_mut_pointer },
10863	.data = elem_ty,
10864	};
10865	const elem_ptr_ty = Type.initPayload(&elem_ptr_pl.base);
10866		10857
10867	const len = dst_ptr_ty.childType().arrayLen();	10858	const len = dst_ptr_ty.childType(mod).arrayLen(mod);
10868		10859
10869	assert(len != 0); // prevented by Sema	10860	assert(len != 0); // prevented by Sema
10870	try self.store(elem_ptr_ty, dst_ptr, src_val);	10861	try self.store(elem_ptr_ty, dst_ptr, src_val);
...	@@ -10889,6 +10880,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {	...	@@ -10889,6 +10880,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
10889	}	10880	}
10890		10881
10891	fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {	10882	fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
		10883	const mod = self.bin_file.options.module.?;
10892	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	10884	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
10893		10885
10894	const dst_ptr = try self.resolveInst(bin_op.lhs);	10886	const dst_ptr = try self.resolveInst(bin_op.lhs);
...	@@ -10906,9 +10898,9 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -10906,9 +10898,9 @@ fn airMemcpy(self: *Self, inst: Air.Inst.Index) !void {
10906	};	10898	};
10907	defer if (src_ptr_lock) \|lock\| self.register_manager.unlockReg(lock);	10899	defer if (src_ptr_lock) \|lock\| self.register_manager.unlockReg(lock);
10908		10900
10909	const len: MCValue = switch (dst_ptr_ty.ptrSize()) {	10901	const len: MCValue = switch (dst_ptr_ty.ptrSize(mod)) {
10910	.Slice => dst_ptr.address().offset(8).deref(),	10902	.Slice => dst_ptr.address().offset(8).deref(),
10911	.One => .{ .immediate = dst_ptr_ty.childType().arrayLen() },	10903	.One => .{ .immediate = dst_ptr_ty.childType(mod).arrayLen(mod) },
10912	.C, .Many => unreachable,	10904	.C, .Many => unreachable,
10913	};	10905	};
10914	const len_lock: ?RegisterLock = switch (len) {	10906	const len_lock: ?RegisterLock = switch (len) {
...	@@ -11059,7 +11051,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11059,7 +11051,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
11059	switch (scalar_ty.zigTypeTag(mod)) {	11051	switch (scalar_ty.zigTypeTag(mod)) {
11060	else => {},	11052	else => {},
11061	.Float => switch (scalar_ty.floatBits(self.target.*)) {	11053	.Float => switch (scalar_ty.floatBits(self.target.*)) {
11062	32 => switch (vector_ty.vectorLen()) {	11054	32 => switch (vector_ty.vectorLen(mod)) {
11063	1 => {	11055	1 => {
11064	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;	11056	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;
11065	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);	11057	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);
...	@@ -11139,7 +11131,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11139,7 +11131,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
11139	},	11131	},
11140	else => {},	11132	else => {},
11141	},	11133	},
11142	64 => switch (vector_ty.vectorLen()) {	11134	64 => switch (vector_ty.vectorLen(mod)) {
11143	1 => {	11135	1 => {
11144	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;	11136	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;
11145	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);	11137	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);
...	@@ -11205,7 +11197,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11205,7 +11197,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
11205	},	11197	},
11206	else => {},	11198	else => {},
11207	},	11199	},
11208	128 => switch (vector_ty.vectorLen()) {	11200	128 => switch (vector_ty.vectorLen(mod)) {
11209	1 => {	11201	1 => {
11210	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;	11202	if (self.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv;
11211	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);	11203	const dst_reg = try self.register_manager.allocReg(inst, dst_rc);
...	@@ -11271,7 +11263,7 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11271,7 +11263,7 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
11271	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	11263	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
11272	const mod = self.bin_file.options.module.?;	11264	const mod = self.bin_file.options.module.?;
11273	const result_ty = self.typeOfIndex(inst);	11265	const result_ty = self.typeOfIndex(inst);
11274	const len = @intCast(usize, result_ty.arrayLen());	11266	const len = @intCast(usize, result_ty.arrayLen(mod));
11275	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	11267	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
11276	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);	11268	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
11277	const result: MCValue = result: {	11269	const result: MCValue = result: {
...	@@ -11375,7 +11367,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11375,7 +11367,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
11375	.Array => {	11367	.Array => {
11376	const frame_index =	11368	const frame_index =
11377	try self.allocFrameIndex(FrameAlloc.initType(result_ty, mod));	11369	try self.allocFrameIndex(FrameAlloc.initType(result_ty, mod));
11378	const elem_ty = result_ty.childType();	11370	const elem_ty = result_ty.childType(mod);
11379	const elem_size = @intCast(u32, elem_ty.abiSize(mod));	11371	const elem_size = @intCast(u32, elem_ty.abiSize(mod));
11380		11372
11381	for (elements, 0..) \|elem, elem_i\| {	11373	for (elements, 0..) \|elem, elem_i\| {
...	@@ -11387,7 +11379,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11387,7 +11379,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
11387	const elem_off = @intCast(i32, elem_size * elem_i);	11379	const elem_off = @intCast(i32, elem_size * elem_i);
11388	try self.genSetMem(.{ .frame = frame_index }, elem_off, elem_ty, mat_elem_mcv);	11380	try self.genSetMem(.{ .frame = frame_index }, elem_off, elem_ty, mat_elem_mcv);
11389	}	11381	}
11390	if (result_ty.sentinel()) \|sentinel\| try self.genSetMem(	11382	if (result_ty.sentinel(mod)) \|sentinel\| try self.genSetMem(
11391	.{ .frame = frame_index },	11383	.{ .frame = frame_index },
11392	@intCast(i32, elem_size * elements.len),	11384	@intCast(i32, elem_size * elements.len),
11393	elem_ty,	11385	elem_ty,
...	@@ -11512,14 +11504,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11512,14 +11504,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
11512	16, 80, 128 => null,	11504	16, 80, 128 => null,
11513	else => unreachable,	11505	else => unreachable,
11514	},	11506	},
11515	.Vector => switch (ty.childType().zigTypeTag(mod)) {	11507	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
11516	.Float => switch (ty.childType().floatBits(self.target.*)) {	11508	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
11517	32 => switch (ty.vectorLen()) {	11509	32 => switch (ty.vectorLen(mod)) {
11518	1 => .{ .v_ss, .fmadd132 },	11510	1 => .{ .v_ss, .fmadd132 },
11519	2...8 => .{ .v_ps, .fmadd132 },	11511	2...8 => .{ .v_ps, .fmadd132 },
11520	else => null,	11512	else => null,
11521	},	11513	},
11522	64 => switch (ty.vectorLen()) {	11514	64 => switch (ty.vectorLen(mod)) {
11523	1 => .{ .v_sd, .fmadd132 },	11515	1 => .{ .v_sd, .fmadd132 },
11524	2...4 => .{ .v_pd, .fmadd132 },	11516	2...4 => .{ .v_pd, .fmadd132 },
11525	else => null,	11517	else => null,
...	@@ -11539,14 +11531,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11539,14 +11531,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
11539	16, 80, 128 => null,	11531	16, 80, 128 => null,
11540	else => unreachable,	11532	else => unreachable,
11541	},	11533	},
11542	.Vector => switch (ty.childType().zigTypeTag(mod)) {	11534	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
11543	.Float => switch (ty.childType().floatBits(self.target.*)) {	11535	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
11544	32 => switch (ty.vectorLen()) {	11536	32 => switch (ty.vectorLen(mod)) {
11545	1 => .{ .v_ss, .fmadd213 },	11537	1 => .{ .v_ss, .fmadd213 },
11546	2...8 => .{ .v_ps, .fmadd213 },	11538	2...8 => .{ .v_ps, .fmadd213 },
11547	else => null,	11539	else => null,
11548	},	11540	},
11549	64 => switch (ty.vectorLen()) {	11541	64 => switch (ty.vectorLen(mod)) {
11550	1 => .{ .v_sd, .fmadd213 },	11542	1 => .{ .v_sd, .fmadd213 },
11551	2...4 => .{ .v_pd, .fmadd213 },	11543	2...4 => .{ .v_pd, .fmadd213 },
11552	else => null,	11544	else => null,
...	@@ -11566,14 +11558,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11566,14 +11558,14 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) !void {
11566	16, 80, 128 => null,	11558	16, 80, 128 => null,
11567	else => unreachable,	11559	else => unreachable,
11568	},	11560	},
11569	.Vector => switch (ty.childType().zigTypeTag(mod)) {	11561	.Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
11570	.Float => switch (ty.childType().floatBits(self.target.*)) {	11562	.Float => switch (ty.childType(mod).floatBits(self.target.*)) {
11571	32 => switch (ty.vectorLen()) {	11563	32 => switch (ty.vectorLen(mod)) {
11572	1 => .{ .v_ss, .fmadd231 },	11564	1 => .{ .v_ss, .fmadd231 },
11573	2...8 => .{ .v_ps, .fmadd231 },	11565	2...8 => .{ .v_ps, .fmadd231 },
11574	else => null,	11566	else => null,
11575	},	11567	},
11576	64 => switch (ty.vectorLen()) {	11568	64 => switch (ty.vectorLen(mod)) {
11577	1 => .{ .v_sd, .fmadd231 },	11569	1 => .{ .v_sd, .fmadd231 },
11578	2...4 => .{ .v_pd, .fmadd231 },	11570	2...4 => .{ .v_pd, .fmadd231 },
11579	else => null,	11571	else => null,

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

...	@@ -76,7 +76,7 @@ pub fn classifySystemV(ty: Type, mod: *const Module, ctx: Context) [8]Class {	...	@@ -76,7 +76,7 @@ pub fn classifySystemV(ty: Type, mod: *const Module, ctx: Context) [8]Class {
76	};	76	};
77	var result = [1]Class{.none} ** 8;	77	var result = [1]Class{.none} ** 8;
78	switch (ty.zigTypeTag(mod)) {	78	switch (ty.zigTypeTag(mod)) {
79	.Pointer => switch (ty.ptrSize()) {	79	.Pointer => switch (ty.ptrSize(mod)) {
80	.Slice => {	80	.Slice => {
81	result[0] = .integer;	81	result[0] = .integer;
82	result[1] = .integer;	82	result[1] = .integer;
...	@@ -158,8 +158,8 @@ pub fn classifySystemV(ty: Type, mod: *const Module, ctx: Context) [8]Class {	...	@@ -158,8 +158,8 @@ pub fn classifySystemV(ty: Type, mod: *const Module, ctx: Context) [8]Class {
158	else => unreachable,	158	else => unreachable,
159	},	159	},
160	.Vector => {	160	.Vector => {
161	const elem_ty = ty.childType();	161	const elem_ty = ty.childType(mod);
162	const bits = elem_ty.bitSize(mod) * ty.arrayLen();	162	const bits = elem_ty.bitSize(mod) * ty.arrayLen(mod);
163	if (bits <= 64) return .{	163	if (bits <= 64) return .{
164	.sse, .none, .none, .none,	164	.sse, .none, .none, .none,
165	.none, .none, .none, .none,	165	.none, .none, .none, .none,

src/codegen.zig+17-19

src/codegen/c.zig+106-97

src/codegen/c/type.zig+4-5

...	@@ -1423,7 +1423,7 @@ pub const CType = extern union {	...	@@ -1423,7 +1423,7 @@ pub const CType = extern union {
1423	}),	1423	}),
1424		1424
1425	.Pointer => {	1425	.Pointer => {
1426	const info = ty.ptrInfo().data;	1426	const info = ty.ptrInfo(mod);
1427	switch (info.size) {	1427	switch (info.size) {
1428	.Slice => {	1428	.Slice => {
1429	if (switch (kind) {	1429	if (switch (kind) {
...	@@ -1625,9 +1625,9 @@ pub const CType = extern union {	...	@@ -1625,9 +1625,9 @@ pub const CType = extern union {
1625	.Vector => .vector,	1625	.Vector => .vector,
1626	else => unreachable,	1626	else => unreachable,
1627	};	1627	};
1628	if (try lookup.typeToIndex(ty.childType(), kind)) \|child_idx\| {	1628	if (try lookup.typeToIndex(ty.childType(mod), kind)) \|child_idx\| {
1629	self.storage = .{ .seq = .{ .base = .{ .tag = t }, .data = .{	1629	self.storage = .{ .seq = .{ .base = .{ .tag = t }, .data = .{
1630	.len = ty.arrayLenIncludingSentinel(),	1630	.len = ty.arrayLenIncludingSentinel(mod),
1631	.elem_type = child_idx,	1631	.elem_type = child_idx,
1632	} } };	1632	} } };
1633	self.value = .{ .cty = initPayload(&self.storage.seq) };	1633	self.value = .{ .cty = initPayload(&self.storage.seq) };
...	@@ -1639,8 +1639,7 @@ pub const CType = extern union {	...	@@ -1639,8 +1639,7 @@ pub const CType = extern union {
1639	},	1639	},
1640		1640
1641	.Optional => {	1641	.Optional => {
1642	var buf: Type.Payload.ElemType = undefined;	1642	const payload_ty = ty.optionalChild(mod);
1643	const payload_ty = ty.optionalChild(&buf);
1644	if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {	1643	if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
1645	if (ty.optionalReprIsPayload(mod)) {	1644	if (ty.optionalReprIsPayload(mod)) {
1646	try self.initType(payload_ty, kind, lookup);	1645	try self.initType(payload_ty, kind, lookup);

src/codegen/llvm.zig+144-182

 @@ -597,7 +597,7 @@ pub const Object = struct {
             llvm_usize_ty,
         };
         const llvm_slice_ty = self.context.structType(&type_fields, type_fields.len, .False);
-        const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+        const slice_ty = Type.const_slice_u8_sentinel_0;
         const slice_alignment = slice_ty.abiAlignment(mod);
         const error_name_list = mod.error_name_list.items;
 @@ -1071,7 +1071,7 @@ pub const Object = struct {
                 .slice => {
                     assert(!it.byval_attr);
                     const param_ty = fn_info.param_types[it.zig_index - 1];
-                    const ptr_info = param_ty.ptrInfo().data;
+                    const ptr_info = param_ty.ptrInfo(mod);
                     if (math.cast(u5, it.zig_index - 1)) |i| {
                         if (@truncate(u1, fn_info.noalias_bits >> i) != 0) {
 @@ -1596,7 +1596,7 @@ pub const Object = struct {
             },
             .Pointer => {
                 // Normalize everything that the debug info does not represent.
-                const ptr_info = ty.ptrInfo().data;
+                const ptr_info = ty.ptrInfo(mod);
                 if (ptr_info.sentinel != null or
                     ptr_info.@"addrspace" != .generic or
 @@ -1755,8 +1755,8 @@ pub const Object = struct {
                 const array_di_ty = dib.createArrayType(
                     ty.abiSize(mod) * 8,
                     ty.abiAlignment(mod) * 8,
-                    try o.lowerDebugType(ty.childType(), .full),
+                    try o.lowerDebugType(ty.childType(mod), .full),
-                    @intCast(c_int, ty.arrayLen()),
+                    @intCast(c_int, ty.arrayLen(mod)),
                 );
                 // The recursive call to `lowerDebugType` means we can't use `gop` anymore.
                 try o.di_type_map.putContext(gpa, ty, AnnotatedDITypePtr.initFull(array_di_ty), .{ .mod = o.module });
 @@ -1781,14 +1781,14 @@ pub const Object = struct {
                         break :blk dib.createBasicType(name, info.bits, dwarf_encoding);
                     },
                     .Bool => dib.createBasicType("bool", 1, DW.ATE.boolean),
-                    else => try o.lowerDebugType(ty.childType(), .full),
+                    else => try o.lowerDebugType(ty.childType(mod), .full),
                 };
                 const vector_di_ty = dib.createVectorType(
                     ty.abiSize(mod) * 8,
                     ty.abiAlignment(mod) * 8,
                     elem_di_type,
-                    ty.vectorLen(),
+                    ty.vectorLen(mod),
                 );
                 // The recursive call to `lowerDebugType` means we can't use `gop` anymore.
                 try o.di_type_map.putContext(gpa, ty, AnnotatedDITypePtr.initFull(vector_di_ty), .{ .mod = o.module });
 @@ -1797,8 +1797,7 @@ pub const Object = struct {
             .Optional => {
                 const name = try ty.nameAlloc(gpa, o.module);
                 defer gpa.free(name);
-                var buf: Type.Payload.ElemType = undefined;
+                const child_ty = ty.optionalChild(mod);
-                const child_ty = ty.optionalChild(&buf);
                 if (!child_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                     const di_bits = 8; // lldb cannot handle non-byte sized types
                     const di_ty = dib.createBasicType(name, di_bits, DW.ATE.boolean);
 @@ -2350,11 +2349,7 @@ pub const Object = struct {
                     try param_di_types.append(try o.lowerDebugType(di_ret_ty, .full));
                     if (sret) {
-                        var ptr_ty_payload: Type.Payload.ElemType = .{
+                        const ptr_ty = try mod.singleMutPtrType(fn_info.return_type);
-                            .base = .{ .tag = .single_mut_pointer },
-                            .data = fn_info.return_type,
-                        };
-                        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                         try param_di_types.append(try o.lowerDebugType(ptr_ty, .full));
                     }
                 } else {
 @@ -2364,11 +2359,7 @@ pub const Object = struct {
                 if (fn_info.return_type.isError(mod) and
                     o.module.comp.bin_file.options.error_return_tracing)
                 {
-                    var ptr_ty_payload: Type.Payload.ElemType = .{
+                    const ptr_ty = try mod.singleMutPtrType(o.getStackTraceType());
-                        .base = .{ .tag = .single_mut_pointer },
-                        .data = o.getStackTraceType(),
-                    };
-                    const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                     try param_di_types.append(try o.lowerDebugType(ptr_ty, .full));
                 }
 @@ -2376,11 +2367,7 @@ pub const Object = struct {
                     if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
                     if (isByRef(param_ty, mod)) {
-                        var ptr_ty_payload: Type.Payload.ElemType = .{
+                        const ptr_ty = try mod.singleMutPtrType(param_ty);
-                            .base = .{ .tag = .single_mut_pointer },
-                            .data = param_ty,
-                        };
-                        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
                         try param_di_types.append(try o.lowerDebugType(ptr_ty, .full));
                     } else {
                         try param_di_types.append(try o.lowerDebugType(param_ty, .full));
 @@ -2843,7 +2830,7 @@ pub const DeclGen = struct {
                     };
                     return dg.context.structType(&fields, fields.len, .False);
                 }
-                const ptr_info = t.ptrInfo().data;
+                const ptr_info = t.ptrInfo(mod);
                 const llvm_addrspace = toLlvmAddressSpace(ptr_info.@"addrspace", target);
                 return dg.context.pointerType(llvm_addrspace);
             },
 @@ -2866,19 +2853,18 @@ pub const DeclGen = struct {
                 return llvm_struct_ty;
             },
             .Array => {
-                const elem_ty = t.childType();
+                const elem_ty = t.childType(mod);
                 assert(elem_ty.onePossibleValue(mod) == null);
                 const elem_llvm_ty = try dg.lowerType(elem_ty);
-                const total_len = t.arrayLen() + @boolToInt(t.sentinel() != null);
+                const total_len = t.arrayLen(mod) + @boolToInt(t.sentinel(mod) != null);
                 return elem_llvm_ty.arrayType(@intCast(c_uint, total_len));
             },
             .Vector => {
-                const elem_type = try dg.lowerType(t.childType());
+                const elem_type = try dg.lowerType(t.childType(mod));
-                return elem_type.vectorType(t.vectorLen());
+                return elem_type.vectorType(t.vectorLen(mod));
             },
             .Optional => {
-                var buf: Type.Payload.ElemType = undefined;
+                const child_ty = t.optionalChild(mod);
-                const child_ty = t.optionalChild(&buf);
                 if (!child_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                     return dg.context.intType(8);
                 }
 @@ -3173,11 +3159,7 @@ pub const DeclGen = struct {
         if (fn_info.return_type.isError(mod) and
             mod.comp.bin_file.options.error_return_tracing)
         {
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(dg.object.getStackTraceType());
-                .base = .{ .tag = .single_mut_pointer },
-                .data = dg.object.getStackTraceType(),
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try llvm_params.append(try dg.lowerType(ptr_ty));
         }
 @@ -3199,9 +3181,8 @@ pub const DeclGen = struct {
             .slice => {
                 const param_ty = fn_info.param_types[it.zig_index - 1];
                 var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                var opt_buf: Type.Payload.ElemType = undefined;
                 const ptr_ty = if (param_ty.zigTypeTag(mod) == .Optional)
-                    param_ty.optionalChild(&opt_buf).slicePtrFieldType(&buf)
+                    param_ty.optionalChild(mod).slicePtrFieldType(&buf)
                 else
                     param_ty.slicePtrFieldType(&buf);
                 const ptr_llvm_ty = try dg.lowerType(ptr_ty);
 @@ -3247,7 +3228,7 @@ pub const DeclGen = struct {
         const lower_elem_ty = switch (elem_ty.zigTypeTag(mod)) {
             .Opaque => true,
             .Fn => !elem_ty.fnInfo().is_generic,
-            .Array => elem_ty.childType().hasRuntimeBitsIgnoreComptime(mod),
+            .Array => elem_ty.childType(mod).hasRuntimeBitsIgnoreComptime(mod),
             else => elem_ty.hasRuntimeBitsIgnoreComptime(mod),
         };
         const llvm_elem_ty = if (lower_elem_ty)
 @@ -3417,7 +3398,7 @@ pub const DeclGen = struct {
                     return llvm_int.constIntToPtr(try dg.lowerType(tv.ty));
                 },
                 .field_ptr, .opt_payload_ptr, .eu_payload_ptr, .elem_ptr => {
-                    return dg.lowerParentPtr(tv.val, tv.ty.ptrInfo().data.bit_offset % 8 == 0);
+                    return dg.lowerParentPtr(tv.val, tv.ty.ptrInfo(mod).bit_offset % 8 == 0);
                 },
                 .null_value, .zero => {
                     const llvm_type = try dg.lowerType(tv.ty);
 @@ -3425,7 +3406,7 @@ pub const DeclGen = struct {
                 },
                 .opt_payload => {
                     const payload = tv.val.castTag(.opt_payload).?.data;
-                    return dg.lowerParentPtr(payload, tv.ty.ptrInfo().data.bit_offset % 8 == 0);
+                    return dg.lowerParentPtr(payload, tv.ty.ptrInfo(mod).bit_offset % 8 == 0);
                 },
                 else => |tag| return dg.todo("implement const of pointer type '{}' ({})", .{
                     tv.ty.fmtDebug(), tag,
 @@ -3436,14 +3417,14 @@ pub const DeclGen = struct {
                     const bytes = tv.val.castTag(.bytes).?.data;
                     return dg.context.constString(
                         bytes.ptr,
-                        @intCast(c_uint, tv.ty.arrayLenIncludingSentinel()),
+                        @intCast(c_uint, tv.ty.arrayLenIncludingSentinel(mod)),
                         .True, // Don't null terminate. Bytes has the sentinel, if any.
                     );
                 },
                 .str_lit => {
                     const str_lit = tv.val.castTag(.str_lit).?.data;
                     const bytes = dg.module.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
-                    if (tv.ty.sentinel()) |sent_val| {
+                    if (tv.ty.sentinel(mod)) |sent_val| {
                         const byte = @intCast(u8, sent_val.toUnsignedInt(mod));
                         if (byte == 0 and bytes.len > 0) {
                             return dg.context.constString(
 @@ -3472,9 +3453,9 @@ pub const DeclGen = struct {
                 },
                 .aggregate => {
                     const elem_vals = tv.val.castTag(.aggregate).?.data;
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
                     const gpa = dg.gpa;
-                    const len = @intCast(usize, tv.ty.arrayLenIncludingSentinel());
+                    const len = @intCast(usize, tv.ty.arrayLenIncludingSentinel(mod));
                     const llvm_elems = try gpa.alloc(*llvm.Value, len);
                     defer gpa.free(llvm_elems);
                     var need_unnamed = false;
 @@ -3498,9 +3479,9 @@ pub const DeclGen = struct {
                 },
                 .repeated => {
                     const val = tv.val.castTag(.repeated).?.data;
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
-                    const sentinel = tv.ty.sentinel();
+                    const sentinel = tv.ty.sentinel(mod);
-                    const len = @intCast(usize, tv.ty.arrayLen());
+                    const len = @intCast(usize, tv.ty.arrayLen(mod));
                     const len_including_sent = len + @boolToInt(sentinel != null);
                     const gpa = dg.gpa;
                     const llvm_elems = try gpa.alloc(*llvm.Value, len_including_sent);
 @@ -3534,8 +3515,8 @@ pub const DeclGen = struct {
                     }
                 },
                 .empty_array_sentinel => {
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
-                    const sent_val = tv.ty.sentinel().?;
+                    const sent_val = tv.ty.sentinel(mod).?;
                     const sentinel = try dg.lowerValue(.{ .ty = elem_ty, .val = sent_val });
                     const llvm_elems: [1]*llvm.Value = .{sentinel};
                     const need_unnamed = dg.isUnnamedType(elem_ty, llvm_elems[0]);
 @@ -3550,8 +3531,7 @@ pub const DeclGen = struct {
             },
             .Optional => {
                 comptime assert(optional_layout_version == 3);
-                var buf: Type.Payload.ElemType = undefined;
+                const payload_ty = tv.ty.optionalChild(mod);
-                const payload_ty = tv.ty.optionalChild(&buf);
                 const llvm_i8 = dg.context.intType(8);
                 const is_pl = !tv.val.isNull(mod);
 @@ -3897,10 +3877,10 @@ pub const DeclGen = struct {
                 .bytes => {
                     // Note, sentinel is not stored even if the type has a sentinel.
                     const bytes = tv.val.castTag(.bytes).?.data;
-                    const vector_len = @intCast(usize, tv.ty.arrayLen());
+                    const vector_len = @intCast(usize, tv.ty.arrayLen(mod));
                     assert(vector_len == bytes.len or vector_len + 1 == bytes.len);
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
                     const llvm_elems = try dg.gpa.alloc(*llvm.Value, vector_len);
                     defer dg.gpa.free(llvm_elems);
                     for (llvm_elems, 0..) |*elem, i| {
 @@ -3923,9 +3903,9 @@ pub const DeclGen = struct {
                     // Note, sentinel is not stored even if the type has a sentinel.
                     // The value includes the sentinel in those cases.
                     const elem_vals = tv.val.castTag(.aggregate).?.data;
-                    const vector_len = @intCast(usize, tv.ty.arrayLen());
+                    const vector_len = @intCast(usize, tv.ty.arrayLen(mod));
                     assert(vector_len == elem_vals.len or vector_len + 1 == elem_vals.len);
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
                     const llvm_elems = try dg.gpa.alloc(*llvm.Value, vector_len);
                     defer dg.gpa.free(llvm_elems);
                     for (llvm_elems, 0..) |*elem, i| {
 @@ -3939,8 +3919,8 @@ pub const DeclGen = struct {
                 .repeated => {
                     // Note, sentinel is not stored even if the type has a sentinel.
                     const val = tv.val.castTag(.repeated).?.data;
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
-                    const len = @intCast(usize, tv.ty.arrayLen());
+                    const len = @intCast(usize, tv.ty.arrayLen(mod));
                     const llvm_elems = try dg.gpa.alloc(*llvm.Value, len);
                     defer dg.gpa.free(llvm_elems);
                     for (llvm_elems) |*elem| {
 @@ -3955,10 +3935,10 @@ pub const DeclGen = struct {
                     // Note, sentinel is not stored
                     const str_lit = tv.val.castTag(.str_lit).?.data;
                     const bytes = dg.module.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
-                    const vector_len = @intCast(usize, tv.ty.arrayLen());
+                    const vector_len = @intCast(usize, tv.ty.arrayLen(mod));
                     assert(vector_len == bytes.len);
-                    const elem_ty = tv.ty.elemType();
+                    const elem_ty = tv.ty.childType(mod);
                     const llvm_elems = try dg.gpa.alloc(*llvm.Value, vector_len);
                     defer dg.gpa.free(llvm_elems);
                     for (llvm_elems, 0..) |*elem, i| {
 @@ -4006,13 +3986,10 @@ pub const DeclGen = struct {
         ptr_val: Value,
         decl_index: Module.Decl.Index,
     ) Error!*llvm.Value {
-        const decl = dg.module.declPtr(decl_index);
+        const mod = dg.module;
-        dg.module.markDeclAlive(decl);
+        const decl = mod.declPtr(decl_index);
-        var ptr_ty_payload: Type.Payload.ElemType = .{
+        mod.markDeclAlive(decl);
-            .base = .{ .tag = .single_mut_pointer },
+        const ptr_ty = try mod.singleMutPtrType(decl.ty);
-            .data = decl.ty,
-        };
-        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
         return try dg.lowerDeclRefValue(.{ .ty = ptr_ty, .val = ptr_val }, decl_index);
     }
 @@ -4135,9 +4112,8 @@ pub const DeclGen = struct {
             .opt_payload_ptr => {
                 const opt_payload_ptr = ptr_val.castTag(.opt_payload_ptr).?.data;
                 const parent_llvm_ptr = try dg.lowerParentPtr(opt_payload_ptr.container_ptr, true);
-                var buf: Type.Payload.ElemType = undefined;
-                const payload_ty = opt_payload_ptr.container_ty.optionalChild(&buf);
+                const payload_ty = opt_payload_ptr.container_ty.optionalChild(mod);
                 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod) or
                     payload_ty.optionalReprIsPayload(mod))
                 {
 @@ -4251,7 +4227,8 @@ pub const DeclGen = struct {
     }
     fn lowerPtrToVoid(dg: *DeclGen, ptr_ty: Type) !*llvm.Value {
-        const alignment = ptr_ty.ptrInfo().data.@"align";
+        const mod = dg.module;
+        const alignment = ptr_ty.ptrInfo(mod).@"align";
         // 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
 @@ -4374,7 +4351,7 @@ pub const DeclGen = struct {
     ) void {
         const mod = dg.module;
         if (param_ty.isPtrAtRuntime(mod)) {
-            const ptr_info = param_ty.ptrInfo().data;
+            const ptr_info = param_ty.ptrInfo(mod);
             if (math.cast(u5, param_index)) |i| {
                 if (@truncate(u1, fn_info.noalias_bits >> i) != 0) {
                     dg.addArgAttr(llvm_fn, llvm_arg_i, "noalias");
 @@ -4786,7 +4763,7 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const zig_fn_ty = switch (callee_ty.zigTypeTag(mod)) {
             .Fn => callee_ty,
-            .Pointer => callee_ty.childType(),
+            .Pointer => callee_ty.childType(mod),
             else => unreachable,
         };
         const fn_info = zig_fn_ty.fnInfo();
 @@ -5014,7 +4991,7 @@ pub const FuncGen = struct {
                 .slice => {
                     assert(!it.byval_attr);
                     const param_ty = fn_info.param_types[it.zig_index - 1];
-                    const ptr_info = param_ty.ptrInfo().data;
+                    const ptr_info = param_ty.ptrInfo(mod);
                     const llvm_arg_i = it.llvm_index - 2;
                     if (math.cast(u5, it.zig_index - 1)) |i| {
 @@ -5098,11 +5075,7 @@ pub const FuncGen = struct {
         const ret_ty = self.typeOf(un_op);
         if (self.ret_ptr) |ret_ptr| {
             const operand = try self.resolveInst(un_op);
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const ptr_ty = try mod.singleMutPtrType(ret_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = ret_ty,
-            };
-            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try self.store(ret_ptr, ptr_ty, operand, .NotAtomic);
             _ = self.builder.buildRetVoid();
             return null;
 @@ -5150,11 +5123,11 @@ pub const FuncGen = struct {
     }
     fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const un_op = self.air.instructions.items(.data)[inst].un_op;
         const ptr_ty = self.typeOf(un_op);
-        const ret_ty = ptr_ty.childType();
+        const ret_ty = ptr_ty.childType(mod);
         const fn_info = self.dg.decl.ty.fnInfo();
-        const mod = self.dg.module;
         if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             if (fn_info.return_type.isError(mod)) {
                 // Functions with an empty error set are emitted with an error code
 @@ -5301,15 +5274,13 @@ pub const FuncGen = struct {
         operand_ty: Type,
         op: math.CompareOperator,
     ) Allocator.Error!*llvm.Value {
-        var opt_buffer: Type.Payload.ElemType = undefined;
         const mod = self.dg.module;
         const scalar_ty = operand_ty.scalarType(mod);
         const int_ty = switch (scalar_ty.zigTypeTag(mod)) {
             .Enum => scalar_ty.intTagType(),
             .Int, .Bool, .Pointer, .ErrorSet => scalar_ty,
             .Optional => blk: {
-                const payload_ty = operand_ty.optionalChild(&opt_buffer);
+                const payload_ty = operand_ty.optionalChild(mod);
                 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod) or
                     operand_ty.optionalReprIsPayload(mod))
                 {
 @@ -5506,11 +5477,12 @@ pub const FuncGen = struct {
     }
     fn airTryPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_pl = self.air.instructions.items(.data)[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 = self.air.extra[extra.end..][0..extra.data.body_len];
-        const err_union_ty = self.typeOf(extra.data.ptr).childType();
+        const err_union_ty = self.typeOf(extra.data.ptr).childType(mod);
         const is_unused = self.liveness.isUnused(inst);
         return lowerTry(self, err_union_ptr, body, err_union_ty, true, true, is_unused);
     }
 @@ -5661,9 +5633,9 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         const operand_ty = self.typeOf(ty_op.operand);
-        const array_ty = operand_ty.childType();
+        const array_ty = operand_ty.childType(mod);
         const llvm_usize = try self.dg.lowerType(Type.usize);
-        const len = llvm_usize.constInt(array_ty.arrayLen(), .False);
+        const len = llvm_usize.constInt(array_ty.arrayLen(mod), .False);
         const slice_llvm_ty = try self.dg.lowerType(self.typeOfIndex(inst));
         const operand = try self.resolveInst(ty_op.operand);
         if (!array_ty.hasRuntimeBitsIgnoreComptime(mod)) {
 @@ -5806,20 +5778,20 @@ pub const FuncGen = struct {
         const mod = fg.dg.module;
         const target = mod.getTarget();
         const llvm_usize_ty = fg.context.intType(target.ptrBitWidth());
-        switch (ty.ptrSize()) {
+        switch (ty.ptrSize(mod)) {
             .Slice => {
                 const len = fg.builder.buildExtractValue(ptr, 1, "");
-                const elem_ty = ty.childType();
+                const elem_ty = ty.childType(mod);
                 const abi_size = elem_ty.abiSize(mod);
                 if (abi_size == 1) return len;
                 const abi_size_llvm_val = llvm_usize_ty.constInt(abi_size, .False);
                 return fg.builder.buildMul(len, abi_size_llvm_val, "");
             },
             .One => {
-                const array_ty = ty.childType();
+                const array_ty = ty.childType(mod);
-                const elem_ty = array_ty.childType();
+                const elem_ty = array_ty.childType(mod);
                 const abi_size = elem_ty.abiSize(mod);
-                return llvm_usize_ty.constInt(array_ty.arrayLen() * abi_size, .False);
+                return llvm_usize_ty.constInt(array_ty.arrayLen(mod) * abi_size, .False);
             },
             .Many, .C => unreachable,
         }
 @@ -5832,10 +5804,11 @@ pub const FuncGen = struct {
     }
     fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: c_uint) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[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 self.dg.lowerPtrElemTy(slice_ptr_ty.childType());
+        const slice_llvm_ty = try self.dg.lowerPtrElemTy(slice_ptr_ty.childType(mod));
         return self.builder.buildStructGEP(slice_llvm_ty, slice_ptr, index, "");
     }
 @@ -5847,7 +5820,7 @@ pub const FuncGen = struct {
         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();
+        const elem_ty = slice_ty.childType(mod);
         const llvm_elem_ty = try self.dg.lowerPtrElemTy(elem_ty);
         const base_ptr = self.builder.buildExtractValue(slice, 0, "");
         const indices: [1]*llvm.Value = .{index};
 @@ -5863,13 +5836,14 @@ pub const FuncGen = struct {
     }
     fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_pl = self.air.instructions.items(.data)[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 self.dg.lowerPtrElemTy(slice_ty.childType());
+        const llvm_elem_ty = try self.dg.lowerPtrElemTy(slice_ty.childType(mod));
         const base_ptr = self.builder.buildExtractValue(slice, 0, "");
         const indices: [1]*llvm.Value = .{index};
         return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
 @@ -5884,7 +5858,7 @@ 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 self.dg.lowerType(array_ty);
-        const elem_ty = array_ty.childType();
+        const elem_ty = array_ty.childType(mod);
         if (isByRef(array_ty, mod)) {
             const indices: [2]*llvm.Value = .{ self.context.intType(32).constNull(), rhs };
             if (isByRef(elem_ty, mod)) {
 @@ -5923,7 +5897,7 @@ pub const FuncGen = struct {
         const inst = body_tail[0];
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const elem_ty = ptr_ty.childType();
+        const elem_ty = ptr_ty.childType(mod);
         const llvm_elem_ty = try self.dg.lowerPtrElemTy(elem_ty);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
 @@ -5951,14 +5925,14 @@ pub const FuncGen = struct {
         const ty_pl = self.air.instructions.items(.data)[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();
+        const elem_ty = ptr_ty.childType(mod);
         if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) return self.dg.lowerPtrToVoid(ptr_ty);
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
         const elem_ptr = self.air.getRefType(ty_pl.ty);
-        if (elem_ptr.ptrInfo().data.vector_index != .none) return base_ptr;
+        if (elem_ptr.ptrInfo(mod).vector_index != .none) return base_ptr;
         const llvm_elem_ty = try self.dg.lowerPtrElemTy(elem_ty);
         if (ptr_ty.isSinglePointer(mod)) {
 @@ -6098,7 +6072,7 @@ pub const FuncGen = struct {
         const field_ptr = try self.resolveInst(extra.field_ptr);
         const target = self.dg.module.getTarget();
-        const parent_ty = self.air.getRefType(ty_pl.ty).childType();
+        const parent_ty = self.air.getRefType(ty_pl.ty).childType(mod);
         const field_offset = parent_ty.structFieldOffset(extra.field_index, mod);
         const res_ty = try self.dg.lowerType(self.air.getRefType(ty_pl.ty));
 @@ -6232,6 +6206,7 @@ pub const FuncGen = struct {
     }
     fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const dib = self.dg.object.di_builder orelse return null;
         const pl_op = self.air.instructions.items(.data)[inst].pl_op;
         const operand = try self.resolveInst(pl_op.operand);
 @@ -6243,7 +6218,7 @@ pub const FuncGen = struct {
             name.ptr,
             self.di_file.?,
             self.prev_dbg_line,
-            try self.dg.object.lowerDebugType(ptr_ty.childType(), .full),
+            try self.dg.object.lowerDebugType(ptr_ty.childType(mod), .full),
             true, // always preserve
             0, // flags
         );
 @@ -6365,7 +6340,7 @@ pub const FuncGen = struct {
                 const output_inst = try self.resolveInst(output);
                 const output_ty = self.typeOf(output);
                 assert(output_ty.zigTypeTag(mod) == .Pointer);
-                const elem_llvm_ty = try self.dg.lowerPtrElemTy(output_ty.childType());
+                const elem_llvm_ty = try self.dg.lowerPtrElemTy(output_ty.childType(mod));
                 if (llvm_ret_indirect[i]) {
                     // Pass the result by reference as an indirect output (e.g. "=*m")
 @@ -6466,7 +6441,7 @@ pub const FuncGen = struct {
             // an elementtype(<ty>) attribute.
             if (constraint[0] == '*') {
                 llvm_param_attrs[llvm_param_i] = llvm_elem_ty orelse
-                    try self.dg.lowerPtrElemTy(arg_ty.childType());
+                    try self.dg.lowerPtrElemTy(arg_ty.childType(mod));
             } else {
                 llvm_param_attrs[llvm_param_i] = null;
             }
 @@ -6657,14 +6632,13 @@ pub const FuncGen = struct {
         operand_is_ptr: bool,
         pred: llvm.IntPredicate,
     ) !?*llvm.Value {
+        const mod = self.dg.module;
         const un_op = self.air.instructions.items(.data)[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() else operand_ty;
+        const optional_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
         const optional_llvm_ty = try self.dg.lowerType(optional_ty);
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = optional_ty.optionalChild(mod);
-        const payload_ty = optional_ty.optionalChild(&buf);
-        const mod = self.dg.module;
         if (optional_ty.optionalReprIsPayload(mod)) {
             const loaded = if (operand_is_ptr)
                 self.builder.buildLoad(optional_llvm_ty, operand, "")
 @@ -6709,7 +6683,7 @@ pub const FuncGen = struct {
         const un_op = self.air.instructions.items(.data)[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() else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
         const payload_ty = err_union_ty.errorUnionPayload();
         const err_set_ty = try self.dg.lowerType(Type.anyerror);
         const zero = err_set_ty.constNull();
 @@ -6748,9 +6722,8 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const optional_ty = self.typeOf(ty_op.operand).childType();
+        const optional_ty = self.typeOf(ty_op.operand).childType(mod);
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = optional_ty.optionalChild(mod);
-        const payload_ty = optional_ty.optionalChild(&buf);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             // We have a pointer to a zero-bit value and we need to return
             // a pointer to a zero-bit value.
 @@ -6770,9 +6743,8 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const optional_ty = self.typeOf(ty_op.operand).childType();
+        const optional_ty = self.typeOf(ty_op.operand).childType(mod);
-        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = optional_ty.optionalChild(mod);
-        const payload_ty = optional_ty.optionalChild(&buf);
         const non_null_bit = self.context.intType(8).constInt(1, .False);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             // We have a pointer to a i8. We need to set it to 1 and then return the same pointer.
 @@ -6827,9 +6799,9 @@ pub const FuncGen = struct {
         const ty_op = self.air.instructions.items(.data)[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() else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
         const result_ty = self.typeOfIndex(inst);
-        const payload_ty = if (operand_is_ptr) result_ty.childType() else result_ty;
+        const payload_ty = if (operand_is_ptr) result_ty.childType(mod) else result_ty;
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             return if (operand_is_ptr) operand else null;
 @@ -6862,7 +6834,7 @@ pub const FuncGen = struct {
         const ty_op = self.air.instructions.items(.data)[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() else operand_ty;
+        const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
         if (err_union_ty.errorUnionSet().errorSetIsEmpty(mod)) {
             const err_llvm_ty = try self.dg.lowerType(Type.anyerror);
             if (operand_is_ptr) {
 @@ -6895,7 +6867,7 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         const operand = try self.resolveInst(ty_op.operand);
-        const err_union_ty = self.typeOf(ty_op.operand).childType();
+        const err_union_ty = self.typeOf(ty_op.operand).childType(mod);
         const payload_ty = err_union_ty.errorUnionPayload();
         const non_error_val = try self.dg.lowerValue(.{ .ty = Type.anyerror, .val = Value.zero });
 @@ -6961,11 +6933,7 @@ pub const FuncGen = struct {
         if (isByRef(optional_ty, mod)) {
             const optional_ptr = self.buildAlloca(llvm_optional_ty, optional_ty.abiAlignment(mod));
             const payload_ptr = self.builder.buildStructGEP(llvm_optional_ty, optional_ptr, 0, "");
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const payload_ptr_ty = try mod.singleMutPtrType(payload_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = payload_ty,
-            };
-            const payload_ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try self.store(payload_ptr, payload_ptr_ty, operand, .NotAtomic);
             const non_null_ptr = self.builder.buildStructGEP(llvm_optional_ty, optional_ptr, 1, "");
             _ = self.builder.buildStore(non_null_bit, non_null_ptr);
 @@ -6995,11 +6963,7 @@ pub const FuncGen = struct {
             const store_inst = self.builder.buildStore(ok_err_code, err_ptr);
             store_inst.setAlignment(Type.anyerror.abiAlignment(mod));
             const payload_ptr = self.builder.buildStructGEP(err_un_llvm_ty, result_ptr, payload_offset, "");
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const payload_ptr_ty = try mod.singleMutPtrType(payload_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = payload_ty,
-            };
-            const payload_ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             try self.store(payload_ptr, payload_ptr_ty, operand, .NotAtomic);
             return result_ptr;
         }
 @@ -7027,11 +6991,7 @@ pub const FuncGen = struct {
             const store_inst = self.builder.buildStore(operand, err_ptr);
             store_inst.setAlignment(Type.anyerror.abiAlignment(mod));
             const payload_ptr = self.builder.buildStructGEP(err_un_llvm_ty, result_ptr, payload_offset, "");
-            var ptr_ty_payload: Type.Payload.ElemType = .{
+            const payload_ptr_ty = try mod.singleMutPtrType(payload_ty);
-                .base = .{ .tag = .single_mut_pointer },
-                .data = payload_ty,
-            };
-            const payload_ptr_ty = Type.initPayload(&ptr_ty_payload.base);
             // TODO store undef to payload_ptr
             _ = payload_ptr;
             _ = payload_ptr_ty;
 @@ -7076,7 +7036,7 @@ pub const FuncGen = struct {
         const operand = try self.resolveInst(extra.rhs);
         const loaded_vector = blk: {
-            const elem_llvm_ty = try self.dg.lowerType(vector_ptr_ty.childType());
+            const elem_llvm_ty = try self.dg.lowerType(vector_ptr_ty.childType(mod));
             const load_inst = self.builder.buildLoad(elem_llvm_ty, vector_ptr, "");
             load_inst.setAlignment(vector_ptr_ty.ptrAlignment(mod));
             load_inst.setVolatile(llvm.Bool.fromBool(vector_ptr_ty.isVolatilePtr()));
 @@ -7287,7 +7247,7 @@ pub const FuncGen = struct {
             const inst_llvm_ty = try self.dg.lowerType(inst_ty);
             const scalar_bit_size_minus_one = scalar_ty.bitSize(mod) - 1;
             const bit_size_minus_one = if (inst_ty.zigTypeTag(mod) == .Vector) const_vector: {
-                const vec_len = inst_ty.vectorLen();
+                const vec_len = inst_ty.vectorLen(mod);
                 const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
                 const shifts = try self.gpa.alloc(*llvm.Value, vec_len);
 @@ -7361,7 +7321,7 @@ pub const FuncGen = struct {
         if (scalar_ty.isSignedInt(mod)) {
             const scalar_bit_size_minus_one = scalar_ty.bitSize(mod) - 1;
             const bit_size_minus_one = if (inst_ty.zigTypeTag(mod) == .Vector) const_vector: {
-                const vec_len = inst_ty.vectorLen();
+                const vec_len = inst_ty.vectorLen(mod);
                 const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
                 const shifts = try self.gpa.alloc(*llvm.Value, vec_len);
 @@ -7384,13 +7344,14 @@ pub const FuncGen = struct {
     }
     fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_pl = self.air.instructions.items(.data)[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 self.dg.lowerPtrElemTy(ptr_ty.childType());
+        const llvm_elem_ty = try self.dg.lowerPtrElemTy(ptr_ty.childType(mod));
-        switch (ptr_ty.ptrSize()) {
+        switch (ptr_ty.ptrSize(mod)) {
             .One => {
                 // It's a pointer to an array, so according to LLVM we need an extra GEP index.
                 const indices: [2]*llvm.Value = .{ self.context.intType(32).constNull(), offset };
 @@ -7409,14 +7370,15 @@ pub const FuncGen = struct {
     }
     fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_pl = self.air.instructions.items(.data)[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 = self.builder.buildNeg(offset, "");
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const llvm_elem_ty = try self.dg.lowerPtrElemTy(ptr_ty.childType());
+        const llvm_elem_ty = try self.dg.lowerPtrElemTy(ptr_ty.childType(mod));
-        switch (ptr_ty.ptrSize()) {
+        switch (ptr_ty.ptrSize(mod)) {
             .One => {
                 // It's a pointer to an array, so according to LLVM we need an extra GEP index.
                 const indices: [2]*llvm.Value = .{
 @@ -7587,7 +7549,7 @@ pub const FuncGen = struct {
         };
         if (ty.zigTypeTag(mod) == .Vector) {
-            const vec_len = ty.vectorLen();
+            const vec_len = ty.vectorLen(mod);
             const vector_result_ty = llvm_i32.vectorType(vec_len);
             var result = vector_result_ty.getUndef();
 @@ -7672,8 +7634,8 @@ pub const FuncGen = struct {
                     const shift_amt = int_llvm_ty.constInt(float_bits - 1, .False);
                     const sign_mask = one.constShl(shift_amt);
                     const result = if (ty.zigTypeTag(mod) == .Vector) blk: {
-                        const splat_sign_mask = self.builder.buildVectorSplat(ty.vectorLen(), sign_mask, "");
+                        const splat_sign_mask = self.builder.buildVectorSplat(ty.vectorLen(mod), sign_mask, "");
-                        const cast_ty = int_llvm_ty.vectorType(ty.vectorLen());
+                        const cast_ty = int_llvm_ty.vectorType(ty.vectorLen(mod));
                         const bitcasted_operand = self.builder.buildBitCast(params[0], cast_ty, "");
                         break :blk self.builder.buildXor(bitcasted_operand, splat_sign_mask, "");
                     } else blk: {
 @@ -7720,7 +7682,7 @@ pub const FuncGen = struct {
                 const libc_fn = self.getLibcFunction(fn_name, param_types[0..params.len], scalar_llvm_ty);
                 if (ty.zigTypeTag(mod) == .Vector) {
                     const result = llvm_ty.getUndef();
-                    return self.buildElementwiseCall(libc_fn, &params, result, ty.vectorLen());
+                    return self.buildElementwiseCall(libc_fn, &params, result, ty.vectorLen(mod));
                 }
                 break :b libc_fn;
 @@ -7887,7 +7849,7 @@ pub const FuncGen = struct {
         const bits = lhs_scalar_llvm_ty.constInt(lhs_bits, .False);
         const lhs_max = lhs_scalar_llvm_ty.constAllOnes();
         if (rhs_ty.zigTypeTag(mod) == .Vector) {
-            const vec_len = rhs_ty.vectorLen();
+            const vec_len = rhs_ty.vectorLen(mod);
             const bits_vec = self.builder.buildVectorSplat(vec_len, bits, "");
             const lhs_max_vec = self.builder.buildVectorSplat(vec_len, lhs_max, "");
             const in_range = self.builder.buildICmp(.ULT, rhs, bits_vec, "");
 @@ -8059,7 +8021,7 @@ pub const FuncGen = struct {
         }
         if (operand_ty.zigTypeTag(mod) == .Vector and inst_ty.zigTypeTag(mod) == .Array) {
-            const elem_ty = operand_ty.childType();
+            const elem_ty = operand_ty.childType(mod);
             if (!result_is_ref) {
                 return self.dg.todo("implement bitcast vector to non-ref array", .{});
             }
 @@ -8074,7 +8036,7 @@ pub const FuncGen = struct {
                 const llvm_usize = try self.dg.lowerType(Type.usize);
                 const llvm_u32 = self.context.intType(32);
                 const zero = llvm_usize.constNull();
-                const vector_len = operand_ty.arrayLen();
+                const vector_len = operand_ty.arrayLen(mod);
                 var i: u64 = 0;
                 while (i < vector_len) : (i += 1) {
                     const index_usize = llvm_usize.constInt(i, .False);
 @@ -8087,7 +8049,7 @@ pub const FuncGen = struct {
             }
             return array_ptr;
         } else if (operand_ty.zigTypeTag(mod) == .Array and inst_ty.zigTypeTag(mod) == .Vector) {
-            const elem_ty = operand_ty.childType();
+            const elem_ty = operand_ty.childType(mod);
             const llvm_vector_ty = try self.dg.lowerType(inst_ty);
             if (!operand_is_ref) {
                 return self.dg.todo("implement bitcast non-ref array to vector", .{});
 @@ -8108,7 +8070,7 @@ pub const FuncGen = struct {
                 const llvm_usize = try self.dg.lowerType(Type.usize);
                 const llvm_u32 = self.context.intType(32);
                 const zero = llvm_usize.constNull();
-                const vector_len = operand_ty.arrayLen();
+                const vector_len = operand_ty.arrayLen(mod);
                 var vector = llvm_vector_ty.getUndef();
                 var i: u64 = 0;
                 while (i < vector_len) : (i += 1) {
 @@ -8207,7 +8169,7 @@ pub const FuncGen = struct {
     fn airAlloc(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
         const mod = self.dg.module;
         const ptr_ty = self.typeOfIndex(inst);
-        const pointee_type = ptr_ty.childType();
+        const pointee_type = ptr_ty.childType(mod);
         if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return self.dg.lowerPtrToVoid(ptr_ty);
         const pointee_llvm_ty = try self.dg.lowerType(pointee_type);
 @@ -8218,7 +8180,7 @@ pub const FuncGen = struct {
     fn airRetPtr(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
         const mod = self.dg.module;
         const ptr_ty = self.typeOfIndex(inst);
-        const ret_ty = ptr_ty.childType();
+        const ret_ty = ptr_ty.childType(mod);
         if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return self.dg.lowerPtrToVoid(ptr_ty);
         if (self.ret_ptr) |ret_ptr| return ret_ptr;
         const ret_llvm_ty = try self.dg.lowerType(ret_ty);
 @@ -8232,11 +8194,11 @@ pub const FuncGen = struct {
     }
     fn airStore(self: *FuncGen, inst: Air.Inst.Index, safety: bool) !?*llvm.Value {
+        const mod = self.dg.module;
         const bin_op = self.air.instructions.items(.data)[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();
+        const operand_ty = ptr_ty.childType(mod);
-        const mod = self.dg.module;
         const val_is_undef = if (self.air.value(bin_op.rhs, mod)) |val| val.isUndefDeep() else false;
         if (val_is_undef) {
 @@ -8271,8 +8233,10 @@ 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 mod = fg.dg.module;
+        const ip = &mod.intern_pool;
         for (body_tail[1..]) |body_inst| {
-            switch (fg.liveness.categorizeOperand(fg.air, body_inst, body_tail[0])) {
+            switch (fg.liveness.categorizeOperand(fg.air, body_inst, body_tail[0], ip.*)) {
                 .none => continue,
                 .write, .noret, .complex => return false,
                 .tomb => return true,
 @@ -8288,7 +8252,7 @@ pub const FuncGen = struct {
         const inst = body_tail[0];
         const ty_op = fg.air.instructions.items(.data)[inst].ty_op;
         const ptr_ty = fg.typeOf(ty_op.operand);
-        const ptr_info = ptr_ty.ptrInfo().data;
+        const ptr_info = ptr_ty.ptrInfo(mod);
         const ptr = try fg.resolveInst(ty_op.operand);
         elide: {
 @@ -8363,7 +8327,7 @@ pub const FuncGen = struct {
         const ptr = try self.resolveInst(extra.ptr);
         var expected_value = try self.resolveInst(extra.expected_value);
         var new_value = try self.resolveInst(extra.new_value);
-        const operand_ty = self.typeOf(extra.ptr).elemType();
+        const operand_ty = self.typeOf(extra.ptr).childType(mod);
         const opt_abi_ty = self.dg.getAtomicAbiType(operand_ty, false);
         if (opt_abi_ty) |abi_ty| {
             // operand needs widening and truncating
 @@ -8409,7 +8373,7 @@ pub const FuncGen = struct {
         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.elemType();
+        const operand_ty = ptr_ty.childType(mod);
         const operand = try self.resolveInst(extra.operand);
         const is_signed_int = operand_ty.isSignedInt(mod);
         const is_float = operand_ty.isRuntimeFloat();
 @@ -8464,7 +8428,7 @@ pub const FuncGen = struct {
         const atomic_load = self.air.instructions.items(.data)[inst].atomic_load;
         const ptr = try self.resolveInst(atomic_load.ptr);
         const ptr_ty = self.typeOf(atomic_load.ptr);
-        const ptr_info = ptr_ty.ptrInfo().data;
+        const ptr_info = ptr_ty.ptrInfo(mod);
         const elem_ty = ptr_info.pointee_type;
         if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod))
             return null;
 @@ -8497,7 +8461,7 @@ pub const FuncGen = struct {
         const mod = self.dg.module;
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
         const ptr_ty = self.typeOf(bin_op.lhs);
-        const operand_ty = ptr_ty.childType();
+        const operand_ty = ptr_ty.childType(mod);
         if (!operand_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return null;
         const ptr = try self.resolveInst(bin_op.lhs);
         var element = try self.resolveInst(bin_op.rhs);
 @@ -8595,9 +8559,9 @@ pub const FuncGen = struct {
         const end_block = self.context.appendBasicBlock(self.llvm_func, "InlineMemsetEnd");
         const llvm_usize_ty = self.context.intType(target.ptrBitWidth());
-        const len = switch (ptr_ty.ptrSize()) {
+        const len = switch (ptr_ty.ptrSize(mod)) {
             .Slice => self.builder.buildExtractValue(dest_slice, 1, ""),
-            .One => llvm_usize_ty.constInt(ptr_ty.childType().arrayLen(), .False),
+            .One => llvm_usize_ty.constInt(ptr_ty.childType(mod).arrayLen(mod), .False),
             .Many, .C => unreachable,
         };
         const elem_llvm_ty = try self.dg.lowerType(elem_ty);
 @@ -8665,7 +8629,7 @@ pub const FuncGen = struct {
     fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
         const mod = self.dg.module;
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-        const un_ty = self.typeOf(bin_op.lhs).childType();
+        const un_ty = self.typeOf(bin_op.lhs).childType(mod);
         const layout = un_ty.unionGetLayout(mod);
         if (layout.tag_size == 0) return null;
         const union_ptr = try self.resolveInst(bin_op.lhs);
 @@ -8791,7 +8755,7 @@ pub const FuncGen = struct {
             // The truncated result at the end will be the correct bswap
             const scalar_llvm_ty = self.context.intType(bits + 8);
             if (operand_ty.zigTypeTag(mod) == .Vector) {
-                const vec_len = operand_ty.vectorLen();
+                const vec_len = operand_ty.vectorLen(mod);
                 operand_llvm_ty = scalar_llvm_ty.vectorType(vec_len);
                 const shifts = try self.gpa.alloc(*llvm.Value, vec_len);
 @@ -8980,7 +8944,7 @@ pub const FuncGen = struct {
         defer self.gpa.free(fqn);
         const llvm_fn_name = try std.fmt.allocPrintZ(arena, "__zig_tag_name_{s}", .{fqn});
-        const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+        const slice_ty = Type.const_slice_u8_sentinel_0;
         const llvm_ret_ty = try self.dg.lowerType(slice_ty);
         const usize_llvm_ty = try self.dg.lowerType(Type.usize);
         const slice_alignment = slice_ty.abiAlignment(mod);
 @@ -9097,10 +9061,11 @@ pub const FuncGen = struct {
     }
     fn airSplat(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
+        const mod = self.dg.module;
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
         const scalar = try self.resolveInst(ty_op.operand);
         const vector_ty = self.typeOfIndex(inst);
-        const len = vector_ty.vectorLen();
+        const len = vector_ty.vectorLen(mod);
         return self.builder.buildVectorSplat(len, scalar, "");
     }
 @@ -9122,7 +9087,7 @@ pub const FuncGen = struct {
         const b = try self.resolveInst(extra.b);
         const mask = self.air.values[extra.mask];
         const mask_len = extra.mask_len;
-        const a_len = self.typeOf(extra.a).vectorLen();
+        const a_len = self.typeOf(extra.a).vectorLen(mod);
         // LLVM uses integers larger than the length of the first array to
         // index into the second array. This was deemed unnecessarily fragile
 @@ -9298,14 +9263,14 @@ pub const FuncGen = struct {
             .ty = scalar_ty,
             .val = Value.initPayload(&init_value_payload.base),
         });
-        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(), init_value);
+        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(mod), init_value);
     }
     fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
         const mod = self.dg.module;
         const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
         const result_ty = self.typeOfIndex(inst);
-        const len = @intCast(usize, result_ty.arrayLen());
+        const len = @intCast(usize, result_ty.arrayLen(mod));
         const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
         const llvm_result_ty = try self.dg.lowerType(result_ty);
 @@ -9400,7 +9365,7 @@ pub const FuncGen = struct {
                 const llvm_usize = try self.dg.lowerType(Type.usize);
                 const alloca_inst = self.buildAlloca(llvm_result_ty, result_ty.abiAlignment(mod));
-                const array_info = result_ty.arrayInfo();
+                const array_info = result_ty.arrayInfo(mod);
                 var elem_ptr_payload: Type.Payload.Pointer = .{
                     .data = .{
                         .pointee_type = array_info.elem_type,
 @@ -9720,7 +9685,7 @@ pub const FuncGen = struct {
         }
         const mod = self.dg.module;
-        const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
+        const slice_ty = Type.const_slice_u8_sentinel_0;
         const slice_alignment = slice_ty.abiAlignment(mod);
         const llvm_slice_ptr_ty = self.context.pointerType(0); // TODO: Address space
 @@ -9763,9 +9728,8 @@ pub const FuncGen = struct {
         opt_ty: Type,
         can_elide_load: bool,
     ) !*llvm.Value {
-        var buf: Type.Payload.ElemType = undefined;
-        const payload_ty = opt_ty.optionalChild(&buf);
         const mod = fg.dg.module;
+        const payload_ty = opt_ty.optionalChild(mod);
         if (isByRef(opt_ty, mod)) {
             // We have a pointer and we need to return a pointer to the first field.
 @@ -9827,13 +9791,13 @@ pub const FuncGen = struct {
         struct_ptr_ty: Type,
         field_index: u32,
     ) !?*llvm.Value {
-        const struct_ty = struct_ptr_ty.childType();
         const mod = self.dg.module;
+        const struct_ty = struct_ptr_ty.childType(mod);
         switch (struct_ty.zigTypeTag(mod)) {
             .Struct => switch (struct_ty.containerLayout()) {
                 .Packed => {
                     const result_ty = self.typeOfIndex(inst);
-                    const result_ty_info = result_ty.ptrInfo().data;
+                    const result_ty_info = result_ty.ptrInfo(mod);
                     if (result_ty_info.host_size != 0) {
                         // From LLVM's perspective, a pointer to a packed struct and a pointer
 @@ -9919,7 +9883,7 @@ pub const FuncGen = struct {
     /// For isByRef=false types, it creates a load instruction and returns it.
     fn load(self: *FuncGen, ptr: *llvm.Value, ptr_ty: Type) !?*llvm.Value {
         const mod = self.dg.module;
-        const info = ptr_ty.ptrInfo().data;
+        const info = ptr_ty.ptrInfo(mod);
         if (!info.pointee_type.hasRuntimeBitsIgnoreComptime(mod)) return null;
         const ptr_alignment = info.alignment(mod);
 @@ -9954,7 +9918,7 @@ pub const FuncGen = struct {
         containing_int.setAlignment(ptr_alignment);
         containing_int.setVolatile(ptr_volatile);
-        const elem_bits = @intCast(c_uint, ptr_ty.elemType().bitSize(mod));
+        const elem_bits = @intCast(c_uint, ptr_ty.childType(mod).bitSize(mod));
         const shift_amt = containing_int.typeOf().constInt(info.bit_offset, .False);
         const shifted_value = self.builder.buildLShr(containing_int, shift_amt, "");
         const elem_llvm_ty = try self.dg.lowerType(info.pointee_type);
 @@ -9992,9 +9956,9 @@ pub const FuncGen = struct {
         elem: *llvm.Value,
         ordering: llvm.AtomicOrdering,
     ) !void {
-        const info = ptr_ty.ptrInfo().data;
-        const elem_ty = info.pointee_type;
         const mod = self.dg.module;
+        const info = ptr_ty.ptrInfo(mod);
+        const elem_ty = info.pointee_type;
         if (!elem_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) {
             return;
         }
 @@ -10026,7 +9990,7 @@ pub const FuncGen = struct {
             assert(ordering == .NotAtomic);
             containing_int.setAlignment(ptr_alignment);
             containing_int.setVolatile(ptr_volatile);
-            const elem_bits = @intCast(c_uint, ptr_ty.elemType().bitSize(mod));
+            const elem_bits = @intCast(c_uint, ptr_ty.childType(mod).bitSize(mod));
             const containing_int_ty = containing_int.typeOf();
             const shift_amt = containing_int_ty.constInt(info.bit_offset, .False);
             // Convert to equally-sized integer type in order to perform the bit
 @@ -10864,8 +10828,7 @@ const ParamTypeIterator = struct {
             .Unspecified, .Inline => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
-                var buf: Type.Payload.ElemType = undefined;
+                if (ty.isSlice(mod) or (ty.zigTypeTag(mod) == .Optional and ty.optionalChild(mod).isSlice(mod))) {
-                if (ty.isSlice(mod) or (ty.zigTypeTag(mod) == .Optional and ty.optionalChild(&buf).isSlice(mod))) {
                     it.llvm_index += 1;
                     return .slice;
                 } else if (isByRef(ty, mod)) {
 @@ -11185,8 +11148,7 @@ fn isByRef(ty: Type, mod: *const Module) bool {
             return true;
         },
         .Optional => {
-            var buf: Type.Payload.ElemType = undefined;
+            const payload_ty = ty.optionalChild(mod);
-            const payload_ty = ty.optionalChild(&buf);
             if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                 return false;
             }

src/codegen/spirv.zig+33-31

src/codegen/spirv/Module.zig+2-1

...	@@ -11,7 +11,8 @@ const std = @import("std");	...	@@ -11,7 +11,8 @@ const std = @import("std");
11	const Allocator = std.mem.Allocator;	11	const Allocator = std.mem.Allocator;
12	const assert = std.debug.assert;	12	const assert = std.debug.assert;
13		13
14	const ZigDecl = @import("../../Module.zig").Decl;	14	const ZigModule = @import("../../Module.zig");
		15	const ZigDecl = ZigModule.Decl;
15		16
16	const spec = @import("spec.zig");	17	const spec = @import("spec.zig");
17	const Word = spec.Word;	18	const Word = spec.Word;

src/link/Dwarf.zig+5-6

src/link/Wasm.zig+2-2

...	@@ -2931,7 +2931,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {	...	@@ -2931,7 +2931,7 @@ pub fn getErrorTableSymbol(wasm: *Wasm) !u32 {
2931		2931
2932	const atom_index = try wasm.createAtom();	2932	const atom_index = try wasm.createAtom();
2933	const atom = wasm.getAtomPtr(atom_index);	2933	const atom = wasm.getAtomPtr(atom_index);
2934	const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);	2934	const slice_ty = Type.const_slice_u8_sentinel_0;
2935	const mod = wasm.base.options.module.?;	2935	const mod = wasm.base.options.module.?;
2936	atom.alignment = slice_ty.abiAlignment(mod);	2936	atom.alignment = slice_ty.abiAlignment(mod);
2937	const sym_index = atom.sym_index;	2937	const sym_index = atom.sym_index;
...	@@ -2988,7 +2988,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void {	...	@@ -2988,7 +2988,7 @@ fn populateErrorNameTable(wasm: *Wasm) !void {
2988	for (mod.error_name_list.items) \|error_name\| {	2988	for (mod.error_name_list.items) \|error_name\| {
2989	const len = @intCast(u32, error_name.len + 1); // names are 0-termianted	2989	const len = @intCast(u32, error_name.len + 1); // names are 0-termianted
2990		2990
2991	const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);	2991	const slice_ty = Type.const_slice_u8_sentinel_0;
2992	const offset = @intCast(u32, atom.code.items.len);	2992	const offset = @intCast(u32, atom.code.items.len);
2993	// first we create the data for the slice of the name	2993	// first we create the data for the slice of the name
2994	try atom.code.appendNTimes(wasm.base.allocator, 0, 4); // ptr to name, will be relocated	2994	try atom.code.appendNTimes(wasm.base.allocator, 0, 4); // ptr to name, will be relocated

src/print_air.zig+4-2

 @@ -433,9 +433,10 @@ const Writer = struct {
     }
     fn writeAggregateInit(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
+        const mod = w.module;
         const ty_pl = w.air.instructions.items(.data)[inst].ty_pl;
         const vector_ty = w.air.getRefType(ty_pl.ty);
-        const len = @intCast(usize, vector_ty.arrayLen());
+        const len = @intCast(usize, vector_ty.arrayLen(mod));
         const elements = @ptrCast([]const Air.Inst.Ref, w.air.extra[ty_pl.payload..][0..len]);
         try w.writeType(s, vector_ty);
 @@ -512,10 +513,11 @@ const Writer = struct {
     }
     fn writeSelect(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
+        const mod = w.module;
         const pl_op = w.air.instructions.items(.data)[inst].pl_op;
         const extra = w.air.extraData(Air.Bin, pl_op.payload).data;
-        const elem_ty = w.typeOfIndex(inst).childType();
+        const elem_ty = w.typeOfIndex(inst).childType(mod);
         try w.writeType(s, elem_ty);
         try s.writeAll(", ");
         try w.writeOperand(s, inst, 0, pl_op.operand);

src/type.zig+472-1298

...	@@ -40,7 +40,7 @@ pub const Type = struct {	...	@@ -40,7 +40,7 @@ pub const Type = struct {
40	.ptr_type => return .Pointer,	40	.ptr_type => return .Pointer,
41	.array_type => return .Array,	41	.array_type => return .Array,
42	.vector_type => return .Vector,	42	.vector_type => return .Vector,
43	.optional_type => return .Optional,	43	.opt_type => return .Optional,
44	.error_union_type => return .ErrorUnion,	44	.error_union_type => return .ErrorUnion,
45	.struct_type => return .Struct,	45	.struct_type => return .Struct,
46	.union_type => return .Union,	46	.union_type => return .Union,
...	@@ -118,38 +118,17 @@ pub const Type = struct {	...	@@ -118,38 +118,17 @@ pub const Type = struct {
118	.function => return .Fn,	118	.function => return .Fn,
119		119
120	.array,	120	.array,
121	.array_u8_sentinel_0,
122	.array_u8,
123	.array_sentinel,	121	.array_sentinel,
124	=> return .Array,	122	=> return .Array,
125		123
126	.vector => return .Vector,
127
128	.single_const_pointer_to_comptime_int,
129	.const_slice_u8,
130	.const_slice_u8_sentinel_0,
131	.single_const_pointer,
132	.single_mut_pointer,
133	.many_const_pointer,
134	.many_mut_pointer,
135	.c_const_pointer,
136	.c_mut_pointer,
137	.const_slice,
138	.mut_slice,
139	.pointer,	124	.pointer,
140	.inferred_alloc_const,	125	.inferred_alloc_const,
141	.inferred_alloc_mut,	126	.inferred_alloc_mut,
142	.manyptr_u8,
143	.manyptr_const_u8,
144	.manyptr_const_u8_sentinel_0,
145	=> return .Pointer,	127	=> return .Pointer,
146		128
147	.optional,	129	.optional => return .Optional,
148	.optional_single_const_pointer,
149	.optional_single_mut_pointer,
150	=> return .Optional,
151		130
152	.anyerror_void_error_union, .error_union => return .ErrorUnion,	131	.error_union => return .ErrorUnion,
153		132
154	.anyframe_T => return .AnyFrame,	133	.anyframe_T => return .AnyFrame,
155		134
...	@@ -177,8 +156,7 @@ pub const Type = struct {	...	@@ -177,8 +156,7 @@ pub const Type = struct {
177	return switch (self.zigTypeTag(mod)) {	156	return switch (self.zigTypeTag(mod)) {
178	.ErrorUnion => self.errorUnionPayload().baseZigTypeTag(mod),	157	.ErrorUnion => self.errorUnionPayload().baseZigTypeTag(mod),
179	.Optional => {	158	.Optional => {
180	var buf: Payload.ElemType = undefined;	159	return self.optionalChild(mod).baseZigTypeTag(mod);
181	return self.optionalChild(&buf).baseZigTypeTag(mod);
182	},	160	},
183	else => \|t\| t,	161	else => \|t\| t,
184	};	162	};
...	@@ -218,8 +196,7 @@ pub const Type = struct {	...	@@ -218,8 +196,7 @@ pub const Type = struct {
218	.Pointer => !ty.isSlice(mod) and (is_equality_cmp or ty.isCPtr()),	196	.Pointer => !ty.isSlice(mod) and (is_equality_cmp or ty.isCPtr()),
219	.Optional => {	197	.Optional => {
220	if (!is_equality_cmp) return false;	198	if (!is_equality_cmp) return false;
221	var buf: Payload.ElemType = undefined;	199	return ty.optionalChild(mod).isSelfComparable(mod, is_equality_cmp);
222	return ty.optionalChild(&buf).isSelfComparable(mod, is_equality_cmp);
223	},	200	},
224	};	201	};
225	}	202	}
...	@@ -275,9 +252,8 @@ pub const Type = struct {	...	@@ -275,9 +252,8 @@ pub const Type = struct {
275	}	252	}
276		253
277	pub fn castTag(self: Type, comptime t: Tag) ?*t.Type() {	254	pub fn castTag(self: Type, comptime t: Tag) ?*t.Type() {
278	if (self.ip_index != .none) {	255	assert(self.ip_index == .none);
279	return null;	256
280	}
281	if (@enumToInt(self.legacy.tag_if_small_enough) < Tag.no_payload_count)	257	if (@enumToInt(self.legacy.tag_if_small_enough) < Tag.no_payload_count)
282	return null;	258	return null;
283		259
...	@@ -287,281 +263,61 @@ pub const Type = struct {	...	@@ -287,281 +263,61 @@ pub const Type = struct {
287	return null;	263	return null;
288	}	264	}
289		265
290	pub fn castPointer(self: Type) ?*Payload.ElemType {
291	return switch (self.tag()) {
292	.single_const_pointer,
293	.single_mut_pointer,
294	.many_const_pointer,
295	.many_mut_pointer,
296	.c_const_pointer,
297	.c_mut_pointer,
298	.const_slice,
299	.mut_slice,
300	.optional_single_const_pointer,
301	.optional_single_mut_pointer,
302	.manyptr_u8,
303	.manyptr_const_u8,
304	.manyptr_const_u8_sentinel_0,
305	=> self.cast(Payload.ElemType),
306
307	.inferred_alloc_const => unreachable,
308	.inferred_alloc_mut => unreachable,
309
310	else => null,
311	};
312	}
313
314	/// If it is a function pointer, returns the function type. Otherwise returns null.	266	/// If it is a function pointer, returns the function type. Otherwise returns null.
315	pub fn castPtrToFn(ty: Type, mod: *const Module) ?Type {	267	pub fn castPtrToFn(ty: Type, mod: *const Module) ?Type {
316	if (ty.zigTypeTag(mod) != .Pointer) return null;	268	if (ty.zigTypeTag(mod) != .Pointer) return null;
317	const elem_ty = ty.childType();	269	const elem_ty = ty.childType(mod);
318	if (elem_ty.zigTypeTag(mod) != .Fn) return null;	270	if (elem_ty.zigTypeTag(mod) != .Fn) return null;
319	return elem_ty;	271	return elem_ty;
320	}	272	}
321		273
322	pub fn ptrIsMutable(ty: Type) bool {	274	pub fn ptrIsMutable(ty: Type, mod: *const Module) bool {
323	return switch (ty.tag()) {	275	return switch (ty.ip_index) {
324	.single_const_pointer_to_comptime_int,	276	.none => switch (ty.tag()) {
325	.const_slice_u8,	277	.pointer => ty.castTag(.pointer).?.data.mutable,
326	.const_slice_u8_sentinel_0,	278	else => unreachable,
327	.single_const_pointer,	279	},
328	.many_const_pointer,	280	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
329	.manyptr_const_u8,	281	.ptr_type => \|ptr_type\| !ptr_type.is_const,
330	.manyptr_const_u8_sentinel_0,	282	else => unreachable,
331	.c_const_pointer,	283	},
332	.const_slice,
333	=> false,
334
335	.single_mut_pointer,
336	.many_mut_pointer,
337	.manyptr_u8,
338	.c_mut_pointer,
339	.mut_slice,
340	=> true,
341
342	.pointer => ty.castTag(.pointer).?.data.mutable,
343
344	else => unreachable,
345	};	284	};
346	}	285	}
347		286
348	pub const ArrayInfo = struct { elem_type: Type, sentinel: ?Value = null, len: u64 };	287	pub const ArrayInfo = struct {
349	pub fn arrayInfo(self: Type) ArrayInfo {	288	elem_type: Type,
		289	sentinel: ?Value = null,
		290	len: u64,
		291	};
		292
		293	pub fn arrayInfo(self: Type, mod: *const Module) ArrayInfo {
350	return .{	294	return .{
351	.len = self.arrayLen(),	295	.len = self.arrayLen(mod),
352	.sentinel = self.sentinel(),	296	.sentinel = self.sentinel(mod),
353	.elem_type = self.elemType(),	297	.elem_type = self.childType(mod),
354	};	298	};
355	}	299	}
356		300
357	pub fn ptrInfo(self: Type) Payload.Pointer {	301	pub fn ptrInfo(ty: Type, mod: *const Module) Payload.Pointer.Data {
358	switch (self.ip_index) {	302	return switch (ty.ip_index) {
359	.none => switch (self.tag()) {	303	.none => switch (ty.tag()) {
360	.single_const_pointer_to_comptime_int => return .{ .data = .{	304	.pointer => ty.castTag(.pointer).?.data,
361	.pointee_type = Type.comptime_int,	305	.optional => b: {
362	.sentinel = null,	306	const child_type = ty.optionalChild(mod);
363	.@"align" = 0,	307	break :b child_type.ptrInfo(mod);
364	.@"addrspace" = .generic,
365	.bit_offset = 0,
366	.host_size = 0,
367	.@"allowzero" = false,
368	.mutable = false,
369	.@"volatile" = false,
370	.size = .One,
371	} },
372	.const_slice_u8 => return .{ .data = .{
373	.pointee_type = Type.u8,
374	.sentinel = null,
375	.@"align" = 0,
376	.@"addrspace" = .generic,
377	.bit_offset = 0,
378	.host_size = 0,
379	.@"allowzero" = false,
380	.mutable = false,
381	.@"volatile" = false,
382	.size = .Slice,
383	} },
384	.const_slice_u8_sentinel_0 => return .{ .data = .{
385	.pointee_type = Type.u8,
386	.sentinel = Value.zero,
387	.@"align" = 0,
388	.@"addrspace" = .generic,
389	.bit_offset = 0,
390	.host_size = 0,
391	.@"allowzero" = false,
392	.mutable = false,
393	.@"volatile" = false,
394	.size = .Slice,
395	} },
396	.single_const_pointer => return .{ .data = .{
397	.pointee_type = self.castPointer().?.data,
398	.sentinel = null,
399	.@"align" = 0,
400	.@"addrspace" = .generic,
401	.bit_offset = 0,
402	.host_size = 0,
403	.@"allowzero" = false,
404	.mutable = false,
405	.@"volatile" = false,
406	.size = .One,
407	} },
408	.single_mut_pointer => return .{ .data = .{
409	.pointee_type = self.castPointer().?.data,
410	.sentinel = null,
411	.@"align" = 0,
412	.@"addrspace" = .generic,
413	.bit_offset = 0,
414	.host_size = 0,
415	.@"allowzero" = false,
416	.mutable = true,
417	.@"volatile" = false,
418	.size = .One,
419	} },
420	.many_const_pointer => return .{ .data = .{
421	.pointee_type = self.castPointer().?.data,
422	.sentinel = null,
423	.@"align" = 0,
424	.@"addrspace" = .generic,
425	.bit_offset = 0,
426	.host_size = 0,
427	.@"allowzero" = false,
428	.mutable = false,
429	.@"volatile" = false,
430	.size = .Many,
431	} },
432	.manyptr_const_u8 => return .{ .data = .{
433	.pointee_type = Type.u8,
434	.sentinel = null,
435	.@"align" = 0,
436	.@"addrspace" = .generic,
437	.bit_offset = 0,
438	.host_size = 0,
439	.@"allowzero" = false,
440	.mutable = false,
441	.@"volatile" = false,
442	.size = .Many,
443	} },
444	.manyptr_const_u8_sentinel_0 => return .{ .data = .{
445	.pointee_type = Type.u8,
446	.sentinel = Value.zero,
447	.@"align" = 0,
448	.@"addrspace" = .generic,
449	.bit_offset = 0,
450	.host_size = 0,
451	.@"allowzero" = false,
452	.mutable = false,
453	.@"volatile" = false,
454	.size = .Many,
455	} },
456	.many_mut_pointer => return .{ .data = .{
457	.pointee_type = self.castPointer().?.data,
458	.sentinel = null,
459	.@"align" = 0,
460	.@"addrspace" = .generic,
461	.bit_offset = 0,
462	.host_size = 0,
463	.@"allowzero" = false,
464	.mutable = true,
465	.@"volatile" = false,
466	.size = .Many,
467	} },
468	.manyptr_u8 => return .{ .data = .{
469	.pointee_type = Type.u8,
470	.sentinel = null,
471	.@"align" = 0,
472	.@"addrspace" = .generic,
473	.bit_offset = 0,
474	.host_size = 0,
475	.@"allowzero" = false,
476	.mutable = true,
477	.@"volatile" = false,
478	.size = .Many,
479	} },
480	.c_const_pointer => return .{ .data = .{
481	.pointee_type = self.castPointer().?.data,
482	.sentinel = null,
483	.@"align" = 0,
484	.@"addrspace" = .generic,
485	.bit_offset = 0,
486	.host_size = 0,
487	.@"allowzero" = true,
488	.mutable = false,
489	.@"volatile" = false,
490	.size = .C,
491	} },
492	.c_mut_pointer => return .{ .data = .{
493	.pointee_type = self.castPointer().?.data,
494	.sentinel = null,
495	.@"align" = 0,
496	.@"addrspace" = .generic,
497	.bit_offset = 0,
498	.host_size = 0,
499	.@"allowzero" = true,
500	.mutable = true,
501	.@"volatile" = false,
502	.size = .C,
503	} },
504	.const_slice => return .{ .data = .{
505	.pointee_type = self.castPointer().?.data,
506	.sentinel = null,
507	.@"align" = 0,
508	.@"addrspace" = .generic,
509	.bit_offset = 0,
510	.host_size = 0,
511	.@"allowzero" = false,
512	.mutable = false,
513	.@"volatile" = false,
514	.size = .Slice,
515	} },
516	.mut_slice => return .{ .data = .{
517	.pointee_type = self.castPointer().?.data,
518	.sentinel = null,
519	.@"align" = 0,
520	.@"addrspace" = .generic,
521	.bit_offset = 0,
522	.host_size = 0,
523	.@"allowzero" = false,
524	.mutable = true,
525	.@"volatile" = false,
526	.size = .Slice,
527	} },
528
529	.pointer => return self.castTag(.pointer).?.*,
530
531	.optional_single_mut_pointer => return .{ .data = .{
532	.pointee_type = self.castPointer().?.data,
533	.sentinel = null,
534	.@"align" = 0,
535	.@"addrspace" = .generic,
536	.bit_offset = 0,
537	.host_size = 0,
538	.@"allowzero" = false,
539	.mutable = true,
540	.@"volatile" = false,
541	.size = .One,
542	} },
543	.optional_single_const_pointer => return .{ .data = .{
544	.pointee_type = self.castPointer().?.data,
545	.sentinel = null,
546	.@"align" = 0,
547	.@"addrspace" = .generic,
548	.bit_offset = 0,
549	.host_size = 0,
550	.@"allowzero" = false,
551	.mutable = false,
552	.@"volatile" = false,
553	.size = .One,
554	} },
555	.optional => {
556	var buf: Payload.ElemType = undefined;
557	const child_type = self.optionalChild(&buf);
558	return child_type.ptrInfo();
559	},	308	},
560		309
561	else => unreachable,	310	else => unreachable,
562	},	311	},
563	else => @panic("TODO"),	312	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
564	}	313	.ptr_type => \|p\| Payload.Pointer.Data.fromKey(p),
		314	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {
		315	.ptr_type => \|p\| Payload.Pointer.Data.fromKey(p),
		316	else => unreachable,
		317	},
		318	else => unreachable,
		319	},
		320	};
565	}	321	}
566		322
567	pub fn eql(a: Type, b: Type, mod: *Module) bool {	323	pub fn eql(a: Type, b: Type, mod: *Module) bool {
...	@@ -658,20 +414,17 @@ pub const Type = struct {	...	@@ -658,20 +414,17 @@ pub const Type = struct {
658	},	414	},
659		415
660	.array,	416	.array,
661	.array_u8_sentinel_0,
662	.array_u8,
663	.array_sentinel,	417	.array_sentinel,
664	.vector,
665	=> {	418	=> {
666	if (a.zigTypeTag(mod) != b.zigTypeTag(mod)) return false;	419	if (a.zigTypeTag(mod) != b.zigTypeTag(mod)) return false;
667		420
668	if (a.arrayLen() != b.arrayLen())	421	if (a.arrayLen(mod) != b.arrayLen(mod))
669	return false;	422	return false;
670	const elem_ty = a.elemType();	423	const elem_ty = a.childType(mod);
671	if (!elem_ty.eql(b.elemType(), mod))	424	if (!elem_ty.eql(b.childType(mod), mod))
672	return false;	425	return false;
673	const sentinel_a = a.sentinel();	426	const sentinel_a = a.sentinel(mod);
674	const sentinel_b = b.sentinel();	427	const sentinel_b = b.sentinel(mod);
675	if (sentinel_a) \|sa\| {	428	if (sentinel_a) \|sa\| {
676	if (sentinel_b) \|sb\| {	429	if (sentinel_b) \|sb\| {
677	return sa.eql(sb, elem_ty, mod);	430	return sa.eql(sb, elem_ty, mod);
...	@@ -683,28 +436,14 @@ pub const Type = struct {	...	@@ -683,28 +436,14 @@ pub const Type = struct {
683	}	436	}
684	},	437	},
685		438
686	.single_const_pointer_to_comptime_int,
687	.const_slice_u8,
688	.const_slice_u8_sentinel_0,
689	.single_const_pointer,
690	.single_mut_pointer,
691	.many_const_pointer,
692	.many_mut_pointer,
693	.c_const_pointer,
694	.c_mut_pointer,
695	.const_slice,
696	.mut_slice,
697	.pointer,	439	.pointer,
698	.inferred_alloc_const,	440	.inferred_alloc_const,
699	.inferred_alloc_mut,	441	.inferred_alloc_mut,
700	.manyptr_u8,
701	.manyptr_const_u8,
702	.manyptr_const_u8_sentinel_0,
703	=> {	442	=> {
704	if (b.zigTypeTag(mod) != .Pointer) return false;	443	if (b.zigTypeTag(mod) != .Pointer) return false;
705		444
706	const info_a = a.ptrInfo().data;	445	const info_a = a.ptrInfo(mod);
707	const info_b = b.ptrInfo().data;	446	const info_b = b.ptrInfo(mod);
708	if (!info_a.pointee_type.eql(info_b.pointee_type, mod))	447	if (!info_a.pointee_type.eql(info_b.pointee_type, mod))
709	return false;	448	return false;
710	if (info_a.@"align" != info_b.@"align")	449	if (info_a.@"align" != info_b.@"align")
...	@@ -743,18 +482,13 @@ pub const Type = struct {	...	@@ -743,18 +482,13 @@ pub const Type = struct {
743	return true;	482	return true;
744	},	483	},
745		484
746	.optional,	485	.optional => {
747	.optional_single_const_pointer,
748	.optional_single_mut_pointer,
749	=> {
750	if (b.zigTypeTag(mod) != .Optional) return false;	486	if (b.zigTypeTag(mod) != .Optional) return false;
751		487
752	var buf_a: Payload.ElemType = undefined;	488	return a.optionalChild(mod).eql(b.optionalChild(mod), mod);
753	var buf_b: Payload.ElemType = undefined;
754	return a.optionalChild(&buf_a).eql(b.optionalChild(&buf_b), mod);
755	},	489	},
756		490
757	.anyerror_void_error_union, .error_union => {	491	.error_union => {
758	if (b.zigTypeTag(mod) != .ErrorUnion) return false;	492	if (b.zigTypeTag(mod) != .ErrorUnion) return false;
759		493
760	const a_set = a.errorUnionSet();	494	const a_set = a.errorUnionSet();
...	@@ -947,47 +681,23 @@ pub const Type = struct {	...	@@ -947,47 +681,23 @@ pub const Type = struct {
947	},	681	},
948		682
949	.array,	683	.array,
950	.array_u8_sentinel_0,
951	.array_u8,
952	.array_sentinel,	684	.array_sentinel,
953	=> {	685	=> {
954	std.hash.autoHash(hasher, std.builtin.TypeId.Array);	686	std.hash.autoHash(hasher, std.builtin.TypeId.Array);
955		687
956	const elem_ty = ty.elemType();	688	const elem_ty = ty.childType(mod);
957	std.hash.autoHash(hasher, ty.arrayLen());	689	std.hash.autoHash(hasher, ty.arrayLen(mod));
958	hashWithHasher(elem_ty, hasher, mod);	690	hashWithHasher(elem_ty, hasher, mod);
959	hashSentinel(ty.sentinel(), elem_ty, hasher, mod);	691	hashSentinel(ty.sentinel(mod), elem_ty, hasher, mod);
960	},	692	},
961		693
962	.vector => {
963	std.hash.autoHash(hasher, std.builtin.TypeId.Vector);
964
965	const elem_ty = ty.elemType();
966	std.hash.autoHash(hasher, ty.vectorLen());
967	hashWithHasher(elem_ty, hasher, mod);
968	},
969
970	.single_const_pointer_to_comptime_int,
971	.const_slice_u8,
972	.const_slice_u8_sentinel_0,
973	.single_const_pointer,
974	.single_mut_pointer,
975	.many_const_pointer,
976	.many_mut_pointer,
977	.c_const_pointer,
978	.c_mut_pointer,
979	.const_slice,
980	.mut_slice,
981	.pointer,	694	.pointer,
982	.inferred_alloc_const,	695	.inferred_alloc_const,
983	.inferred_alloc_mut,	696	.inferred_alloc_mut,
984	.manyptr_u8,
985	.manyptr_const_u8,
986	.manyptr_const_u8_sentinel_0,
987	=> {	697	=> {
988	std.hash.autoHash(hasher, std.builtin.TypeId.Pointer);	698	std.hash.autoHash(hasher, std.builtin.TypeId.Pointer);
989		699
990	const info = ty.ptrInfo().data;	700	const info = ty.ptrInfo(mod);
991	hashWithHasher(info.pointee_type, hasher, mod);	701	hashWithHasher(info.pointee_type, hasher, mod);
992	hashSentinel(info.sentinel, info.pointee_type, hasher, mod);	702	hashSentinel(info.sentinel, info.pointee_type, hasher, mod);
993	std.hash.autoHash(hasher, info.@"align");	703	std.hash.autoHash(hasher, info.@"align");
...	@@ -1001,17 +711,13 @@ pub const Type = struct {	...	@@ -1001,17 +711,13 @@ pub const Type = struct {
1001	std.hash.autoHash(hasher, info.size);	711	std.hash.autoHash(hasher, info.size);
1002	},	712	},
1003		713
1004	.optional,	714	.optional => {
1005	.optional_single_const_pointer,
1006	.optional_single_mut_pointer,
1007	=> {
1008	std.hash.autoHash(hasher, std.builtin.TypeId.Optional);	715	std.hash.autoHash(hasher, std.builtin.TypeId.Optional);
1009		716
1010	var buf: Payload.ElemType = undefined;	717	hashWithHasher(ty.optionalChild(mod), hasher, mod);
1011	hashWithHasher(ty.optionalChild(&buf), hasher, mod);
1012	},	718	},
1013		719
1014	.anyerror_void_error_union, .error_union => {	720	.error_union => {
1015	std.hash.autoHash(hasher, std.builtin.TypeId.ErrorUnion);	721	std.hash.autoHash(hasher, std.builtin.TypeId.ErrorUnion);
1016		722
1017	const set_ty = ty.errorUnionSet();	723	const set_ty = ty.errorUnionSet();
...	@@ -1023,7 +729,7 @@ pub const Type = struct {	...	@@ -1023,7 +729,7 @@ pub const Type = struct {
1023		729
1024	.anyframe_T => {	730	.anyframe_T => {
1025	std.hash.autoHash(hasher, std.builtin.TypeId.AnyFrame);	731	std.hash.autoHash(hasher, std.builtin.TypeId.AnyFrame);
1026	hashWithHasher(ty.childType(), hasher, mod);	732	hashWithHasher(ty.childType(mod), hasher, mod);
1027	},	733	},
1028		734
1029	.empty_struct => {	735	.empty_struct => {
...	@@ -1129,33 +835,12 @@ pub const Type = struct {	...	@@ -1129,33 +835,12 @@ pub const Type = struct {
1129	.legacy = .{ .tag_if_small_enough = self.legacy.tag_if_small_enough },	835	.legacy = .{ .tag_if_small_enough = self.legacy.tag_if_small_enough },
1130	};	836	};
1131	} else switch (self.legacy.ptr_otherwise.tag) {	837	} else switch (self.legacy.ptr_otherwise.tag) {
1132	.single_const_pointer_to_comptime_int,
1133	.const_slice_u8,
1134	.const_slice_u8_sentinel_0,
1135	.anyerror_void_error_union,
1136	.inferred_alloc_const,	838	.inferred_alloc_const,
1137	.inferred_alloc_mut,	839	.inferred_alloc_mut,
1138	.empty_struct_literal,	840	.empty_struct_literal,
1139	.manyptr_u8,
1140	.manyptr_const_u8,
1141	.manyptr_const_u8_sentinel_0,
1142	=> unreachable,	841	=> unreachable,
1143		842
1144	.array_u8,
1145	.array_u8_sentinel_0,
1146	=> return self.copyPayloadShallow(allocator, Payload.Len),
1147
1148	.single_const_pointer,
1149	.single_mut_pointer,
1150	.many_const_pointer,
1151	.many_mut_pointer,
1152	.c_const_pointer,
1153	.c_mut_pointer,
1154	.const_slice,
1155	.mut_slice,
1156	.optional,	843	.optional,
1157	.optional_single_mut_pointer,
1158	.optional_single_const_pointer,
1159	.anyframe_T,	844	.anyframe_T,
1160	=> {	845	=> {
1161	const payload = self.cast(Payload.ElemType).?;	846	const payload = self.cast(Payload.ElemType).?;
...	@@ -1170,13 +855,6 @@ pub const Type = struct {	...	@@ -1170,13 +855,6 @@ pub const Type = struct {
1170	};	855	};
1171	},	856	},
1172		857
1173	.vector => {
1174	const payload = self.castTag(.vector).?.data;
1175	return Tag.vector.create(allocator, .{
1176	.len = payload.len,
1177	.elem_type = try payload.elem_type.copy(allocator),
1178	});
1179	},
1180	.array => {	858	.array => {
1181	const payload = self.castTag(.array).?.data;	859	const payload = self.castTag(.array).?.data;
1182	return Tag.array.create(allocator, .{	860	return Tag.array.create(allocator, .{
...	@@ -1408,13 +1086,6 @@ pub const Type = struct {	...	@@ -1408,13 +1086,6 @@ pub const Type = struct {
1408	});	1086	});
1409	},	1087	},
1410		1088
1411	.anyerror_void_error_union => return writer.writeAll("anyerror!void"),
1412	.const_slice_u8 => return writer.writeAll("[]const u8"),
1413	.const_slice_u8_sentinel_0 => return writer.writeAll("[:0]const u8"),
1414	.single_const_pointer_to_comptime_int => return writer.writeAll("*const comptime_int"),
1415	.manyptr_u8 => return writer.writeAll("[*]u8"),
1416	.manyptr_const_u8 => return writer.writeAll("[*]const u8"),
1417	.manyptr_const_u8_sentinel_0 => return writer.writeAll("[*:0]const u8"),
1418	.function => {	1089	.function => {
1419	const payload = ty.castTag(.function).?.data;	1090	const payload = ty.castTag(.function).?.data;
1420	try writer.writeAll("fn(");	1091	try writer.writeAll("fn(");
...	@@ -1447,20 +1118,6 @@ pub const Type = struct {	...	@@ -1447,20 +1118,6 @@ pub const Type = struct {
1447	ty = return_type;	1118	ty = return_type;
1448	continue;	1119	continue;
1449	},	1120	},
1450	.array_u8 => {
1451	const len = ty.castTag(.array_u8).?.data;
1452	return writer.print("[{d}]u8", .{len});
1453	},
1454	.array_u8_sentinel_0 => {
1455	const len = ty.castTag(.array_u8_sentinel_0).?.data;
1456	return writer.print("[{d}:0]u8", .{len});
1457	},
1458	.vector => {
1459	const payload = ty.castTag(.vector).?.data;
1460	try writer.print("@Vector({d}, ", .{payload.len});
1461	try payload.elem_type.dump("", .{}, writer);
1462	return writer.writeAll(")");
1463	},
1464	.array => {	1121	.array => {
1465	const payload = ty.castTag(.array).?.data;	1122	const payload = ty.castTag(.array).?.data;
1466	try writer.print("[{d}]", .{payload.len});	1123	try writer.print("[{d}]", .{payload.len});
...	@@ -1512,72 +1169,12 @@ pub const Type = struct {	...	@@ -1512,72 +1169,12 @@ pub const Type = struct {
1512	try writer.writeAll("}");	1169	try writer.writeAll("}");
1513	return;	1170	return;
1514	},	1171	},
1515	.single_const_pointer => {
1516	const pointee_type = ty.castTag(.single_const_pointer).?.data;
1517	try writer.writeAll("*const ");
1518	ty = pointee_type;
1519	continue;
1520	},
1521	.single_mut_pointer => {
1522	const pointee_type = ty.castTag(.single_mut_pointer).?.data;
1523	try writer.writeAll("*");
1524	ty = pointee_type;
1525	continue;
1526	},
1527	.many_const_pointer => {
1528	const pointee_type = ty.castTag(.many_const_pointer).?.data;
1529	try writer.writeAll("[*]const ");
1530	ty = pointee_type;
1531	continue;
1532	},
1533	.many_mut_pointer => {
1534	const pointee_type = ty.castTag(.many_mut_pointer).?.data;
1535	try writer.writeAll("[*]");
1536	ty = pointee_type;
1537	continue;
1538	},
1539	.c_const_pointer => {
1540	const pointee_type = ty.castTag(.c_const_pointer).?.data;
1541	try writer.writeAll("[*c]const ");
1542	ty = pointee_type;
1543	continue;
1544	},
1545	.c_mut_pointer => {
1546	const pointee_type = ty.castTag(.c_mut_pointer).?.data;
1547	try writer.writeAll("[*c]");
1548	ty = pointee_type;
1549	continue;
1550	},
1551	.const_slice => {
1552	const pointee_type = ty.castTag(.const_slice).?.data;
1553	try writer.writeAll("[]const ");
1554	ty = pointee_type;
1555	continue;
1556	},
1557	.mut_slice => {
1558	const pointee_type = ty.castTag(.mut_slice).?.data;
1559	try writer.writeAll("[]");
1560	ty = pointee_type;
1561	continue;
1562	},
1563	.optional => {	1172	.optional => {
1564	const child_type = ty.castTag(.optional).?.data;	1173	const child_type = ty.castTag(.optional).?.data;
1565	try writer.writeByte('?');	1174	try writer.writeByte('?');
1566	ty = child_type;	1175	ty = child_type;
1567	continue;	1176	continue;
1568	},	1177	},
1569	.optional_single_const_pointer => {
1570	const pointee_type = ty.castTag(.optional_single_const_pointer).?.data;
1571	try writer.writeAll("?*const ");
1572	ty = pointee_type;
1573	continue;
1574	},
1575	.optional_single_mut_pointer => {
1576	const pointee_type = ty.castTag(.optional_single_mut_pointer).?.data;
1577	try writer.writeAll("?*");
1578	ty = pointee_type;
1579	continue;
1580	},
1581		1178
1582	.pointer => {	1179	.pointer => {
1583	const payload = ty.castTag(.pointer).?.data;	1180	const payload = ty.castTag(.pointer).?.data;
...	@@ -1680,7 +1277,7 @@ pub const Type = struct {	...	@@ -1680,7 +1277,7 @@ pub const Type = struct {
1680	.ptr_type => @panic("TODO"),	1277	.ptr_type => @panic("TODO"),
1681	.array_type => @panic("TODO"),	1278	.array_type => @panic("TODO"),
1682	.vector_type => @panic("TODO"),	1279	.vector_type => @panic("TODO"),
1683	.optional_type => @panic("TODO"),	1280	.opt_type => @panic("TODO"),
1684	.error_union_type => @panic("TODO"),	1281	.error_union_type => @panic("TODO"),
1685	.simple_type => \|s\| return writer.writeAll(@tagName(s)),	1282	.simple_type => \|s\| return writer.writeAll(@tagName(s)),
1686	.struct_type => @panic("TODO"),	1283	.struct_type => @panic("TODO"),
...	@@ -1733,14 +1330,6 @@ pub const Type = struct {	...	@@ -1733,14 +1330,6 @@ pub const Type = struct {
1733	try decl.renderFullyQualifiedName(mod, writer);	1330	try decl.renderFullyQualifiedName(mod, writer);
1734	},	1331	},
1735		1332
1736	.anyerror_void_error_union => try writer.writeAll("anyerror!void"),
1737	.const_slice_u8 => try writer.writeAll("[]const u8"),
1738	.const_slice_u8_sentinel_0 => try writer.writeAll("[:0]const u8"),
1739	.single_const_pointer_to_comptime_int => try writer.writeAll("*const comptime_int"),
1740	.manyptr_u8 => try writer.writeAll("[*]u8"),
1741	.manyptr_const_u8 => try writer.writeAll("[*]const u8"),
1742	.manyptr_const_u8_sentinel_0 => try writer.writeAll("[*:0]const u8"),
1743
1744	.error_set_inferred => {	1333	.error_set_inferred => {
1745	const func = ty.castTag(.error_set_inferred).?.data.func;	1334	const func = ty.castTag(.error_set_inferred).?.data.func;
1746		1335
...	@@ -1799,20 +1388,6 @@ pub const Type = struct {	...	@@ -1799,20 +1388,6 @@ pub const Type = struct {
1799	try print(error_union.payload, writer, mod);	1388	try print(error_union.payload, writer, mod);
1800	},	1389	},
1801		1390
1802	.array_u8 => {
1803	const len = ty.castTag(.array_u8).?.data;
1804	try writer.print("[{d}]u8", .{len});
1805	},
1806	.array_u8_sentinel_0 => {
1807	const len = ty.castTag(.array_u8_sentinel_0).?.data;
1808	try writer.print("[{d}:0]u8", .{len});
1809	},
1810	.vector => {
1811	const payload = ty.castTag(.vector).?.data;
1812	try writer.print("@Vector({d}, ", .{payload.len});
1813	try print(payload.elem_type, writer, mod);
1814	try writer.writeAll(")");
1815	},
1816	.array => {	1391	.array => {
1817	const payload = ty.castTag(.array).?.data;	1392	const payload = ty.castTag(.array).?.data;
1818	try writer.print("[{d}]", .{payload.len});	1393	try writer.print("[{d}]", .{payload.len});
...	@@ -1865,17 +1440,8 @@ pub const Type = struct {	...	@@ -1865,17 +1440,8 @@ pub const Type = struct {
1865	try writer.writeAll("}");	1440	try writer.writeAll("}");
1866	},	1441	},
1867		1442
1868	.pointer,	1443	.pointer => {
1869	.single_const_pointer,	1444	const info = ty.ptrInfo(mod);
1870	.single_mut_pointer,
1871	.many_const_pointer,
1872	.many_mut_pointer,
1873	.c_const_pointer,
1874	.c_mut_pointer,
1875	.const_slice,
1876	.mut_slice,
1877	=> {
1878	const info = ty.ptrInfo().data;
1879		1445
1880	if (info.sentinel) \|s\| switch (info.size) {	1446	if (info.sentinel) \|s\| switch (info.size) {
1881	.One, .C => unreachable,	1447	.One, .C => unreachable,
...	@@ -1920,16 +1486,6 @@ pub const Type = struct {	...	@@ -1920,16 +1486,6 @@ pub const Type = struct {
1920	try writer.writeByte('?');	1486	try writer.writeByte('?');
1921	try print(child_type, writer, mod);	1487	try print(child_type, writer, mod);
1922	},	1488	},
1923	.optional_single_mut_pointer => {
1924	const pointee_type = ty.castTag(.optional_single_mut_pointer).?.data;
1925	try writer.writeAll("?*");
1926	try print(pointee_type, writer, mod);
1927	},
1928	.optional_single_const_pointer => {
1929	const pointee_type = ty.castTag(.optional_single_const_pointer).?.data;
1930	try writer.writeAll("?*const ");
1931	try print(pointee_type, writer, mod);
1932	},
1933	.anyframe_T => {	1489	.anyframe_T => {
1934	const return_type = ty.castTag(.anyframe_T).?.data;	1490	const return_type = ty.castTag(.anyframe_T).?.data;
1935	try writer.print("anyframe->", .{});	1491	try writer.print("anyframe->", .{});
...	@@ -1963,12 +1519,6 @@ pub const Type = struct {	...	@@ -1963,12 +1519,6 @@ pub const Type = struct {
1963	pub fn toValue(self: Type, allocator: Allocator) Allocator.Error!Value {	1519	pub fn toValue(self: Type, allocator: Allocator) Allocator.Error!Value {
1964	if (self.ip_index != .none) return self.ip_index.toValue();	1520	if (self.ip_index != .none) return self.ip_index.toValue();
1965	switch (self.tag()) {	1521	switch (self.tag()) {
1966	.single_const_pointer_to_comptime_int => return Value{ .ip_index = .single_const_pointer_to_comptime_int_type, .legacy = undefined },
1967	.const_slice_u8 => return Value{ .ip_index = .const_slice_u8_type, .legacy = undefined },
1968	.const_slice_u8_sentinel_0 => return Value{ .ip_index = .const_slice_u8_sentinel_0_type, .legacy = undefined },
1969	.manyptr_u8 => return Value{ .ip_index = .manyptr_u8_type, .legacy = undefined },
1970	.manyptr_const_u8 => return Value{ .ip_index = .manyptr_const_u8_type, .legacy = undefined },
1971	.manyptr_const_u8_sentinel_0 => return Value{ .ip_index = .manyptr_const_u8_sentinel_0_type, .legacy = undefined },
1972	.inferred_alloc_const => unreachable,	1522	.inferred_alloc_const => unreachable,
1973	.inferred_alloc_mut => unreachable,	1523	.inferred_alloc_mut => unreachable,
1974	else => return Value.Tag.ty.create(allocator, self),	1524	else => return Value.Tag.ty.create(allocator, self),
...	@@ -1996,10 +1546,41 @@ pub const Type = struct {	...	@@ -1996,10 +1546,41 @@ pub const Type = struct {
1996	) RuntimeBitsError!bool {	1546	) RuntimeBitsError!bool {
1997	if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {	1547	if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {
1998	.int_type => \|int_type\| return int_type.bits != 0,	1548	.int_type => \|int_type\| return int_type.bits != 0,
1999	.ptr_type => @panic("TODO"),	1549	.ptr_type => \|ptr_type\| {
2000	.array_type => @panic("TODO"),	1550	// Pointers to zero-bit types still have a runtime address; however, pointers
2001	.vector_type => @panic("TODO"),	1551	// to comptime-only types do not, with the exception of function pointers.
2002	.optional_type => @panic("TODO"),	1552	if (ignore_comptime_only) return true;
		1553	const child_ty = ptr_type.elem_type.toType();
		1554	if (child_ty.zigTypeTag(mod) == .Fn) return !child_ty.fnInfo().is_generic;
		1555	if (strat == .sema) return !(try strat.sema.typeRequiresComptime(ty));
		1556	return !comptimeOnly(ty, mod);
		1557	},
		1558	.array_type => \|array_type\| {
		1559	if (array_type.sentinel != .none) {
		1560	return array_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
		1561	} else {
		1562	return array_type.len > 0 and
		1563	try array_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
		1564	}
		1565	},
		1566	.vector_type => \|vector_type\| {
		1567	return vector_type.len > 0 and
		1568	try vector_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
		1569	},
		1570	.opt_type => \|child\| {
		1571	const child_ty = child.toType();
		1572	if (child_ty.isNoReturn()) {
		1573	// Then the optional is comptime-known to be null.
		1574	return false;
		1575	}
		1576	if (ignore_comptime_only) {
		1577	return true;
		1578	} else if (strat == .sema) {
		1579	return !(try strat.sema.typeRequiresComptime(child_ty));
		1580	} else {
		1581	return !comptimeOnly(child_ty, mod);
		1582	}
		1583	},
2003	.error_union_type => @panic("TODO"),	1584	.error_union_type => @panic("TODO"),
2004	.simple_type => \|t\| return switch (t) {	1585	.simple_type => \|t\| return switch (t) {
2005	.f16,	1586	.f16,
...	@@ -2058,14 +1639,7 @@ pub const Type = struct {	...	@@ -2058,14 +1639,7 @@ pub const Type = struct {
2058	.enum_tag => unreachable, // it's a value, not a type	1639	.enum_tag => unreachable, // it's a value, not a type
2059	};	1640	};
2060	switch (ty.tag()) {	1641	switch (ty.tag()) {
2061	.const_slice_u8,
2062	.const_slice_u8_sentinel_0,
2063	.array_u8_sentinel_0,
2064	.anyerror_void_error_union,
2065	.error_set_inferred,	1642	.error_set_inferred,
2066	.manyptr_u8,
2067	.manyptr_const_u8,
2068	.manyptr_const_u8_sentinel_0,
2069		1643
2070	.@"opaque",	1644	.@"opaque",
2071	.error_set_single,	1645	.error_set_single,
...	@@ -2077,22 +1651,12 @@ pub const Type = struct {	...	@@ -2077,22 +1651,12 @@ pub const Type = struct {
2077	// Pointers to zero-bit types still have a runtime address; however, pointers	1651	// Pointers to zero-bit types still have a runtime address; however, pointers
2078	// to comptime-only types do not, with the exception of function pointers.	1652	// to comptime-only types do not, with the exception of function pointers.
2079	.anyframe_T,	1653	.anyframe_T,
2080	.optional_single_mut_pointer,
2081	.optional_single_const_pointer,
2082	.single_const_pointer,
2083	.single_mut_pointer,
2084	.many_const_pointer,
2085	.many_mut_pointer,
2086	.c_const_pointer,
2087	.c_mut_pointer,
2088	.const_slice,
2089	.mut_slice,
2090	.pointer,	1654	.pointer,
2091	=> {	1655	=> {
2092	if (ignore_comptime_only) {	1656	if (ignore_comptime_only) {
2093	return true;	1657	return true;
2094	} else if (ty.childType().zigTypeTag(mod) == .Fn) {	1658	} else if (ty.childType(mod).zigTypeTag(mod) == .Fn) {
2095	return !ty.childType().fnInfo().is_generic;	1659	return !ty.childType(mod).fnInfo().is_generic;
2096	} else if (strat == .sema) {	1660	} else if (strat == .sema) {
2097	return !(try strat.sema.typeRequiresComptime(ty));	1661	return !(try strat.sema.typeRequiresComptime(ty));
2098	} else {	1662	} else {
...	@@ -2101,7 +1665,6 @@ pub const Type = struct {	...	@@ -2101,7 +1665,6 @@ pub const Type = struct {
2101	},	1665	},
2102		1666
2103	// These are false because they are comptime-only types.	1667	// These are false because they are comptime-only types.
2104	.single_const_pointer_to_comptime_int,
2105	.empty_struct,	1668	.empty_struct,
2106	.empty_struct_literal,	1669	.empty_struct_literal,
2107	// These are function bodies, not pointers.	1670	// These are function bodies, not pointers.
...	@@ -2111,8 +1674,7 @@ pub const Type = struct {	...	@@ -2111,8 +1674,7 @@ pub const Type = struct {
2111	=> return false,	1674	=> return false,
2112		1675
2113	.optional => {	1676	.optional => {
2114	var buf: Payload.ElemType = undefined;	1677	const child_ty = ty.optionalChild(mod);
2115	const child_ty = ty.optionalChild(&buf);
2116	if (child_ty.isNoReturn()) {	1678	if (child_ty.isNoReturn()) {
2117	// Then the optional is comptime-known to be null.	1679	// Then the optional is comptime-known to be null.
2118	return false;	1680	return false;
...	@@ -2200,10 +1762,9 @@ pub const Type = struct {	...	@@ -2200,10 +1762,9 @@ pub const Type = struct {
2200	}	1762	}
2201	},	1763	},
2202		1764
2203	.array, .vector => return ty.arrayLen() != 0 and	1765	.array => return ty.arrayLen(mod) != 0 and
2204	try ty.elemType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),	1766	try ty.childType(mod).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
2205	.array_u8 => return ty.arrayLen() != 0,	1767	.array_sentinel => return ty.childType(mod).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
2206	.array_sentinel => return ty.childType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
2207		1768
2208	.tuple, .anon_struct => {	1769	.tuple, .anon_struct => {
2209	const tuple = ty.tupleFields();	1770	const tuple = ty.tupleFields();
...	@@ -2224,14 +1785,14 @@ pub const Type = struct {	...	@@ -2224,14 +1785,14 @@ pub const Type = struct {
2224	/// readFrom/writeToMemory are supported only for types with a well-	1785	/// readFrom/writeToMemory are supported only for types with a well-
2225	/// defined memory layout	1786	/// defined memory layout
2226	pub fn hasWellDefinedLayout(ty: Type, mod: *const Module) bool {	1787	pub fn hasWellDefinedLayout(ty: Type, mod: *const Module) bool {
2227	if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {	1788	if (ty.ip_index != .none) return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
2228	.int_type => return true,	1789	.int_type => true,
2229	.ptr_type => @panic("TODO"),	1790	.ptr_type => true,
2230	.array_type => @panic("TODO"),	1791	.array_type => \|array_type\| array_type.child.toType().hasWellDefinedLayout(mod),
2231	.vector_type => @panic("TODO"),	1792	.vector_type => true,
2232	.optional_type => @panic("TODO"),	1793	.opt_type => \|child\| child.toType().isPtrLikeOptional(mod),
2233	.error_union_type => @panic("TODO"),	1794	.error_union_type => false,
2234	.simple_type => \|t\| return switch (t) {	1795	.simple_type => \|t\| switch (t) {
2235	.f16,	1796	.f16,
2236	.f32,	1797	.f32,
2237	.f64,	1798	.f64,
...	@@ -2287,23 +1848,8 @@ pub const Type = struct {	...	@@ -2287,23 +1848,8 @@ pub const Type = struct {
2287	.enum_tag => unreachable, // it's a value, not a type	1848	.enum_tag => unreachable, // it's a value, not a type
2288	};	1849	};
2289	return switch (ty.tag()) {	1850	return switch (ty.tag()) {
2290	.manyptr_u8,
2291	.manyptr_const_u8,
2292	.manyptr_const_u8_sentinel_0,
2293	.array_u8,
2294	.array_u8_sentinel_0,
2295	.pointer,	1851	.pointer,
2296	.single_const_pointer,
2297	.single_mut_pointer,
2298	.many_const_pointer,
2299	.many_mut_pointer,
2300	.c_const_pointer,
2301	.c_mut_pointer,
2302	.single_const_pointer_to_comptime_int,
2303	.enum_numbered,	1852	.enum_numbered,
2304	.vector,
2305	.optional_single_mut_pointer,
2306	.optional_single_const_pointer,
2307	=> true,	1853	=> true,
2308		1854
2309	.error_set,	1855	.error_set,
...	@@ -2313,13 +1859,8 @@ pub const Type = struct {	...	@@ -2313,13 +1859,8 @@ pub const Type = struct {
2313	.@"opaque",	1859	.@"opaque",
2314	// These are function bodies, not function pointers.	1860	// These are function bodies, not function pointers.
2315	.function,	1861	.function,
2316	.const_slice_u8,
2317	.const_slice_u8_sentinel_0,
2318	.const_slice,
2319	.mut_slice,
2320	.enum_simple,	1862	.enum_simple,
2321	.error_union,	1863	.error_union,
2322	.anyerror_void_error_union,
2323	.anyframe_T,	1864	.anyframe_T,
2324	.tuple,	1865	.tuple,
2325	.anon_struct,	1866	.anon_struct,
...	@@ -2336,7 +1877,7 @@ pub const Type = struct {	...	@@ -2336,7 +1877,7 @@ pub const Type = struct {
2336		1877
2337	.array,	1878	.array,
2338	.array_sentinel,	1879	.array_sentinel,
2339	=> ty.childType().hasWellDefinedLayout(mod),	1880	=> ty.childType(mod).hasWellDefinedLayout(mod),
2340		1881
2341	.optional => ty.isPtrLikeOptional(mod),	1882	.optional => ty.isPtrLikeOptional(mod),
2342	.@"struct" => ty.castTag(.@"struct").?.data.layout != .Auto,	1883	.@"struct" => ty.castTag(.@"struct").?.data.layout != .Auto,
...	@@ -2417,76 +1958,36 @@ pub const Type = struct {	...	@@ -2417,76 +1958,36 @@ pub const Type = struct {
2417	}	1958	}
2418		1959
2419	pub fn ptrAlignmentAdvanced(ty: Type, mod: const Module, opt_sema: ?Sema) !u32 {	1960	pub fn ptrAlignmentAdvanced(ty: Type, mod: const Module, opt_sema: ?Sema) !u32 {
2420	switch (ty.tag()) {	1961	switch (ty.ip_index) {
2421	.single_const_pointer,	1962	.none => switch (ty.tag()) {
2422	.single_mut_pointer,	1963	.pointer => {
2423	.many_const_pointer,	1964	const ptr_info = ty.castTag(.pointer).?.data;
2424	.many_mut_pointer,	1965	if (ptr_info.@"align" != 0) {
2425	.c_const_pointer,	1966	return ptr_info.@"align";
2426	.c_mut_pointer,	1967	} else if (opt_sema) \|sema\| {
2427	.const_slice,	1968	const res = try ptr_info.pointee_type.abiAlignmentAdvanced(mod, .{ .sema = sema });
2428	.mut_slice,	1969	return res.scalar;
2429	.optional_single_const_pointer,	1970	} else {
2430	.optional_single_mut_pointer,	1971	return (ptr_info.pointee_type.abiAlignmentAdvanced(mod, .eager) catch unreachable).scalar;
2431	=> {	1972	}
2432	const child_type = ty.cast(Payload.ElemType).?.data;	1973	},
2433	if (opt_sema) \|sema\| {	1974	.optional => return ty.castTag(.optional).?.data.ptrAlignmentAdvanced(mod, opt_sema),
2434	const res = try child_type.abiAlignmentAdvanced(mod, .{ .sema = sema });
2435	return res.scalar;
2436	}
2437	return (child_type.abiAlignmentAdvanced(mod, .eager) catch unreachable).scalar;
2438	},
2439
2440	.manyptr_u8,
2441	.manyptr_const_u8,
2442	.manyptr_const_u8_sentinel_0,
2443	.const_slice_u8,
2444	.const_slice_u8_sentinel_0,
2445	=> return 1,
2446		1975
2447	.pointer => {	1976	else => unreachable,
2448	const ptr_info = ty.castTag(.pointer).?.data;	1977	},
2449	if (ptr_info.@"align" != 0) {	1978	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
2450	return ptr_info.@"align";	1979	else => @panic("TODO"),
2451	} else if (opt_sema) \|sema\| {
2452	const res = try ptr_info.pointee_type.abiAlignmentAdvanced(mod, .{ .sema = sema });
2453	return res.scalar;
2454	} else {
2455	return (ptr_info.pointee_type.abiAlignmentAdvanced(mod, .eager) catch unreachable).scalar;
2456	}
2457	},	1980	},
2458	.optional => return ty.castTag(.optional).?.data.ptrAlignmentAdvanced(mod, opt_sema),
2459
2460	else => unreachable,
2461	}	1981	}
2462	}	1982	}
2463		1983
2464	pub fn ptrAddressSpace(self: Type) std.builtin.AddressSpace {	1984	pub fn ptrAddressSpace(self: Type, mod: *const Module) std.builtin.AddressSpace {
2465	return switch (self.tag()) {	1985	return switch (self.tag()) {
2466	.single_const_pointer_to_comptime_int,
2467	.const_slice_u8,
2468	.const_slice_u8_sentinel_0,
2469	.single_const_pointer,
2470	.single_mut_pointer,
2471	.many_const_pointer,
2472	.many_mut_pointer,
2473	.c_const_pointer,
2474	.c_mut_pointer,
2475	.const_slice,
2476	.mut_slice,
2477	.inferred_alloc_const,
2478	.inferred_alloc_mut,
2479	.manyptr_u8,
2480	.manyptr_const_u8,
2481	.manyptr_const_u8_sentinel_0,
2482	=> .generic,
2483
2484	.pointer => self.castTag(.pointer).?.data.@"addrspace",	1986	.pointer => self.castTag(.pointer).?.data.@"addrspace",
2485		1987
2486	.optional => {	1988	.optional => {
2487	var buf: Payload.ElemType = undefined;	1989	const child_type = self.optionalChild(mod);
2488	const child_type = self.optionalChild(&buf);	1990	return child_type.ptrAddressSpace(mod);
2489	return child_type.ptrAddressSpace();
2490	},	1991	},
2491		1992
2492	else => unreachable,	1993	else => unreachable,
...	@@ -2530,15 +2031,31 @@ pub const Type = struct {	...	@@ -2530,15 +2031,31 @@ pub const Type = struct {
2530	) Module.CompileError!AbiAlignmentAdvanced {	2031	) Module.CompileError!AbiAlignmentAdvanced {
2531	const target = mod.getTarget();	2032	const target = mod.getTarget();
2532		2033
		2034	const opt_sema = switch (strat) {
		2035	.sema => \|sema\| sema,
		2036	else => null,
		2037	};
		2038
2533	if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {	2039	if (ty.ip_index != .none) switch (mod.intern_pool.indexToKey(ty.ip_index)) {
2534	.int_type => \|int_type\| {	2040	.int_type => \|int_type\| {
2535	if (int_type.bits == 0) return AbiAlignmentAdvanced{ .scalar = 0 };	2041	if (int_type.bits == 0) return AbiAlignmentAdvanced{ .scalar = 0 };
2536	return AbiAlignmentAdvanced{ .scalar = intAbiAlignment(int_type.bits, target) };	2042	return AbiAlignmentAdvanced{ .scalar = intAbiAlignment(int_type.bits, target) };
2537	},	2043	},
2538	.ptr_type => @panic("TODO"),	2044	.ptr_type => {
2539	.array_type => @panic("TODO"),	2045	return AbiAlignmentAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) };
2540	.vector_type => @panic("TODO"),	2046	},
2541	.optional_type => @panic("TODO"),	2047	.array_type => \|array_type\| {
		2048	return array_type.child.toType().abiAlignmentAdvanced(mod, strat);
		2049	},
		2050	.vector_type => \|vector_type\| {
		2051	const bits_u64 = try bitSizeAdvanced(vector_type.child.toType(), mod, opt_sema);
		2052	const bits = @intCast(u32, bits_u64);
		2053	const bytes = ((bits * vector_type.len) + 7) / 8;
		2054	const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
		2055	return AbiAlignmentAdvanced{ .scalar = alignment };
		2056	},
		2057
		2058	.opt_type => @panic("TODO"),
2542	.error_union_type => @panic("TODO"),	2059	.error_union_type => @panic("TODO"),
2543	.simple_type => \|t\| switch (t) {	2060	.simple_type => \|t\| switch (t) {
2544	.bool,	2061	.bool,
...	@@ -2617,15 +2134,8 @@ pub const Type = struct {	...	@@ -2617,15 +2134,8 @@ pub const Type = struct {
2617	.enum_tag => unreachable, // it's a value, not a type	2134	.enum_tag => unreachable, // it's a value, not a type
2618	};	2135	};
2619		2136
2620	const opt_sema = switch (strat) {
2621	.sema => \|sema\| sema,
2622	else => null,
2623	};
2624	switch (ty.tag()) {	2137	switch (ty.tag()) {
2625	.array_u8_sentinel_0,	2138	.@"opaque" => return AbiAlignmentAdvanced{ .scalar = 1 },
2626	.array_u8,
2627	.@"opaque",
2628	=> return AbiAlignmentAdvanced{ .scalar = 1 },
2629		2139
2630	// represents machine code; not a pointer	2140	// represents machine code; not a pointer
2631	.function => {	2141	.function => {
...	@@ -2634,47 +2144,21 @@ pub const Type = struct {	...	@@ -2634,47 +2144,21 @@ pub const Type = struct {
2634	return AbiAlignmentAdvanced{ .scalar = target_util.defaultFunctionAlignment(target) };	2144	return AbiAlignmentAdvanced{ .scalar = target_util.defaultFunctionAlignment(target) };
2635	},	2145	},
2636		2146
2637	.single_const_pointer_to_comptime_int,
2638	.const_slice_u8,
2639	.const_slice_u8_sentinel_0,
2640	.single_const_pointer,
2641	.single_mut_pointer,
2642	.many_const_pointer,
2643	.many_mut_pointer,
2644	.c_const_pointer,
2645	.c_mut_pointer,
2646	.const_slice,
2647	.mut_slice,
2648	.optional_single_const_pointer,
2649	.optional_single_mut_pointer,
2650	.pointer,	2147	.pointer,
2651	.manyptr_u8,
2652	.manyptr_const_u8,
2653	.manyptr_const_u8_sentinel_0,
2654	.anyframe_T,	2148	.anyframe_T,
2655	=> return AbiAlignmentAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },	2149	=> return AbiAlignmentAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },
2656		2150
2657	// TODO revisit this when we have the concept of the error tag type	2151	// TODO revisit this when we have the concept of the error tag type
2658	.anyerror_void_error_union,
2659	.error_set_inferred,	2152	.error_set_inferred,
2660	.error_set_single,	2153	.error_set_single,
2661	.error_set,	2154	.error_set,
2662	.error_set_merged,	2155	.error_set_merged,
2663	=> return AbiAlignmentAdvanced{ .scalar = 2 },	2156	=> return AbiAlignmentAdvanced{ .scalar = 2 },
2664		2157
2665	.array, .array_sentinel => return ty.elemType().abiAlignmentAdvanced(mod, strat),	2158	.array, .array_sentinel => return ty.childType(mod).abiAlignmentAdvanced(mod, strat),
2666
2667	.vector => {
2668	const len = ty.arrayLen();
2669	const bits = try bitSizeAdvanced(ty.elemType(), mod, opt_sema);
2670	const bytes = ((bits * len) + 7) / 8;
2671	const alignment = std.math.ceilPowerOfTwoAssert(u64, bytes);
2672	return AbiAlignmentAdvanced{ .scalar = @intCast(u32, alignment) };
2673	},
2674		2159
2675	.optional => {	2160	.optional => {
2676	var buf: Payload.ElemType = undefined;	2161	const child_type = ty.optionalChild(mod);
2677	const child_type = ty.optionalChild(&buf);
2678		2162
2679	switch (child_type.zigTypeTag(mod)) {	2163	switch (child_type.zigTypeTag(mod)) {
2680	.Pointer => return AbiAlignmentAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },	2164	.Pointer => return AbiAlignmentAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },
...	@@ -2933,8 +2417,29 @@ pub const Type = struct {	...	@@ -2933,8 +2417,29 @@ pub const Type = struct {
2933	},	2417	},
2934	.ptr_type => @panic("TODO"),	2418	.ptr_type => @panic("TODO"),
2935	.array_type => @panic("TODO"),	2419	.array_type => @panic("TODO"),
2936	.vector_type => @panic("TODO"),	2420	.vector_type => \|vector_type\| {
2937	.optional_type => @panic("TODO"),	2421	const opt_sema = switch (strat) {
		2422	.sema => \|sema\| sema,
		2423	.eager => null,
		2424	.lazy => \|arena\| return AbiSizeAdvanced{
		2425	.val = try Value.Tag.lazy_size.create(arena, ty),
		2426	},
		2427	};
		2428	const elem_bits_u64 = try vector_type.child.toType().bitSizeAdvanced(mod, opt_sema);
		2429	const elem_bits = @intCast(u32, elem_bits_u64);
		2430	const total_bits = elem_bits * vector_type.len;
		2431	const total_bytes = (total_bits + 7) / 8;
		2432	const alignment = switch (try ty.abiAlignmentAdvanced(mod, strat)) {
		2433	.scalar => \|x\| x,
		2434	.val => return AbiSizeAdvanced{
		2435	.val = try Value.Tag.lazy_size.create(strat.lazy, ty),
		2436	},
		2437	};
		2438	const result = std.mem.alignForwardGeneric(u32, total_bytes, alignment);
		2439	return AbiSizeAdvanced{ .scalar = result };
		2440	},
		2441
		2442	.opt_type => @panic("TODO"),
2938	.error_union_type => @panic("TODO"),	2443	.error_union_type => @panic("TODO"),
2939	.simple_type => \|t\| switch (t) {	2444	.simple_type => \|t\| switch (t) {
2940	.bool,	2445	.bool,
...	@@ -3014,7 +2519,6 @@ pub const Type = struct {	...	@@ -3014,7 +2519,6 @@ pub const Type = struct {
3014	.inferred_alloc_const => unreachable,	2519	.inferred_alloc_const => unreachable,
3015	.inferred_alloc_mut => unreachable,	2520	.inferred_alloc_mut => unreachable,
3016		2521
3017	.single_const_pointer_to_comptime_int,
3018	.empty_struct_literal,	2522	.empty_struct_literal,
3019	.empty_struct,	2523	.empty_struct,
3020	=> return AbiSizeAdvanced{ .scalar = 0 },	2524	=> return AbiSizeAdvanced{ .scalar = 0 },
...	@@ -3068,8 +2572,6 @@ pub const Type = struct {	...	@@ -3068,8 +2572,6 @@ pub const Type = struct {
3068	return abiSizeAdvancedUnion(ty, mod, strat, union_obj, true);	2572	return abiSizeAdvancedUnion(ty, mod, strat, union_obj, true);
3069	},	2573	},
3070		2574
3071	.array_u8 => return AbiSizeAdvanced{ .scalar = ty.castTag(.array_u8).?.data },
3072	.array_u8_sentinel_0 => return AbiSizeAdvanced{ .scalar = ty.castTag(.array_u8_sentinel_0).?.data + 1 },
3073	.array => {	2575	.array => {
3074	const payload = ty.castTag(.array).?.data;	2576	const payload = ty.castTag(.array).?.data;
3075	switch (try payload.elem_type.abiSizeAdvanced(mod, strat)) {	2577	switch (try payload.elem_type.abiSizeAdvanced(mod, strat)) {
...	@@ -3093,47 +2595,7 @@ pub const Type = struct {	...	@@ -3093,47 +2595,7 @@ pub const Type = struct {
3093	}	2595	}
3094	},	2596	},
3095		2597
3096	.vector => {	2598	.anyframe_T => return AbiSizeAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },
3097	const payload = ty.castTag(.vector).?.data;
3098	const opt_sema = switch (strat) {
3099	.sema => \|sema\| sema,
3100	.eager => null,
3101	.lazy => \|arena\| return AbiSizeAdvanced{
3102	.val = try Value.Tag.lazy_size.create(arena, ty),
3103	},
3104	};
3105	const elem_bits = try payload.elem_type.bitSizeAdvanced(mod, opt_sema);
3106	const total_bits = elem_bits * payload.len;
3107	const total_bytes = (total_bits + 7) / 8;
3108	const alignment = switch (try ty.abiAlignmentAdvanced(mod, strat)) {
3109	.scalar => \|x\| x,
3110	.val => return AbiSizeAdvanced{
3111	.val = try Value.Tag.lazy_size.create(strat.lazy, ty),
3112	},
3113	};
3114	const result = std.mem.alignForwardGeneric(u64, total_bytes, alignment);
3115	return AbiSizeAdvanced{ .scalar = result };
3116	},
3117
3118	.anyframe_T,
3119	.optional_single_const_pointer,
3120	.optional_single_mut_pointer,
3121	.single_const_pointer,
3122	.single_mut_pointer,
3123	.many_const_pointer,
3124	.many_mut_pointer,
3125	.c_const_pointer,
3126	.c_mut_pointer,
3127	.manyptr_u8,
3128	.manyptr_const_u8,
3129	.manyptr_const_u8_sentinel_0,
3130	=> return AbiSizeAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) },
3131
3132	.const_slice,
3133	.mut_slice,
3134	.const_slice_u8,
3135	.const_slice_u8_sentinel_0,
3136	=> return AbiSizeAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) * 2 },
3137		2599
3138	.pointer => switch (ty.castTag(.pointer).?.data.size) {	2600	.pointer => switch (ty.castTag(.pointer).?.data.size) {
3139	.Slice => return AbiSizeAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) * 2 },	2601	.Slice => return AbiSizeAdvanced{ .scalar = @divExact(target.ptrBitWidth(), 8) * 2 },
...	@@ -3141,7 +2603,6 @@ pub const Type = struct {	...	@@ -3141,7 +2603,6 @@ pub const Type = struct {
3141	},	2603	},
3142		2604
3143	// TODO revisit this when we have the concept of the error tag type	2605	// TODO revisit this when we have the concept of the error tag type
3144	.anyerror_void_error_union,
3145	.error_set_inferred,	2606	.error_set_inferred,
3146	.error_set,	2607	.error_set,
3147	.error_set_merged,	2608	.error_set_merged,
...	@@ -3149,8 +2610,7 @@ pub const Type = struct {	...	@@ -3149,8 +2610,7 @@ pub const Type = struct {
3149	=> return AbiSizeAdvanced{ .scalar = 2 },	2610	=> return AbiSizeAdvanced{ .scalar = 2 },
3150		2611
3151	.optional => {	2612	.optional => {
3152	var buf: Payload.ElemType = undefined;	2613	const child_type = ty.optionalChild(mod);
3153	const child_type = ty.optionalChild(&buf);
3154		2614
3155	if (child_type.isNoReturn()) {	2615	if (child_type.isNoReturn()) {
3156	return AbiSizeAdvanced{ .scalar = 0 };	2616	return AbiSizeAdvanced{ .scalar = 0 };
...	@@ -3272,8 +2732,12 @@ pub const Type = struct {	...	@@ -3272,8 +2732,12 @@ pub const Type = struct {
3272	.int_type => \|int_type\| return int_type.bits,	2732	.int_type => \|int_type\| return int_type.bits,
3273	.ptr_type => @panic("TODO"),	2733	.ptr_type => @panic("TODO"),
3274	.array_type => @panic("TODO"),	2734	.array_type => @panic("TODO"),
3275	.vector_type => @panic("TODO"),	2735	.vector_type => \|vector_type\| {
3276	.optional_type => @panic("TODO"),	2736	const child_ty = vector_type.child.toType();
		2737	const elem_bit_size = try bitSizeAdvanced(child_ty, mod, opt_sema);
		2738	return elem_bit_size * vector_type.len;
		2739	},
		2740	.opt_type => @panic("TODO"),
3277	.error_union_type => @panic("TODO"),	2741	.error_union_type => @panic("TODO"),
3278	.simple_type => \|t\| switch (t) {	2742	.simple_type => \|t\| switch (t) {
3279	.f16 => return 16,	2743	.f16 => return 16,
...	@@ -3339,7 +2803,6 @@ pub const Type = struct {	...	@@ -3339,7 +2803,6 @@ pub const Type = struct {
3339		2803
3340	switch (ty.tag()) {	2804	switch (ty.tag()) {
3341	.function => unreachable, // represents machine code; not a pointer	2805	.function => unreachable, // represents machine code; not a pointer
3342	.single_const_pointer_to_comptime_int => unreachable,
3343	.empty_struct => unreachable,	2806	.empty_struct => unreachable,
3344	.empty_struct_literal => unreachable,	2807	.empty_struct_literal => unreachable,
3345	.inferred_alloc_const => unreachable,	2808	.inferred_alloc_const => unreachable,
...	@@ -3388,13 +2851,6 @@ pub const Type = struct {	...	@@ -3388,13 +2851,6 @@ pub const Type = struct {
3388	return size;	2851	return size;
3389	},	2852	},
3390		2853
3391	.vector => {
3392	const payload = ty.castTag(.vector).?.data;
3393	const elem_bit_size = try bitSizeAdvanced(payload.elem_type, mod, opt_sema);
3394	return elem_bit_size * payload.len;
3395	},
3396	.array_u8 => return 8 * ty.castTag(.array_u8).?.data,
3397	.array_u8_sentinel_0 => return 8 * (ty.castTag(.array_u8_sentinel_0).?.data + 1),
3398	.array => {	2854	.array => {
3399	const payload = ty.castTag(.array).?.data;	2855	const payload = ty.castTag(.array).?.data;
3400	const elem_size = std.math.max(payload.elem_type.abiAlignment(mod), payload.elem_type.abiSize(mod));	2856	const elem_size = std.math.max(payload.elem_type.abiAlignment(mod), payload.elem_type.abiSize(mod));
...	@@ -3415,43 +2871,13 @@ pub const Type = struct {	...	@@ -3415,43 +2871,13 @@ pub const Type = struct {
3415		2871
3416	.anyframe_T => return target.ptrBitWidth(),	2872	.anyframe_T => return target.ptrBitWidth(),
3417		2873
3418	.const_slice,
3419	.mut_slice,
3420	=> return target.ptrBitWidth() * 2,
3421
3422	.const_slice_u8,
3423	.const_slice_u8_sentinel_0,
3424	=> return target.ptrBitWidth() * 2,
3425
3426	.optional_single_const_pointer,
3427	.optional_single_mut_pointer,
3428	=> {
3429	return target.ptrBitWidth();
3430	},
3431
3432	.single_const_pointer,
3433	.single_mut_pointer,
3434	.many_const_pointer,
3435	.many_mut_pointer,
3436	.c_const_pointer,
3437	.c_mut_pointer,
3438	=> {
3439	return target.ptrBitWidth();
3440	},
3441
3442	.pointer => switch (ty.castTag(.pointer).?.data.size) {	2874	.pointer => switch (ty.castTag(.pointer).?.data.size) {
3443	.Slice => return target.ptrBitWidth() * 2,	2875	.Slice => return target.ptrBitWidth() * 2,
3444	else => return target.ptrBitWidth(),	2876	else => return target.ptrBitWidth(),
3445	},	2877	},
3446		2878
3447	.manyptr_u8,
3448	.manyptr_const_u8,
3449	.manyptr_const_u8_sentinel_0,
3450	=> return target.ptrBitWidth(),
3451
3452	.error_set,	2879	.error_set,
3453	.error_set_single,	2880	.error_set_single,
3454	.anyerror_void_error_union,
3455	.error_set_inferred,	2881	.error_set_inferred,
3456	.error_set_merged,	2882	.error_set_merged,
3457	=> return 16, // TODO revisit this when we have the concept of the error tag type	2883	=> return 16, // TODO revisit this when we have the concept of the error tag type
...	@@ -3481,12 +2907,11 @@ pub const Type = struct {	...	@@ -3481,12 +2907,11 @@ pub const Type = struct {
3481	return true;	2907	return true;
3482	},	2908	},
3483	.Array => {	2909	.Array => {
3484	if (ty.arrayLenIncludingSentinel() == 0) return true;	2910	if (ty.arrayLenIncludingSentinel(mod) == 0) return true;
3485	return ty.childType().layoutIsResolved(mod);	2911	return ty.childType(mod).layoutIsResolved(mod);
3486	},	2912	},
3487	.Optional => {	2913	.Optional => {
3488	var buf: Type.Payload.ElemType = undefined;	2914	const payload_ty = ty.optionalChild(mod);
3489	const payload_ty = ty.optionalChild(&buf);
3490	return payload_ty.layoutIsResolved(mod);	2915	return payload_ty.layoutIsResolved(mod);
3491	},	2916	},
3492	.ErrorUnion => {	2917	.ErrorUnion => {
...	@@ -3500,9 +2925,6 @@ pub const Type = struct {	...	@@ -3500,9 +2925,6 @@ pub const Type = struct {
3500	pub fn isSinglePointer(ty: Type, mod: *const Module) bool {	2925	pub fn isSinglePointer(ty: Type, mod: *const Module) bool {
3501	switch (ty.ip_index) {	2926	switch (ty.ip_index) {
3502	.none => return switch (ty.tag()) {	2927	.none => return switch (ty.tag()) {
3503	.single_const_pointer,
3504	.single_mut_pointer,
3505	.single_const_pointer_to_comptime_int,
3506	.inferred_alloc_const,	2928	.inferred_alloc_const,
3507	.inferred_alloc_mut,	2929	.inferred_alloc_mut,
3508	=> true,	2930	=> true,
...	@@ -3519,54 +2941,33 @@ pub const Type = struct {	...	@@ -3519,54 +2941,33 @@ pub const Type = struct {
3519	}	2941	}
3520		2942
3521	/// Asserts `ty` is a pointer.	2943	/// Asserts `ty` is a pointer.
3522	pub fn ptrSize(ty: Type) std.builtin.Type.Pointer.Size {	2944	pub fn ptrSize(ty: Type, mod: *const Module) std.builtin.Type.Pointer.Size {
3523	return ptrSizeOrNull(ty).?;	2945	return ptrSizeOrNull(ty, mod).?;
3524	}	2946	}
3525		2947
3526	/// Returns `null` if `ty` is not a pointer.	2948	/// Returns `null` if `ty` is not a pointer.
3527	pub fn ptrSizeOrNull(ty: Type) ?std.builtin.Type.Pointer.Size {	2949	pub fn ptrSizeOrNull(ty: Type, mod: *const Module) ?std.builtin.Type.Pointer.Size {
3528	return switch (ty.tag()) {	2950	return switch (ty.ip_index) {
3529	.const_slice,	2951	.none => switch (ty.tag()) {
3530	.mut_slice,	2952	.inferred_alloc_const,
3531	.const_slice_u8,	2953	.inferred_alloc_mut,
3532	.const_slice_u8_sentinel_0,	2954	=> .One,
3533	=> .Slice,
3534
3535	.many_const_pointer,
3536	.many_mut_pointer,
3537	.manyptr_u8,
3538	.manyptr_const_u8,
3539	.manyptr_const_u8_sentinel_0,
3540	=> .Many,
3541
3542	.c_const_pointer,
3543	.c_mut_pointer,
3544	=> .C,
3545
3546	.single_const_pointer,
3547	.single_mut_pointer,
3548	.single_const_pointer_to_comptime_int,
3549	.inferred_alloc_const,
3550	.inferred_alloc_mut,
3551	=> .One,
3552		2955
3553	.pointer => ty.castTag(.pointer).?.data.size,	2956	.pointer => ty.castTag(.pointer).?.data.size,
3554		2957
3555	else => null,	2958	else => null,
		2959	},
		2960	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
		2961	.ptr_type => \|ptr_info\| ptr_info.size,
		2962	else => null,
		2963	},
3556	};	2964	};
3557	}	2965	}
3558		2966
3559	pub fn isSlice(ty: Type, mod: *const Module) bool {	2967	pub fn isSlice(ty: Type, mod: *const Module) bool {
3560	return switch (ty.ip_index) {	2968	return switch (ty.ip_index) {
3561	.none => switch (ty.tag()) {	2969	.none => switch (ty.tag()) {
3562	.const_slice,
3563	.mut_slice,
3564	.const_slice_u8,
3565	.const_slice_u8_sentinel_0,
3566	=> true,
3567
3568	.pointer => ty.castTag(.pointer).?.data.size == .Slice,	2970	.pointer => ty.castTag(.pointer).?.data.size == .Slice,
3569
3570	else => false,	2971	else => false,
3571	},	2972	},
3572	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {	2973	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
...	@@ -3583,78 +2984,28 @@ pub const Type = struct {	...	@@ -3583,78 +2984,28 @@ pub const Type = struct {
3583		2984
3584	pub fn slicePtrFieldType(self: Type, buffer: *SlicePtrFieldTypeBuffer) Type {	2985	pub fn slicePtrFieldType(self: Type, buffer: *SlicePtrFieldTypeBuffer) Type {
3585	switch (self.tag()) {	2986	switch (self.tag()) {
3586	.const_slice_u8 => return Type.initTag(.manyptr_const_u8),
3587	.const_slice_u8_sentinel_0 => return Type.initTag(.manyptr_const_u8_sentinel_0),
3588
3589	.const_slice => {
3590	const elem_type = self.castTag(.const_slice).?.data;
3591	buffer.* = .{
3592	.elem_type = .{
3593	.base = .{ .tag = .many_const_pointer },
3594	.data = elem_type,
3595	},
3596	};
3597	return Type.initPayload(&buffer.elem_type.base);
3598	},
3599	.mut_slice => {
3600	const elem_type = self.castTag(.mut_slice).?.data;
3601	buffer.* = .{
3602	.elem_type = .{
3603	.base = .{ .tag = .many_mut_pointer },
3604	.data = elem_type,
3605	},
3606	};
3607	return Type.initPayload(&buffer.elem_type.base);
3608	},
3609
3610	.pointer => {	2987	.pointer => {
3611	const payload = self.castTag(.pointer).?.data;	2988	const payload = self.castTag(.pointer).?.data;
3612	assert(payload.size == .Slice);	2989	assert(payload.size == .Slice);
3613		2990
3614	if (payload.sentinel != null or	2991	buffer.* = .{
3615	payload.@"align" != 0 or	2992	.pointer = .{
3616	payload.@"addrspace" != .generic or	2993	.data = .{
3617	payload.bit_offset != 0 or	2994	.pointee_type = payload.pointee_type,
3618	payload.host_size != 0 or	2995	.sentinel = payload.sentinel,
3619	payload.vector_index != .none or	2996	.@"align" = payload.@"align",
3620	payload.@"allowzero" or	2997	.@"addrspace" = payload.@"addrspace",
3621	payload.@"volatile")	2998	.bit_offset = payload.bit_offset,
3622	{	2999	.host_size = payload.host_size,
3623	buffer.* = .{	3000	.vector_index = payload.vector_index,
3624	.pointer = .{	3001	.@"allowzero" = payload.@"allowzero",
3625	.data = .{	3002	.mutable = payload.mutable,
3626	.pointee_type = payload.pointee_type,	3003	.@"volatile" = payload.@"volatile",
3627	.sentinel = payload.sentinel,	3004	.size = .Many,
3628	.@"align" = payload.@"align",
3629	.@"addrspace" = payload.@"addrspace",
3630	.bit_offset = payload.bit_offset,
3631	.host_size = payload.host_size,
3632	.vector_index = payload.vector_index,
3633	.@"allowzero" = payload.@"allowzero",
3634	.mutable = payload.mutable,
3635	.@"volatile" = payload.@"volatile",
3636	.size = .Many,
3637	},
3638	},
3639	};
3640	return Type.initPayload(&buffer.pointer.base);
3641	} else if (payload.mutable) {
3642	buffer.* = .{
3643	.elem_type = .{
3644	.base = .{ .tag = .many_mut_pointer },
3645	.data = payload.pointee_type,
3646	},
3647	};
3648	return Type.initPayload(&buffer.elem_type.base);
3649	} else {
3650	buffer.* = .{
3651	.elem_type = .{
3652	.base = .{ .tag = .many_const_pointer },
3653	.data = payload.pointee_type,
3654	},	3005	},
3655	};	3006	},
3656	return Type.initPayload(&buffer.elem_type.base);	3007	};
3657	}	3008	return Type.initPayload(&buffer.pointer.base);
3658	},	3009	},
3659		3010
3660	else => unreachable,	3011	else => unreachable,
...	@@ -3663,19 +3014,7 @@ pub const Type = struct {	...	@@ -3663,19 +3014,7 @@ pub const Type = struct {
3663		3014
3664	pub fn isConstPtr(self: Type) bool {	3015	pub fn isConstPtr(self: Type) bool {
3665	return switch (self.tag()) {	3016	return switch (self.tag()) {
3666	.single_const_pointer,
3667	.many_const_pointer,
3668	.c_const_pointer,
3669	.single_const_pointer_to_comptime_int,
3670	.const_slice_u8,
3671	.const_slice_u8_sentinel_0,
3672	.const_slice,
3673	.manyptr_const_u8,
3674	.manyptr_const_u8_sentinel_0,
3675	=> true,
3676
3677	.pointer => !self.castTag(.pointer).?.data.mutable,	3017	.pointer => !self.castTag(.pointer).?.data.mutable,
3678
3679	else => false,	3018	else => false,
3680	};	3019	};
3681	}	3020	}
...	@@ -3702,49 +3041,46 @@ pub const Type = struct {	...	@@ -3702,49 +3041,46 @@ pub const Type = struct {
3702		3041
3703	pub fn isCPtr(self: Type) bool {	3042	pub fn isCPtr(self: Type) bool {
3704	return switch (self.tag()) {	3043	return switch (self.tag()) {
3705	.c_const_pointer,
3706	.c_mut_pointer,
3707	=> return true,
3708
3709	.pointer => self.castTag(.pointer).?.data.size == .C,	3044	.pointer => self.castTag(.pointer).?.data.size == .C,
3710		3045
3711	else => return false,	3046	else => return false,
3712	};	3047	};
3713	}	3048	}
3714		3049
3715	pub fn isPtrAtRuntime(self: Type, mod: *const Module) bool {	3050	pub fn isPtrAtRuntime(ty: Type, mod: *const Module) bool {
3716	switch (self.tag()) {	3051	switch (ty.ip_index) {
3717	.c_const_pointer,	3052	.none => switch (ty.tag()) {
3718	.c_mut_pointer,	3053	.pointer => switch (ty.castTag(.pointer).?.data.size) {
3719	.many_const_pointer,	3054	.Slice => return false,
3720	.many_mut_pointer,	3055	.One, .Many, .C => return true,
3721	.manyptr_const_u8,	3056	},
3722	.manyptr_const_u8_sentinel_0,
3723	.manyptr_u8,
3724	.optional_single_const_pointer,
3725	.optional_single_mut_pointer,
3726	.single_const_pointer,
3727	.single_const_pointer_to_comptime_int,
3728	.single_mut_pointer,
3729	=> return true,
3730		3057
3731	.pointer => switch (self.castTag(.pointer).?.data.size) {	3058	.optional => {
3732	.Slice => return false,	3059	const child_type = ty.optionalChild(mod);
3733	.One, .Many, .C => return true,	3060	if (child_type.zigTypeTag(mod) != .Pointer) return false;
3734	},	3061	const info = child_type.ptrInfo(mod);
		3062	switch (info.size) {
		3063	.Slice, .C => return false,
		3064	.Many, .One => return !info.@"allowzero",
		3065	}
		3066	},
3735		3067
3736	.optional => {	3068	else => return false,
3737	var buf: Payload.ElemType = undefined;	3069	},
3738	const child_type = self.optionalChild(&buf);	3070	else => return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
3739	if (child_type.zigTypeTag(mod) != .Pointer) return false;	3071	.ptr_type => \|ptr_type\| switch (ptr_type.size) {
3740	const info = child_type.ptrInfo().data;	3072	.Slice => false,
3741	switch (info.size) {	3073	.One, .Many, .C => true,
3742	.Slice, .C => return false,	3074	},
3743	.Many, .One => return !info.@"allowzero",	3075	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {
3744	}	3076	.ptr_type => \|p\| switch (p.size) {
		3077	.Slice, .C => false,
		3078	.Many, .One => !p.is_allowzero,
		3079	},
		3080	else => false,
		3081	},
		3082	else => false,
3745	},	3083	},
3746
3747	else => return false,
3748	}	3084	}
3749	}	3085	}
3750		3086
...	@@ -3754,23 +3090,17 @@ pub const Type = struct {	...	@@ -3754,23 +3090,17 @@ pub const Type = struct {
3754	if (ty.isPtrLikeOptional(mod)) {	3090	if (ty.isPtrLikeOptional(mod)) {
3755	return true;	3091	return true;
3756	}	3092	}
3757	return ty.ptrInfo().data.@"allowzero";	3093	return ty.ptrInfo(mod).@"allowzero";
3758	}	3094	}
3759		3095
3760	/// See also `isPtrLikeOptional`.	3096	/// See also `isPtrLikeOptional`.
3761	pub fn optionalReprIsPayload(ty: Type, mod: *const Module) bool {	3097	pub fn optionalReprIsPayload(ty: Type, mod: *const Module) bool {
3762	switch (ty.tag()) {	3098	switch (ty.tag()) {
3763	.optional_single_const_pointer,
3764	.optional_single_mut_pointer,
3765	.c_const_pointer,
3766	.c_mut_pointer,
3767	=> return true,
3768
3769	.optional => {	3099	.optional => {
3770	const child_ty = ty.castTag(.optional).?.data;	3100	const child_ty = ty.castTag(.optional).?.data;
3771	switch (child_ty.zigTypeTag(mod)) {	3101	switch (child_ty.zigTypeTag(mod)) {
3772	.Pointer => {	3102	.Pointer => {
3773	const info = child_ty.ptrInfo().data;	3103	const info = child_ty.ptrInfo(mod);
3774	switch (info.size) {	3104	switch (info.size) {
3775	.C => return false,	3105	.C => return false,
3776	.Slice, .Many, .One => return !info.@"allowzero",	3106	.Slice, .Many, .One => return !info.@"allowzero",
...	@@ -3793,7 +3123,7 @@ pub const Type = struct {	...	@@ -3793,7 +3123,7 @@ pub const Type = struct {
3793	pub fn isPtrLikeOptional(ty: Type, mod: *const Module) bool {	3123	pub fn isPtrLikeOptional(ty: Type, mod: *const Module) bool {
3794	if (ty.ip_index != .none) return switch (mod.intern_pool.indexToKey(ty.ip_index)) {	3124	if (ty.ip_index != .none) return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
3795	.ptr_type => \|ptr_type\| ptr_type.size == .C,	3125	.ptr_type => \|ptr_type\| ptr_type.size == .C,
3796	.optional_type => \|o\| switch (mod.intern_pool.indexToKey(o.payload_type)) {	3126	.opt_type => \|child\| switch (mod.intern_pool.indexToKey(child)) {
3797	.ptr_type => \|ptr_type\| switch (ptr_type.size) {	3127	.ptr_type => \|ptr_type\| switch (ptr_type.size) {
3798	.Slice, .C => false,	3128	.Slice, .C => false,
3799	.Many, .One => !ptr_type.is_allowzero,	3129	.Many, .One => !ptr_type.is_allowzero,
...	@@ -3803,16 +3133,10 @@ pub const Type = struct {	...	@@ -3803,16 +3133,10 @@ pub const Type = struct {
3803	else => false,	3133	else => false,
3804	};	3134	};
3805	switch (ty.tag()) {	3135	switch (ty.tag()) {
3806	.optional_single_const_pointer,
3807	.optional_single_mut_pointer,
3808	.c_const_pointer,
3809	.c_mut_pointer,
3810	=> return true,
3811
3812	.optional => {	3136	.optional => {
3813	const child_ty = ty.castTag(.optional).?.data;	3137	const child_ty = ty.castTag(.optional).?.data;
3814	if (child_ty.zigTypeTag(mod) != .Pointer) return false;	3138	if (child_ty.zigTypeTag(mod) != .Pointer) return false;
3815	const info = child_ty.ptrInfo().data;	3139	const info = child_ty.ptrInfo(mod);
3816	switch (info.size) {	3140	switch (info.size) {
3817	.Slice, .C => return false,	3141	.Slice, .C => return false,
3818	.Many, .One => return !info.@"allowzero",	3142	.Many, .One => return !info.@"allowzero",
...	@@ -3828,43 +3152,24 @@ pub const Type = struct {	...	@@ -3828,43 +3152,24 @@ pub const Type = struct {
3828	/// For *[N]T, returns [N]T.	3152	/// For *[N]T, returns [N]T.
3829	/// For *T, returns T.	3153	/// For *T, returns T.
3830	/// For [*]T, returns T.	3154	/// For [*]T, returns T.
3831	pub fn childType(ty: Type) Type {	3155	pub fn childType(ty: Type, mod: *const Module) Type {
3832	return switch (ty.tag()) {	3156	return childTypeIp(ty, mod.intern_pool);
3833	.vector => ty.castTag(.vector).?.data.elem_type,	3157	}
3834	.array => ty.castTag(.array).?.data.elem_type,
3835	.array_sentinel => ty.castTag(.array_sentinel).?.data.elem_type,
3836	.optional_single_mut_pointer,
3837	.optional_single_const_pointer,
3838	.single_const_pointer,
3839	.single_mut_pointer,
3840	.many_const_pointer,
3841	.many_mut_pointer,
3842	.c_const_pointer,
3843	.c_mut_pointer,
3844	.const_slice,
3845	.mut_slice,
3846	=> ty.castPointer().?.data,
3847
3848	.array_u8,
3849	.array_u8_sentinel_0,
3850	.const_slice_u8,
3851	.const_slice_u8_sentinel_0,
3852	.manyptr_u8,
3853	.manyptr_const_u8,
3854	.manyptr_const_u8_sentinel_0,
3855	=> Type.u8,
3856
3857	.single_const_pointer_to_comptime_int => Type.comptime_int,
3858	.pointer => ty.castTag(.pointer).?.data.pointee_type,
3859		3158
3860	else => unreachable,	3159	pub fn childTypeIp(ty: Type, ip: InternPool) Type {
		3160	return switch (ty.ip_index) {
		3161	.none => switch (ty.tag()) {
		3162	.array => ty.castTag(.array).?.data.elem_type,
		3163	.array_sentinel => ty.castTag(.array_sentinel).?.data.elem_type,
		3164
		3165	.pointer => ty.castTag(.pointer).?.data.pointee_type,
		3166
		3167	else => unreachable,
		3168	},
		3169	else => ip.childType(ty.ip_index).toType(),
3861	};	3170	};
3862	}	3171	}
3863		3172
3864	/// Asserts the type is a pointer or array type.
3865	/// TODO this is deprecated in favor of `childType`.
3866	pub const elemType = childType;
3867
3868	/// For *[N]T, returns T.	3173	/// For *[N]T, returns T.
3869	/// For ?*T, returns T.	3174	/// For ?*T, returns T.
3870	/// For ?*[N]T, returns T.	3175	/// For ?*[N]T, returns T.
...	@@ -3875,54 +3180,42 @@ pub const Type = struct {	...	@@ -3875,54 +3180,42 @@ pub const Type = struct {
3875	/// For []T, returns T.	3180	/// For []T, returns T.
3876	/// For anyframe->T, returns T.	3181	/// For anyframe->T, returns T.
3877	pub fn elemType2(ty: Type, mod: *const Module) Type {	3182	pub fn elemType2(ty: Type, mod: *const Module) Type {
3878	return switch (ty.tag()) {	3183	return switch (ty.ip_index) {
3879	.vector => ty.castTag(.vector).?.data.elem_type,	3184	.none => switch (ty.tag()) {
3880	.array => ty.castTag(.array).?.data.elem_type,	3185	.array => ty.castTag(.array).?.data.elem_type,
3881	.array_sentinel => ty.castTag(.array_sentinel).?.data.elem_type,	3186	.array_sentinel => ty.castTag(.array_sentinel).?.data.elem_type,
3882	.many_const_pointer,	3187
3883	.many_mut_pointer,	3188	.pointer => {
3884	.c_const_pointer,	3189	const info = ty.castTag(.pointer).?.data;
3885	.c_mut_pointer,	3190	const child_ty = info.pointee_type;
3886	.const_slice,	3191	if (info.size == .One) {
3887	.mut_slice,	3192	return child_ty.shallowElemType(mod);
3888	=> ty.castPointer().?.data,	3193	} else {
3889		3194	return child_ty;
3890	.single_const_pointer,	3195	}
3891	.single_mut_pointer,	3196	},
3892	=> ty.castPointer().?.data.shallowElemType(mod),	3197	.optional => ty.castTag(.optional).?.data.childType(mod),
3893
3894	.array_u8,
3895	.array_u8_sentinel_0,
3896	.const_slice_u8,
3897	.const_slice_u8_sentinel_0,
3898	.manyptr_u8,
3899	.manyptr_const_u8,
3900	.manyptr_const_u8_sentinel_0,
3901	=> Type.u8,
3902
3903	.single_const_pointer_to_comptime_int => Type.comptime_int,
3904	.pointer => {
3905	const info = ty.castTag(.pointer).?.data;
3906	const child_ty = info.pointee_type;
3907	if (info.size == .One) {
3908	return child_ty.shallowElemType(mod);
3909	} else {
3910	return child_ty;
3911	}
3912	},
3913	.optional => ty.castTag(.optional).?.data.childType(),
3914	.optional_single_mut_pointer => ty.castPointer().?.data,
3915	.optional_single_const_pointer => ty.castPointer().?.data,
3916		3198
3917	.anyframe_T => ty.castTag(.anyframe_T).?.data,	3199	.anyframe_T => ty.castTag(.anyframe_T).?.data,
3918		3200
3919	else => unreachable,	3201	else => unreachable,
		3202	},
		3203	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
		3204	.ptr_type => \|ptr_type\| switch (ptr_type.size) {
		3205	.One => ptr_type.elem_type.toType().shallowElemType(mod),
		3206	.Many, .C, .Slice => ptr_type.elem_type.toType(),
		3207	},
		3208	.vector_type => \|vector_type\| vector_type.child.toType(),
		3209	.array_type => \|array_type\| array_type.child.toType(),
		3210	.opt_type => \|child\| mod.intern_pool.childType(child).toType(),
		3211	else => unreachable,
		3212	},
3920	};	3213	};
3921	}	3214	}
3922		3215
3923	fn shallowElemType(child_ty: Type, mod: *const Module) Type {	3216	fn shallowElemType(child_ty: Type, mod: *const Module) Type {
3924	return switch (child_ty.zigTypeTag(mod)) {	3217	return switch (child_ty.zigTypeTag(mod)) {
3925	.Array, .Vector => child_ty.childType(),	3218	.Array, .Vector => child_ty.childType(mod),
3926	else => child_ty,	3219	else => child_ty,
3927	};	3220	};
3928	}	3221	}
...	@@ -3930,7 +3223,7 @@ pub const Type = struct {	...	@@ -3930,7 +3223,7 @@ pub const Type = struct {
3930	/// For vectors, returns the element type. Otherwise returns self.	3223	/// For vectors, returns the element type. Otherwise returns self.
3931	pub fn scalarType(ty: Type, mod: *const Module) Type {	3224	pub fn scalarType(ty: Type, mod: *const Module) Type {
3932	return switch (ty.zigTypeTag(mod)) {	3225	return switch (ty.zigTypeTag(mod)) {
3933	.Vector => ty.childType(),	3226	.Vector => ty.childType(mod),
3934	else => ty,	3227	else => ty,
3935	};	3228	};
3936	}	3229	}
...	@@ -3938,51 +3231,25 @@ pub const Type = struct {	...	@@ -3938,51 +3231,25 @@ pub const Type = struct {
3938	/// Asserts that the type is an optional.	3231	/// Asserts that the type is an optional.
3939	/// Resulting `Type` will have inner memory referencing `buf`.	3232	/// Resulting `Type` will have inner memory referencing `buf`.
3940	/// Note that for C pointers this returns the type unmodified.	3233	/// Note that for C pointers this returns the type unmodified.
3941	pub fn optionalChild(ty: Type, buf: *Payload.ElemType) Type {	3234	pub fn optionalChild(ty: Type, mod: *const Module) Type {
3942	return switch (ty.tag()) {	3235	return switch (ty.ip_index) {
3943	.optional => ty.castTag(.optional).?.data,	3236	.none => switch (ty.tag()) {
3944	.optional_single_mut_pointer => {	3237	.optional => ty.castTag(.optional).?.data,
3945	buf.* = .{
3946	.base = .{ .tag = .single_mut_pointer },
3947	.data = ty.castPointer().?.data,
3948	};
3949	return Type.initPayload(&buf.base);
3950	},
3951	.optional_single_const_pointer => {
3952	buf.* = .{
3953	.base = .{ .tag = .single_const_pointer },
3954	.data = ty.castPointer().?.data,
3955	};
3956	return Type.initPayload(&buf.base);
3957	},
3958		3238
3959	.pointer, // here we assume it is a C pointer	3239	.pointer, // here we assume it is a C pointer
3960	.c_const_pointer,	3240	=> return ty,
3961	.c_mut_pointer,
3962	=> return ty,
3963		3241
3964	else => unreachable,	3242	else => unreachable,
3965	};
3966	}
3967
3968	/// Asserts that the type is an optional.
3969	/// Same as `optionalChild` but allocates the buffer if needed.
3970	pub fn optionalChildAlloc(ty: Type, allocator: Allocator) !Type {
3971	switch (ty.tag()) {
3972	.optional => return ty.castTag(.optional).?.data,
3973	.optional_single_mut_pointer => {
3974	return Tag.single_mut_pointer.create(allocator, ty.castPointer().?.data);
3975	},	3243	},
3976	.optional_single_const_pointer => {	3244	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
3977	return Tag.single_const_pointer.create(allocator, ty.castPointer().?.data);	3245	.opt_type => \|child\| child.toType(),
		3246	.ptr_type => \|ptr_type\| b: {
		3247	assert(ptr_type.size == .C);
		3248	break :b ty;
		3249	},
		3250	else => unreachable,
3978	},	3251	},
3979	.pointer, // here we assume it is a C pointer	3252	};
3980	.c_const_pointer,
3981	.c_mut_pointer,
3982	=> return ty,
3983
3984	else => unreachable,
3985	}
3986	}	3253	}
3987		3254
3988	/// Returns the tag type of a union, if the type is a union and it has a tag type.	3255	/// Returns the tag type of a union, if the type is a union and it has a tag type.
...	@@ -4071,19 +3338,25 @@ pub const Type = struct {	...	@@ -4071,19 +3338,25 @@ pub const Type = struct {
4071	}	3338	}
4072		3339
4073	/// Asserts that the type is an error union.	3340	/// Asserts that the type is an error union.
4074	pub fn errorUnionPayload(self: Type) Type {	3341	pub fn errorUnionPayload(ty: Type) Type {
4075	return switch (self.tag()) {	3342	return switch (ty.ip_index) {
4076	.anyerror_void_error_union => Type.void,	3343	.anyerror_void_error_union_type => Type.void,
4077	.error_union => self.castTag(.error_union).?.data.payload,	3344	.none => switch (ty.tag()) {
4078	else => unreachable,	3345	.error_union => ty.castTag(.error_union).?.data.payload,
		3346	else => unreachable,
		3347	},
		3348	else => @panic("TODO"),
4079	};	3349	};
4080	}	3350	}
4081		3351
4082	pub fn errorUnionSet(self: Type) Type {	3352	pub fn errorUnionSet(ty: Type) Type {
4083	return switch (self.tag()) {	3353	return switch (ty.ip_index) {
4084	.anyerror_void_error_union => Type.anyerror,	3354	.anyerror_void_error_union_type => Type.anyerror,
4085	.error_union => self.castTag(.error_union).?.data.error_set,	3355	.none => switch (ty.tag()) {
4086	else => unreachable,	3356	.error_union => ty.castTag(.error_union).?.data.error_set,
		3357	else => unreachable,
		3358	},
		3359	else => @panic("TODO"),
4087	};	3360	};
4088	}	3361	}
4089		3362
...	@@ -4168,67 +3441,73 @@ pub const Type = struct {	...	@@ -4168,67 +3441,73 @@ pub const Type = struct {
4168	}	3441	}
4169		3442
4170	/// Asserts the type is an array or vector or struct.	3443	/// Asserts the type is an array or vector or struct.
4171	pub fn arrayLen(ty: Type) u64 {	3444	pub fn arrayLen(ty: Type, mod: *const Module) u64 {
4172	return switch (ty.tag()) {	3445	return arrayLenIp(ty, mod.intern_pool);
4173	.vector => ty.castTag(.vector).?.data.len,	3446	}
4174	.array => ty.castTag(.array).?.data.len,
4175	.array_sentinel => ty.castTag(.array_sentinel).?.data.len,
4176	.array_u8 => ty.castTag(.array_u8).?.data,
4177	.array_u8_sentinel_0 => ty.castTag(.array_u8_sentinel_0).?.data,
4178	.tuple => ty.castTag(.tuple).?.data.types.len,
4179	.anon_struct => ty.castTag(.anon_struct).?.data.types.len,
4180	.@"struct" => ty.castTag(.@"struct").?.data.fields.count(),
4181	.empty_struct, .empty_struct_literal => 0,
4182		3447
4183	else => unreachable,	3448	pub fn arrayLenIp(ty: Type, ip: InternPool) u64 {
		3449	return switch (ty.ip_index) {
		3450	.none => switch (ty.tag()) {
		3451	.array => ty.castTag(.array).?.data.len,
		3452	.array_sentinel => ty.castTag(.array_sentinel).?.data.len,
		3453	.tuple => ty.castTag(.tuple).?.data.types.len,
		3454	.anon_struct => ty.castTag(.anon_struct).?.data.types.len,
		3455	.@"struct" => ty.castTag(.@"struct").?.data.fields.count(),
		3456	.empty_struct, .empty_struct_literal => 0,
		3457
		3458	else => unreachable,
		3459	},
		3460	else => switch (ip.indexToKey(ty.ip_index)) {
		3461	.vector_type => \|vector_type\| vector_type.len,
		3462	.array_type => \|array_type\| array_type.len,
		3463	else => unreachable,
		3464	},
4184	};	3465	};
4185	}	3466	}
4186		3467
4187	pub fn arrayLenIncludingSentinel(ty: Type) u64 {	3468	pub fn arrayLenIncludingSentinel(ty: Type, mod: *const Module) u64 {
4188	return ty.arrayLen() + @boolToInt(ty.sentinel() != null);	3469	return ty.arrayLen(mod) + @boolToInt(ty.sentinel(mod) != null);
4189	}	3470	}
4190		3471
4191	pub fn vectorLen(ty: Type) u32 {	3472	pub fn vectorLen(ty: Type, mod: *const Module) u32 {
4192	return switch (ty.tag()) {	3473	return switch (ty.ip_index) {
4193	.vector => @intCast(u32, ty.castTag(.vector).?.data.len),	3474	.none => switch (ty.tag()) {
4194	.tuple => @intCast(u32, ty.castTag(.tuple).?.data.types.len),	3475	.tuple => @intCast(u32, ty.castTag(.tuple).?.data.types.len),
4195	.anon_struct => @intCast(u32, ty.castTag(.anon_struct).?.data.types.len),	3476	.anon_struct => @intCast(u32, ty.castTag(.anon_struct).?.data.types.len),
4196	else => unreachable,	3477	else => unreachable,
		3478	},
		3479	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
		3480	.vector_type => \|vector_type\| vector_type.len,
		3481	else => unreachable,
		3482	},
4197	};	3483	};
4198	}	3484	}
4199		3485
4200	/// Asserts the type is an array, pointer or vector.	3486	/// Asserts the type is an array, pointer or vector.
4201	pub fn sentinel(self: Type) ?Value {	3487	pub fn sentinel(ty: Type, mod: *const Module) ?Value {
4202	return switch (self.tag()) {	3488	return switch (ty.ip_index) {
4203	.single_const_pointer,	3489	.none => switch (ty.tag()) {
4204	.single_mut_pointer,	3490	.array,
4205	.many_const_pointer,	3491	.tuple,
4206	.many_mut_pointer,	3492	.empty_struct_literal,
4207	.c_const_pointer,	3493	.@"struct",
4208	.c_mut_pointer,	3494	=> null,
4209	.single_const_pointer_to_comptime_int,
4210	.vector,
4211	.array,
4212	.array_u8,
4213	.manyptr_u8,
4214	.manyptr_const_u8,
4215	.const_slice_u8,
4216	.const_slice,
4217	.mut_slice,
4218	.tuple,
4219	.empty_struct_literal,
4220	.@"struct",
4221	=> return null,
4222		3495
4223	.pointer => return self.castTag(.pointer).?.data.sentinel,	3496	.pointer => ty.castTag(.pointer).?.data.sentinel,
4224	.array_sentinel => return self.castTag(.array_sentinel).?.data.sentinel,	3497	.array_sentinel => ty.castTag(.array_sentinel).?.data.sentinel,
4225		3498
4226	.array_u8_sentinel_0,	3499	else => unreachable,
4227	.const_slice_u8_sentinel_0,	3500	},
4228	.manyptr_const_u8_sentinel_0,	3501	else => switch (mod.intern_pool.indexToKey(ty.ip_index)) {
4229	=> return Value.zero,	3502	.vector_type,
		3503	.struct_type,
		3504	=> null,
4230		3505
4231	else => unreachable,	3506	.array_type => \|t\| if (t.sentinel != .none) t.sentinel.toValue() else null,
		3507	.ptr_type => \|t\| if (t.sentinel != .none) t.sentinel.toValue() else null,
		3508
		3509	else => unreachable,
		3510	},
4232	};	3511	};
4233	}	3512	}
4234		3513
...	@@ -4292,8 +3571,6 @@ pub const Type = struct {	...	@@ -4292,8 +3571,6 @@ pub const Type = struct {
4292	return .{ .signedness = .unsigned, .bits = 16 };	3571	return .{ .signedness = .unsigned, .bits = 16 };
4293	},	3572	},
4294		3573
4295	.vector => ty = ty.castTag(.vector).?.data.elem_type,
4296
4297	.@"struct" => {	3574	.@"struct" => {
4298	const struct_obj = ty.castTag(.@"struct").?.data;	3575	const struct_obj = ty.castTag(.@"struct").?.data;
4299	assert(struct_obj.layout == .Packed);	3576	assert(struct_obj.layout == .Packed);
...	@@ -4321,8 +3598,9 @@ pub const Type = struct {	...	@@ -4321,8 +3598,9 @@ pub const Type = struct {
4321	.int_type => \|int_type\| return int_type,	3598	.int_type => \|int_type\| return int_type,
4322	.ptr_type => unreachable,	3599	.ptr_type => unreachable,
4323	.array_type => unreachable,	3600	.array_type => unreachable,
4324	.vector_type => @panic("TODO"),	3601	.vector_type => \|vector_type\| ty = vector_type.child.toType(),
4325	.optional_type => unreachable,	3602
		3603	.opt_type => unreachable,
4326	.error_union_type => unreachable,	3604	.error_union_type => unreachable,
4327	.simple_type => unreachable, // handled via Index enum tag above	3605	.simple_type => unreachable, // handled via Index enum tag above
4328	.struct_type => @panic("TODO"),	3606	.struct_type => @panic("TODO"),
...	@@ -4426,7 +3704,11 @@ pub const Type = struct {	...	@@ -4426,7 +3704,11 @@ pub const Type = struct {
4426		3704
4427	/// Asserts the type is a function or a function pointer.	3705	/// Asserts the type is a function or a function pointer.
4428	pub fn fnReturnType(ty: Type) Type {	3706	pub fn fnReturnType(ty: Type) Type {
4429	const fn_ty = if (ty.castPointer()) \|p\| p.data else ty;	3707	const fn_ty = switch (ty.tag()) {
		3708	.pointer => ty.castTag(.pointer).?.data.pointee_type,
		3709	.function => ty,
		3710	else => unreachable,
		3711	};
4430	return fn_ty.castTag(.function).?.data.return_type;	3712	return fn_ty.castTag(.function).?.data.return_type;
4431	}	3713	}
4432		3714
...	@@ -4516,8 +3798,12 @@ pub const Type = struct {	...	@@ -4516,8 +3798,12 @@ pub const Type = struct {
4516	},	3798	},
4517	.ptr_type => @panic("TODO"),	3799	.ptr_type => @panic("TODO"),
4518	.array_type => @panic("TODO"),	3800	.array_type => @panic("TODO"),
4519	.vector_type => @panic("TODO"),	3801	.vector_type => \|vector_type\| {
4520	.optional_type => @panic("TODO"),	3802	if (vector_type.len == 0) return Value.initTag(.empty_array);
		3803	if (vector_type.child.toType().onePossibleValue(mod)) \|v\| return v;
		3804	return null;
		3805	},
		3806	.opt_type => @panic("TODO"),
4521	.error_union_type => @panic("TODO"),	3807	.error_union_type => @panic("TODO"),
4522	.simple_type => \|t\| switch (t) {	3808	.simple_type => \|t\| switch (t) {
4523	.f16,	3809	.f16,
...	@@ -4580,34 +3866,15 @@ pub const Type = struct {	...	@@ -4580,34 +3866,15 @@ pub const Type = struct {
4580	.error_set,	3866	.error_set,
4581	.error_set_merged,	3867	.error_set_merged,
4582	.function,	3868	.function,
4583	.single_const_pointer_to_comptime_int,
4584	.array_sentinel,	3869	.array_sentinel,
4585	.array_u8_sentinel_0,
4586	.const_slice_u8,
4587	.const_slice_u8_sentinel_0,
4588	.const_slice,
4589	.mut_slice,
4590	.optional_single_mut_pointer,
4591	.optional_single_const_pointer,
4592	.anyerror_void_error_union,
4593	.error_set_inferred,	3870	.error_set_inferred,
4594	.@"opaque",	3871	.@"opaque",
4595	.manyptr_u8,
4596	.manyptr_const_u8,
4597	.manyptr_const_u8_sentinel_0,
4598	.anyframe_T,	3872	.anyframe_T,
4599	.many_const_pointer,
4600	.many_mut_pointer,
4601	.c_const_pointer,
4602	.c_mut_pointer,
4603	.single_const_pointer,
4604	.single_mut_pointer,
4605	.pointer,	3873	.pointer,
4606	=> return null,	3874	=> return null,
4607		3875
4608	.optional => {	3876	.optional => {
4609	var buf: Payload.ElemType = undefined;	3877	const child_ty = ty.optionalChild(mod);
4610	const child_ty = ty.optionalChild(&buf);
4611	if (child_ty.isNoReturn()) {	3878	if (child_ty.isNoReturn()) {
4612	return Value.null;	3879	return Value.null;
4613	} else {	3880	} else {
...	@@ -4690,10 +3957,10 @@ pub const Type = struct {	...	@@ -4690,10 +3957,10 @@ pub const Type = struct {
4690		3957
4691	.empty_struct, .empty_struct_literal => return Value.initTag(.empty_struct_value),	3958	.empty_struct, .empty_struct_literal => return Value.initTag(.empty_struct_value),
4692		3959
4693	.vector, .array, .array_u8 => {	3960	.array => {
4694	if (ty.arrayLen() == 0)	3961	if (ty.arrayLen(mod) == 0)
4695	return Value.initTag(.empty_array);	3962	return Value.initTag(.empty_array);
4696	if (ty.elemType().onePossibleValue(mod) != null)	3963	if (ty.childType(mod).onePossibleValue(mod) != null)
4697	return Value.initTag(.the_only_possible_value);	3964	return Value.initTag(.the_only_possible_value);
4698	return null;	3965	return null;
4699	},	3966	},
...	@@ -4711,9 +3978,9 @@ pub const Type = struct {	...	@@ -4711,9 +3978,9 @@ pub const Type = struct {
4711	if (ty.ip_index != .none) return switch (mod.intern_pool.indexToKey(ty.ip_index)) {	3978	if (ty.ip_index != .none) return switch (mod.intern_pool.indexToKey(ty.ip_index)) {
4712	.int_type => false,	3979	.int_type => false,
4713	.ptr_type => @panic("TODO"),	3980	.ptr_type => @panic("TODO"),
4714	.array_type => @panic("TODO"),	3981	.array_type => \|array_type\| return array_type.child.toType().comptimeOnly(mod),
4715	.vector_type => @panic("TODO"),	3982	.vector_type => \|vector_type\| return vector_type.child.toType().comptimeOnly(mod),
4716	.optional_type => @panic("TODO"),	3983	.opt_type => @panic("TODO"),
4717	.error_union_type => @panic("TODO"),	3984	.error_union_type => @panic("TODO"),
4718	.simple_type => \|t\| switch (t) {	3985	.simple_type => \|t\| switch (t) {
4719	.f16,	3986	.f16,
...	@@ -4772,12 +4039,6 @@ pub const Type = struct {	...	@@ -4772,12 +4039,6 @@ pub const Type = struct {
4772	};	4039	};
4773		4040
4774	return switch (ty.tag()) {	4041	return switch (ty.tag()) {
4775	.manyptr_u8,
4776	.manyptr_const_u8,
4777	.manyptr_const_u8_sentinel_0,
4778	.const_slice_u8,
4779	.const_slice_u8_sentinel_0,
4780	.anyerror_void_error_union,
4781	.empty_struct_literal,	4042	.empty_struct_literal,
4782	.empty_struct,	4043	.empty_struct,
4783	.error_set,	4044	.error_set,
...	@@ -4785,35 +4046,21 @@ pub const Type = struct {	...	@@ -4785,35 +4046,21 @@ pub const Type = struct {
4785	.error_set_inferred,	4046	.error_set_inferred,
4786	.error_set_merged,	4047	.error_set_merged,
4787	.@"opaque",	4048	.@"opaque",
4788	.array_u8,
4789	.array_u8_sentinel_0,
4790	.enum_simple,	4049	.enum_simple,
4791	=> false,	4050	=> false,
4792		4051
4793	.single_const_pointer_to_comptime_int,
4794	// These are function bodies, not function pointers.	4052	// These are function bodies, not function pointers.
4795	.function,	4053	.function => true,
4796	=> true,
4797		4054
4798	.inferred_alloc_mut => unreachable,	4055	.inferred_alloc_mut => unreachable,
4799	.inferred_alloc_const => unreachable,	4056	.inferred_alloc_const => unreachable,
4800		4057
4801	.array,	4058	.array,
4802	.array_sentinel,	4059	.array_sentinel,
4803	.vector,	4060	=> return ty.childType(mod).comptimeOnly(mod),
4804	=> return ty.childType().comptimeOnly(mod),
4805		4061
4806	.pointer,	4062	.pointer => {
4807	.single_const_pointer,	4063	const child_ty = ty.childType(mod);
4808	.single_mut_pointer,
4809	.many_const_pointer,
4810	.many_mut_pointer,
4811	.c_const_pointer,
4812	.c_mut_pointer,
4813	.const_slice,
4814	.mut_slice,
4815	=> {
4816	const child_ty = ty.childType();
4817	if (child_ty.zigTypeTag(mod) == .Fn) {	4064	if (child_ty.zigTypeTag(mod) == .Fn) {
4818	return false;	4065	return false;
4819	} else {	4066	} else {
...	@@ -4821,12 +4068,8 @@ pub const Type = struct {	...	@@ -4821,12 +4068,8 @@ pub const Type = struct {
4821	}	4068	}
4822	},	4069	},
4823		4070
4824	.optional,	4071	.optional => {
4825	.optional_single_mut_pointer,	4072	return ty.optionalChild(mod).comptimeOnly(mod);
4826	.optional_single_const_pointer,
4827	=> {
4828	var buf: Type.Payload.ElemType = undefined;
4829	return ty.optionalChild(&buf).comptimeOnly(mod);
4830	},	4073	},
4831		4074
4832	.tuple, .anon_struct => {	4075	.tuple, .anon_struct => {
...	@@ -4882,6 +4125,10 @@ pub const Type = struct {	...	@@ -4882,6 +4125,10 @@ pub const Type = struct {
4882	};	4125	};
4883	}	4126	}
4884		4127
		4128	pub fn isVector(ty: Type, mod: *const Module) bool {
		4129	return ty.zigTypeTag(mod) == .Vector;
		4130	}
		4131
4885	pub fn isArrayOrVector(ty: Type, mod: *const Module) bool {	4132	pub fn isArrayOrVector(ty: Type, mod: *const Module) bool {
4886	return switch (ty.zigTypeTag(mod)) {	4133	return switch (ty.zigTypeTag(mod)) {
4887	.Array, .Vector => true,	4134	.Array, .Vector => true,
...	@@ -4892,9 +4139,9 @@ pub const Type = struct {	...	@@ -4892,9 +4139,9 @@ pub const Type = struct {
4892	pub fn isIndexable(ty: Type, mod: *const Module) bool {	4139	pub fn isIndexable(ty: Type, mod: *const Module) bool {
4893	return switch (ty.zigTypeTag(mod)) {	4140	return switch (ty.zigTypeTag(mod)) {
4894	.Array, .Vector => true,	4141	.Array, .Vector => true,
4895	.Pointer => switch (ty.ptrSize()) {	4142	.Pointer => switch (ty.ptrSize(mod)) {
4896	.Slice, .Many, .C => true,	4143	.Slice, .Many, .C => true,
4897	.One => ty.elemType().zigTypeTag(mod) == .Array,	4144	.One => ty.childType(mod).zigTypeTag(mod) == .Array,
4898	},	4145	},
4899	.Struct => ty.isTuple(),	4146	.Struct => ty.isTuple(),
4900	else => false,	4147	else => false,
...	@@ -4904,10 +4151,10 @@ pub const Type = struct {	...	@@ -4904,10 +4151,10 @@ pub const Type = struct {
4904	pub fn indexableHasLen(ty: Type, mod: *const Module) bool {	4151	pub fn indexableHasLen(ty: Type, mod: *const Module) bool {
4905	return switch (ty.zigTypeTag(mod)) {	4152	return switch (ty.zigTypeTag(mod)) {
4906	.Array, .Vector => true,	4153	.Array, .Vector => true,
4907	.Pointer => switch (ty.ptrSize()) {	4154	.Pointer => switch (ty.ptrSize(mod)) {
4908	.Many, .C => false,	4155	.Many, .C => false,
4909	.Slice => true,	4156	.Slice => true,
4910	.One => ty.elemType().zigTypeTag(mod) == .Array,	4157	.One => ty.childType(mod).zigTypeTag(mod) == .Array,
4911	},	4158	},
4912	.Struct => ty.isTuple(),	4159	.Struct => ty.isTuple(),
4913	else => false,	4160	else => false,
...	@@ -5527,14 +4774,6 @@ pub const Type = struct {	...	@@ -5527,14 +4774,6 @@ pub const Type = struct {
5527	/// with different enum tags, because the the former requires more payload data than the latter.	4774	/// with different enum tags, because the the former requires more payload data than the latter.
5528	/// See `zigTypeTag` for the function that corresponds to `std.builtin.TypeId`.	4775	/// See `zigTypeTag` for the function that corresponds to `std.builtin.TypeId`.
5529	pub const Tag = enum(usize) {	4776	pub const Tag = enum(usize) {
5530	// The first section of this enum are tags that require no payload.
5531	manyptr_u8,
5532	manyptr_const_u8,
5533	manyptr_const_u8_sentinel_0,
5534	single_const_pointer_to_comptime_int,
5535	const_slice_u8,
5536	const_slice_u8_sentinel_0,
5537	anyerror_void_error_union,
5538	/// Same as `empty_struct` except it has an empty namespace.	4777	/// Same as `empty_struct` except it has an empty namespace.
5539	empty_struct_literal,	4778	empty_struct_literal,
5540	/// This is a special value that tracks a set of types that have been stored	4779	/// This is a special value that tracks a set of types that have been stored
...	@@ -5545,28 +4784,15 @@ pub const Type = struct {	...	@@ -5545,28 +4784,15 @@ pub const Type = struct {
5545	inferred_alloc_const, // See last_no_payload_tag below.	4784	inferred_alloc_const, // See last_no_payload_tag below.
5546	// After this, the tag requires a payload.	4785	// After this, the tag requires a payload.
5547		4786
5548	array_u8,
5549	array_u8_sentinel_0,
5550	array,	4787	array,
5551	array_sentinel,	4788	array_sentinel,
5552	vector,
5553	/// Possible Value tags for this: @"struct"	4789	/// Possible Value tags for this: @"struct"
5554	tuple,	4790	tuple,
5555	/// Possible Value tags for this: @"struct"	4791	/// Possible Value tags for this: @"struct"
5556	anon_struct,	4792	anon_struct,
5557	pointer,	4793	pointer,
5558	single_const_pointer,
5559	single_mut_pointer,
5560	many_const_pointer,
5561	many_mut_pointer,
5562	c_const_pointer,
5563	c_mut_pointer,
5564	const_slice,
5565	mut_slice,
5566	function,	4794	function,
5567	optional,	4795	optional,
5568	optional_single_mut_pointer,
5569	optional_single_const_pointer,
5570	error_union,	4796	error_union,
5571	anyframe_T,	4797	anyframe_T,
5572	error_set,	4798	error_set,
...	@@ -5590,33 +4816,12 @@ pub const Type = struct {	...	@@ -5590,33 +4816,12 @@ pub const Type = struct {
5590		4816
5591	pub fn Type(comptime t: Tag) type {	4817	pub fn Type(comptime t: Tag) type {
5592	return switch (t) {	4818	return switch (t) {
5593	.single_const_pointer_to_comptime_int,
5594	.anyerror_void_error_union,
5595	.const_slice_u8,
5596	.const_slice_u8_sentinel_0,
5597	.inferred_alloc_const,	4819	.inferred_alloc_const,
5598	.inferred_alloc_mut,	4820	.inferred_alloc_mut,
5599	.empty_struct_literal,	4821	.empty_struct_literal,
5600	.manyptr_u8,
5601	.manyptr_const_u8,
5602	.manyptr_const_u8_sentinel_0,
5603	=> @compileError("Type Tag " ++ @tagName(t) ++ " has no payload"),	4822	=> @compileError("Type Tag " ++ @tagName(t) ++ " has no payload"),
5604		4823
5605	.array_u8,
5606	.array_u8_sentinel_0,
5607	=> Payload.Len,
5608
5609	.single_const_pointer,
5610	.single_mut_pointer,
5611	.many_const_pointer,
5612	.many_mut_pointer,
5613	.c_const_pointer,
5614	.c_mut_pointer,
5615	.const_slice,
5616	.mut_slice,
5617	.optional,	4824	.optional,
5618	.optional_single_mut_pointer,
5619	.optional_single_const_pointer,
5620	.anyframe_T,	4825	.anyframe_T,
5621	=> Payload.ElemType,	4826	=> Payload.ElemType,
5622		4827
...	@@ -5624,7 +4829,7 @@ pub const Type = struct {	...	@@ -5624,7 +4829,7 @@ pub const Type = struct {
5624	.error_set_inferred => Payload.ErrorSetInferred,	4829	.error_set_inferred => Payload.ErrorSetInferred,
5625	.error_set_merged => Payload.ErrorSetMerged,	4830	.error_set_merged => Payload.ErrorSetMerged,
5626		4831
5627	.array, .vector => Payload.Array,	4832	.array => Payload.Array,
5628	.array_sentinel => Payload.ArraySentinel,	4833	.array_sentinel => Payload.ArraySentinel,
5629	.pointer => Payload.Pointer,	4834	.pointer => Payload.Pointer,
5630	.function => Payload.Function,	4835	.function => Payload.Function,
...	@@ -5847,15 +5052,28 @@ pub const Type = struct {	...	@@ -5847,15 +5052,28 @@ pub const Type = struct {
5847	@"volatile": bool = false,	5052	@"volatile": bool = false,
5848	size: std.builtin.Type.Pointer.Size = .One,	5053	size: std.builtin.Type.Pointer.Size = .One,
5849		5054
5850	pub const VectorIndex = enum(u32) {	5055	pub const VectorIndex = InternPool.Key.PtrType.VectorIndex;
5851	none = std.math.maxInt(u32),	5056
5852	runtime = std.math.maxInt(u32) - 1,
5853	_,
5854	};
5855	pub fn alignment(data: Data, mod: *const Module) u32 {	5057	pub fn alignment(data: Data, mod: *const Module) u32 {
5856	if (data.@"align" != 0) return data.@"align";	5058	if (data.@"align" != 0) return data.@"align";
5857	return abiAlignment(data.pointee_type, mod);	5059	return abiAlignment(data.pointee_type, mod);
5858	}	5060	}
		5061
		5062	pub fn fromKey(p: InternPool.Key.PtrType) Data {
		5063	return .{
		5064	.pointee_type = p.elem_type.toType(),
		5065	.sentinel = if (p.sentinel != .none) p.sentinel.toValue() else null,
		5066	.@"align" = p.alignment,
		5067	.@"addrspace" = p.address_space,
		5068	.bit_offset = p.bit_offset,
		5069	.host_size = p.host_size,
		5070	.vector_index = p.vector_index,
		5071	.@"allowzero" = p.is_allowzero,
		5072	.mutable = !p.is_const,
		5073	.@"volatile" = p.is_volatile,
		5074	.size = p.size,
		5075	};
		5076	}
5859	};	5077	};
5860	};	5078	};
5861		5079
...	@@ -5986,6 +5204,17 @@ pub const Type = struct {	...	@@ -5986,6 +5204,17 @@ pub const Type = struct {
5986	pub const @"c_ulonglong": Type = .{ .ip_index = .c_ulonglong_type, .legacy = undefined };	5204	pub const @"c_ulonglong": Type = .{ .ip_index = .c_ulonglong_type, .legacy = undefined };
5987	pub const @"c_longdouble": Type = .{ .ip_index = .c_longdouble_type, .legacy = undefined };	5205	pub const @"c_longdouble": Type = .{ .ip_index = .c_longdouble_type, .legacy = undefined };
5988		5206
		5207	pub const const_slice_u8: Type = .{ .ip_index = .const_slice_u8_type, .legacy = undefined };
		5208	pub const manyptr_u8: Type = .{ .ip_index = .manyptr_u8_type, .legacy = undefined };
		5209	pub const single_const_pointer_to_comptime_int: Type = .{
		5210	.ip_index = .single_const_pointer_to_comptime_int_type,
		5211	.legacy = undefined,
		5212	};
		5213	pub const const_slice_u8_sentinel_0: Type = .{
		5214	.ip_index = .const_slice_u8_sentinel_0_type,
		5215	.legacy = undefined,
		5216	};
		5217
5989	pub const generic_poison: Type = .{ .ip_index = .generic_poison_type, .legacy = undefined };	5218	pub const generic_poison: Type = .{ .ip_index = .generic_poison_type, .legacy = undefined };
5990		5219
5991	pub const err_int = Type.u16;	5220	pub const err_int = Type.u16;
...	@@ -6019,50 +5248,6 @@ pub const Type = struct {	...	@@ -6019,50 +5248,6 @@ pub const Type = struct {
6019	}	5248	}
6020	}	5249	}
6021		5250
6022	if (d.@"align" == 0 and d.@"addrspace" == .generic and
6023	d.bit_offset == 0 and d.host_size == 0 and d.vector_index == .none and
6024	!d.@"allowzero" and !d.@"volatile")
6025	{
6026	if (d.sentinel) \|sent\| {
6027	if (!d.mutable and d.pointee_type.eql(Type.u8, mod)) {
6028	switch (d.size) {
6029	.Slice => {
6030	if (sent.compareAllWithZero(.eq, mod)) {
6031	return Type.initTag(.const_slice_u8_sentinel_0);
6032	}
6033	},
6034	.Many => {
6035	if (sent.compareAllWithZero(.eq, mod)) {
6036	return Type.initTag(.manyptr_const_u8_sentinel_0);
6037	}
6038	},
6039	else => {},
6040	}
6041	}
6042	} else if (!d.mutable and d.pointee_type.eql(Type.u8, mod)) {
6043	switch (d.size) {
6044	.Slice => return Type.initTag(.const_slice_u8),
6045	.Many => return Type.initTag(.manyptr_const_u8),
6046	else => {},
6047	}
6048	} else {
6049	const T = Type.Tag;
6050	const type_payload = try arena.create(Type.Payload.ElemType);
6051	type_payload.* = .{
6052	.base = .{
6053	.tag = switch (d.size) {
6054	.One => if (d.mutable) T.single_mut_pointer else T.single_const_pointer,
6055	.Many => if (d.mutable) T.many_mut_pointer else T.many_const_pointer,
6056	.C => if (d.mutable) T.c_mut_pointer else T.c_const_pointer,
6057	.Slice => if (d.mutable) T.mut_slice else T.const_slice,
6058	},
6059	},
6060	.data = d.pointee_type,
6061	};
6062	return Type.initPayload(&type_payload.base);
6063	}
6064	}
6065
6066	return Type.Tag.pointer.create(arena, d);	5251	return Type.Tag.pointer.create(arena, d);
6067	}	5252	}
6068		5253
...	@@ -6073,13 +5258,21 @@ pub const Type = struct {	...	@@ -6073,13 +5258,21 @@ pub const Type = struct {
6073	elem_type: Type,	5258	elem_type: Type,
6074	mod: *Module,	5259	mod: *Module,
6075	) Allocator.Error!Type {	5260	) Allocator.Error!Type {
6076	if (elem_type.eql(Type.u8, mod)) {	5261	if (elem_type.ip_index != .none) {
6077	if (sent) \|some\| {	5262	if (sent) \|s\| {
6078	if (some.eql(Value.zero, elem_type, mod)) {	5263	if (s.ip_index != .none) {
6079	return Tag.array_u8_sentinel_0.create(arena, len);	5264	return mod.arrayType(.{
		5265	.len = len,
		5266	.child = elem_type.ip_index,
		5267	.sentinel = s.ip_index,
		5268	});
6080	}	5269	}
6081	} else {	5270	} else {
6082	return Tag.array_u8.create(arena, len);	5271	return mod.arrayType(.{
		5272	.len = len,
		5273	.child = elem_type.ip_index,
		5274	.sentinel = .none,
		5275	});
6083	}	5276	}
6084	}	5277	}
6085		5278
...	@@ -6097,24 +5290,11 @@ pub const Type = struct {	...	@@ -6097,24 +5290,11 @@ pub const Type = struct {
6097	});	5290	});
6098	}	5291	}
6099		5292
6100	pub fn vector(arena: Allocator, len: u64, elem_type: Type) Allocator.Error!Type {	5293	pub fn optional(arena: Allocator, child_type: Type, mod: *Module) Allocator.Error!Type {
6101	return Tag.vector.create(arena, .{	5294	if (child_type.ip_index != .none) {
6102	.len = len,	5295	return mod.optionalType(child_type.ip_index);
6103	.elem_type = elem_type,	5296	} else {
6104	});	5297	return Type.Tag.optional.create(arena, child_type);
6105	}
6106
6107	pub fn optional(arena: Allocator, child_type: Type) Allocator.Error!Type {
6108	switch (child_type.tag()) {
6109	.single_const_pointer => return Type.Tag.optional_single_const_pointer.create(
6110	arena,
6111	child_type.elemType(),
6112	),
6113	.single_mut_pointer => return Type.Tag.optional_single_mut_pointer.create(
6114	arena,
6115	child_type.elemType(),
6116	),
6117	else => return Type.Tag.optional.create(arena, child_type),
6118	}	5298	}
6119	}	5299	}
6120		5300
...	@@ -6125,12 +5305,6 @@ pub const Type = struct {	...	@@ -6125,12 +5305,6 @@ pub const Type = struct {
6125	mod: *Module,	5305	mod: *Module,
6126	) Allocator.Error!Type {	5306	) Allocator.Error!Type {
6127	assert(error_set.zigTypeTag(mod) == .ErrorSet);	5307	assert(error_set.zigTypeTag(mod) == .ErrorSet);
6128	if (error_set.eql(Type.anyerror, mod) and
6129	payload.eql(Type.void, mod))
6130	{
6131	return Type.initTag(.anyerror_void_error_union);
6132	}
6133
6134	return Type.Tag.error_union.create(arena, .{	5308	return Type.Tag.error_union.create(arena, .{
6135	.error_set = error_set,	5309	.error_set = error_set,
6136	.payload = payload,	5310	.payload = payload,

src/value.zig+80-128

...	@@ -225,6 +225,7 @@ pub fn categorizeOperand(	...	@@ -225,6 +225,7 @@ pub fn categorizeOperand(
225	air: Air,	225	air: Air,
226	inst: Air.Inst.Index,	226	inst: Air.Inst.Index,
227	operand: Air.Inst.Index,	227	operand: Air.Inst.Index,
		228	ip: InternPool,
228	) OperandCategory {	229	) OperandCategory {
229	const air_tags = air.instructions.items(.tag);	230	const air_tags = air.instructions.items(.tag);
230	const air_datas = air.instructions.items(.data);	231	const air_datas = air.instructions.items(.data);
...	@@ -534,7 +535,7 @@ pub fn categorizeOperand(	...	@@ -534,7 +535,7 @@ pub fn categorizeOperand(
534	.aggregate_init => {	535	.aggregate_init => {
535	const ty_pl = air_datas[inst].ty_pl;	536	const ty_pl = air_datas[inst].ty_pl;
536	const aggregate_ty = air.getRefType(ty_pl.ty);	537	const aggregate_ty = air.getRefType(ty_pl.ty);
537	const len = @intCast(usize, aggregate_ty.arrayLen());	538	const len = @intCast(usize, aggregate_ty.arrayLenIp(ip));
538	const elements = @ptrCast([]const Air.Inst.Ref, air.extra[ty_pl.payload..][0..len]);	539	const elements = @ptrCast([]const Air.Inst.Ref, air.extra[ty_pl.payload..][0..len]);
539		540
540	if (elements.len <= bpi - 1) {	541	if (elements.len <= bpi - 1) {
...	@@ -625,7 +626,7 @@ pub fn categorizeOperand(	...	@@ -625,7 +626,7 @@ pub fn categorizeOperand(
625		626
626	var operand_live: bool = true;	627	var operand_live: bool = true;
627	for (air.extra[cond_extra.end..][0..2]) \|cond_inst\| {	628	for (air.extra[cond_extra.end..][0..2]) \|cond_inst\| {
628	if (l.categorizeOperand(air, cond_inst, operand) == .tomb)	629	if (l.categorizeOperand(air, cond_inst, operand, ip) == .tomb)
629	operand_live = false;	630	operand_live = false;
630		631
631	switch (air_tags[cond_inst]) {	632	switch (air_tags[cond_inst]) {
...	@@ -872,6 +873,7 @@ fn analyzeInst(	...	@@ -872,6 +873,7 @@ fn analyzeInst(
872	data: *LivenessPassData(pass),	873	data: *LivenessPassData(pass),
873	inst: Air.Inst.Index,	874	inst: Air.Inst.Index,
874	) Allocator.Error!void {	875	) Allocator.Error!void {
		876	const ip = a.intern_pool;
875	const inst_tags = a.air.instructions.items(.tag);	877	const inst_tags = a.air.instructions.items(.tag);
876	const inst_datas = a.air.instructions.items(.data);	878	const inst_datas = a.air.instructions.items(.data);
877		879
...	@@ -1140,7 +1142,7 @@ fn analyzeInst(	...	@@ -1140,7 +1142,7 @@ fn analyzeInst(
1140	.aggregate_init => {	1142	.aggregate_init => {
1141	const ty_pl = inst_datas[inst].ty_pl;	1143	const ty_pl = inst_datas[inst].ty_pl;
1142	const aggregate_ty = a.air.getRefType(ty_pl.ty);	1144	const aggregate_ty = a.air.getRefType(ty_pl.ty);
1143	const len = @intCast(usize, aggregate_ty.arrayLen());	1145	const len = @intCast(usize, aggregate_ty.arrayLenIp(ip.*));
1144	const elements = @ptrCast([]const Air.Inst.Ref, a.air.extra[ty_pl.payload..][0..len]);	1146	const elements = @ptrCast([]const Air.Inst.Ref, a.air.extra[ty_pl.payload..][0..len]);
1145		1147
1146	if (elements.len <= bpi - 1) {	1148	if (elements.len <= bpi - 1) {

...	@@ -807,7 +807,7 @@ fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: u32) !u	...	@@ -807,7 +807,7 @@ fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: u32) !u
807	/// Use a pointer instruction as the basis for allocating stack memory.	807	/// Use a pointer instruction as the basis for allocating stack memory.
808	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {	808	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
809	const mod = self.bin_file.options.module.?;	809	const mod = self.bin_file.options.module.?;
810	const elem_ty = self.typeOfIndex(inst).elemType();	810	const elem_ty = self.typeOfIndex(inst).childType(mod);
811	const abi_size = math.cast(u32, elem_ty.abiSize(mod)) orelse {	811	const abi_size = math.cast(u32, elem_ty.abiSize(mod)) orelse {
812	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(mod)});	812	return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(mod)});
813	};	813	};
...	@@ -1099,9 +1099,9 @@ fn binOp(	...	@@ -1099,9 +1099,9 @@ fn binOp(
1099	switch (lhs_ty.zigTypeTag(mod)) {	1099	switch (lhs_ty.zigTypeTag(mod)) {
1100	.Pointer => {	1100	.Pointer => {
1101	const ptr_ty = lhs_ty;	1101	const ptr_ty = lhs_ty;
1102	const elem_ty = switch (ptr_ty.ptrSize()) {	1102	const elem_ty = switch (ptr_ty.ptrSize(mod)) {
1103	.One => ptr_ty.childType().childType(), // ptr to array, so get array element type	1103	.One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
1104	else => ptr_ty.childType(),	1104	else => ptr_ty.childType(mod),
1105	};	1105	};
1106	const elem_size = elem_ty.abiSize(mod);	1106	const elem_size = elem_ty.abiSize(mod);
1107		1107
...	@@ -1502,7 +1502,8 @@ fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_ind	...	@@ -1502,7 +1502,8 @@ fn reuseOperand(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, op_ind
1502	}	1502	}
1503		1503
1504	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {	1504	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
1505	const elem_ty = ptr_ty.elemType();	1505	const mod = self.bin_file.options.module.?;
		1506	const elem_ty = ptr_ty.childType(mod);
1506	switch (ptr) {	1507	switch (ptr) {
1507	.none => unreachable,	1508	.none => unreachable,
1508	.undef => unreachable,	1509	.undef => unreachable,
...	@@ -2496,8 +2497,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2496,8 +2497,9 @@ fn airReduce(self: *Self, inst: Air.Inst.Index) !void {
2496	}	2497	}
2497		2498
2498	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	2499	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
		2500	const mod = self.bin_file.options.module.?;
2499	const vector_ty = self.typeOfIndex(inst);	2501	const vector_ty = self.typeOfIndex(inst);
2500	const len = vector_ty.vectorLen();	2502	const len = vector_ty.vectorLen(mod);
2501	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	2503	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2502	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);	2504	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
2503	const result: MCValue = res: {	2505	const result: MCValue = res: {

...	@@ -838,8 +838,9 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -838,8 +838,9 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
838	}	838	}
839		839
840	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {	840	fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
		841	const mod = self.bin_file.options.module.?;
841	const vector_ty = self.typeOfIndex(inst);	842	const vector_ty = self.typeOfIndex(inst);
842	const len = vector_ty.vectorLen();	843	const len = vector_ty.vectorLen(mod);
843	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	844	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
844	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);	845	const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
845	const result: MCValue = res: {	846	const result: MCValue = res: {
...	@@ -871,12 +872,13 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -871,12 +872,13 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
871	}	872	}
872		873
873	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {	874	fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
		875	const mod = self.bin_file.options.module.?;
874	const ty_op = self.air.instructions.items(.data)[inst].ty_op;	876	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
875	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {	877	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
876	const ptr_ty = self.typeOf(ty_op.operand);	878	const ptr_ty = self.typeOf(ty_op.operand);
877	const ptr = try self.resolveInst(ty_op.operand);	879	const ptr = try self.resolveInst(ty_op.operand);
878	const array_ty = ptr_ty.childType();	880	const array_ty = ptr_ty.childType(mod);
879	const array_len = @intCast(u32, array_ty.arrayLen());	881	const array_len = @intCast(u32, array_ty.arrayLen(mod));
880		882
881	const ptr_bits = self.target.ptrBitWidth();	883	const ptr_bits = self.target.ptrBitWidth();
882	const ptr_bytes = @divExact(ptr_bits, 8);	884	const ptr_bytes = @divExact(ptr_bits, 8);
...	@@ -1300,7 +1302,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier	...	@@ -1300,7 +1302,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
1300	const mod = self.bin_file.options.module.?;	1302	const mod = self.bin_file.options.module.?;
1301	const fn_ty = switch (ty.zigTypeTag(mod)) {	1303	const fn_ty = switch (ty.zigTypeTag(mod)) {
1302	.Fn => ty,	1304	.Fn => ty,
1303	.Pointer => ty.childType(),	1305	.Pointer => ty.childType(mod),
1304	else => unreachable,	1306	else => unreachable,
1305	};	1307	};
1306		1308
...	@@ -1440,8 +1442,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {	...	@@ -1440,8 +1442,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
1440	.Pointer => Type.usize,	1442	.Pointer => Type.usize,
1441	.ErrorSet => Type.u16,	1443	.ErrorSet => Type.u16,
1442	.Optional => blk: {	1444	.Optional => blk: {
1443	var opt_buffer: Type.Payload.ElemType = undefined;	1445	const payload_ty = lhs_ty.optionalChild(mod);
1444	const payload_ty = lhs_ty.optionalChild(&opt_buffer);
1445	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {	1446	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
1446	break :blk Type.u1;	1447	break :blk Type.u1;
1447	} else if (lhs_ty.isPtrLikeOptional(mod)) {	1448	} else if (lhs_ty.isPtrLikeOptional(mod)) {
...	@@ -2447,6 +2448,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2447,6 +2448,7 @@ fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
2447	}	2448	}
2448		2449
2449	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {	2450	fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
		2451	const mod = self.bin_file.options.module.?;
2450	const is_volatile = false; // TODO	2452	const is_volatile = false; // TODO
2451	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2453	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2452		2454
...	@@ -2456,8 +2458,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -2456,8 +2458,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
2456	const index_mcv = try self.resolveInst(bin_op.rhs);	2458	const index_mcv = try self.resolveInst(bin_op.rhs);
2457		2459
2458	const slice_ty = self.typeOf(bin_op.lhs);	2460	const slice_ty = self.typeOf(bin_op.lhs);
2459	const elem_ty = slice_ty.childType();	2461	const elem_ty = slice_ty.childType(mod);
2460	const mod = self.bin_file.options.module.?;
2461	const elem_size = elem_ty.abiSize(mod);	2462	const elem_size = elem_ty.abiSize(mod);
2462		2463
2463	var buf: Type.SlicePtrFieldTypeBuffer = undefined;	2464	var buf: Type.SlicePtrFieldTypeBuffer = undefined;
...	@@ -2797,7 +2798,7 @@ fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: u32) !u	...	@@ -2797,7 +2798,7 @@ fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: u32) !u
2797	/// Use a pointer instruction as the basis for allocating stack memory.	2798	/// Use a pointer instruction as the basis for allocating stack memory.
2798	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {	2799	fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
2799	const mod = self.bin_file.options.module.?;	2800	const mod = self.bin_file.options.module.?;
2800	const elem_ty = self.typeOfIndex(inst).elemType();	2801	const elem_ty = self.typeOfIndex(inst).childType(mod);
2801		2802
2802	if (!elem_ty.hasRuntimeBits(mod)) {	2803	if (!elem_ty.hasRuntimeBits(mod)) {
2803	// As this stack item will never be dereferenced at runtime,	2804	// As this stack item will never be dereferenced at runtime,
...	@@ -3001,9 +3002,9 @@ fn binOp(	...	@@ -3001,9 +3002,9 @@ fn binOp(
3001	switch (lhs_ty.zigTypeTag(mod)) {	3002	switch (lhs_ty.zigTypeTag(mod)) {
3002	.Pointer => {	3003	.Pointer => {
3003	const ptr_ty = lhs_ty;	3004	const ptr_ty = lhs_ty;
3004	const elem_ty = switch (ptr_ty.ptrSize()) {	3005	const elem_ty = switch (ptr_ty.ptrSize(mod)) {
3005	.One => ptr_ty.childType().childType(), // ptr to array, so get array element type	3006	.One => ptr_ty.childType(mod).childType(mod), // ptr to array, so get array element type
3006	else => ptr_ty.childType(),	3007	else => ptr_ty.childType(mod),
3007	};	3008	};
3008	const elem_size = elem_ty.abiSize(mod);	3009	const elem_size = elem_ty.abiSize(mod);
3009		3010
...	@@ -3019,7 +3020,7 @@ fn binOp(	...	@@ -3019,7 +3020,7 @@ fn binOp(
3019	// multiplying it with elem_size	3020	// multiplying it with elem_size
3020		3021
3021	const offset = try self.binOp(.mul, rhs, .{ .immediate = elem_size }, Type.usize, Type.usize, null);	3022	const offset = try self.binOp(.mul, rhs, .{ .immediate = elem_size }, Type.usize, Type.usize, null);
3022	const addr = try self.binOp(tag, lhs, offset, Type.initTag(.manyptr_u8), Type.usize, null);	3023	const addr = try self.binOp(tag, lhs, offset, Type.manyptr_u8, Type.usize, null);
3023	return addr;	3024	return addr;
3024	}	3025	}
3025	},	3026	},
...	@@ -4042,11 +4043,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro	...	@@ -4042,11 +4043,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
4042	const reg = try self.copyToTmpRegister(ty, mcv);	4043	const reg = try self.copyToTmpRegister(ty, mcv);
4043	return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });	4044	return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
4044	} else {	4045	} else {
4045	var ptr_ty_payload: Type.Payload.ElemType = .{	4046	const ptr_ty = try mod.singleMutPtrType(ty);
4046	.base = .{ .tag = .single_mut_pointer },
4047	.data = ty,
4048	};
4049	const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
4050		4047
4051	const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null }, gp);	4048	const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null }, gp);
4052	const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);	4049	const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);
...	@@ -4269,7 +4266,7 @@ fn jump(self: *Self, inst: Mir.Inst.Index) !void {	...	@@ -4269,7 +4266,7 @@ fn jump(self: *Self, inst: Mir.Inst.Index) !void {
4269		4266
4270	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {	4267	fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!void {
4271	const mod = self.bin_file.options.module.?;	4268	const mod = self.bin_file.options.module.?;
4272	const elem_ty = ptr_ty.elemType();	4269	const elem_ty = ptr_ty.childType(mod);
4273	const elem_size = elem_ty.abiSize(mod);	4270	const elem_size = elem_ty.abiSize(mod);
4274		4271
4275	switch (ptr) {	4272	switch (ptr) {
...	@@ -4729,7 +4726,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde	...	@@ -4729,7 +4726,7 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
4729	const mod = self.bin_file.options.module.?;	4726	const mod = self.bin_file.options.module.?;
4730	const mcv = try self.resolveInst(operand);	4727	const mcv = try self.resolveInst(operand);
4731	const ptr_ty = self.typeOf(operand);	4728	const ptr_ty = self.typeOf(operand);
4732	const struct_ty = ptr_ty.childType();	4729	const struct_ty = ptr_ty.childType(mod);
4733	const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, mod));	4730	const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, mod));
4734	switch (mcv) {	4731	switch (mcv) {
4735	.ptr_stack_offset => \|off\| {	4732	.ptr_stack_offset => \|off\| {

...	@@ -230,7 +230,7 @@ pub fn generateSymbol(	...	@@ -230,7 +230,7 @@ pub fn generateSymbol(
230	.Array => switch (typed_value.val.tag()) {	230	.Array => switch (typed_value.val.tag()) {
231	.bytes => {	231	.bytes => {
232	const bytes = typed_value.val.castTag(.bytes).?.data;	232	const bytes = typed_value.val.castTag(.bytes).?.data;
233	const len = @intCast(usize, typed_value.ty.arrayLenIncludingSentinel());	233	const len = @intCast(usize, typed_value.ty.arrayLenIncludingSentinel(mod));
234	// The bytes payload already includes the sentinel, if any	234	// The bytes payload already includes the sentinel, if any
235	try code.ensureUnusedCapacity(len);	235	try code.ensureUnusedCapacity(len);
236	code.appendSliceAssumeCapacity(bytes[0..len]);	236	code.appendSliceAssumeCapacity(bytes[0..len]);
...	@@ -241,7 +241,7 @@ pub fn generateSymbol(	...	@@ -241,7 +241,7 @@ pub fn generateSymbol(
241	const bytes = mod.string_literal_bytes.items[str_lit.index..][0..str_lit.len];	241	const bytes = mod.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
242	try code.ensureUnusedCapacity(bytes.len + 1);	242	try code.ensureUnusedCapacity(bytes.len + 1);
243	code.appendSliceAssumeCapacity(bytes);	243	code.appendSliceAssumeCapacity(bytes);
244	if (typed_value.ty.sentinel()) \|sent_val\| {	244	if (typed_value.ty.sentinel(mod)) \|sent_val\| {
245	const byte = @intCast(u8, sent_val.toUnsignedInt(mod));	245	const byte = @intCast(u8, sent_val.toUnsignedInt(mod));
246	code.appendAssumeCapacity(byte);	246	code.appendAssumeCapacity(byte);
247	}	247	}
...	@@ -249,8 +249,8 @@ pub fn generateSymbol(	...	@@ -249,8 +249,8 @@ pub fn generateSymbol(
249	},	249	},
250	.aggregate => {	250	.aggregate => {
251	const elem_vals = typed_value.val.castTag(.aggregate).?.data;	251	const elem_vals = typed_value.val.castTag(.aggregate).?.data;
252	const elem_ty = typed_value.ty.elemType();	252	const elem_ty = typed_value.ty.childType(mod);
253	const len = @intCast(usize, typed_value.ty.arrayLenIncludingSentinel());	253	const len = @intCast(usize, typed_value.ty.arrayLenIncludingSentinel(mod));
254	for (elem_vals[0..len]) \|elem_val\| {	254	for (elem_vals[0..len]) \|elem_val\| {
255	switch (try generateSymbol(bin_file, src_loc, .{	255	switch (try generateSymbol(bin_file, src_loc, .{
256	.ty = elem_ty,	256	.ty = elem_ty,
...	@@ -264,9 +264,9 @@ pub fn generateSymbol(	...	@@ -264,9 +264,9 @@ pub fn generateSymbol(
264	},	264	},
265	.repeated => {	265	.repeated => {
266	const array = typed_value.val.castTag(.repeated).?.data;	266	const array = typed_value.val.castTag(.repeated).?.data;
267	const elem_ty = typed_value.ty.childType();	267	const elem_ty = typed_value.ty.childType(mod);
268	const sentinel = typed_value.ty.sentinel();	268	const sentinel = typed_value.ty.sentinel(mod);
269	const len = typed_value.ty.arrayLen();	269	const len = typed_value.ty.arrayLen(mod);
270		270
271	var index: u64 = 0;	271	var index: u64 = 0;
272	while (index < len) : (index += 1) {	272	while (index < len) : (index += 1) {
...	@@ -292,8 +292,8 @@ pub fn generateSymbol(	...	@@ -292,8 +292,8 @@ pub fn generateSymbol(
292	return Result.ok;	292	return Result.ok;
293	},	293	},
294	.empty_array_sentinel => {	294	.empty_array_sentinel => {
295	const elem_ty = typed_value.ty.childType();	295	const elem_ty = typed_value.ty.childType(mod);
296	const sentinel_val = typed_value.ty.sentinel().?;	296	const sentinel_val = typed_value.ty.sentinel(mod).?;
297	switch (try generateSymbol(bin_file, src_loc, .{	297	switch (try generateSymbol(bin_file, src_loc, .{
298	.ty = elem_ty,	298	.ty = elem_ty,
299	.val = sentinel_val,	299	.val = sentinel_val,
...	@@ -618,8 +618,7 @@ pub fn generateSymbol(	...	@@ -618,8 +618,7 @@ pub fn generateSymbol(
618	return Result.ok;	618	return Result.ok;
619	},	619	},
620	.Optional => {	620	.Optional => {
621	var opt_buf: Type.Payload.ElemType = undefined;	621	const payload_type = typed_value.ty.optionalChild(mod);
622	const payload_type = typed_value.ty.optionalChild(&opt_buf);
623	const is_pl = !typed_value.val.isNull(mod);	622	const is_pl = !typed_value.val.isNull(mod);
624	const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;	623	const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;
625		624
...	@@ -751,7 +750,7 @@ pub fn generateSymbol(	...	@@ -751,7 +750,7 @@ pub fn generateSymbol(
751	.Vector => switch (typed_value.val.tag()) {	750	.Vector => switch (typed_value.val.tag()) {
752	.bytes => {	751	.bytes => {
753	const bytes = typed_value.val.castTag(.bytes).?.data;	752	const bytes = typed_value.val.castTag(.bytes).?.data;
754	const len = math.cast(usize, typed_value.ty.arrayLen()) orelse return error.Overflow;	753	const len = math.cast(usize, typed_value.ty.arrayLen(mod)) orelse return error.Overflow;
755	const padding = math.cast(usize, typed_value.ty.abiSize(mod) - len) orelse	754	const padding = math.cast(usize, typed_value.ty.abiSize(mod) - len) orelse
756	return error.Overflow;	755	return error.Overflow;
757	try code.ensureUnusedCapacity(len + padding);	756	try code.ensureUnusedCapacity(len + padding);
...	@@ -761,8 +760,8 @@ pub fn generateSymbol(	...	@@ -761,8 +760,8 @@ pub fn generateSymbol(
761	},	760	},
762	.aggregate => {	761	.aggregate => {
763	const elem_vals = typed_value.val.castTag(.aggregate).?.data;	762	const elem_vals = typed_value.val.castTag(.aggregate).?.data;
764	const elem_ty = typed_value.ty.elemType();	763	const elem_ty = typed_value.ty.childType(mod);
765	const len = math.cast(usize, typed_value.ty.arrayLen()) orelse return error.Overflow;	764	const len = math.cast(usize, typed_value.ty.arrayLen(mod)) orelse return error.Overflow;
766	const padding = math.cast(usize, typed_value.ty.abiSize(mod) -	765	const padding = math.cast(usize, typed_value.ty.abiSize(mod) -
767	(math.divCeil(u64, elem_ty.bitSize(mod) * len, 8) catch \|err\| switch (err) {	766	(math.divCeil(u64, elem_ty.bitSize(mod) * len, 8) catch \|err\| switch (err) {
768	error.DivisionByZero => unreachable,	767	error.DivisionByZero => unreachable,
...	@@ -782,8 +781,8 @@ pub fn generateSymbol(	...	@@ -782,8 +781,8 @@ pub fn generateSymbol(
782	},	781	},
783	.repeated => {	782	.repeated => {
784	const array = typed_value.val.castTag(.repeated).?.data;	783	const array = typed_value.val.castTag(.repeated).?.data;
785	const elem_ty = typed_value.ty.childType();	784	const elem_ty = typed_value.ty.childType(mod);
786	const len = typed_value.ty.arrayLen();	785	const len = typed_value.ty.arrayLen(mod);
787	const padding = math.cast(usize, typed_value.ty.abiSize(mod) -	786	const padding = math.cast(usize, typed_value.ty.abiSize(mod) -
788	(math.divCeil(u64, elem_ty.bitSize(mod) * len, 8) catch \|err\| switch (err) {	787	(math.divCeil(u64, elem_ty.bitSize(mod) * len, 8) catch \|err\| switch (err) {
789	error.DivisionByZero => unreachable,	788	error.DivisionByZero => unreachable,
...	@@ -1188,7 +1187,7 @@ pub fn genTypedValue(	...	@@ -1188,7 +1187,7 @@ pub fn genTypedValue(
1188		1187
1189	switch (typed_value.ty.zigTypeTag(mod)) {	1188	switch (typed_value.ty.zigTypeTag(mod)) {
1190	.Void => return GenResult.mcv(.none),	1189	.Void => return GenResult.mcv(.none),
1191	.Pointer => switch (typed_value.ty.ptrSize()) {	1190	.Pointer => switch (typed_value.ty.ptrSize(mod)) {
1192	.Slice => {},	1191	.Slice => {},
1193	else => {	1192	else => {
1194	switch (typed_value.val.tag()) {	1193	switch (typed_value.val.tag()) {
...	@@ -1219,9 +1218,8 @@ pub fn genTypedValue(	...	@@ -1219,9 +1218,8 @@ pub fn genTypedValue(
1219	if (typed_value.ty.isPtrLikeOptional(mod)) {	1218	if (typed_value.ty.isPtrLikeOptional(mod)) {
1220	if (typed_value.val.tag() == .null_value) return GenResult.mcv(.{ .immediate = 0 });	1219	if (typed_value.val.tag() == .null_value) return GenResult.mcv(.{ .immediate = 0 });
1221		1220
1222	var buf: Type.Payload.ElemType = undefined;
1223	return genTypedValue(bin_file, src_loc, .{	1221	return genTypedValue(bin_file, src_loc, .{
1224	.ty = typed_value.ty.optionalChild(&buf),	1222	.ty = typed_value.ty.optionalChild(mod),
1225	.val = if (typed_value.val.castTag(.opt_payload)) \|pl\| pl.data else typed_value.val,	1223	.val = if (typed_value.val.castTag(.opt_payload)) \|pl\| pl.data else typed_value.val,
1226	}, owner_decl_index);	1224	}, owner_decl_index);
1227	} else if (typed_value.ty.abiSize(mod) == 1) {	1225	} else if (typed_value.ty.abiSize(mod) == 1) {

...	@@ -625,20 +625,20 @@ pub const DeclGen = struct {	...	@@ -625,20 +625,20 @@ pub const DeclGen = struct {
625	.Array => switch (val.tag()) {	625	.Array => switch (val.tag()) {
626	.aggregate => {	626	.aggregate => {
627	const elem_vals = val.castTag(.aggregate).?.data;	627	const elem_vals = val.castTag(.aggregate).?.data;
628	const elem_ty = ty.elemType();	628	const elem_ty = ty.childType(mod);
629	const len = @intCast(u32, ty.arrayLenIncludingSentinel()); // TODO: limit spir-v to 32 bit arrays in a more elegant way.	629	const len = @intCast(u32, ty.arrayLenIncludingSentinel(mod)); // TODO: limit spir-v to 32 bit arrays in a more elegant way.
630	for (elem_vals[0..len]) \|elem_val\| {	630	for (elem_vals[0..len]) \|elem_val\| {
631	try self.lower(elem_ty, elem_val);	631	try self.lower(elem_ty, elem_val);
632	}	632	}
633	},	633	},
634	.repeated => {	634	.repeated => {
635	const elem_val = val.castTag(.repeated).?.data;	635	const elem_val = val.castTag(.repeated).?.data;
636	const elem_ty = ty.elemType();	636	const elem_ty = ty.childType(mod);
637	const len = @intCast(u32, ty.arrayLen());	637	const len = @intCast(u32, ty.arrayLen(mod));
638	for (0..len) \|_\| {	638	for (0..len) \|_\| {
639	try self.lower(elem_ty, elem_val);	639	try self.lower(elem_ty, elem_val);
640	}	640	}
641	if (ty.sentinel()) \|sentinel\| {	641	if (ty.sentinel(mod)) \|sentinel\| {
642	try self.lower(elem_ty, sentinel);	642	try self.lower(elem_ty, sentinel);
643	}	643	}
644	},	644	},
...	@@ -646,7 +646,7 @@ pub const DeclGen = struct {	...	@@ -646,7 +646,7 @@ pub const DeclGen = struct {
646	const str_lit = val.castTag(.str_lit).?.data;	646	const str_lit = val.castTag(.str_lit).?.data;
647	const bytes = dg.module.string_literal_bytes.items[str_lit.index..][0..str_lit.len];	647	const bytes = dg.module.string_literal_bytes.items[str_lit.index..][0..str_lit.len];
648	try self.addBytes(bytes);	648	try self.addBytes(bytes);
649	if (ty.sentinel()) \|sentinel\| {	649	if (ty.sentinel(mod)) \|sentinel\| {
650	try self.addByte(@intCast(u8, sentinel.toUnsignedInt(mod)));	650	try self.addByte(@intCast(u8, sentinel.toUnsignedInt(mod)));
651	}	651	}
652	},	652	},
...	@@ -706,8 +706,7 @@ pub const DeclGen = struct {	...	@@ -706,8 +706,7 @@ pub const DeclGen = struct {
706	}	706	}
707	},	707	},
708	.Optional => {	708	.Optional => {
709	var opt_buf: Type.Payload.ElemType = undefined;	709	const payload_ty = ty.optionalChild(mod);
710	const payload_ty = ty.optionalChild(&opt_buf);
711	const has_payload = !val.isNull(mod);	710	const has_payload = !val.isNull(mod);
712	const abi_size = ty.abiSize(mod);	711	const abi_size = ty.abiSize(mod);
713		712
...	@@ -1216,10 +1215,10 @@ pub const DeclGen = struct {	...	@@ -1216,10 +1215,10 @@ pub const DeclGen = struct {
1216	return try self.spv.resolve(.{ .float_type = .{ .bits = bits } });	1215	return try self.spv.resolve(.{ .float_type = .{ .bits = bits } });
1217	},	1216	},
1218	.Array => {	1217	.Array => {
1219	const elem_ty = ty.childType();	1218	const elem_ty = ty.childType(mod);
1220	const elem_ty_ref = try self.resolveType(elem_ty, .direct);	1219	const elem_ty_ref = try self.resolveType(elem_ty, .direct);
1221	const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel()) orelse {	1220	const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel(mod)) orelse {
1222	return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel()});	1221	return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel(mod)});
1223	};	1222	};
1224	return self.spv.arrayType(total_len, elem_ty_ref);	1223	return self.spv.arrayType(total_len, elem_ty_ref);
1225	},	1224	},
...	@@ -1248,7 +1247,7 @@ pub const DeclGen = struct {	...	@@ -1248,7 +1247,7 @@ pub const DeclGen = struct {
1248	},	1247	},
1249	},	1248	},
1250	.Pointer => {	1249	.Pointer => {
1251	const ptr_info = ty.ptrInfo().data;	1250	const ptr_info = ty.ptrInfo(mod);
1252		1251
1253	const storage_class = spvStorageClass(ptr_info.@"addrspace");	1252	const storage_class = spvStorageClass(ptr_info.@"addrspace");
1254	const child_ty_ref = try self.resolveType(ptr_info.pointee_type, .indirect);	1253	const child_ty_ref = try self.resolveType(ptr_info.pointee_type, .indirect);
...	@@ -1280,8 +1279,8 @@ pub const DeclGen = struct {	...	@@ -1280,8 +1279,8 @@ pub const DeclGen = struct {
1280	// TODO: Properly verify sizes and child type.	1279	// TODO: Properly verify sizes and child type.
1281		1280
1282	return try self.spv.resolve(.{ .vector_type = .{	1281	return try self.spv.resolve(.{ .vector_type = .{
1283	.component_type = try self.resolveType(ty.elemType(), repr),	1282	.component_type = try self.resolveType(ty.childType(mod), repr),
1284	.component_count = @intCast(u32, ty.vectorLen()),	1283	.component_count = @intCast(u32, ty.vectorLen(mod)),
1285	} });	1284	} });
1286	},	1285	},
1287	.Struct => {	1286	.Struct => {
...	@@ -1335,8 +1334,7 @@ pub const DeclGen = struct {	...	@@ -1335,8 +1334,7 @@ pub const DeclGen = struct {
1335	} });	1334	} });
1336	},	1335	},
1337	.Optional => {	1336	.Optional => {
1338	var buf: Type.Payload.ElemType = undefined;	1337	const payload_ty = ty.optionalChild(mod);
1339	const payload_ty = ty.optionalChild(&buf);
1340	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {	1338	if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
1341	// Just use a bool.	1339	// Just use a bool.
1342	// Note: Always generate the bool with indirect format, to save on some sanity	1340	// Note: Always generate the bool with indirect format, to save on some sanity
...	@@ -1685,7 +1683,8 @@ pub const DeclGen = struct {	...	@@ -1685,7 +1683,8 @@ pub const DeclGen = struct {
1685	}	1683	}
1686		1684
1687	fn load(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef) !IdRef {	1685	fn load(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef) !IdRef {
1688	const value_ty = ptr_ty.childType();	1686	const mod = self.module;
		1687	const value_ty = ptr_ty.childType(mod);
1689	const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);	1688	const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
1690	const result_id = self.spv.allocId();	1689	const result_id = self.spv.allocId();
1691	const access = spec.MemoryAccess.Extended{	1690	const access = spec.MemoryAccess.Extended{
...	@@ -1701,7 +1700,8 @@ pub const DeclGen = struct {	...	@@ -1701,7 +1700,8 @@ pub const DeclGen = struct {
1701	}	1700	}
1702		1701
1703	fn store(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, value_id: IdRef) !void {	1702	fn store(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, value_id: IdRef) !void {
1704	const value_ty = ptr_ty.childType();	1703	const mod = self.module;
		1704	const value_ty = ptr_ty.childType(mod);
1705	const indirect_value_id = try self.convertToIndirect(value_ty, value_id);	1705	const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
1706	const access = spec.MemoryAccess.Extended{	1706	const access = spec.MemoryAccess.Extended{
1707	.Volatile = ptr_ty.isVolatilePtr(),	1707	.Volatile = ptr_ty.isVolatilePtr(),
...	@@ -2072,7 +2072,7 @@ pub const DeclGen = struct {	...	@@ -2072,7 +2072,7 @@ pub const DeclGen = struct {
2072	const b = try self.resolve(extra.b);	2072	const b = try self.resolve(extra.b);
2073	const mask = self.air.values[extra.mask];	2073	const mask = self.air.values[extra.mask];
2074	const mask_len = extra.mask_len;	2074	const mask_len = extra.mask_len;
2075	const a_len = self.typeOf(extra.a).vectorLen();	2075	const a_len = self.typeOf(extra.a).vectorLen(mod);
2076		2076
2077	const result_id = self.spv.allocId();	2077	const result_id = self.spv.allocId();
2078	const result_type_id = try self.resolveTypeId(ty);	2078	const result_type_id = try self.resolveTypeId(ty);
...	@@ -2138,9 +2138,10 @@ pub const DeclGen = struct {	...	@@ -2138,9 +2138,10 @@ pub const DeclGen = struct {
2138	}	2138	}
2139		2139
2140	fn ptrAdd(self: *DeclGen, result_ty: Type, ptr_ty: Type, ptr_id: IdRef, offset_id: IdRef) !IdRef {	2140	fn ptrAdd(self: *DeclGen, result_ty: Type, ptr_ty: Type, ptr_id: IdRef, offset_id: IdRef) !IdRef {
		2141	const mod = self.module;
2141	const result_ty_ref = try self.resolveType(result_ty, .direct);	2142	const result_ty_ref = try self.resolveType(result_ty, .direct);
2142		2143
2143	switch (ptr_ty.ptrSize()) {	2144	switch (ptr_ty.ptrSize(mod)) {
2144	.One => {	2145	.One => {
2145	// Pointer to array	2146	// Pointer to array
2146	// TODO: Is this correct?	2147	// TODO: Is this correct?
...	@@ -2498,7 +2499,7 @@ pub const DeclGen = struct {	...	@@ -2498,7 +2499,7 @@ pub const DeclGen = struct {
2498	// Construct new pointer type for the resulting pointer	2499	// Construct new pointer type for the resulting pointer
2499	const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.	2500	const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
2500	const elem_ty_ref = try self.resolveType(elem_ty, .direct);	2501	const elem_ty_ref = try self.resolveType(elem_ty, .direct);
2501	const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace()));	2502	const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
2502	if (ptr_ty.isSinglePointer(mod)) {	2503	if (ptr_ty.isSinglePointer(mod)) {
2503	// Pointer-to-array. In this case, the resulting pointer is not of the same type	2504	// Pointer-to-array. In this case, the resulting pointer is not of the same type
2504	// as the ptr_ty (we want a T, not a [N]T), and hence we need to use accessChain.	2505	// as the ptr_ty (we want a T, not a [N]T), and hence we need to use accessChain.
...	@@ -2516,7 +2517,7 @@ pub const DeclGen = struct {	...	@@ -2516,7 +2517,7 @@ pub const DeclGen = struct {
2516	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;	2517	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2517	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;	2518	const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
2518	const ptr_ty = self.typeOf(bin_op.lhs);	2519	const ptr_ty = self.typeOf(bin_op.lhs);
2519	const elem_ty = ptr_ty.childType();	2520	const elem_ty = ptr_ty.childType(mod);
2520	// TODO: Make this return a null ptr or something	2521	// TODO: Make this return a null ptr or something
2521	if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) return null;	2522	if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) return null;
2522		2523
...	@@ -2526,6 +2527,7 @@ pub const DeclGen = struct {	...	@@ -2526,6 +2527,7 @@ pub const DeclGen = struct {
2526	}	2527	}
2527		2528
2528	fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	2529	fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
		2530	const mod = self.module;
2529	const bin_op = self.air.instructions.items(.data)[inst].bin_op;	2531	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2530	const ptr_ty = self.typeOf(bin_op.lhs);	2532	const ptr_ty = self.typeOf(bin_op.lhs);
2531	const ptr_id = try self.resolve(bin_op.lhs);	2533	const ptr_id = try self.resolve(bin_op.lhs);
...	@@ -2536,9 +2538,9 @@ pub const DeclGen = struct {	...	@@ -2536,9 +2538,9 @@ pub const DeclGen = struct {
2536	// If we have a pointer-to-array, construct an element pointer to use with load()	2538	// If we have a pointer-to-array, construct an element pointer to use with load()
2537	// If we pass ptr_ty directly, it will attempt to load the entire array rather than	2539	// If we pass ptr_ty directly, it will attempt to load the entire array rather than
2538	// just an element.	2540	// just an element.
2539	var elem_ptr_info = ptr_ty.ptrInfo();	2541	var elem_ptr_info = ptr_ty.ptrInfo(mod);
2540	elem_ptr_info.data.size = .One;	2542	elem_ptr_info.size = .One;
2541	const elem_ptr_ty = Type.initPayload(&elem_ptr_info.base);	2543	const elem_ptr_ty = try Type.ptr(undefined, mod, elem_ptr_info);
2542		2544
2543	return try self.load(elem_ptr_ty, elem_ptr_id);	2545	return try self.load(elem_ptr_ty, elem_ptr_id);
2544	}	2546	}
...	@@ -2586,7 +2588,7 @@ pub const DeclGen = struct {	...	@@ -2586,7 +2588,7 @@ pub const DeclGen = struct {
2586	field_index: u32,	2588	field_index: u32,
2587	) !?IdRef {	2589	) !?IdRef {
2588	const mod = self.module;	2590	const mod = self.module;
2589	const object_ty = object_ptr_ty.childType();	2591	const object_ty = object_ptr_ty.childType(mod);
2590	switch (object_ty.zigTypeTag(mod)) {	2592	switch (object_ty.zigTypeTag(mod)) {
2591	.Struct => switch (object_ty.containerLayout()) {	2593	.Struct => switch (object_ty.containerLayout()) {
2592	.Packed => unreachable, // TODO	2594	.Packed => unreachable, // TODO
...	@@ -2662,9 +2664,10 @@ pub const DeclGen = struct {	...	@@ -2662,9 +2664,10 @@ pub const DeclGen = struct {
2662		2664
2663	fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {	2665	fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2664	if (self.liveness.isUnused(inst)) return null;	2666	if (self.liveness.isUnused(inst)) return null;
		2667	const mod = self.module;
2665	const ptr_ty = self.typeOfIndex(inst);	2668	const ptr_ty = self.typeOfIndex(inst);
2666	assert(ptr_ty.ptrAddressSpace() == .generic);	2669	assert(ptr_ty.ptrAddressSpace(mod) == .generic);
2667	const child_ty = ptr_ty.childType();	2670	const child_ty = ptr_ty.childType(mod);
2668	const child_ty_ref = try self.resolveType(child_ty, .indirect);	2671	const child_ty_ref = try self.resolveType(child_ty, .indirect);
2669	return try self.alloc(child_ty_ref, null);	2672	return try self.alloc(child_ty_ref, null);
2670	}	2673	}
...	@@ -2834,7 +2837,7 @@ pub const DeclGen = struct {	...	@@ -2834,7 +2837,7 @@ pub const DeclGen = struct {
2834	const mod = self.module;	2837	const mod = self.module;
2835	const un_op = self.air.instructions.items(.data)[inst].un_op;	2838	const un_op = self.air.instructions.items(.data)[inst].un_op;
2836	const ptr_ty = self.typeOf(un_op);	2839	const ptr_ty = self.typeOf(un_op);
2837	const ret_ty = ptr_ty.childType();	2840	const ret_ty = ptr_ty.childType(mod);
2838		2841
2839	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {	2842	if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
2840	try self.func.body.emit(self.spv.gpa, .OpReturn, {});	2843	try self.func.body.emit(self.spv.gpa, .OpReturn, {});
...	@@ -2971,8 +2974,7 @@ pub const DeclGen = struct {	...	@@ -2971,8 +2974,7 @@ pub const DeclGen = struct {
2971	const operand_id = try self.resolve(un_op);	2974	const operand_id = try self.resolve(un_op);
2972	const optional_ty = self.typeOf(un_op);	2975	const optional_ty = self.typeOf(un_op);
2973		2976
2974	var buf: Type.Payload.ElemType = undefined;	2977	const payload_ty = optional_ty.optionalChild(mod);
2975	const payload_ty = optional_ty.optionalChild(&buf);
2976		2978
2977	const bool_ty_ref = try self.resolveType(Type.bool, .direct);	2979	const bool_ty_ref = try self.resolveType(Type.bool, .direct);
2978		2980

...	@@ -219,8 +219,7 @@ pub const DeclState = struct {	...	@@ -219,8 +219,7 @@ pub const DeclState = struct {
219	try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});	219	try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(mod)});
220	} else {	220	} else {
221	// Non-pointer optionals are structs: struct { .maybe = , .val = }	221	// Non-pointer optionals are structs: struct { .maybe = , .val = }
222	var buf = try arena.create(Type.Payload.ElemType);	222	const payload_ty = ty.optionalChild(mod);
223	const payload_ty = ty.optionalChild(buf);
224	// DW.AT.structure_type	223	// DW.AT.structure_type
225	try dbg_info_buffer.append(@enumToInt(AbbrevKind.struct_type));	224	try dbg_info_buffer.append(@enumToInt(AbbrevKind.struct_type));
226	// DW.AT.byte_size, DW.FORM.udata	225	// DW.AT.byte_size, DW.FORM.udata
...	@@ -304,7 +303,7 @@ pub const DeclState = struct {	...	@@ -304,7 +303,7 @@ pub const DeclState = struct {
304	// DW.AT.type, DW.FORM.ref4	303	// DW.AT.type, DW.FORM.ref4
305	const index = dbg_info_buffer.items.len;	304	const index = dbg_info_buffer.items.len;
306	try dbg_info_buffer.resize(index + 4);	305	try dbg_info_buffer.resize(index + 4);
307	try self.addTypeRelocGlobal(atom_index, ty.childType(), @intCast(u32, index));	306	try self.addTypeRelocGlobal(atom_index, ty.childType(mod), @intCast(u32, index));
308	}	307	}
309	},	308	},
310	.Array => {	309	.Array => {
...	@@ -315,7 +314,7 @@ pub const DeclState = struct {	...	@@ -315,7 +314,7 @@ pub const DeclState = struct {
315	// DW.AT.type, DW.FORM.ref4	314	// DW.AT.type, DW.FORM.ref4
316	var index = dbg_info_buffer.items.len;	315	var index = dbg_info_buffer.items.len;
317	try dbg_info_buffer.resize(index + 4);	316	try dbg_info_buffer.resize(index + 4);
318	try self.addTypeRelocGlobal(atom_index, ty.childType(), @intCast(u32, index));	317	try self.addTypeRelocGlobal(atom_index, ty.childType(mod), @intCast(u32, index));
319	// DW.AT.subrange_type	318	// DW.AT.subrange_type
320	try dbg_info_buffer.append(@enumToInt(AbbrevKind.array_dim));	319	try dbg_info_buffer.append(@enumToInt(AbbrevKind.array_dim));
321	// DW.AT.type, DW.FORM.ref4	320	// DW.AT.type, DW.FORM.ref4
...	@@ -323,7 +322,7 @@ pub const DeclState = struct {	...	@@ -323,7 +322,7 @@ pub const DeclState = struct {
323	try dbg_info_buffer.resize(index + 4);	322	try dbg_info_buffer.resize(index + 4);
324	try self.addTypeRelocGlobal(atom_index, Type.usize, @intCast(u32, index));	323	try self.addTypeRelocGlobal(atom_index, Type.usize, @intCast(u32, index));
325	// DW.AT.count, DW.FORM.udata	324	// DW.AT.count, DW.FORM.udata
326	const len = ty.arrayLenIncludingSentinel();	325	const len = ty.arrayLenIncludingSentinel(mod);
327	try leb128.writeULEB128(dbg_info_buffer.writer(), len);	326	try leb128.writeULEB128(dbg_info_buffer.writer(), len);
328	// DW.AT.array_type delimit children	327	// DW.AT.array_type delimit children
329	try dbg_info_buffer.append(0);	328	try dbg_info_buffer.append(0);
...	@@ -688,7 +687,7 @@ pub const DeclState = struct {	...	@@ -688,7 +687,7 @@ pub const DeclState = struct {
688	const mod = self.mod;	687	const mod = self.mod;
689	const target = mod.getTarget();	688	const target = mod.getTarget();
690	const endian = target.cpu.arch.endian();	689	const endian = target.cpu.arch.endian();
691	const child_ty = if (is_ptr) ty.childType() else ty;	690	const child_ty = if (is_ptr) ty.childType(mod) else ty;
692		691
693	switch (loc) {	692	switch (loc) {
694	.register => \|reg\| {	693	.register => \|reg\| {