llvm: finish converting lowerValue

src/Module.zig

@@ -835,10 +835,6 @@ pub const Decl = struct {
         assert(decl.has_tv);
         return @as(u32, @intCast(decl.alignment.toByteUnitsOptional() orelse decl.ty.abiAlignment(mod)));
     }
-
-    pub fn intern(decl: *Decl, mod: *Module) Allocator.Error!void {
-        decl.val = (try decl.val.intern(decl.ty, mod)).toValue();
-    }
 };
 
 /// This state is attached to every Decl when Module emit_h is non-null.
@@ -4204,7 +4200,7 @@ pub fn semaFile(mod: *Module, file: *File) SemaError!void {
             try wip_captures.finalize();
             for (comptime_mutable_decls.items) |decl_index| {
                 const decl = mod.declPtr(decl_index);
-                try decl.intern(mod);
+                _ = try decl.internValue(mod);
             }
             new_decl.analysis = .complete;
         } else |err| switch (err) {
@@ -4315,7 +4311,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !bool {
     try wip_captures.finalize();
     for (comptime_mutable_decls.items) |ct_decl_index| {
         const ct_decl = mod.declPtr(ct_decl_index);
-        try ct_decl.intern(mod);
+        _ = try ct_decl.internValue(mod);
     }
     const align_src: LazySrcLoc = .{ .node_offset_var_decl_align = 0 };
     const section_src: LazySrcLoc = .{ .node_offset_var_decl_section = 0 };
@@ -5362,7 +5358,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: InternPool.Index, arena: Allocato
     try wip_captures.finalize();
     for (comptime_mutable_decls.items) |ct_decl_index| {
         const ct_decl = mod.declPtr(ct_decl_index);
-        try ct_decl.intern(mod);
+        _ = try ct_decl.internValue(mod);
     }
 
     // Copy the block into place and mark that as the main block.
@@ -6369,7 +6365,7 @@ pub fn markDeclAlive(mod: *Module, decl: *Decl) Allocator.Error!void {
     if (decl.alive) return;
     decl.alive = true;
 
-    try decl.intern(mod);
+    _ = try decl.internValue(mod);
 
     // This is the first time we are marking this Decl alive. We must
     // therefore recurse into its value and mark any Decl it references

src/Sema.zig

@@ -3899,7 +3899,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
             try mod.declareDeclDependency(sema.owner_decl_index, decl_index);
 
             const decl = mod.declPtr(decl_index);
-            if (iac.is_const) try decl.intern(mod);
+            if (iac.is_const) _ = try decl.internValue(mod);
             const final_elem_ty = decl.ty;
             const final_ptr_ty = try mod.ptrType(.{
                 .child = final_elem_ty.toIntern(),
@@ -33577,7 +33577,7 @@ fn semaBackingIntType(mod: *Module, struct_obj: *Module.Struct) CompileError!voi
         try wip_captures.finalize();
         for (comptime_mutable_decls.items) |ct_decl_index| {
             const ct_decl = mod.declPtr(ct_decl_index);
-            try ct_decl.intern(mod);
+            _ = try ct_decl.internValue(mod);
         }
     } else {
         if (fields_bit_sum > std.math.maxInt(u16)) {
@@ -34645,7 +34645,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
     try wip_captures.finalize();
     for (comptime_mutable_decls.items) |ct_decl_index| {
         const ct_decl = mod.declPtr(ct_decl_index);
-        try ct_decl.intern(mod);
+        _ = try ct_decl.internValue(mod);
     }
 
     struct_obj.have_field_inits = true;
@@ -34744,7 +34744,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
     try wip_captures.finalize();
     for (comptime_mutable_decls.items) |ct_decl_index| {
         const ct_decl = mod.declPtr(ct_decl_index);
-        try ct_decl.intern(mod);
+        _ = try ct_decl.internValue(mod);
     }
 
     try union_obj.fields.ensureTotalCapacity(mod.tmp_hack_arena.allocator(), fields_len);

src/codegen/llvm.zig

@@ -579,7 +579,7 @@ pub const Object = struct {
     /// The LLVM global table which holds the names corresponding to Zig errors.
     /// Note that the values are not added until flushModule, when all errors in
     /// the compilation are known.
-    error_name_table: ?*llvm.Value,
+    error_name_table: Builder.Variable.Index,
     /// This map is usually very close to empty. It tracks only the cases when a
     /// second extern Decl could not be emitted with the correct name due to a
     /// name collision.
@@ -763,7 +763,7 @@ pub const Object = struct {
             .named_enum_map = .{},
             .type_map = .{},
             .di_type_map = .{},
-            .error_name_table = null,
+            .error_name_table = .none,
             .extern_collisions = .{},
             .null_opt_addr = null,
         };
@@ -803,51 +803,85 @@ pub const Object = struct {
         return slice.ptr;
     }
 
-    fn genErrorNameTable(o: *Object) !void {
+    fn genErrorNameTable(o: *Object) Allocator.Error!void {
         // If o.error_name_table is null, there was no instruction that actually referenced the error table.
-        const error_name_table_ptr_global = o.error_name_table orelse return;
+        const error_name_table_ptr_global = o.error_name_table;
+        if (error_name_table_ptr_global == .none) return;
 
         const mod = o.module;
 
-        // TODO: Address space
-        const llvm_usize_ty = try o.lowerType(Type.usize);
-        const llvm_slice_ty = (try o.builder.structType(.normal, &.{ .ptr, llvm_usize_ty })).toLlvm(&o.builder);
-        const slice_ty = Type.slice_const_u8_sentinel_0;
-        const slice_alignment = slice_ty.abiAlignment(mod);
-
         const error_name_list = mod.global_error_set.keys();
-        const llvm_errors = try mod.gpa.alloc(*llvm.Value, error_name_list.len);
+        const llvm_errors = try mod.gpa.alloc(Builder.Constant, error_name_list.len);
         defer mod.gpa.free(llvm_errors);
 
-        llvm_errors[0] = llvm_slice_ty.getUndef();
+        // TODO: Address space
+        const slice_ty = Type.slice_const_u8_sentinel_0;
+        const slice_alignment = slice_ty.abiAlignment(mod);
+        const llvm_usize_ty = try o.lowerType(Type.usize);
+        const llvm_slice_ty = try o.lowerType(slice_ty);
+        const llvm_table_ty = try o.builder.arrayType(error_name_list.len, llvm_slice_ty);
+
+        llvm_errors[0] = try o.builder.undefConst(llvm_slice_ty);
         for (llvm_errors[1..], error_name_list[1..]) |*llvm_error, name_nts| {
-            const name = mod.intern_pool.stringToSlice(name_nts);
-            const str_init = o.context.constString(name.ptr, @as(c_uint, @intCast(name.len)), .False);
-            const str_global = o.llvm_module.addGlobal(str_init.typeOf(), "");
-            str_global.setInitializer(str_init);
+            const name = try o.builder.string(mod.intern_pool.stringToSlice(name_nts));
+            const str_init = try o.builder.stringNullConst(name);
+            const str_ty = str_init.typeOf(&o.builder);
+            const str_global = o.llvm_module.addGlobal(str_ty.toLlvm(&o.builder), "");
+            str_global.setInitializer(str_init.toLlvm(&o.builder));
             str_global.setLinkage(.Private);
             str_global.setGlobalConstant(.True);
             str_global.setUnnamedAddr(.True);
             str_global.setAlignment(1);
 
-            const slice_fields = [_]*llvm.Value{
-                str_global,
-                (try o.builder.intConst(llvm_usize_ty, name.len)).toLlvm(&o.builder),
+            var global = Builder.Global{
+                .linkage = .private,
+                .unnamed_addr = .unnamed_addr,
+                .type = str_ty,
+                .alignment = comptime Builder.Alignment.fromByteUnits(1),
+                .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
             };
-            llvm_error.* = llvm_slice_ty.constNamedStruct(&slice_fields, slice_fields.len);
+            var variable = Builder.Variable{
+                .global = @enumFromInt(o.builder.globals.count()),
+                .mutability = .constant,
+                .init = str_init,
+            };
+            try o.builder.llvm_globals.append(o.gpa, str_global);
+            const str_global_index = try o.builder.addGlobal(.none, global);
+            try o.builder.variables.append(o.gpa, variable);
+
+            llvm_error.* = try o.builder.structConst(llvm_slice_ty, &.{
+                str_global_index.toConst(),
+                try o.builder.intConst(llvm_usize_ty, name.toSlice(&o.builder).?.len),
+            });
         }
 
-        const error_name_table_init = llvm_slice_ty.constArray(llvm_errors.ptr, @as(c_uint, @intCast(error_name_list.len)));
-
-        const error_name_table_global = o.llvm_module.addGlobal(error_name_table_init.typeOf(), "");
-        error_name_table_global.setInitializer(error_name_table_init);
+        const error_name_table_init = try o.builder.arrayConst(llvm_table_ty, llvm_errors);
+        const error_name_table_global = o.llvm_module.addGlobal(llvm_table_ty.toLlvm(&o.builder), "");
+        error_name_table_global.setInitializer(error_name_table_init.toLlvm(&o.builder));
         error_name_table_global.setLinkage(.Private);
         error_name_table_global.setGlobalConstant(.True);
         error_name_table_global.setUnnamedAddr(.True);
         error_name_table_global.setAlignment(slice_alignment); // TODO: Dont hardcode
 
+        var global = Builder.Global{
+            .linkage = .private,
+            .unnamed_addr = .unnamed_addr,
+            .type = llvm_table_ty,
+            .alignment = Builder.Alignment.fromByteUnits(slice_alignment),
+            .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
+        };
+        var variable = Builder.Variable{
+            .global = @enumFromInt(o.builder.globals.count()),
+            .mutability = .constant,
+            .init = error_name_table_init,
+        };
+        try o.builder.llvm_globals.append(o.gpa, error_name_table_global);
+        _ = try o.builder.addGlobal(.none, global);
+        try o.builder.variables.append(o.gpa, variable);
+
         const error_name_table_ptr = error_name_table_global;
-        error_name_table_ptr_global.setInitializer(error_name_table_ptr);
+        error_name_table_ptr_global.ptr(&o.builder).init = variable.global.toConst();
+        error_name_table_ptr_global.toLlvm(&o.builder).setInitializer(error_name_table_ptr);
     }
 
     fn genCmpLtErrorsLenFunction(object: *Object) !void {
@@ -1116,9 +1150,9 @@ pub const Object = struct {
             .err_msg = null,
         };
 
-        const function_index = try o.resolveLlvmFunction(decl_index);
-        const function = function_index.ptr(&o.builder);
-        const llvm_func = function.global.toLlvm(&o.builder);
+        const function = try o.resolveLlvmFunction(decl_index);
+        const global = function.ptrConst(&o.builder).global;
+        const llvm_func = global.toLlvm(&o.builder);
 
         if (func.analysis(ip).is_noinline) {
             o.addFnAttr(llvm_func, "noinline");
@@ -1155,8 +1189,10 @@ pub const Object = struct {
             o.addFnAttrString(llvm_func, "no-stack-arg-probe", "");
         }
 
-        if (ip.stringToSliceUnwrap(decl.@"linksection")) |section|
+        if (ip.stringToSliceUnwrap(decl.@"linksection")) |section| {
+            global.ptr(&o.builder).section = try o.builder.string(section);
             llvm_func.setSection(section);
+        }
 
         // Remove all the basic blocks of a function in order to start over, generating
         // LLVM IR from an empty function body.
@@ -1166,7 +1202,7 @@ pub const Object = struct {
 
         const builder = o.context.createBuilder();
 
-        function.body = {};
+        function.ptr(&o.builder).body = {};
         const entry_block = o.context.appendBasicBlock(llvm_func, "Entry");
         builder.positionBuilderAtEnd(entry_block);
 
@@ -1487,8 +1523,8 @@ pub const Object = struct {
         const gpa = mod.gpa;
         // If the module does not already have the function, we ignore this function call
         // because we call `updateDeclExports` at the end of `updateFunc` and `updateDecl`.
-        const global_index = self.decl_map.get(decl_index) orelse return;
-        const llvm_global = global_index.toLlvm(&self.builder);
+        const global = self.decl_map.get(decl_index) orelse return;
+        const llvm_global = global.toLlvm(&self.builder);
         const decl = mod.declPtr(decl_index);
         if (decl.isExtern(mod)) {
             const decl_name = decl_name: {
@@ -1511,18 +1547,17 @@ pub const Object = struct {
                 }
             }
 
-            try global_index.rename(&self.builder, decl_name);
-            const decl_name_slice = decl_name.toSlice(&self.builder).?;
-            const global = global_index.ptr(&self.builder);
-            global.unnamed_addr = .default;
+            try global.rename(&self.builder, decl_name);
+            global.ptr(&self.builder).unnamed_addr = .default;
             llvm_global.setUnnamedAddr(.False);
-            global.linkage = .external;
+            global.ptr(&self.builder).linkage = .external;
             llvm_global.setLinkage(.External);
             if (mod.wantDllExports()) {
-                global.dll_storage_class = .default;
+                global.ptr(&self.builder).dll_storage_class = .default;
                 llvm_global.setDLLStorageClass(.Default);
             }
             if (self.di_map.get(decl)) |di_node| {
+                const decl_name_slice = decl_name.toSlice(&self.builder).?;
                 if (try decl.isFunction(mod)) {
                     const di_func = @as(*llvm.DISubprogram, @ptrCast(di_node));
                     const linkage_name = llvm.MDString.get(self.context, decl_name_slice.ptr, decl_name_slice.len);
@@ -1533,21 +1568,31 @@ pub const Object = struct {
                     di_global.replaceLinkageName(linkage_name);
                 }
             }
-            if (decl.val.getVariable(mod)) |variable| {
-                if (variable.is_threadlocal) {
+            if (decl.val.getVariable(mod)) |decl_var| {
+                if (decl_var.is_threadlocal) {
+                    global.ptrConst(&self.builder).kind.variable.ptr(&self.builder).thread_local =
+                        .generaldynamic;
                     llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
                 } else {
+                    global.ptrConst(&self.builder).kind.variable.ptr(&self.builder).thread_local =
+                        .default;
                     llvm_global.setThreadLocalMode(.NotThreadLocal);
                 }
-                if (variable.is_weak_linkage) {
+                if (decl_var.is_weak_linkage) {
+                    global.ptr(&self.builder).linkage = .extern_weak;
                     llvm_global.setLinkage(.ExternalWeak);
                 }
             }
+            global.ptr(&self.builder).updateAttributes();
         } else if (exports.len != 0) {
             const exp_name = try self.builder.string(mod.intern_pool.stringToSlice(exports[0].opts.name));
-            try global_index.rename(&self.builder, exp_name);
+            try global.rename(&self.builder, exp_name);
+            global.ptr(&self.builder).unnamed_addr = .default;
             llvm_global.setUnnamedAddr(.False);
-            if (mod.wantDllExports()) llvm_global.setDLLStorageClass(.DLLExport);
+            if (mod.wantDllExports()) {
+                global.ptr(&self.builder).dll_storage_class = .dllexport;
+                llvm_global.setDLLStorageClass(.DLLExport);
+            }
             if (self.di_map.get(decl)) |di_node| {
                 const exp_name_slice = exp_name.toSlice(&self.builder).?;
                 if (try decl.isFunction(mod)) {
@@ -1562,23 +1607,45 @@ pub const Object = struct {
             }
             switch (exports[0].opts.linkage) {
                 .Internal => unreachable,
-                .Strong => llvm_global.setLinkage(.External),
-                .Weak => llvm_global.setLinkage(.WeakODR),
-                .LinkOnce => llvm_global.setLinkage(.LinkOnceODR),
+                .Strong => {
+                    global.ptr(&self.builder).linkage = .external;
+                    llvm_global.setLinkage(.External);
+                },
+                .Weak => {
+                    global.ptr(&self.builder).linkage = .weak_odr;
+                    llvm_global.setLinkage(.WeakODR);
+                },
+                .LinkOnce => {
+                    global.ptr(&self.builder).linkage = .linkonce_odr;
+                    llvm_global.setLinkage(.LinkOnceODR);
+                },
             }
             switch (exports[0].opts.visibility) {
-                .default => llvm_global.setVisibility(.Default),
-                .hidden => llvm_global.setVisibility(.Hidden),
-                .protected => llvm_global.setVisibility(.Protected),
+                .default => {
+                    global.ptr(&self.builder).visibility = .default;
+                    llvm_global.setVisibility(.Default);
+                },
+                .hidden => {
+                    global.ptr(&self.builder).visibility = .hidden;
+                    llvm_global.setVisibility(.Hidden);
+                },
+                .protected => {
+                    global.ptr(&self.builder).visibility = .protected;
+                    llvm_global.setVisibility(.Protected);
+                },
             }
             if (mod.intern_pool.stringToSliceUnwrap(exports[0].opts.section)) |section| {
+                global.ptr(&self.builder).section = try self.builder.string(section);
                 llvm_global.setSection(section);
             }
-            if (decl.val.getVariable(mod)) |variable| {
-                if (variable.is_threadlocal) {
+            if (decl.val.getVariable(mod)) |decl_var| {
+                if (decl_var.is_threadlocal) {
+                    global.ptrConst(&self.builder).kind.variable.ptr(&self.builder).thread_local =
+                        .generaldynamic;
                     llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
                 }
             }
+            global.ptr(&self.builder).updateAttributes();
 
             // If a Decl is exported more than one time (which is rare),
             // we add aliases for all but the first export.
@@ -1602,18 +1669,28 @@ pub const Object = struct {
             }
         } else {
             const fqn = try self.builder.string(mod.intern_pool.stringToSlice(try decl.getFullyQualifiedName(mod)));
-            try global_index.rename(&self.builder, fqn);
+            try global.rename(&self.builder, fqn);
+            global.ptr(&self.builder).linkage = .internal;
             llvm_global.setLinkage(.Internal);
-            if (mod.wantDllExports()) llvm_global.setDLLStorageClass(.Default);
+            if (mod.wantDllExports()) {
+                global.ptr(&self.builder).dll_storage_class = .default;
+                llvm_global.setDLLStorageClass(.Default);
+            }
+            global.ptr(&self.builder).unnamed_addr = .unnamed_addr;
             llvm_global.setUnnamedAddr(.True);
-            if (decl.val.getVariable(mod)) |variable| {
+            if (decl.val.getVariable(mod)) |decl_var| {
                 const single_threaded = mod.comp.bin_file.options.single_threaded;
-                if (variable.is_threadlocal and !single_threaded) {
+                if (decl_var.is_threadlocal and !single_threaded) {
+                    global.ptrConst(&self.builder).kind.variable.ptr(&self.builder).thread_local =
+                        .generaldynamic;
                     llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
                 } else {
+                    global.ptrConst(&self.builder).kind.variable.ptr(&self.builder).thread_local =
+                        .default;
                     llvm_global.setThreadLocalMode(.NotThreadLocal);
                 }
             }
+            global.ptr(&self.builder).updateAttributes();
         }
     }
 
@@ -2658,31 +2735,44 @@ pub const Object = struct {
         const mod = o.module;
         const target = mod.getTarget();
         const ty = try mod.intern(.{ .opt_type = .usize_type });
-        const null_opt_usize = try mod.intern(.{ .opt = .{
+
+        const llvm_init = try o.lowerValue(try mod.intern(.{ .opt = .{
             .ty = ty,
             .val = .none,
-        } });
-
-        const llvm_init = try o.lowerValue(.{
-            .ty = ty.toType(),
-            .val = null_opt_usize.toValue(),
-        });
+        } }));
+        const llvm_ty = llvm_init.typeOf(&o.builder);
         const llvm_wanted_addrspace = toLlvmAddressSpace(.generic, target);
         const llvm_actual_addrspace = toLlvmGlobalAddressSpace(.generic, target);
-        const global = o.llvm_module.addGlobalInAddressSpace(
-            llvm_init.typeOf(),
+        const llvm_alignment = ty.toType().abiAlignment(mod);
+        const llvm_global = o.llvm_module.addGlobalInAddressSpace(
+            llvm_ty.toLlvm(&o.builder),
             "",
             @intFromEnum(llvm_actual_addrspace),
         );
-        global.setLinkage(.Internal);
-        global.setUnnamedAddr(.True);
-        global.setAlignment(ty.toType().abiAlignment(mod));
-        global.setInitializer(llvm_init);
+        llvm_global.setLinkage(.Internal);
+        llvm_global.setUnnamedAddr(.True);
+        llvm_global.setAlignment(llvm_alignment);
+        llvm_global.setInitializer(llvm_init.toLlvm(&o.builder));
+
+        var global = Builder.Global{
+            .linkage = .internal,
+            .unnamed_addr = .unnamed_addr,
+            .type = llvm_ty,
+            .alignment = Builder.Alignment.fromByteUnits(llvm_alignment),
+            .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
+        };
+        var variable = Builder.Variable{
+            .global = @enumFromInt(o.builder.globals.count()),
+            .init = llvm_init,
+        };
+        try o.builder.llvm_globals.append(o.gpa, llvm_global);
+        _ = try o.builder.addGlobal(.none, global);
+        try o.builder.variables.append(o.gpa, variable);
 
         const addrspace_casted_global = if (llvm_wanted_addrspace != llvm_actual_addrspace)
-            global.constAddrSpaceCast(o.context.pointerType(@intFromEnum(llvm_wanted_addrspace)))
+            llvm_global.constAddrSpaceCast((try o.builder.ptrType(llvm_wanted_addrspace)).toLlvm(&o.builder))
         else
-            global;
+            llvm_global;
 
         o.null_opt_addr = addrspace_casted_global;
         return addrspace_casted_global;
@@ -2691,7 +2781,7 @@ pub const Object = struct {
     /// If the llvm function does not exist, create it.
     /// Note that this can be called before the function's semantic analysis has
     /// completed, so if any attributes rely on that, they must be done in updateFunc, not here.
-    fn resolveLlvmFunction(o: *Object, decl_index: Module.Decl.Index) !Builder.Function.Index {
+    fn resolveLlvmFunction(o: *Object, decl_index: Module.Decl.Index) Allocator.Error!Builder.Function.Index {
         const mod = o.module;
         const gpa = o.gpa;
         const decl = mod.declPtr(decl_index);
@@ -2722,7 +2812,9 @@ pub const Object = struct {
 
         const is_extern = decl.isExtern(mod);
         if (!is_extern) {
+            global.linkage = .internal;
             llvm_fn.setLinkage(.Internal);
+            global.unnamed_addr = .unnamed_addr;
             llvm_fn.setUnnamedAddr(.True);
         } else {
             if (target.isWasm()) {
@@ -2767,7 +2859,8 @@ pub const Object = struct {
         }
 
         if (fn_info.alignment.toByteUnitsOptional()) |a| {
-            llvm_fn.setAlignment(@as(c_uint, @intCast(a)));
+            global.alignment = Builder.Alignment.fromByteUnits(a);
+            llvm_fn.setAlignment(@intCast(a));
         }
 
         // Function attributes that are independent of analysis results of the function body.
@@ -2864,9 +2957,9 @@ pub const Object = struct {
         }
     }
 
-    fn resolveGlobalDecl(o: *Object, decl_index: Module.Decl.Index) Error!Builder.Object.Index {
+    fn resolveGlobalDecl(o: *Object, decl_index: Module.Decl.Index) Allocator.Error!Builder.Variable.Index {
         const gop = try o.decl_map.getOrPut(o.gpa, decl_index);
-        if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.object;
+        if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.variable;
         errdefer assert(o.decl_map.remove(decl_index));
 
         const mod = o.module;
@@ -2880,9 +2973,9 @@ pub const Object = struct {
         var global = Builder.Global{
             .addr_space = toLlvmGlobalAddressSpace(decl.@"addrspace", target),
             .type = try o.lowerType(decl.ty),
-            .kind = .{ .object = @enumFromInt(o.builder.objects.items.len) },
+            .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
         };
-        var object = Builder.Object{
+        var variable = Builder.Variable{
             .global = @enumFromInt(o.builder.globals.count()),
         };
 
@@ -2903,16 +2996,16 @@ pub const Object = struct {
             llvm_global.setUnnamedAddr(.False);
             global.linkage = .external;
             llvm_global.setLinkage(.External);
-            if (decl.val.getVariable(mod)) |variable| {
+            if (decl.val.getVariable(mod)) |decl_var| {
                 const single_threaded = mod.comp.bin_file.options.single_threaded;
-                if (variable.is_threadlocal and !single_threaded) {
-                    object.thread_local = .generaldynamic;
+                if (decl_var.is_threadlocal and !single_threaded) {
+                    variable.thread_local = .generaldynamic;
                     llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
                 } else {
-                    object.thread_local = .default;
+                    variable.thread_local = .default;
                     llvm_global.setThreadLocalMode(.NotThreadLocal);
                 }
-                if (variable.is_weak_linkage) {
+                if (decl_var.is_weak_linkage) {
                     global.linkage = .extern_weak;
                     llvm_global.setLinkage(.ExternalWeak);
                 }
@@ -2926,17 +3019,8 @@ pub const Object = struct {
 
         try o.builder.llvm_globals.append(o.gpa, llvm_global);
         gop.value_ptr.* = try o.builder.addGlobal(name, global);
-        try o.builder.objects.append(o.gpa, object);
-        return global.kind.object;
-    }
-
-    fn isUnnamedType(o: *Object, ty: Type, val: *llvm.Value) bool {
-        // Once `lowerType` succeeds, successive calls to it with the same Zig type
-        // are guaranteed to succeed. So if a call to `lowerType` fails here it means
-        // it is the first time lowering the type, which means the value can't possible
-        // have that type.
-        const llvm_ty = (o.lowerType(ty) catch return true).toLlvm(&o.builder);
-        return val.typeOf() != llvm_ty;
+        try o.builder.variables.append(o.gpa, variable);
+        return global.kind.variable;
     }
 
     fn lowerType(o: *Object, t: Type) Allocator.Error!Builder.Type {
@@ -3069,14 +3153,17 @@ pub const Object = struct {
             => unreachable,
             else => switch (mod.intern_pool.indexToKey(t.toIntern())) {
                 .int_type => |int_type| try o.builder.intType(int_type.bits),
-                .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-                    .One, .Many, .C => try o.builder.ptrType(
+                .ptr_type => |ptr_type| type: {
+                    const ptr_ty = try o.builder.ptrType(
                         toLlvmAddressSpace(ptr_type.flags.address_space, target),
-                    ),
-                    .Slice => try o.builder.structType(.normal, &.{
-                        .ptr,
-                        try o.lowerType(Type.usize),
-                    }),
+                    );
+                    break :type switch (ptr_type.flags.size) {
+                        .One, .Many, .C => ptr_ty,
+                        .Slice => try o.builder.structType(.normal, &.{
+                            ptr_ty,
+                            try o.lowerType(Type.usize),
+                        }),
+                    };
                 },
                 .array_type => |array_type| o.builder.arrayType(
                     array_type.len + @intFromBool(array_type.sentinel != .none),
@@ -3094,13 +3181,16 @@ pub const Object = struct {
                     if (t.optionalReprIsPayload(mod)) return payload_ty;
 
                     comptime assert(optional_layout_version == 3);
-                    var fields_buf: [3]Builder.Type = .{ payload_ty, .i8, .none };
+                    var fields: [3]Builder.Type = .{ payload_ty, .i8, undefined };
+                    var fields_len: usize = 2;
                     const offset = child_ty.toType().abiSize(mod) + 1;
                     const abi_size = t.abiSize(mod);
-                    const padding = abi_size - offset;
-                    if (padding == 0) return o.builder.structType(.normal, fields_buf[0..2]);
-                    fields_buf[2] = try o.builder.arrayType(padding, .i8);
-                    return o.builder.structType(.normal, fields_buf[0..3]);
+                    const padding_len = abi_size - offset;
+                    if (padding_len > 0) {
+                        fields[2] = try o.builder.arrayType(padding_len, .i8);
+                        fields_len = 3;
+                    }
+                    return o.builder.structType(.normal, fields[0..fields_len]);
                 },
                 .anyframe_type => @panic("TODO implement lowerType for AnyFrame types"),
                 .error_union_type => |error_union_type| {
@@ -3115,30 +3205,30 @@ pub const Object = struct {
                     const payload_size = error_union_type.payload_type.toType().abiSize(mod);
                     const error_size = Type.err_int.abiSize(mod);
 
-                    var fields_buf: [3]Builder.Type = undefined;
-                    if (error_align > payload_align) {
-                        fields_buf[0] = error_type;
-                        fields_buf[1] = payload_type;
+                    var fields: [3]Builder.Type = undefined;
+                    var fields_len: usize = 2;
+                    const padding_len = if (error_align > payload_align) pad: {
+                        fields[0] = error_type;
+                        fields[1] = payload_type;
                         const payload_end =
                             std.mem.alignForward(u64, error_size, payload_align) +
                             payload_size;
                         const abi_size = std.mem.alignForward(u64, payload_end, error_align);
-                        const padding = abi_size - payload_end;
-                        if (padding == 0) return o.builder.structType(.normal, fields_buf[0..2]);
-                        fields_buf[2] = try o.builder.arrayType(padding, .i8);
-                        return o.builder.structType(.normal, fields_buf[0..3]);
-                    } else {
-                        fields_buf[0] = payload_type;
-                        fields_buf[1] = error_type;
+                        break :pad abi_size - payload_end;
+                    } else pad: {
+                        fields[0] = payload_type;
+                        fields[1] = error_type;
                         const error_end =
                             std.mem.alignForward(u64, payload_size, error_align) +
                             error_size;
                         const abi_size = std.mem.alignForward(u64, error_end, payload_align);
-                        const padding = abi_size - error_end;
-                        if (padding == 0) return o.builder.structType(.normal, fields_buf[0..2]);
-                        fields_buf[2] = try o.builder.arrayType(padding, .i8);
-                        return o.builder.structType(.normal, fields_buf[0..3]);
+                        break :pad abi_size - error_end;
+                    };
+                    if (padding_len > 0) {
+                        fields[2] = try o.builder.arrayType(padding_len, .i8);
+                        fields_len = 3;
                     }
+                    return o.builder.structType(.normal, fields[0..fields_len]);
                 },
                 .simple_type => unreachable,
                 .struct_type => |struct_type| {
@@ -3371,6 +3461,7 @@ pub const Object = struct {
     fn lowerTypeFn(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type {
         const mod = o.module;
         const ip = &mod.intern_pool;
+        const target = mod.getTarget();
         const ret_ty = try lowerFnRetTy(o, fn_info);
 
         var llvm_params = std.ArrayListUnmanaged(Builder.Type){};
@@ -3404,7 +3495,11 @@ pub const Object = struct {
                 ));
             },
             .slice => {
-                try llvm_params.appendSlice(o.gpa, &.{ .ptr, try o.lowerType(Type.usize) });
+                const param_ty = fn_info.param_types.get(ip)[it.zig_index - 1].toType();
+                try llvm_params.appendSlice(o.gpa, &.{
+                    try o.builder.ptrType(toLlvmAddressSpace(param_ty.ptrAddressSpace(mod), target)),
+                    try o.lowerType(Type.usize),
+                });
             },
             .multiple_llvm_types => {
                 try llvm_params.appendSlice(o.gpa, it.types_buffer[0..it.types_len]);
@@ -3433,20 +3528,23 @@ pub const Object = struct {
         );
     }
 
-    fn lowerValue(o: *Object, arg_tv: TypedValue) Error!*llvm.Value {
+    fn lowerValue(o: *Object, arg_val: InternPool.Index) Error!Builder.Constant {
         const mod = o.module;
-        const gpa = o.gpa;
         const target = mod.getTarget();
-        var tv = arg_tv;
-        switch (mod.intern_pool.indexToKey(tv.val.toIntern())) {
-            .runtime_value => |rt| tv.val = rt.val.toValue(),
+
+        var val = arg_val.toValue();
+        const arg_val_key = mod.intern_pool.indexToKey(arg_val);
+        switch (arg_val_key) {
+            .runtime_value => |rt| val = rt.val.toValue(),
             else => {},
         }
-        if (tv.val.isUndefDeep(mod)) {
-            return (try o.lowerType(tv.ty)).toLlvm(&o.builder).getUndef();
+        if (val.isUndefDeep(mod)) {
+            return o.builder.undefConst(try o.lowerType(arg_val_key.typeOf().toType()));
         }
 
-        switch (mod.intern_pool.indexToKey(tv.val.toIntern())) {
+        const val_key = mod.intern_pool.indexToKey(val.toIntern());
+        const ty = val_key.typeOf().toType();
+        return switch (val_key) {
             .int_type,
             .ptr_type,
             .array_type,
@@ -3474,8 +3572,8 @@ pub const Object = struct {
                 .@"unreachable",
                 .generic_poison,
                 => unreachable, // non-runtime values
-                .false => return Builder.Constant.false.toLlvm(&o.builder),
-                .true => return Builder.Constant.true.toLlvm(&o.builder),
+                .false => .false,
+                .true => .true,
             },
             .variable,
             .enum_literal,
@@ -3486,259 +3584,266 @@ pub const Object = struct {
                 const fn_decl = mod.declPtr(fn_decl_index);
                 try mod.markDeclAlive(fn_decl);
                 const function_index = try o.resolveLlvmFunction(fn_decl_index);
-                return function_index.toLlvm(&o.builder);
+                return function_index.ptrConst(&o.builder).global.toConst();
             },
             .func => |func| {
                 const fn_decl_index = func.owner_decl;
                 const fn_decl = mod.declPtr(fn_decl_index);
                 try mod.markDeclAlive(fn_decl);
                 const function_index = try o.resolveLlvmFunction(fn_decl_index);
-                return function_index.toLlvm(&o.builder);
+                return function_index.ptrConst(&o.builder).global.toConst();
             },
             .int => {
                 var bigint_space: Value.BigIntSpace = undefined;
-                const bigint = tv.val.toBigInt(&bigint_space, mod);
-                return lowerBigInt(o, tv.ty, bigint);
+                const bigint = val.toBigInt(&bigint_space, mod);
+                return lowerBigInt(o, ty, bigint);
             },
             .err => |err| {
                 const int = try mod.getErrorValue(err.name);
                 const llvm_int = try o.builder.intConst(Builder.Type.err_int, int);
-                return llvm_int.toLlvm(&o.builder);
+                return llvm_int;
             },
             .error_union => |error_union| {
-                const err_tv: TypedValue = switch (error_union.val) {
-                    .err_name => |err_name| .{
-                        .ty = tv.ty.errorUnionSet(mod),
-                        .val = (try mod.intern(.{ .err = .{
-                            .ty = tv.ty.errorUnionSet(mod).toIntern(),
-                            .name = err_name,
-                        } })).toValue(),
-                    },
-                    .payload => .{
-                        .ty = Type.err_int,
-                        .val = try mod.intValue(Type.err_int, 0),
-                    },
+                const err_val = switch (error_union.val) {
+                    .err_name => |err_name| try mod.intern(.{ .err = .{
+                        .ty = ty.errorUnionSet(mod).toIntern(),
+                        .name = err_name,
+                    } }),
+                    .payload => (try mod.intValue(Type.err_int, 0)).toIntern(),
                 };
-                const payload_type = tv.ty.errorUnionPayload(mod);
+                const payload_type = ty.errorUnionPayload(mod);
                 if (!payload_type.hasRuntimeBitsIgnoreComptime(mod)) {
                     // We use the error type directly as the type.
-                    return o.lowerValue(err_tv);
+                    return o.lowerValue(err_val);
                 }
 
                 const payload_align = payload_type.abiAlignment(mod);
-                const error_align = err_tv.ty.abiAlignment(mod);
-                const llvm_error_value = try o.lowerValue(err_tv);
-                const llvm_payload_value = try o.lowerValue(.{
-                    .ty = payload_type,
-                    .val = switch (error_union.val) {
-                        .err_name => try mod.intern(.{ .undef = payload_type.toIntern() }),
-                        .payload => |payload| payload,
-                    }.toValue(),
+                const error_align = Type.err_int.abiAlignment(mod);
+                const llvm_error_value = try o.lowerValue(err_val);
+                const llvm_payload_value = try o.lowerValue(switch (error_union.val) {
+                    .err_name => try mod.intern(.{ .undef = payload_type.toIntern() }),
+                    .payload => |payload| payload,
                 });
-                var fields_buf: [3]*llvm.Value = undefined;
-
-                const llvm_ty = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-                const llvm_field_count = llvm_ty.countStructElementTypes();
-                if (llvm_field_count > 2) {
-                    assert(llvm_field_count == 3);
-                    fields_buf[2] = llvm_ty.structGetTypeAtIndex(2).getUndef();
-                }
 
+                var fields: [3]Builder.Type = undefined;
+                var vals: [3]Builder.Constant = undefined;
                 if (error_align > payload_align) {
-                    fields_buf[0] = llvm_error_value;
-                    fields_buf[1] = llvm_payload_value;
-                    return o.context.constStruct(&fields_buf, llvm_field_count, .False);
+                    vals[0] = llvm_error_value;
+                    vals[1] = llvm_payload_value;
                 } else {
-                    fields_buf[0] = llvm_payload_value;
-                    fields_buf[1] = llvm_error_value;
-                    return o.context.constStruct(&fields_buf, llvm_field_count, .False);
+                    vals[0] = llvm_payload_value;
+                    vals[1] = llvm_error_value;
                 }
+                fields[0] = vals[0].typeOf(&o.builder);
+                fields[1] = vals[1].typeOf(&o.builder);
+
+                const llvm_ty = try o.lowerType(ty);
+                const llvm_ty_fields = llvm_ty.structFields(&o.builder);
+                if (llvm_ty_fields.len > 2) {
+                    assert(llvm_ty_fields.len == 3);
+                    fields[2] = llvm_ty_fields[2];
+                    vals[2] = try o.builder.undefConst(fields[2]);
+                }
+                return o.builder.structConst(try o.builder.structType(
+                    llvm_ty.structKind(&o.builder),
+                    fields[0..llvm_ty_fields.len],
+                ), vals[0..llvm_ty_fields.len]);
             },
-            .enum_tag => |enum_tag| return o.lowerValue(.{
-                .ty = mod.intern_pool.typeOf(enum_tag.int).toType(),
-                .val = enum_tag.int.toValue(),
-            }),
-            .float => return switch (tv.ty.floatBits(target)) {
-                16 => int: {
-                    const repr: i16 = @bitCast(tv.val.toFloat(f16, mod));
-                    break :int try o.builder.intConst(.i16, repr);
-                },
-                32 => int: {
-                    const repr: i32 = @bitCast(tv.val.toFloat(f32, mod));
-                    break :int try o.builder.intConst(.i32, repr);
-                },
-                64 => int: {
-                    const repr: i64 = @bitCast(tv.val.toFloat(f64, mod));
-                    break :int try o.builder.intConst(.i64, repr);
-                },
-                80 => int: {
-                    const repr: i80 = @bitCast(tv.val.toFloat(f80, mod));
-                    break :int try o.builder.intConst(.i80, repr);
-                },
-                128 => int: {
-                    const repr: i128 = @bitCast(tv.val.toFloat(f128, mod));
-                    break :int try o.builder.intConst(.i128, repr);
-                },
+            .enum_tag => |enum_tag| o.lowerValue(enum_tag.int),
+            .float => switch (ty.floatBits(target)) {
+                16 => if (backendSupportsF16(target))
+                    try o.builder.halfConst(val.toFloat(f16, mod))
+                else
+                    try o.builder.intConst(.i16, @as(i16, @bitCast(val.toFloat(f16, mod)))),
+                32 => try o.builder.floatConst(val.toFloat(f32, mod)),
+                64 => try o.builder.doubleConst(val.toFloat(f64, mod)),
+                80 => if (backendSupportsF80(target))
+                    try o.builder.x86_fp80Const(val.toFloat(f80, mod))
+                else
+                    try o.builder.intConst(.i80, @as(i80, @bitCast(val.toFloat(f80, mod)))),
+                128 => try o.builder.fp128Const(val.toFloat(f128, mod)),
                 else => unreachable,
-            }.toLlvm(&o.builder).constBitCast((try o.lowerType(tv.ty)).toLlvm(&o.builder)),
+            },
             .ptr => |ptr| {
-                const ptr_tv: TypedValue = switch (ptr.len) {
-                    .none => tv,
-                    else => .{ .ty = tv.ty.slicePtrFieldType(mod), .val = tv.val.slicePtr(mod) },
+                const ptr_ty = switch (ptr.len) {
+                    .none => ty,
+                    else => ty.slicePtrFieldType(mod),
                 };
-                const llvm_ptr_val = switch (ptr.addr) {
-                    .decl => |decl| try o.lowerDeclRefValue(ptr_tv, decl),
-                    .mut_decl => |mut_decl| try o.lowerDeclRefValue(ptr_tv, mut_decl.decl),
-                    .int => |int| try o.lowerIntAsPtr(int.toValue()),
+                const ptr_val = switch (ptr.addr) {
+                    .decl => |decl| try o.lowerDeclRefValue(ptr_ty, decl),
+                    .mut_decl => |mut_decl| try o.lowerDeclRefValue(ptr_ty, mut_decl.decl),
+                    .int => |int| try o.lowerIntAsPtr(int),
                     .eu_payload,
                     .opt_payload,
                     .elem,
                     .field,
-                    => try o.lowerParentPtr(ptr_tv.val, ptr_tv.ty.ptrInfo(mod).packed_offset.bit_offset % 8 == 0),
+                    => try o.lowerParentPtr(val, ty.ptrInfo(mod).packed_offset.bit_offset % 8 == 0),
                     .comptime_field => unreachable,
                 };
                 switch (ptr.len) {
-                    .none => return llvm_ptr_val,
-                    else => {
-                        const fields: [2]*llvm.Value = .{
-                            llvm_ptr_val,
-                            try o.lowerValue(.{ .ty = Type.usize, .val = ptr.len.toValue() }),
-                        };
-                        return o.context.constStruct(&fields, fields.len, .False);
-                    },
+                    .none => return ptr_val,
+                    else => return o.builder.structConst(try o.lowerType(ty), &.{
+                        ptr_val, try o.lowerValue(ptr.len),
+                    }),
                 }
             },
             .opt => |opt| {
                 comptime assert(optional_layout_version == 3);
-                const payload_ty = tv.ty.optionalChild(mod);
+                const payload_ty = ty.optionalChild(mod);
 
-                const non_null_bit = (try o.builder.intConst(.i8, @intFromBool(opt.val != .none))).toLlvm(&o.builder);
+                const non_null_bit = try o.builder.intConst(.i8, @intFromBool(opt.val != .none));
                 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                     return non_null_bit;
                 }
-                const llvm_ty = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-                if (tv.ty.optionalReprIsPayload(mod)) return switch (opt.val) {
-                    .none => llvm_ty.constNull(),
-                    else => |payload| o.lowerValue(.{ .ty = payload_ty, .val = payload.toValue() }),
+                const llvm_ty = try o.lowerType(ty);
+                if (ty.optionalReprIsPayload(mod)) return switch (opt.val) {
+                    .none => switch (llvm_ty.tag(&o.builder)) {
+                        .integer => try o.builder.intConst(llvm_ty, 0),
+                        .pointer => try o.builder.nullConst(llvm_ty),
+                        .structure => try o.builder.zeroInitConst(llvm_ty),
+                        else => unreachable,
+                    },
+                    else => |payload| try o.lowerValue(payload),
                 };
                 assert(payload_ty.zigTypeTag(mod) != .Fn);
 
-                const llvm_field_count = llvm_ty.countStructElementTypes();
-                var fields_buf: [3]*llvm.Value = undefined;
-                fields_buf[0] = try o.lowerValue(.{
-                    .ty = payload_ty,
-                    .val = switch (opt.val) {
-                        .none => try mod.intern(.{ .undef = payload_ty.toIntern() }),
-                        else => |payload| payload,
-                    }.toValue(),
+                var fields: [3]Builder.Type = undefined;
+                var vals: [3]Builder.Constant = undefined;
+                vals[0] = try o.lowerValue(switch (opt.val) {
+                    .none => try mod.intern(.{ .undef = payload_ty.toIntern() }),
+                    else => |payload| payload,
                 });
-                fields_buf[1] = non_null_bit;
-                if (llvm_field_count > 2) {
-                    assert(llvm_field_count == 3);
-                    fields_buf[2] = llvm_ty.structGetTypeAtIndex(2).getUndef();
+                vals[1] = non_null_bit;
+                fields[0] = vals[0].typeOf(&o.builder);
+                fields[1] = vals[1].typeOf(&o.builder);
+
+                const llvm_ty_fields = llvm_ty.structFields(&o.builder);
+                if (llvm_ty_fields.len > 2) {
+                    assert(llvm_ty_fields.len == 3);
+                    fields[2] = llvm_ty_fields[2];
+                    vals[2] = try o.builder.undefConst(fields[2]);
                 }
-                return o.context.constStruct(&fields_buf, llvm_field_count, .False);
+                return o.builder.structConst(try o.builder.structType(
+                    llvm_ty.structKind(&o.builder),
+                    fields[0..llvm_ty_fields.len],
+                ), vals[0..llvm_ty_fields.len]);
             },
-            .aggregate => |aggregate| switch (mod.intern_pool.indexToKey(tv.ty.toIntern())) {
-                .array_type => switch (aggregate.storage) {
-                    .bytes => |bytes| return o.context.constString(
-                        bytes.ptr,
-                        @as(c_uint, @intCast(tv.ty.arrayLenIncludingSentinel(mod))),
-                        .True, // Don't null terminate. Bytes has the sentinel, if any.
-                    ),
-                    .elems => |elem_vals| {
-                        const elem_ty = tv.ty.childType(mod);
-                        const llvm_elems = try gpa.alloc(*llvm.Value, elem_vals.len);
-                        defer gpa.free(llvm_elems);
+            .aggregate => |aggregate| switch (mod.intern_pool.indexToKey(ty.toIntern())) {
+                .array_type => |array_type| switch (aggregate.storage) {
+                    .bytes => |bytes| try o.builder.stringConst(try o.builder.string(bytes)),
+                    .elems => |elems| {
+                        const array_ty = try o.lowerType(ty);
+                        const elem_ty = array_ty.childType(&o.builder);
+                        assert(elems.len == array_ty.aggregateLen(&o.builder));
+
+                        const ExpectedContents = extern struct {
+                            vals: [Builder.expected_fields_len]Builder.Constant,
+                            fields: [Builder.expected_fields_len]Builder.Type,
+                        };
+                        var stack align(@max(
+                            @alignOf(std.heap.StackFallbackAllocator(0)),
+                            @alignOf(ExpectedContents),
+                        )) = std.heap.stackFallback(@sizeOf(ExpectedContents), o.gpa);
+                        const allocator = stack.get();
+                        const vals = try allocator.alloc(Builder.Constant, elems.len);
+                        defer allocator.free(vals);
+                        const fields = try allocator.alloc(Builder.Type, elems.len);
+                        defer allocator.free(fields);
+
                         var need_unnamed = false;
-                        for (elem_vals, 0..) |elem_val, i| {
-                            llvm_elems[i] = try o.lowerValue(.{ .ty = elem_ty, .val = elem_val.toValue() });
-                            need_unnamed = need_unnamed or o.isUnnamedType(elem_ty, llvm_elems[i]);
-                        }
-                        if (need_unnamed) {
-                            return o.context.constStruct(
-                                llvm_elems.ptr,
-                                @as(c_uint, @intCast(llvm_elems.len)),
-                                .True,
-                            );
-                        } else {
-                            const llvm_elem_ty = (try o.lowerType(elem_ty)).toLlvm(&o.builder);
-                            return llvm_elem_ty.constArray(
-                                llvm_elems.ptr,
-                                @as(c_uint, @intCast(llvm_elems.len)),
-                            );
+                        for (vals, fields, elems) |*result_val, *result_field, elem| {
+                            result_val.* = try o.lowerValue(elem);
+                            result_field.* = result_val.typeOf(&o.builder);
+                            if (result_field.* != elem_ty) need_unnamed = true;
                         }
+                        return if (need_unnamed) try o.builder.structConst(
+                            try o.builder.structType(.normal, fields),
+                            vals,
+                        ) else try o.builder.arrayConst(array_ty, vals);
                     },
-                    .repeated_elem => |val| {
-                        const elem_ty = tv.ty.childType(mod);
-                        const sentinel = tv.ty.sentinel(mod);
-                        const len = @as(usize, @intCast(tv.ty.arrayLen(mod)));
-                        const len_including_sent = len + @intFromBool(sentinel != null);
-                        const llvm_elems = try gpa.alloc(*llvm.Value, len_including_sent);
-                        defer gpa.free(llvm_elems);
+                    .repeated_elem => |elem| {
+                        const len: usize = @intCast(array_type.len);
+                        const len_including_sentinel: usize =
+                            @intCast(len + @intFromBool(array_type.sentinel != .none));
+                        const array_ty = try o.lowerType(ty);
+                        const elem_ty = array_ty.childType(&o.builder);
+
+                        const ExpectedContents = extern struct {
+                            vals: [Builder.expected_fields_len]Builder.Constant,
+                            fields: [Builder.expected_fields_len]Builder.Type,
+                        };
+                        var stack align(@max(
+                            @alignOf(std.heap.StackFallbackAllocator(0)),
+                            @alignOf(ExpectedContents),
+                        )) = std.heap.stackFallback(@sizeOf(ExpectedContents), o.gpa);
+                        const allocator = stack.get();
+                        const vals = try allocator.alloc(Builder.Constant, len_including_sentinel);
+                        defer allocator.free(vals);
+                        const fields = try allocator.alloc(Builder.Type, len_including_sentinel);
+                        defer allocator.free(fields);
 
                         var need_unnamed = false;
-                        if (len != 0) {
-                            for (llvm_elems[0..len]) |*elem| {
-                                elem.* = try o.lowerValue(.{ .ty = elem_ty, .val = val.toValue() });
-                            }
-                            need_unnamed = need_unnamed or o.isUnnamedType(elem_ty, llvm_elems[0]);
+                        @memset(vals[0..len], try o.lowerValue(elem));
+                        @memset(fields[0..len], vals[0].typeOf(&o.builder));
+                        if (fields[0] != elem_ty) need_unnamed = true;
+
+                        if (array_type.sentinel != .none) {
+                            vals[len] = try o.lowerValue(array_type.sentinel);
+                            fields[len] = vals[len].typeOf(&o.builder);
+                            if (fields[len] != elem_ty) need_unnamed = true;
                         }
 
-                        if (sentinel) |sent| {
-                            llvm_elems[len] = try o.lowerValue(.{ .ty = elem_ty, .val = sent });
-                            need_unnamed = need_unnamed or o.isUnnamedType(elem_ty, llvm_elems[len]);
-                        }
-
-                        if (need_unnamed) {
-                            return o.context.constStruct(
-                                llvm_elems.ptr,
-                                @as(c_uint, @intCast(llvm_elems.len)),
-                                .True,
-                            );
-                        } else {
-                            const llvm_elem_ty = (try o.lowerType(elem_ty)).toLlvm(&o.builder);
-                            return llvm_elem_ty.constArray(
-                                llvm_elems.ptr,
-                                @as(c_uint, @intCast(llvm_elems.len)),
-                            );
-                        }
+                        return if (need_unnamed) try o.builder.structConst(
+                            try o.builder.structType(.@"packed", fields),
+                            vals,
+                        ) else try o.builder.arrayConst(array_ty, vals);
                     },
                 },
                 .vector_type => |vector_type| {
-                    const elem_ty = vector_type.child.toType();
-                    const llvm_elems = try gpa.alloc(*llvm.Value, vector_type.len);
-                    defer gpa.free(llvm_elems);
-                    for (llvm_elems, 0..) |*llvm_elem, i| {
-                        llvm_elem.* = switch (aggregate.storage) {
-                            .bytes => |bytes| (try o.builder.intConst(.i8, bytes[i])).toLlvm(&o.builder),
-                            .elems => |elems| try o.lowerValue(.{
-                                .ty = elem_ty,
-                                .val = elems[i].toValue(),
-                            }),
-                            .repeated_elem => |elem| try o.lowerValue(.{
-                                .ty = elem_ty,
-                                .val = elem.toValue(),
-                            }),
-                        };
+                    const ExpectedContents = [Builder.expected_fields_len]Builder.Constant;
+                    var stack align(@max(
+                        @alignOf(std.heap.StackFallbackAllocator(0)),
+                        @alignOf(ExpectedContents),
+                    )) = std.heap.stackFallback(@sizeOf(ExpectedContents), o.gpa);
+                    const allocator = stack.get();
+                    const vals = try allocator.alloc(Builder.Constant, vector_type.len);
+                    defer allocator.free(vals);
+
+                    switch (aggregate.storage) {
+                        .bytes => |bytes| for (vals, bytes) |*result_val, byte| {
+                            result_val.* = try o.builder.intConst(.i8, byte);
+                        },
+                        .elems => |elems| for (vals, elems) |*result_val, elem| {
+                            result_val.* = try o.lowerValue(elem);
+                        },
+                        .repeated_elem => |elem| @memset(vals, try o.lowerValue(elem)),
                     }
-                    return llvm.constVector(
-                        llvm_elems.ptr,
-                        @as(c_uint, @intCast(llvm_elems.len)),
-                    );
+                    return o.builder.vectorConst(try o.lowerType(ty), vals);
                 },
                 .anon_struct_type => |tuple| {
-                    var llvm_fields: std.ArrayListUnmanaged(*llvm.Value) = .{};
-                    defer llvm_fields.deinit(gpa);
+                    const struct_ty = try o.lowerType(ty);
+                    const llvm_len = struct_ty.aggregateLen(&o.builder);
 
-                    try llvm_fields.ensureUnusedCapacity(gpa, tuple.types.len);
+                    const ExpectedContents = extern struct {
+                        vals: [Builder.expected_fields_len]Builder.Constant,
+                        fields: [Builder.expected_fields_len]Builder.Type,
+                    };
+                    var stack align(@max(
+                        @alignOf(std.heap.StackFallbackAllocator(0)),
+                        @alignOf(ExpectedContents),
+                    )) = std.heap.stackFallback(@sizeOf(ExpectedContents), o.gpa);
+                    const allocator = stack.get();
+                    const vals = try allocator.alloc(Builder.Constant, llvm_len);
+                    defer allocator.free(vals);
+                    const fields = try allocator.alloc(Builder.Type, llvm_len);
+                    defer allocator.free(fields);
 
                     comptime assert(struct_layout_version == 2);
+                    var llvm_index: usize = 0;
                     var offset: u64 = 0;
                     var big_align: u32 = 0;
                     var need_unnamed = false;
-
-                    for (tuple.types, tuple.values, 0..) |field_ty, field_val, i| {
+                    for (tuple.types, tuple.values, 0..) |field_ty, field_val, field_index| {
                         if (field_val != .none) continue;
                         if (!field_ty.toType().hasRuntimeBitsIgnoreComptime(mod)) continue;
 
@@ -3749,20 +3854,20 @@ pub const Object = struct {
 
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
-                            const llvm_array_ty = try o.builder.arrayType(padding_len, .i8);
                             // TODO make this and all other padding elsewhere in debug
                             // builds be 0xaa not undef.
-                            llvm_fields.appendAssumeCapacity(llvm_array_ty.toLlvm(&o.builder).getUndef());
+                            fields[llvm_index] = try o.builder.arrayType(padding_len, .i8);
+                            vals[llvm_index] = try o.builder.undefConst(fields[llvm_index]);
+                            assert(fields[llvm_index] == struct_ty.structFields(&o.builder)[llvm_index]);
+                            llvm_index += 1;
                         }
 
-                        const field_llvm_val = try o.lowerValue(.{
-                            .ty = field_ty.toType(),
-                            .val = try tv.val.fieldValue(mod, i),
-                        });
-
-                        need_unnamed = need_unnamed or o.isUnnamedType(field_ty.toType(), field_llvm_val);
-
-                        llvm_fields.appendAssumeCapacity(field_llvm_val);
+                        vals[llvm_index] =
+                            try o.lowerValue((try val.fieldValue(mod, field_index)).toIntern());
+                        fields[llvm_index] = vals[llvm_index].typeOf(&o.builder);
+                        if (fields[llvm_index] != struct_ty.structFields(&o.builder)[llvm_index])
+                            need_unnamed = true;
+                        llvm_index += 1;
 
                         offset += field_ty.toType().abiSize(mod);
                     }
@@ -3771,73 +3876,71 @@ pub const Object = struct {
                         offset = std.mem.alignForward(u64, offset, big_align);
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
-                            const llvm_array_ty = try o.builder.arrayType(padding_len, .i8);
-                            llvm_fields.appendAssumeCapacity(llvm_array_ty.toLlvm(&o.builder).getUndef());
+                            fields[llvm_index] = try o.builder.arrayType(padding_len, .i8);
+                            vals[llvm_index] = try o.builder.undefConst(fields[llvm_index]);
+                            assert(fields[llvm_index] == struct_ty.structFields(&o.builder)[llvm_index]);
+                            llvm_index += 1;
                         }
                     }
+                    assert(llvm_index == llvm_len);
 
-                    if (need_unnamed) {
-                        return o.context.constStruct(
-                            llvm_fields.items.ptr,
-                            @as(c_uint, @intCast(llvm_fields.items.len)),
-                            .False,
-                        );
-                    } else {
-                        const llvm_struct_ty = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-                        return llvm_struct_ty.constNamedStruct(
-                            llvm_fields.items.ptr,
-                            @as(c_uint, @intCast(llvm_fields.items.len)),
-                        );
-                    }
+                    return try o.builder.structConst(if (need_unnamed)
+                        try o.builder.structType(struct_ty.structKind(&o.builder), fields)
+                    else
+                        struct_ty, vals);
                 },
                 .struct_type => |struct_type| {
                     const struct_obj = mod.structPtrUnwrap(struct_type.index).?;
-                    const llvm_struct_ty = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-
+                    assert(struct_obj.haveLayout());
+                    const struct_ty = try o.lowerType(ty);
                     if (struct_obj.layout == .Packed) {
-                        assert(struct_obj.haveLayout());
-                        const big_bits = struct_obj.backing_int_ty.bitSize(mod);
-                        const int_llvm_ty = try o.builder.intType(@intCast(big_bits));
-                        const fields = struct_obj.fields.values();
                         comptime assert(Type.packed_struct_layout_version == 2);
-                        var running_int = (try o.builder.intConst(int_llvm_ty, 0)).toLlvm(&o.builder);
+                        var running_int = try o.builder.intConst(struct_ty, 0);
                         var running_bits: u16 = 0;
-                        for (fields, 0..) |field, i| {
+                        for (struct_obj.fields.values(), 0..) |field, field_index| {
                             if (!field.ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
 
-                            const non_int_val = try o.lowerValue(.{
-                                .ty = field.ty,
-                                .val = try tv.val.fieldValue(mod, i),
-                            });
-                            const ty_bit_size = @as(u16, @intCast(field.ty.bitSize(mod)));
-                            const small_int_ty = (try o.builder.intType(@intCast(ty_bit_size))).toLlvm(&o.builder);
-                            const small_int_val = if (field.ty.isPtrAtRuntime(mod))
-                                non_int_val.constPtrToInt(small_int_ty)
-                            else
-                                non_int_val.constBitCast(small_int_ty);
-                            const shift_rhs = (try o.builder.intConst(int_llvm_ty, running_bits)).toLlvm(&o.builder);
-                            // If the field is as large as the entire packed struct, this
-                            // zext would go from, e.g. i16 to i16. This is legal with
-                            // constZExtOrBitCast but not legal with constZExt.
-                            const extended_int_val = small_int_val.constZExtOrBitCast(int_llvm_ty.toLlvm(&o.builder));
-                            const shifted = extended_int_val.constShl(shift_rhs);
-                            running_int = running_int.constOr(shifted);
+                            const non_int_val =
+                                try o.lowerValue((try val.fieldValue(mod, field_index)).toIntern());
+                            const ty_bit_size: u16 = @intCast(field.ty.bitSize(mod));
+                            const small_int_ty = try o.builder.intType(ty_bit_size);
+                            const small_int_val = try o.builder.castConst(
+                                if (field.ty.isPtrAtRuntime(mod)) .ptrtoint else .bitcast,
+                                non_int_val,
+                                small_int_ty,
+                            );
+                            const shift_rhs = try o.builder.intConst(struct_ty, running_bits);
+                            const extended_int_val =
+                                try o.builder.convConst(.unsigned, small_int_val, struct_ty);
+                            const shifted = try o.builder.binConst(.shl, extended_int_val, shift_rhs);
+                            running_int = try o.builder.binConst(.@"or", running_int, shifted);
                             running_bits += ty_bit_size;
                         }
                         return running_int;
                     }
+                    const llvm_len = struct_ty.aggregateLen(&o.builder);
 
-                    const llvm_field_count = llvm_struct_ty.countStructElementTypes();
-                    var llvm_fields = try std.ArrayListUnmanaged(*llvm.Value).initCapacity(gpa, llvm_field_count);
-                    defer llvm_fields.deinit(gpa);
+                    const ExpectedContents = extern struct {
+                        vals: [Builder.expected_fields_len]Builder.Constant,
+                        fields: [Builder.expected_fields_len]Builder.Type,
+                    };
+                    var stack align(@max(
+                        @alignOf(std.heap.StackFallbackAllocator(0)),
+                        @alignOf(ExpectedContents),
+                    )) = std.heap.stackFallback(@sizeOf(ExpectedContents), o.gpa);
+                    const allocator = stack.get();
+                    const vals = try allocator.alloc(Builder.Constant, llvm_len);
+                    defer allocator.free(vals);
+                    const fields = try allocator.alloc(Builder.Type, llvm_len);
+                    defer allocator.free(fields);
 
                     comptime assert(struct_layout_version == 2);
+                    var llvm_index: usize = 0;
                     var offset: u64 = 0;
                     var big_align: u32 = 0;
                     var need_unnamed = false;
-
-                    var it = struct_obj.runtimeFieldIterator(mod);
-                    while (it.next()) |field_and_index| {
+                    var field_it = struct_obj.runtimeFieldIterator(mod);
+                    while (field_it.next()) |field_and_index| {
                         const field = field_and_index.field;
                         const field_align = field.alignment(mod, struct_obj.layout);
                         big_align = @max(big_align, field_align);
@@ -3846,20 +3949,22 @@ pub const Object = struct {
 
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
-                            const llvm_array_ty = try o.builder.arrayType(padding_len, .i8);
                             // TODO make this and all other padding elsewhere in debug
                             // builds be 0xaa not undef.
-                            llvm_fields.appendAssumeCapacity(llvm_array_ty.toLlvm(&o.builder).getUndef());
+                            fields[llvm_index] = try o.builder.arrayType(padding_len, .i8);
+                            vals[llvm_index] = try o.builder.undefConst(fields[llvm_index]);
+                            assert(fields[llvm_index] ==
+                                struct_ty.structFields(&o.builder)[llvm_index]);
+                            llvm_index += 1;
                         }
 
-                        const field_llvm_val = try o.lowerValue(.{
-                            .ty = field.ty,
-                            .val = try tv.val.fieldValue(mod, field_and_index.index),
-                        });
-
-                        need_unnamed = need_unnamed or o.isUnnamedType(field.ty, field_llvm_val);
-
-                        llvm_fields.appendAssumeCapacity(field_llvm_val);
+                        vals[llvm_index] = try o.lowerValue(
+                            (try val.fieldValue(mod, field_and_index.index)).toIntern(),
+                        );
+                        fields[llvm_index] = vals[llvm_index].typeOf(&o.builder);
+                        if (fields[llvm_index] != struct_ty.structFields(&o.builder)[llvm_index])
+                            need_unnamed = true;
+                        llvm_index += 1;
 
                         offset += field.ty.abiSize(mod);
                     }
@@ -3868,135 +3973,118 @@ pub const Object = struct {
                         offset = std.mem.alignForward(u64, offset, big_align);
                         const padding_len = offset - prev_offset;
                         if (padding_len > 0) {
-                            const llvm_array_ty = try o.builder.arrayType(padding_len, .i8);
-                            llvm_fields.appendAssumeCapacity(llvm_array_ty.toLlvm(&o.builder).getUndef());
+                            fields[llvm_index] = try o.builder.arrayType(padding_len, .i8);
+                            vals[llvm_index] = try o.builder.undefConst(fields[llvm_index]);
+                            assert(fields[llvm_index] == struct_ty.structFields(&o.builder)[llvm_index]);
+                            llvm_index += 1;
                         }
                     }
+                    assert(llvm_index == llvm_len);
 
-                    if (need_unnamed) {
-                        return o.context.constStruct(
-                            llvm_fields.items.ptr,
-                            @as(c_uint, @intCast(llvm_fields.items.len)),
-                            .False,
-                        );
-                    } else {
-                        return llvm_struct_ty.constNamedStruct(
-                            llvm_fields.items.ptr,
-                            @as(c_uint, @intCast(llvm_fields.items.len)),
-                        );
-                    }
+                    return try o.builder.structConst(if (need_unnamed)
+                        try o.builder.structType(struct_ty.structKind(&o.builder), fields)
+                    else
+                        struct_ty, vals);
                 },
                 else => unreachable,
             },
-            .un => {
-                const llvm_union_ty = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-                const tag_and_val: Value.Payload.Union.Data = switch (tv.val.toIntern()) {
-                    .none => tv.val.castTag(.@"union").?.data,
-                    else => switch (mod.intern_pool.indexToKey(tv.val.toIntern())) {
-                        .un => |un| .{ .tag = un.tag.toValue(), .val = un.val.toValue() },
-                        else => unreachable,
-                    },
-                };
+            .un => |un| {
+                const union_ty = try o.lowerType(ty);
+                const layout = ty.unionGetLayout(mod);
+                if (layout.payload_size == 0) return o.lowerValue(un.tag);
 
-                const layout = tv.ty.unionGetLayout(mod);
-
-                if (layout.payload_size == 0) {
-                    return lowerValue(o, .{
-                        .ty = tv.ty.unionTagTypeSafety(mod).?,
-                        .val = tag_and_val.tag,
-                    });
-                }
-                const union_obj = mod.typeToUnion(tv.ty).?;
-                const field_index = tv.ty.unionTagFieldIndex(tag_and_val.tag, o.module).?;
+                const union_obj = mod.typeToUnion(ty).?;
+                const field_index = ty.unionTagFieldIndex(un.tag.toValue(), o.module).?;
                 assert(union_obj.haveFieldTypes());
 
                 const field_ty = union_obj.fields.values()[field_index].ty;
                 if (union_obj.layout == .Packed) {
-                    if (!field_ty.hasRuntimeBits(mod))
-                        return llvm_union_ty.constNull();
-                    const non_int_val = try lowerValue(o, .{ .ty = field_ty, .val = tag_and_val.val });
-                    const ty_bit_size = @as(u16, @intCast(field_ty.bitSize(mod)));
-                    const small_int_ty = (try o.builder.intType(@intCast(ty_bit_size))).toLlvm(&o.builder);
-                    const small_int_val = if (field_ty.isPtrAtRuntime(mod))
-                        non_int_val.constPtrToInt(small_int_ty)
-                    else
-                        non_int_val.constBitCast(small_int_ty);
-                    return small_int_val.constZExtOrBitCast(llvm_union_ty);
+                    if (!field_ty.hasRuntimeBits(mod)) return o.builder.intConst(union_ty, 0);
+                    const small_int_val = try o.builder.castConst(
+                        if (field_ty.isPtrAtRuntime(mod)) .ptrtoint else .bitcast,
+                        try o.lowerValue(un.val),
+                        try o.builder.intType(@intCast(field_ty.bitSize(mod))),
+                    );
+                    return o.builder.convConst(.unsigned, small_int_val, union_ty);
                 }
 
                 // Sometimes we must make an unnamed struct because LLVM does
                 // not support bitcasting our payload struct to the true union payload type.
                 // Instead we use an unnamed struct and every reference to the global
                 // must pointer cast to the expected type before accessing the union.
-                var need_unnamed: bool = layout.most_aligned_field != field_index;
+                var need_unnamed = layout.most_aligned_field != field_index;
                 const payload = p: {
                     if (!field_ty.hasRuntimeBitsIgnoreComptime(mod)) {
-                        const padding_len = @as(c_uint, @intCast(layout.payload_size));
-                        break :p (try o.builder.arrayType(padding_len, .i8)).toLlvm(&o.builder).getUndef();
+                        const padding_len = layout.payload_size;
+                        break :p try o.builder.undefConst(try o.builder.arrayType(padding_len, .i8));
                     }
-                    const field = try lowerValue(o, .{ .ty = field_ty, .val = tag_and_val.val });
-                    need_unnamed = need_unnamed or o.isUnnamedType(field_ty, field);
+                    const payload = try o.lowerValue(un.val);
+                    const payload_ty = payload.typeOf(&o.builder);
+                    if (payload_ty != union_ty.structFields(&o.builder)[
+                        @intFromBool(layout.tag_align >= layout.payload_align)
+                    ]) need_unnamed = true;
                     const field_size = field_ty.abiSize(mod);
-                    if (field_size == layout.payload_size) {
-                        break :p field;
-                    }
-                    const padding_len = @as(c_uint, @intCast(layout.payload_size - field_size));
-                    const fields: [2]*llvm.Value = .{
-                        field, (try o.builder.arrayType(padding_len, .i8)).toLlvm(&o.builder).getUndef(),
-                    };
-                    break :p o.context.constStruct(&fields, fields.len, .True);
+                    if (field_size == layout.payload_size) break :p payload;
+                    const padding_len = layout.payload_size - field_size;
+                    const padding_ty = try o.builder.arrayType(padding_len, .i8);
+                    break :p try o.builder.structConst(
+                        try o.builder.structType(.@"packed", &.{ payload_ty, padding_ty }),
+                        &.{ payload, try o.builder.undefConst(padding_ty) },
+                    );
                 };
+                const payload_ty = payload.typeOf(&o.builder);
 
-                if (layout.tag_size == 0) {
-                    const fields: [1]*llvm.Value = .{payload};
-                    if (need_unnamed) {
-                        return o.context.constStruct(&fields, fields.len, .False);
-                    } else {
-                        return llvm_union_ty.constNamedStruct(&fields, fields.len);
-                    }
-                }
-                const llvm_tag_value = try lowerValue(o, .{
-                    .ty = tv.ty.unionTagTypeSafety(mod).?,
-                    .val = tag_and_val.tag,
-                });
-                var fields: [3]*llvm.Value = undefined;
-                var fields_len: c_uint = 2;
+                if (layout.tag_size == 0) return o.builder.structConst(if (need_unnamed)
+                    try o.builder.structType(union_ty.structKind(&o.builder), &.{payload_ty})
+                else
+                    union_ty, &.{payload});
+                const tag = try o.lowerValue(un.tag);
+                const tag_ty = tag.typeOf(&o.builder);
+                var fields: [3]Builder.Type = undefined;
+                var vals: [3]Builder.Constant = undefined;
+                var len: usize = 2;
                 if (layout.tag_align >= layout.payload_align) {
-                    fields = .{ llvm_tag_value, payload, undefined };
+                    fields = .{ tag_ty, payload_ty, undefined };
+                    vals = .{ tag, payload, undefined };
                 } else {
-                    fields = .{ payload, llvm_tag_value, undefined };
+                    fields = .{ payload_ty, tag_ty, undefined };
+                    vals = .{ payload, tag, undefined };
                 }
                 if (layout.padding != 0) {
-                    fields[2] = (try o.builder.arrayType(layout.padding, .i8)).toLlvm(&o.builder).getUndef();
-                    fields_len = 3;
-                }
-                if (need_unnamed) {
-                    return o.context.constStruct(&fields, fields_len, .False);
-                } else {
-                    return llvm_union_ty.constNamedStruct(&fields, fields_len);
+                    fields[2] = try o.builder.arrayType(layout.padding, .i8);
+                    vals[2] = try o.builder.undefConst(fields[2]);
+                    len = 3;
                 }
+                return try o.builder.structConst(if (need_unnamed)
+                    try o.builder.structType(union_ty.structKind(&o.builder), fields[0..len])
+                else
+                    union_ty, vals[0..len]);
             },
             .memoized_call => unreachable,
-        }
+        };
     }
 
-    fn lowerIntAsPtr(o: *Object, val: Value) Allocator.Error!*llvm.Value {
+    fn lowerIntAsPtr(o: *Object, val: InternPool.Index) Allocator.Error!Builder.Constant {
         const mod = o.module;
-        switch (mod.intern_pool.indexToKey(val.toIntern())) {
-            .undef => return o.context.pointerType(0).getUndef(),
+        switch (mod.intern_pool.indexToKey(val)) {
+            .undef => return o.builder.undefConst(.ptr),
             .int => {
                 var bigint_space: Value.BigIntSpace = undefined;
-                const bigint = val.toBigInt(&bigint_space, mod);
+                const bigint = val.toValue().toBigInt(&bigint_space, mod);
                 const llvm_int = try lowerBigInt(o, Type.usize, bigint);
-                return llvm_int.constIntToPtr(o.context.pointerType(0));
+                return o.builder.castConst(.inttoptr, llvm_int, .ptr);
             },
             else => unreachable,
         }
     }
 
-    fn lowerBigInt(o: *Object, ty: Type, bigint: std.math.big.int.Const) Allocator.Error!*llvm.Value {
-        return (try o.builder.bigIntConst(try o.builder.intType(ty.intInfo(o.module).bits), bigint))
-            .toLlvm(&o.builder);
+    fn lowerBigInt(
+        o: *Object,
+        ty: Type,
+        bigint: std.math.big.int.Const,
+    ) Allocator.Error!Builder.Constant {
+        const mod = o.module;
+        return o.builder.bigIntConst(try o.builder.intType(ty.intInfo(mod).bits), bigint);
     }
 
     const ParentPtr = struct {
@@ -4004,45 +4092,41 @@ pub const Object = struct {
         llvm_ptr: *llvm.Value,
     };
 
-    fn lowerParentPtrDecl(
-        o: *Object,
-        ptr_val: Value,
-        decl_index: Module.Decl.Index,
-    ) Error!*llvm.Value {
+    fn lowerParentPtrDecl(o: *Object, decl_index: Module.Decl.Index) Allocator.Error!Builder.Constant {
         const mod = o.module;
         const decl = mod.declPtr(decl_index);
         try mod.markDeclAlive(decl);
         const ptr_ty = try mod.singleMutPtrType(decl.ty);
-        return try o.lowerDeclRefValue(.{ .ty = ptr_ty, .val = ptr_val }, decl_index);
+        return o.lowerDeclRefValue(ptr_ty, decl_index);
     }
 
-    fn lowerParentPtr(o: *Object, ptr_val: Value, byte_aligned: bool) Error!*llvm.Value {
+    fn lowerParentPtr(o: *Object, ptr_val: Value, byte_aligned: bool) Allocator.Error!Builder.Constant {
         const mod = o.module;
         return switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {
-            .decl => |decl| o.lowerParentPtrDecl(ptr_val, decl),
-            .mut_decl => |mut_decl| o.lowerParentPtrDecl(ptr_val, mut_decl.decl),
-            .int => |int| o.lowerIntAsPtr(int.toValue()),
+            .decl => |decl| o.lowerParentPtrDecl(decl),
+            .mut_decl => |mut_decl| o.lowerParentPtrDecl(mut_decl.decl),
+            .int => |int| try o.lowerIntAsPtr(int),
             .eu_payload => |eu_ptr| {
-                const parent_llvm_ptr = try o.lowerParentPtr(eu_ptr.toValue(), true);
+                const parent_ptr = try o.lowerParentPtr(eu_ptr.toValue(), true);
 
                 const eu_ty = mod.intern_pool.typeOf(eu_ptr).toType().childType(mod);
                 const payload_ty = eu_ty.errorUnionPayload(mod);
                 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
                     // In this case, we represent pointer to error union the same as pointer
                     // to the payload.
-                    return parent_llvm_ptr;
+                    return parent_ptr;
                 }
 
-                const payload_offset: u8 = if (payload_ty.abiAlignment(mod) > Type.anyerror.abiSize(mod)) 2 else 1;
-                const indices: [2]*llvm.Value = .{
-                    (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
-                    (try o.builder.intConst(.i32, payload_offset)).toLlvm(&o.builder),
-                };
-                const eu_llvm_ty = (try o.lowerType(eu_ty)).toLlvm(&o.builder);
-                return eu_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
+                return o.builder.gepConst(.inbounds, try o.lowerType(eu_ty), parent_ptr, &.{
+                    try o.builder.intConst(.i32, 0),
+                    try o.builder.intConst(.i32, @as(
+                        i32,
+                        if (payload_ty.abiAlignment(mod) > Type.err_int.abiSize(mod)) 2 else 1,
+                    )),
+                });
             },
             .opt_payload => |opt_ptr| {
-                const parent_llvm_ptr = try o.lowerParentPtr(opt_ptr.toValue(), true);
+                const parent_ptr = try o.lowerParentPtr(opt_ptr.toValue(), true);
 
                 const opt_ty = mod.intern_pool.typeOf(opt_ptr).toType().childType(mod);
                 const payload_ty = opt_ty.optionalChild(mod);
@@ -4051,96 +4135,87 @@ pub const Object = struct {
                 {
                     // In this case, we represent pointer to optional the same as pointer
                     // to the payload.
-                    return parent_llvm_ptr;
+                    return parent_ptr;
                 }
 
-                const indices: [2]*llvm.Value = .{
-                    (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
-                } ** 2;
-                const opt_llvm_ty = (try o.lowerType(opt_ty)).toLlvm(&o.builder);
-                return opt_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
+                return o.builder.gepConst(.inbounds, try o.lowerType(opt_ty), parent_ptr, &(.{
+                    try o.builder.intConst(.i32, 0),
+                } ** 2));
             },
             .comptime_field => unreachable,
             .elem => |elem_ptr| {
-                const parent_llvm_ptr = try o.lowerParentPtr(elem_ptr.base.toValue(), true);
-
-                const indices: [1]*llvm.Value = .{
-                    (try o.builder.intConst(try o.lowerType(Type.usize), elem_ptr.index)).toLlvm(&o.builder),
-                };
+                const parent_ptr = try o.lowerParentPtr(elem_ptr.base.toValue(), true);
                 const elem_ty = mod.intern_pool.typeOf(elem_ptr.base).toType().elemType2(mod);
-                const elem_llvm_ty = (try o.lowerType(elem_ty)).toLlvm(&o.builder);
-                return elem_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
+
+                return o.builder.gepConst(.inbounds, try o.lowerType(elem_ty), parent_ptr, &.{
+                    try o.builder.intConst(try o.lowerType(Type.usize), elem_ptr.index),
+                });
             },
             .field => |field_ptr| {
-                const parent_llvm_ptr = try o.lowerParentPtr(field_ptr.base.toValue(), byte_aligned);
+                const parent_ptr = try o.lowerParentPtr(field_ptr.base.toValue(), byte_aligned);
                 const parent_ty = mod.intern_pool.typeOf(field_ptr.base).toType().childType(mod);
 
-                const field_index = @as(u32, @intCast(field_ptr.index));
+                const field_index: u32 = @intCast(field_ptr.index);
                 switch (parent_ty.zigTypeTag(mod)) {
                     .Union => {
                         if (parent_ty.containerLayout(mod) == .Packed) {
-                            return parent_llvm_ptr;
+                            return parent_ptr;
                         }
 
                         const layout = parent_ty.unionGetLayout(mod);
                         if (layout.payload_size == 0) {
                             // In this case a pointer to the union and a pointer to any
                             // (void) payload is the same.
-                            return parent_llvm_ptr;
+                            return parent_ptr;
                         }
-                        const llvm_pl_index = if (layout.tag_size == 0)
-                            0
-                        else
-                            @intFromBool(layout.tag_align >= layout.payload_align);
-                        const indices: [2]*llvm.Value = .{
-                            (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
-                            (try o.builder.intConst(.i32, llvm_pl_index)).toLlvm(&o.builder),
-                        };
-                        const parent_llvm_ty = (try o.lowerType(parent_ty)).toLlvm(&o.builder);
-                        return parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
+
+                        return o.builder.gepConst(.inbounds, try o.lowerType(parent_ty), parent_ptr, &.{
+                            try o.builder.intConst(.i32, 0),
+                            try o.builder.intConst(.i32, @intFromBool(
+                                layout.tag_size > 0 and layout.tag_align >= layout.payload_align,
+                            )),
+                        });
                     },
                     .Struct => {
                         if (parent_ty.containerLayout(mod) == .Packed) {
-                            if (!byte_aligned) return parent_llvm_ptr;
+                            if (!byte_aligned) return parent_ptr;
                             const llvm_usize = try o.lowerType(Type.usize);
-                            const base_addr = parent_llvm_ptr.constPtrToInt(llvm_usize.toLlvm(&o.builder));
+                            const base_addr =
+                                try o.builder.castConst(.ptrtoint, parent_ptr, llvm_usize);
                             // count bits of fields before this one
                             const prev_bits = b: {
                                 var b: usize = 0;
                                 for (parent_ty.structFields(mod).values()[0..field_index]) |field| {
                                     if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
-                                    b += @as(usize, @intCast(field.ty.bitSize(mod)));
+                                    b += @intCast(field.ty.bitSize(mod));
                                 }
                                 break :b b;
                             };
-                            const byte_offset = (try o.builder.intConst(llvm_usize, prev_bits / 8)).toLlvm(&o.builder);
-                            const field_addr = base_addr.constAdd(byte_offset);
-                            const final_llvm_ty = o.context.pointerType(0);
-                            return field_addr.constIntToPtr(final_llvm_ty);
+                            const byte_offset = try o.builder.intConst(llvm_usize, prev_bits / 8);
+                            const field_addr = try o.builder.binConst(.add, base_addr, byte_offset);
+                            return o.builder.castConst(.inttoptr, field_addr, .ptr);
                         }
 
-                        const parent_llvm_ty = (try o.lowerType(parent_ty)).toLlvm(&o.builder);
-                        if (llvmField(parent_ty, field_index, mod)) |llvm_field| {
-                            const indices: [2]*llvm.Value = .{
-                                (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
-                                (try o.builder.intConst(.i32, llvm_field.index)).toLlvm(&o.builder),
-                            };
-                            return parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
-                        } else {
-                            const indices: [1]*llvm.Value = .{
-                                (try o.builder.intConst(.i32, @intFromBool(parent_ty.hasRuntimeBitsIgnoreComptime(mod)))).toLlvm(&o.builder),
-                            };
-                            return parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
-                        }
+                        return o.builder.gepConst(
+                            .inbounds,
+                            try o.lowerType(parent_ty),
+                            parent_ptr,
+                            if (llvmField(parent_ty, field_index, mod)) |llvm_field| &.{
+                                try o.builder.intConst(.i32, 0),
+                                try o.builder.intConst(.i32, llvm_field.index),
+                            } else &.{
+                                try o.builder.intConst(.i32, @intFromBool(
+                                    parent_ty.hasRuntimeBitsIgnoreComptime(mod),
+                                )),
+                            },
+                        );
                     },
                     .Pointer => {
                         assert(parent_ty.isSlice(mod));
-                        const indices: [2]*llvm.Value = .{
-                            (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
-                            (try o.builder.intConst(.i32, field_index)).toLlvm(&o.builder),
-                        };
-                        const parent_llvm_ty = (try o.lowerType(parent_ty)).toLlvm(&o.builder);
-                        return parent_llvm_ty.constInBoundsGEP(parent_llvm_ptr, &indices, indices.len);
+                        return o.builder.gepConst(.inbounds, try o.lowerType(parent_ty), parent_ptr, &.{
+                            try o.builder.intConst(.i32, 0),
+                            try o.builder.intConst(.i32, field_index),
+                        });
                     },
                     else => unreachable,
                 }
@@ -4148,11 +4223,7 @@ pub const Object = struct {
         };
     }
 
-    fn lowerDeclRefValue(
-        o: *Object,
-        tv: TypedValue,
-        decl_index: Module.Decl.Index,
-    ) Error!*llvm.Value {
+    fn lowerDeclRefValue(o: *Object, ty: Type, decl_index: Module.Decl.Index) Allocator.Error!Builder.Constant {
         const mod = o.module;
 
         // In the case of something like:
@@ -4163,69 +4234,63 @@ pub const Object = struct {
         const decl = mod.declPtr(decl_index);
         if (decl.val.getFunction(mod)) |func| {
             if (func.owner_decl != decl_index) {
-                return o.lowerDeclRefValue(tv, func.owner_decl);
+                return o.lowerDeclRefValue(ty, func.owner_decl);
             }
         } else if (decl.val.getExternFunc(mod)) |func| {
             if (func.decl != decl_index) {
-                return o.lowerDeclRefValue(tv, func.decl);
+                return o.lowerDeclRefValue(ty, func.decl);
             }
         }
 
         const is_fn_body = decl.ty.zigTypeTag(mod) == .Fn;
         if ((!is_fn_body and !decl.ty.hasRuntimeBits(mod)) or
             (is_fn_body and mod.typeToFunc(decl.ty).?.is_generic))
-        {
-            return o.lowerPtrToVoid(tv.ty);
-        }
+            return o.lowerPtrToVoid(ty);
 
         try mod.markDeclAlive(decl);
 
-        const llvm_decl_val = if (is_fn_body)
-            (try o.resolveLlvmFunction(decl_index)).toLlvm(&o.builder)
+        const llvm_global = if (is_fn_body)
+            (try o.resolveLlvmFunction(decl_index)).ptrConst(&o.builder).global
         else
-            (try o.resolveGlobalDecl(decl_index)).toLlvm(&o.builder);
+            (try o.resolveGlobalDecl(decl_index)).ptrConst(&o.builder).global;
 
         const target = mod.getTarget();
         const llvm_wanted_addrspace = toLlvmAddressSpace(decl.@"addrspace", target);
         const llvm_actual_addrspace = toLlvmGlobalAddressSpace(decl.@"addrspace", target);
-        const llvm_val = if (llvm_wanted_addrspace != llvm_actual_addrspace) blk: {
-            const llvm_decl_wanted_ptr_ty = o.context.pointerType(@intFromEnum(llvm_wanted_addrspace));
-            break :blk llvm_decl_val.constAddrSpaceCast(llvm_decl_wanted_ptr_ty);
-        } else llvm_decl_val;
+        const llvm_val = if (llvm_wanted_addrspace != llvm_actual_addrspace) try o.builder.castConst(
+            .addrspacecast,
+            llvm_global.toConst(),
+            try o.builder.ptrType(llvm_wanted_addrspace),
+        ) else llvm_global.toConst();
 
-        const llvm_type = (try o.lowerType(tv.ty)).toLlvm(&o.builder);
-        if (tv.ty.zigTypeTag(mod) == .Int) {
-            return llvm_val.constPtrToInt(llvm_type);
-        } else {
-            return llvm_val.constBitCast(llvm_type);
-        }
+        return o.builder.convConst(if (ty.isAbiInt(mod)) switch (ty.intInfo(mod).signedness) {
+            .signed => .signed,
+            .unsigned => .unsigned,
+        } else .unneeded, llvm_val, try o.lowerType(ty));
     }
 
-    fn lowerPtrToVoid(o: *Object, ptr_ty: Type) !*llvm.Value {
+    fn lowerPtrToVoid(o: *Object, ptr_ty: Type) Allocator.Error!Builder.Constant {
         const mod = o.module;
         // Even though we are pointing at something which has zero bits (e.g. `void`),
         // Pointers are defined to have bits. So we must return something here.
         // The value cannot be undefined, because we use the `nonnull` annotation
         // for non-optional pointers. We also need to respect the alignment, even though
         // the address will never be dereferenced.
-        const llvm_usize = try o.lowerType(Type.usize);
-        const llvm_ptr_ty = (try o.lowerType(ptr_ty)).toLlvm(&o.builder);
-        if (ptr_ty.ptrInfo(mod).flags.alignment.toByteUnitsOptional()) |alignment| {
-            return (try o.builder.intConst(llvm_usize, alignment)).toLlvm(&o.builder).constIntToPtr(llvm_ptr_ty);
-        }
-        // Note that these 0xaa values are appropriate even in release-optimized builds
-        // because we need a well-defined value that is not null, and LLVM does not
-        // have an "undef_but_not_null" attribute. As an example, if this `alloc` AIR
-        // instruction is followed by a `wrap_optional`, it will return this value
-        // verbatim, and the result should test as non-null.
-        const target = mod.getTarget();
-        const int = try o.builder.intConst(llvm_usize, @as(u64, switch (target.ptrBitWidth()) {
+        const int: u64 = ptr_ty.ptrInfo(mod).flags.alignment.toByteUnitsOptional() orelse
+            // Note that these 0xaa values are appropriate even in release-optimized builds
+            // because we need a well-defined value that is not null, and LLVM does not
+            // have an "undef_but_not_null" attribute. As an example, if this `alloc` AIR
+            // instruction is followed by a `wrap_optional`, it will return this value
+            // verbatim, and the result should test as non-null.
+            switch (mod.getTarget().ptrBitWidth()) {
             16 => 0xaaaa,
             32 => 0xaaaaaaaa,
             64 => 0xaaaaaaaa_aaaaaaaa,
             else => unreachable,
-        }));
-        return int.toLlvm(&o.builder).constIntToPtr(llvm_ptr_ty);
+        };
+        const llvm_usize = try o.lowerType(Type.usize);
+        const llvm_ptr_ty = try o.lowerType(ptr_ty);
+        return o.builder.castConst(.inttoptr, try o.builder.intConst(llvm_usize, int), llvm_ptr_ty);
     }
 
     fn addAttr(o: *Object, val: *llvm.Value, index: llvm.AttributeIndex, name: []const u8) void {
@@ -4436,26 +4501,29 @@ pub const DeclGen = struct {
             _ = try o.resolveLlvmFunction(extern_func.decl);
         } else {
             const target = mod.getTarget();
-            const object_index = try o.resolveGlobalDecl(decl_index);
-            const object = object_index.ptr(&o.builder);
-            const global = object.global.ptr(&o.builder);
-            var llvm_global = object.global.toLlvm(&o.builder);
-            global.alignment = Builder.Alignment.fromByteUnits(decl.getAlignment(mod));
+            const object = try o.resolveGlobalDecl(decl_index);
+            const global = object.ptrConst(&o.builder).global;
+            var llvm_global = global.toLlvm(&o.builder);
+            global.ptr(&o.builder).alignment = Builder.Alignment.fromByteUnits(decl.getAlignment(mod));
             llvm_global.setAlignment(decl.getAlignment(mod));
-            if (mod.intern_pool.stringToSliceUnwrap(decl.@"linksection")) |s| llvm_global.setSection(s);
+            if (mod.intern_pool.stringToSliceUnwrap(decl.@"linksection")) |section| {
+                global.ptr(&o.builder).section = try o.builder.string(section);
+                llvm_global.setSection(section);
+            }
             assert(decl.has_tv);
-            const init_val = if (decl.val.getVariable(mod)) |variable| init_val: {
-                object.mutability = .global;
-                break :init_val variable.init;
+            const init_val = if (decl.val.getVariable(mod)) |decl_var| init_val: {
+                object.ptr(&o.builder).mutability = .global;
+                break :init_val decl_var.init;
             } else init_val: {
-                object.mutability = .constant;
+                object.ptr(&o.builder).mutability = .constant;
                 llvm_global.setGlobalConstant(.True);
                 break :init_val decl.val.toIntern();
             };
             if (init_val != .none) {
-                const llvm_init = try o.lowerValue(.{ .ty = decl.ty, .val = init_val.toValue() });
-                if (llvm_global.globalGetValueType() == llvm_init.typeOf()) {
-                    llvm_global.setInitializer(llvm_init);
+                const llvm_init = try o.lowerValue(init_val);
+                if (llvm_global.globalGetValueType() == llvm_init.typeOf(&o.builder).toLlvm(&o.builder)) {
+                    object.ptr(&o.builder).init = llvm_init;
+                    llvm_global.setInitializer(llvm_init.toLlvm(&o.builder));
                 } else {
                     // LLVM does not allow us to change the type of globals. So we must
                     // create a new global with the correct type, copy all its attributes,
@@ -4472,20 +4540,21 @@ pub const DeclGen = struct {
                     // Related: https://github.com/ziglang/zig/issues/13265
                     const llvm_global_addrspace = toLlvmGlobalAddressSpace(decl.@"addrspace", target);
                     const new_global = o.llvm_module.addGlobalInAddressSpace(
-                        llvm_init.typeOf(),
+                        llvm_init.typeOf(&o.builder).toLlvm(&o.builder),
                         "",
                         @intFromEnum(llvm_global_addrspace),
                     );
                     new_global.setLinkage(llvm_global.getLinkage());
                     new_global.setUnnamedAddr(llvm_global.getUnnamedAddress());
                     new_global.setAlignment(llvm_global.getAlignment());
-                    if (mod.intern_pool.stringToSliceUnwrap(decl.@"linksection")) |s|
-                        new_global.setSection(s);
-                    new_global.setInitializer(llvm_init);
+                    if (mod.intern_pool.stringToSliceUnwrap(decl.@"linksection")) |section|
+                        new_global.setSection(section);
+                    new_global.setInitializer(llvm_init.toLlvm(&o.builder));
                     // TODO: How should this work then the address space of a global changed?
                     llvm_global.replaceAllUsesWith(new_global);
                     new_global.takeName(llvm_global);
-                    o.builder.llvm_globals.items[@intFromEnum(object.global)] = new_global;
+                    o.builder.llvm_globals.items[@intFromEnum(object.ptrConst(&o.builder).global)] =
+                        new_global;
                     llvm_global.deleteGlobal();
                     llvm_global = new_global;
                 }
@@ -4601,24 +4670,45 @@ pub const FuncGen = struct {
     fn resolveValue(self: *FuncGen, tv: TypedValue) !*llvm.Value {
         const o = self.dg.object;
         const mod = o.module;
-        const llvm_val = try o.lowerValue(tv);
-        if (!isByRef(tv.ty, mod)) return llvm_val;
+        const llvm_val = try o.lowerValue(tv.val.toIntern());
+        if (!isByRef(tv.ty, mod)) return llvm_val.toLlvm(&o.builder);
 
         // We have an LLVM value but we need to create a global constant and
         // set the value as its initializer, and then return a pointer to the global.
         const target = mod.getTarget();
         const llvm_wanted_addrspace = toLlvmAddressSpace(.generic, target);
         const llvm_actual_addrspace = toLlvmGlobalAddressSpace(.generic, target);
-        const global = o.llvm_module.addGlobalInAddressSpace(llvm_val.typeOf(), "", @intFromEnum(llvm_actual_addrspace));
-        global.setInitializer(llvm_val);
-        global.setLinkage(.Private);
-        global.setGlobalConstant(.True);
-        global.setUnnamedAddr(.True);
-        global.setAlignment(tv.ty.abiAlignment(mod));
+        const llvm_ty = llvm_val.typeOf(&o.builder);
+        const llvm_alignment = tv.ty.abiAlignment(mod);
+        const llvm_global = o.llvm_module.addGlobalInAddressSpace(llvm_ty.toLlvm(&o.builder), "", @intFromEnum(llvm_actual_addrspace));
+        llvm_global.setInitializer(llvm_val.toLlvm(&o.builder));
+        llvm_global.setLinkage(.Private);
+        llvm_global.setGlobalConstant(.True);
+        llvm_global.setUnnamedAddr(.True);
+        llvm_global.setAlignment(llvm_alignment);
+
+        var global = Builder.Global{
+            .linkage = .private,
+            .unnamed_addr = .unnamed_addr,
+            .type = llvm_ty,
+            .alignment = Builder.Alignment.fromByteUnits(llvm_alignment),
+            .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
+        };
+        var variable = Builder.Variable{
+            .global = @enumFromInt(o.builder.globals.count()),
+            .mutability = .constant,
+            .init = llvm_val,
+        };
+        try o.builder.llvm_globals.append(o.gpa, llvm_global);
+        _ = try o.builder.addGlobal(.none, global);
+        try o.builder.variables.append(o.gpa, variable);
+
         const addrspace_casted_ptr = if (llvm_actual_addrspace != llvm_wanted_addrspace)
-            global.constAddrSpaceCast(self.context.pointerType(@intFromEnum(llvm_wanted_addrspace)))
+            llvm_global.constAddrSpaceCast(
+                (try o.builder.ptrType(llvm_wanted_addrspace)).toLlvm(&o.builder),
+            )
         else
-            global;
+            llvm_global;
         return addrspace_casted_ptr;
     }
 
@@ -5197,10 +5287,7 @@ pub const FuncGen = struct {
         const msg_decl_index = mod.panic_messages[@intFromEnum(panic_id)].unwrap().?;
         const msg_decl = mod.declPtr(msg_decl_index);
         const msg_len = msg_decl.ty.childType(mod).arrayLen(mod);
-        const msg_ptr = try o.lowerValue(.{
-            .ty = msg_decl.ty,
-            .val = msg_decl.val,
-        });
+        const msg_ptr = try o.lowerValue(try msg_decl.internValue(mod));
         const null_opt_addr_global = try o.getNullOptAddr();
         const target = mod.getTarget();
         const llvm_usize = try o.lowerType(Type.usize);
@@ -5212,9 +5299,9 @@ pub const FuncGen = struct {
         //   ptr @2,                                                 ; addr (null ?usize)
         // )
         const args = [4]*llvm.Value{
-            msg_ptr,
+            msg_ptr.toLlvm(&o.builder),
             (try o.builder.intConst(llvm_usize, msg_len)).toLlvm(&o.builder),
-            fg.context.pointerType(0).constNull(),
+            (try o.builder.nullConst(.ptr)).toLlvm(&o.builder),
             null_opt_addr_global,
         };
         const panic_func = mod.funcInfo(mod.panic_func_index);
@@ -5672,8 +5759,8 @@ pub const FuncGen = struct {
 
         if (!err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
             const is_err = err: {
-                const err_set_ty = (try o.lowerType(Type.anyerror)).toLlvm(&o.builder);
-                const zero = err_set_ty.constNull();
+                const err_set_ty = Builder.Type.err_int.toLlvm(&o.builder);
+                const zero = (try o.builder.intConst(Builder.Type.err_int, 0)).toLlvm(&o.builder);
                 if (!payload_has_bits) {
                     // TODO add alignment to this load
                     const loaded = if (operand_is_ptr)
@@ -6034,7 +6121,10 @@ pub const FuncGen = struct {
         const array_llvm_ty = (try o.lowerType(array_ty)).toLlvm(&o.builder);
         const elem_ty = array_ty.childType(mod);
         if (isByRef(array_ty, mod)) {
-            const indices: [2]*llvm.Value = .{ Builder.Type.i32.toLlvm(&o.builder).constNull(), rhs };
+            const indices: [2]*llvm.Value = .{
+                (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+                rhs,
+            };
             if (isByRef(elem_ty, mod)) {
                 const elem_ptr = self.builder.buildInBoundsGEP(array_llvm_ty, array_llvm_val, &indices, indices.len, "");
                 if (canElideLoad(self, body_tail))
@@ -6082,7 +6172,10 @@ pub const FuncGen = struct {
         // TODO: when we go fully opaque pointers in LLVM 16 we can remove this branch
         const ptr = if (ptr_ty.isSinglePointer(mod)) ptr: {
             // If this is a single-item pointer to an array, we need another index in the GEP.
-            const indices: [2]*llvm.Value = .{ Builder.Type.i32.toLlvm(&o.builder).constNull(), rhs };
+            const indices: [2]*llvm.Value = .{
+                (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+                rhs,
+            };
             break :ptr self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
         } else ptr: {
             const indices: [1]*llvm.Value = .{rhs};
@@ -6105,7 +6198,8 @@ pub const FuncGen = struct {
         const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
         const ptr_ty = self.typeOf(bin_op.lhs);
         const elem_ty = ptr_ty.childType(mod);
-        if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod)) return o.lowerPtrToVoid(ptr_ty);
+        if (!elem_ty.hasRuntimeBitsIgnoreComptime(mod))
+            return (try o.lowerPtrToVoid(ptr_ty)).toLlvm(&o.builder);
 
         const base_ptr = try self.resolveInst(bin_op.lhs);
         const rhs = try self.resolveInst(bin_op.rhs);
@@ -6116,7 +6210,10 @@ pub const FuncGen = struct {
         const llvm_elem_ty = (try o.lowerPtrElemTy(elem_ty)).toLlvm(&o.builder);
         if (ptr_ty.isSinglePointer(mod)) {
             // If this is a single-item pointer to an array, we need another index in the GEP.
-            const indices: [2]*llvm.Value = .{ Builder.Type.i32.toLlvm(&o.builder).constNull(), rhs };
+            const indices: [2]*llvm.Value = .{
+                (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+                rhs,
+            };
             return self.builder.buildInBoundsGEP(llvm_elem_ty, base_ptr, &indices, indices.len, "");
         } else {
             const indices: [1]*llvm.Value = .{rhs};
@@ -6829,8 +6926,11 @@ pub const FuncGen = struct {
                 operand;
             if (payload_ty.isSlice(mod)) {
                 const slice_ptr = self.builder.buildExtractValue(loaded, 0, "");
-                const ptr_ty = (try o.lowerType(payload_ty.slicePtrFieldType(mod))).toLlvm(&o.builder);
-                return self.builder.buildICmp(pred, slice_ptr, ptr_ty.constNull(), "");
+                const ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(
+                    payload_ty.ptrAddressSpace(mod),
+                    mod.getTarget(),
+                ));
+                return self.builder.buildICmp(pred, slice_ptr, (try o.builder.nullConst(ptr_ty)).toLlvm(&o.builder), "");
             }
             return self.builder.buildICmp(pred, loaded, optional_llvm_ty.constNull(), "");
         }
@@ -6867,8 +6967,7 @@ pub const FuncGen = struct {
         const operand_ty = self.typeOf(un_op);
         const err_union_ty = if (operand_is_ptr) operand_ty.childType(mod) else operand_ty;
         const payload_ty = err_union_ty.errorUnionPayload(mod);
-        const err_set_ty = (try o.lowerType(Type.anyerror)).toLlvm(&o.builder);
-        const zero = err_set_ty.constNull();
+        const zero = (try o.builder.intConst(Builder.Type.err_int, 0)).toLlvm(&o.builder);
 
         if (err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) {
             const val: Builder.Constant = switch (op) {
@@ -6892,7 +6991,7 @@ pub const FuncGen = struct {
         if (operand_is_ptr or isByRef(err_union_ty, mod)) {
             const err_union_llvm_ty = (try o.lowerType(err_union_ty)).toLlvm(&o.builder);
             const err_field_ptr = self.builder.buildStructGEP(err_union_llvm_ty, operand, err_field_index, "");
-            const loaded = self.builder.buildLoad(err_set_ty, err_field_ptr, "");
+            const loaded = self.builder.buildLoad(Builder.Type.err_int.toLlvm(&o.builder), err_field_ptr, "");
             return self.builder.buildICmp(op, loaded, zero, "");
         }
 
@@ -7057,9 +7156,9 @@ pub const FuncGen = struct {
         const err_union_ty = self.typeOf(ty_op.operand).childType(mod);
 
         const payload_ty = err_union_ty.errorUnionPayload(mod);
-        const non_error_val = try o.lowerValue(.{ .ty = Type.anyerror, .val = try mod.intValue(Type.err_int, 0) });
+        const non_error_val = try o.lowerValue((try mod.intValue(Type.err_int, 0)).toIntern());
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
-            _ = self.builder.buildStore(non_error_val, operand);
+            _ = self.builder.buildStore(non_error_val.toLlvm(&o.builder), operand);
             return operand;
         }
         const err_union_llvm_ty = (try o.lowerType(err_union_ty)).toLlvm(&o.builder);
@@ -7067,7 +7166,7 @@ pub const FuncGen = struct {
             const error_offset = errUnionErrorOffset(payload_ty, mod);
             // First set the non-error value.
             const non_null_ptr = self.builder.buildStructGEP(err_union_llvm_ty, operand, error_offset, "");
-            const store_inst = self.builder.buildStore(non_error_val, non_null_ptr);
+            const store_inst = self.builder.buildStore(non_error_val.toLlvm(&o.builder), non_null_ptr);
             store_inst.setAlignment(Type.anyerror.abiAlignment(mod));
         }
         // Then return the payload pointer (only if it is used).
@@ -7146,7 +7245,7 @@ pub const FuncGen = struct {
         if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
             return operand;
         }
-        const ok_err_code = (try o.lowerType(Type.anyerror)).toLlvm(&o.builder).constNull();
+        const ok_err_code = (try o.builder.intConst(Builder.Type.err_int, 0)).toLlvm(&o.builder);
         const err_un_llvm_ty = (try o.lowerType(err_un_ty)).toLlvm(&o.builder);
 
         const payload_offset = errUnionPayloadOffset(payload_ty, mod);
@@ -7606,7 +7705,10 @@ pub const FuncGen = struct {
         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 = .{ Builder.Type.i32.toLlvm(&o.builder).constNull(), offset };
+                const indices: [2]*llvm.Value = .{
+                    (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+                    offset,
+                };
                 return self.builder.buildInBoundsGEP(llvm_elem_ty, ptr, &indices, indices.len, "");
             },
             .C, .Many => {
@@ -7635,7 +7737,8 @@ pub const FuncGen = struct {
             .One => {
                 // It's a pointer to an array, so according to LLVM we need an extra GEP index.
                 const indices: [2]*llvm.Value = .{
-                    Builder.Type.i32.toLlvm(&o.builder).constNull(), negative_offset,
+                    (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+                    negative_offset,
                 };
                 return self.builder.buildInBoundsGEP(llvm_elem_ty, ptr, &indices, indices.len, "");
             },
@@ -8448,7 +8551,7 @@ pub const FuncGen = struct {
         const ptr_ty = self.typeOfIndex(inst);
         const pointee_type = ptr_ty.childType(mod);
         if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime(mod))
-            return o.lowerPtrToVoid(ptr_ty);
+            return (try o.lowerPtrToVoid(ptr_ty)).toLlvm(&o.builder);
 
         const pointee_llvm_ty = (try o.lowerType(pointee_type)).toLlvm(&o.builder);
         const alignment = ptr_ty.ptrAlignment(mod);
@@ -8460,7 +8563,8 @@ pub const FuncGen = struct {
         const mod = o.module;
         const ptr_ty = self.typeOfIndex(inst);
         const ret_ty = ptr_ty.childType(mod);
-        if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return o.lowerPtrToVoid(ptr_ty);
+        if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime(mod))
+            return (try o.lowerPtrToVoid(ptr_ty)).toLlvm(&o.builder);
         if (self.ret_ptr) |ret_ptr| return ret_ptr;
         const ret_llvm_ty = (try o.lowerType(ret_ty)).toLlvm(&o.builder);
         return self.buildAlloca(ret_llvm_ty, ptr_ty.ptrAlignment(mod));
@@ -8566,18 +8670,19 @@ pub const FuncGen = struct {
         _ = inst;
         const o = self.dg.object;
         const mod = o.module;
-        const llvm_usize = (try o.lowerType(Type.usize)).toLlvm(&o.builder);
+        const llvm_usize = try o.lowerType(Type.usize);
         const target = mod.getTarget();
         if (!target_util.supportsReturnAddress(target)) {
             // https://github.com/ziglang/zig/issues/11946
-            return llvm_usize.constNull();
+            return (try o.builder.intConst(llvm_usize, 0)).toLlvm(&o.builder);
         }
 
-        const llvm_i32 = Builder.Type.i32.toLlvm(&o.builder);
         const llvm_fn = try self.getIntrinsic("llvm.returnaddress", &.{});
-        const params = [_]*llvm.Value{llvm_i32.constNull()};
+        const params = [_]*llvm.Value{
+            (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+        };
         const ptr_val = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &params, params.len, .Fast, .Auto, "");
-        return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
+        return self.builder.buildPtrToInt(ptr_val, llvm_usize.toLlvm(&o.builder), "");
     }
 
     fn airFrameAddress(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
@@ -8589,7 +8694,9 @@ pub const FuncGen = struct {
             break :blk o.llvm_module.addFunction(llvm_fn_name, fn_type.toLlvm(&o.builder));
         };
 
-        const params = [_]*llvm.Value{Builder.Type.i32.toLlvm(&o.builder).constNull()};
+        const params = [_]*llvm.Value{
+            (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
+        };
         const ptr_val = self.builder.buildCall(llvm_fn.globalGetValueType(), llvm_fn, &params, params.len, .Fast, .Auto, "");
         const llvm_usize = (try o.lowerType(Type.usize)).toLlvm(&o.builder);
         return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
@@ -9060,10 +9167,9 @@ pub const FuncGen = struct {
         const operand_ty = self.typeOf(ty_op.operand);
         const operand = try self.resolveInst(ty_op.operand);
 
-        const llvm_i1 = Builder.Type.i1.toLlvm(&o.builder);
         const fn_val = try self.getIntrinsic(llvm_fn_name, &.{try o.lowerType(operand_ty)});
 
-        const params = [_]*llvm.Value{ operand, llvm_i1.constNull() };
+        const params = [_]*llvm.Value{ operand, Builder.Constant.false.toLlvm(&o.builder) };
         const wrong_size_result = self.builder.buildCall(fn_val.globalGetValueType(), fn_val, &params, params.len, .C, .Auto, "");
         const result_ty = self.typeOfIndex(inst);
         const result_llvm_ty = (try o.lowerType(result_ty)).toLlvm(&o.builder);
@@ -9170,11 +9276,9 @@ pub const FuncGen = struct {
 
         for (names) |name| {
             const err_int = @as(Module.ErrorInt, @intCast(mod.global_error_set.getIndex(name).?));
-            const this_tag_int_value = try o.lowerValue(.{
-                .ty = Type.err_int,
-                .val = try mod.intValue(Type.err_int, err_int),
-            });
-            switch_instr.addCase(this_tag_int_value, valid_block);
+            const this_tag_int_value =
+                try o.lowerValue((try mod.intValue(Type.err_int, err_int)).toIntern());
+            switch_instr.addCase(this_tag_int_value.toLlvm(&o.builder), valid_block);
         }
         self.builder.positionBuilderAtEnd(valid_block);
         _ = self.builder.buildBr(end_block);
@@ -9258,13 +9362,9 @@ pub const FuncGen = struct {
 
         for (enum_type.names, 0..) |_, field_index_usize| {
             const field_index = @as(u32, @intCast(field_index_usize));
-            const this_tag_int_value = int: {
-                break :int try o.lowerValue(.{
-                    .ty = enum_ty,
-                    .val = try mod.enumValueFieldIndex(enum_ty, field_index),
-                });
-            };
-            switch_instr.addCase(this_tag_int_value, named_block);
+            const this_tag_int_value =
+                try o.lowerValue((try mod.enumValueFieldIndex(enum_ty, field_index)).toIntern());
+            switch_instr.addCase(this_tag_int_value.toLlvm(&o.builder), named_block);
         }
         self.builder.positionBuilderAtEnd(named_block);
         _ = self.builder.buildRet(Builder.Constant.true.toLlvm(&o.builder));
@@ -9371,11 +9471,9 @@ pub const FuncGen = struct {
             slice_global.setAlignment(slice_alignment);
 
             const return_block = self.context.appendBasicBlock(fn_val, "Name");
-            const this_tag_int_value = try o.lowerValue(.{
-                .ty = enum_ty,
-                .val = try mod.enumValueFieldIndex(enum_ty, field_index),
-            });
-            switch_instr.addCase(this_tag_int_value, return_block);
+            const this_tag_int_value =
+                try o.lowerValue((try mod.enumValueFieldIndex(enum_ty, field_index)).toIntern());
+            switch_instr.addCase(this_tag_int_value.toLlvm(&o.builder), return_block);
 
             self.builder.positionBuilderAtEnd(return_block);
             const loaded = self.builder.buildLoad(llvm_ret_ty, slice_global, "");
@@ -9404,7 +9502,12 @@ pub const FuncGen = struct {
         const fn_type = try o.builder.fnType(.i1, &.{Builder.Type.err_int}, .normal);
         const llvm_fn = o.llvm_module.addFunction(lt_errors_fn_name, fn_type.toLlvm(&o.builder));
 
+        llvm_fn.setLinkage(.Internal);
+        llvm_fn.setFunctionCallConv(.Fast);
+        o.addCommonFnAttributes(llvm_fn);
+
         var global = Builder.Global{
+            .linkage = .internal,
             .type = fn_type,
             .kind = .{ .function = @enumFromInt(o.builder.functions.items.len) },
         };
@@ -9412,10 +9515,6 @@ pub const FuncGen = struct {
             .global = @enumFromInt(o.builder.globals.count()),
         };
 
-        llvm_fn.setLinkage(.Internal);
-        llvm_fn.setFunctionCallConv(.Fast);
-        o.addCommonFnAttributes(llvm_fn);
-
         try o.builder.llvm_globals.append(self.gpa, llvm_fn);
         _ = try o.builder.addGlobal(try o.builder.string(lt_errors_fn_name), global);
         try o.builder.functions.append(self.gpa, function);
@@ -9431,7 +9530,7 @@ pub const FuncGen = struct {
 
         const error_name_table_ptr = try self.getErrorNameTable();
         const ptr_slice_llvm_ty = self.context.pointerType(0);
-        const error_name_table = self.builder.buildLoad(ptr_slice_llvm_ty, error_name_table_ptr, "");
+        const error_name_table = self.builder.buildLoad(ptr_slice_llvm_ty, error_name_table_ptr.toLlvm(&o.builder), "");
         const indices = [_]*llvm.Value{operand};
         const error_name_ptr = self.builder.buildInBoundsGEP(slice_llvm_ty, error_name_table, &indices, indices.len, "");
         return self.builder.buildLoad(slice_llvm_ty, error_name_ptr, "");
@@ -9588,18 +9687,18 @@ pub const FuncGen = struct {
             .Add => switch (scalar_ty.zigTypeTag(mod)) {
                 .Int => return self.builder.buildAddReduce(operand),
                 .Float => if (intrinsicsAllowed(scalar_ty, target)) {
-                    const scalar_llvm_ty = (try o.lowerType(scalar_ty)).toLlvm(&o.builder);
-                    const neutral_value = scalar_llvm_ty.constReal(-0.0);
-                    return self.builder.buildFPAddReduce(neutral_value, operand);
+                    const scalar_llvm_ty = try o.lowerType(scalar_ty);
+                    const neutral_value = try o.builder.fpConst(scalar_llvm_ty, -0.0);
+                    return self.builder.buildFPAddReduce(neutral_value.toLlvm(&o.builder), operand);
                 },
                 else => unreachable,
             },
             .Mul => switch (scalar_ty.zigTypeTag(mod)) {
                 .Int => return self.builder.buildMulReduce(operand),
                 .Float => if (intrinsicsAllowed(scalar_ty, target)) {
-                    const scalar_llvm_ty = (try o.lowerType(scalar_ty)).toLlvm(&o.builder);
-                    const neutral_value = scalar_llvm_ty.constReal(1.0);
-                    return self.builder.buildFPMulReduce(neutral_value, operand);
+                    const scalar_llvm_ty = try o.lowerType(scalar_ty);
+                    const neutral_value = try o.builder.fpConst(scalar_llvm_ty, 1.0);
+                    return self.builder.buildFPMulReduce(neutral_value.toLlvm(&o.builder), operand);
                 },
                 else => unreachable,
             },
@@ -9626,17 +9725,14 @@ pub const FuncGen = struct {
 
         const param_llvm_ty = try o.lowerType(scalar_ty);
         const libc_fn = try self.getLibcFunction(fn_name, &(.{param_llvm_ty} ** 2), param_llvm_ty);
-        const init_value = try o.lowerValue(.{
-            .ty = scalar_ty,
-            .val = try mod.floatValue(scalar_ty, switch (reduce.operation) {
-                .Min => std.math.nan(f32),
-                .Max => std.math.nan(f32),
-                .Add => -0.0,
-                .Mul => 1.0,
-                else => unreachable,
-            }),
-        });
-        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(mod), init_value);
+        const init_value = try o.lowerValue((try mod.floatValue(scalar_ty, switch (reduce.operation) {
+            .Min => std.math.nan(f32),
+            .Max => std.math.nan(f32),
+            .Add => -0.0,
+            .Mul => 1.0,
+            else => unreachable,
+        })).toIntern());
+        return self.buildReducedCall(libc_fn, operand, operand_ty.vectorLen(mod), init_value.toLlvm(&o.builder));
     }
 
     fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) !?*llvm.Value {
@@ -10030,26 +10126,42 @@ pub const FuncGen = struct {
         return self.amdgcnWorkIntrinsic(dimension, 0, "llvm.amdgcn.workgroup.id");
     }
 
-    fn getErrorNameTable(self: *FuncGen) !*llvm.Value {
+    fn getErrorNameTable(self: *FuncGen) Allocator.Error!Builder.Variable.Index {
         const o = self.dg.object;
-        if (o.error_name_table) |table| {
-            return table;
-        }
+        const table = o.error_name_table;
+        if (table != .none) return table;
 
         const mod = o.module;
         const slice_ty = Type.slice_const_u8_sentinel_0;
         const slice_alignment = slice_ty.abiAlignment(mod);
-        const llvm_slice_ptr_ty = self.context.pointerType(0); // TODO: Address space
+        const undef_init = try o.builder.undefConst(.ptr); // TODO: Address space
 
-        const error_name_table_global = o.llvm_module.addGlobal(llvm_slice_ptr_ty, "__zig_err_name_table");
-        error_name_table_global.setInitializer(llvm_slice_ptr_ty.getUndef());
+        const name = try o.builder.string("__zig_err_name_table");
+        const error_name_table_global = o.llvm_module.addGlobal(Builder.Type.ptr.toLlvm(&o.builder), name.toSlice(&o.builder).?);
+        error_name_table_global.setInitializer(undef_init.toLlvm(&o.builder));
         error_name_table_global.setLinkage(.Private);
         error_name_table_global.setGlobalConstant(.True);
         error_name_table_global.setUnnamedAddr(.True);
         error_name_table_global.setAlignment(slice_alignment);
 
-        o.error_name_table = error_name_table_global;
-        return error_name_table_global;
+        var global = Builder.Global{
+            .linkage = .private,
+            .unnamed_addr = .unnamed_addr,
+            .type = .ptr,
+            .alignment = Builder.Alignment.fromByteUnits(slice_alignment),
+            .kind = .{ .variable = @enumFromInt(o.builder.variables.items.len) },
+        };
+        var variable = Builder.Variable{
+            .global = @enumFromInt(o.builder.globals.count()),
+            .mutability = .constant,
+            .init = undef_init,
+        };
+        try o.builder.llvm_globals.append(o.gpa, error_name_table_global);
+        _ = try o.builder.addGlobal(name, global);
+        try o.builder.variables.append(o.gpa, variable);
+
+        o.error_name_table = global.kind.variable;
+        return global.kind.variable;
     }
 
     /// Assumes the optional is not pointer-like and payload has bits.
@@ -10273,14 +10385,14 @@ pub const FuncGen = struct {
             return llvm_inst;
         }
 
-        const int_elem_ty = (try o.builder.intType(@intCast(info.packed_offset.host_size * 8))).toLlvm(&o.builder);
-        const containing_int = self.builder.buildLoad(int_elem_ty, ptr, "");
+        const containing_int_ty = try o.builder.intType(@intCast(info.packed_offset.host_size * 8));
+        const containing_int = self.builder.buildLoad(containing_int_ty.toLlvm(&o.builder), ptr, "");
         containing_int.setAlignment(ptr_alignment);
         containing_int.setVolatile(ptr_volatile);
 
         const elem_bits = @as(c_uint, @intCast(ptr_ty.childType(mod).bitSize(mod)));
-        const shift_amt = containing_int.typeOf().constInt(info.packed_offset.bit_offset, .False);
-        const shifted_value = self.builder.buildLShr(containing_int, shift_amt, "");
+        const shift_amt = try o.builder.intConst(containing_int_ty, info.packed_offset.bit_offset);
+        const shifted_value = self.builder.buildLShr(containing_int, shift_amt.toLlvm(&o.builder), "");
         const elem_llvm_ty = (try o.lowerType(elem_ty)).toLlvm(&o.builder);
 
         if (isByRef(elem_ty, mod)) {
@@ -10346,30 +10458,29 @@ pub const FuncGen = struct {
         }
 
         if (info.packed_offset.host_size != 0) {
-            const int_elem_ty = (try o.builder.intType(@intCast(info.packed_offset.host_size * 8))).toLlvm(&o.builder);
-            const containing_int = self.builder.buildLoad(int_elem_ty, ptr, "");
+            const containing_int_ty = try o.builder.intType(@intCast(info.packed_offset.host_size * 8));
+            const containing_int = self.builder.buildLoad(containing_int_ty.toLlvm(&o.builder), ptr, "");
             assert(ordering == .NotAtomic);
             containing_int.setAlignment(ptr_alignment);
             containing_int.setVolatile(ptr_volatile);
             const elem_bits = @as(c_uint, @intCast(ptr_ty.childType(mod).bitSize(mod)));
-            const containing_int_ty = containing_int.typeOf();
-            const shift_amt = containing_int_ty.constInt(info.packed_offset.bit_offset, .False);
+            const shift_amt = try o.builder.intConst(containing_int_ty, info.packed_offset.bit_offset);
             // Convert to equally-sized integer type in order to perform the bit
             // operations on the value to store
-            const value_bits_type = (try o.builder.intType(@intCast(elem_bits))).toLlvm(&o.builder);
+            const value_bits_type = try o.builder.intType(@intCast(elem_bits));
             const value_bits = if (elem_ty.isPtrAtRuntime(mod))
-                self.builder.buildPtrToInt(elem, value_bits_type, "")
+                self.builder.buildPtrToInt(elem, value_bits_type.toLlvm(&o.builder), "")
             else
-                self.builder.buildBitCast(elem, value_bits_type, "");
+                self.builder.buildBitCast(elem, value_bits_type.toLlvm(&o.builder), "");
 
-            var mask_val = value_bits_type.constAllOnes();
-            mask_val = mask_val.constZExt(containing_int_ty);
-            mask_val = mask_val.constShl(shift_amt);
+            var mask_val = (try o.builder.intConst(value_bits_type, -1)).toLlvm(&o.builder);
+            mask_val = mask_val.constZExt(containing_int_ty.toLlvm(&o.builder));
+            mask_val = mask_val.constShl(shift_amt.toLlvm(&o.builder));
             mask_val = mask_val.constNot();
 
             const anded_containing_int = self.builder.buildAnd(containing_int, mask_val, "");
-            const extended_value = self.builder.buildZExt(value_bits, containing_int_ty, "");
-            const shifted_value = self.builder.buildShl(extended_value, shift_amt, "");
+            const extended_value = self.builder.buildZExt(value_bits, containing_int_ty.toLlvm(&o.builder), "");
+            const shifted_value = self.builder.buildShl(extended_value, shift_amt.toLlvm(&o.builder), "");
             const ored_value = self.builder.buildOr(shifted_value, anded_containing_int, "");
 
             const store_inst = self.builder.buildStore(ored_value, ptr);

src/codegen/llvm/Builder.zig

@@ -27,7 +27,7 @@ globals: std.AutoArrayHashMapUnmanaged(String, Global) = .{},
 next_unnamed_global: String = @enumFromInt(0),
 next_unique_global_id: std.AutoHashMapUnmanaged(String, u32) = .{},
 aliases: std.ArrayListUnmanaged(Alias) = .{},
-objects: std.ArrayListUnmanaged(Object) = .{},
+variables: std.ArrayListUnmanaged(Variable) = .{},
 functions: std.ArrayListUnmanaged(Function) = .{},
 
 constant_map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
@@ -35,10 +35,12 @@ constant_items: std.MultiArrayList(Constant.Item) = .{},
 constant_extra: std.ArrayListUnmanaged(u32) = .{},
 constant_limbs: std.ArrayListUnmanaged(std.math.big.Limb) = .{},
 
+pub const expected_fields_len = 32;
+pub const expected_gep_indices_len = 8;
+
 pub const String = enum(u32) {
     none = std.math.maxInt(u31),
     empty,
-    debugme,
     _,
 
     pub fn toSlice(self: String, b: *const Builder) ?[:0]const u8 {
@@ -58,22 +60,23 @@ pub const String = enum(u32) {
         _: std.fmt.FormatOptions,
         writer: anytype,
     ) @TypeOf(writer).Error!void {
+        if (comptime std.mem.indexOfNone(u8, fmt_str, "@\"")) |_|
+            @compileError("invalid format string: '" ++ fmt_str ++ "'");
         assert(data.string != .none);
         const slice = data.string.toSlice(data.builder) orelse
             return writer.print("{d}", .{@intFromEnum(data.string)});
-        const need_quotes = if (comptime std.mem.eql(u8, fmt_str, ""))
-            !isValidIdentifier(slice)
-        else if (comptime std.mem.eql(u8, fmt_str, "\""))
-            true
-        else
-            @compileError("invalid format string: '" ++ fmt_str ++ "'");
-        if (need_quotes) try writer.writeByte('\"');
-        for (slice) |character| switch (character) {
+        const full_slice = slice[0 .. slice.len + comptime @intFromBool(
+            std.mem.indexOfScalar(u8, fmt_str, '@') != null,
+        )];
+        const need_quotes = (comptime std.mem.indexOfScalar(u8, fmt_str, '"') != null) or
+            !isValidIdentifier(full_slice);
+        if (need_quotes) try writer.writeByte('"');
+        for (full_slice) |character| switch (character) {
             '\\' => try writer.writeAll("\\\\"),
             ' '...'"' - 1, '"' + 1...'\\' - 1, '\\' + 1...'~' => try writer.writeByte(character),
             else => try writer.print("\\{X:0>2}", .{character}),
         };
-        if (need_quotes) try writer.writeByte('\"');
+        if (need_quotes) try writer.writeByte('"');
     }
     pub fn fmt(self: String, builder: *const Builder) std.fmt.Formatter(format) {
         return .{ .data = .{ .string = self, .builder = builder } };
@@ -92,8 +95,8 @@ pub const String = enum(u32) {
         pub fn hash(_: Adapter, key: []const u8) u32 {
             return @truncate(std.hash.Wyhash.hash(0, key));
         }
-        pub fn eql(ctx: Adapter, lhs: []const u8, _: void, rhs_index: usize) bool {
-            return std.mem.eql(u8, lhs, String.fromIndex(rhs_index).toSlice(ctx.builder).?);
+        pub fn eql(ctx: Adapter, lhs_key: []const u8, _: void, rhs_index: usize) bool {
+            return std.mem.eql(u8, lhs_key, String.fromIndex(rhs_index).toSlice(ctx.builder).?);
         }
     };
 };
@@ -204,9 +207,167 @@ pub const Type = enum(u32) {
     pub const Item = packed struct(u32) {
         tag: Tag,
         data: ExtraIndex,
+
+        pub const ExtraIndex = u28;
     };
 
-    pub const ExtraIndex = u28;
+    pub fn tag(self: Type, builder: *const Builder) Tag {
+        return builder.type_items.items[@intFromEnum(self)].tag;
+    }
+
+    pub fn unnamedTag(self: Type, builder: *const Builder) Tag {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        return switch (item.tag) {
+            .named_structure => builder.typeExtraData(Type.NamedStructure, item.data).body
+                .unnamedTag(builder),
+            else => item.tag,
+        };
+    }
+
+    pub fn scalarTag(self: Type, builder: *const Builder) Tag {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        return switch (item.tag) {
+            .vector, .scalable_vector => builder.typeExtraData(Type.Vector, item.data)
+                .child.tag(builder),
+            else => item.tag,
+        };
+    }
+
+    pub fn isFn(self: Type, builder: *const Builder) bool {
+        return switch (self.tag(builder)) {
+            .function, .vararg_function => true,
+            else => false,
+        };
+    }
+
+    pub fn fnKind(self: Type, builder: *const Builder) Type.Function.Kind {
+        return switch (self.tag(builder)) {
+            .function => .normal,
+            .vararg_function => .vararg,
+            else => unreachable,
+        };
+    }
+
+    pub fn isVector(self: Type, builder: *const Builder) bool {
+        return switch (self.tag(builder)) {
+            .vector, .scalable_vector => true,
+            else => false,
+        };
+    }
+
+    pub fn vectorKind(self: Type, builder: *const Builder) Type.Vector.Kind {
+        return switch (self.tag(builder)) {
+            .vector => .normal,
+            .scalable_vector => .scalable,
+            else => unreachable,
+        };
+    }
+
+    pub fn isStruct(self: Type, builder: *const Builder) bool {
+        return switch (self.tag(builder)) {
+            .structure, .packed_structure, .named_structure => true,
+            else => false,
+        };
+    }
+
+    pub fn structKind(self: Type, builder: *const Builder) Type.Structure.Kind {
+        return switch (self.unnamedTag(builder)) {
+            .structure => .normal,
+            .packed_structure => .@"packed",
+            else => unreachable,
+        };
+    }
+
+    pub fn scalarBits(self: Type, builder: *const Builder) u24 {
+        return switch (self) {
+            .void, .label, .token, .metadata, .none, .x86_amx => unreachable,
+            .i1 => 1,
+            .i8 => 8,
+            .half, .bfloat, .i16 => 16,
+            .i29 => 29,
+            .float, .i32 => 32,
+            .double, .i64, .x86_mmx => 64,
+            .x86_fp80, .i80 => 80,
+            .fp128, .ppc_fp128, .i128 => 128,
+            .ptr => @panic("TODO: query data layout"),
+            _ => {
+                const item = builder.type_items.items[@intFromEnum(self)];
+                return switch (item.tag) {
+                    .simple,
+                    .function,
+                    .vararg_function,
+                    => unreachable,
+                    .integer => @intCast(item.data),
+                    .pointer => @panic("TODO: query data layout"),
+                    .target => unreachable,
+                    .vector,
+                    .scalable_vector,
+                    => builder.typeExtraData(Type.Vector, item.data).child.scalarBits(builder),
+                    .small_array,
+                    .array,
+                    .structure,
+                    .packed_structure,
+                    .named_structure,
+                    => unreachable,
+                };
+            },
+        };
+    }
+
+    pub fn childType(self: Type, builder: *const Builder) Type {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        return switch (item.tag) {
+            .vector,
+            .scalable_vector,
+            .small_array,
+            => builder.typeExtraData(Type.Vector, item.data).child,
+            .array => builder.typeExtraData(Type.Array, item.data).child,
+            .named_structure => builder.typeExtraData(Type.NamedStructure, item.data).body,
+            else => unreachable,
+        };
+    }
+
+    pub fn vectorLen(self: Type, builder: *const Builder) u32 {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        return switch (item.tag) {
+            .vector,
+            .scalable_vector,
+            => builder.typeExtraData(Type.Vector, item.data).len,
+            else => unreachable,
+        };
+    }
+
+    pub fn aggregateLen(self: Type, builder: *const Builder) u64 {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        return switch (item.tag) {
+            .vector,
+            .scalable_vector,
+            .small_array,
+            => builder.typeExtraData(Type.Vector, item.data).len,
+            .array => builder.typeExtraData(Type.Array, item.data).len(),
+            .structure,
+            .packed_structure,
+            => builder.typeExtraData(Type.Structure, item.data).fields_len,
+            .named_structure => builder.typeExtraData(Type.NamedStructure, item.data).body
+                .aggregateLen(builder),
+            else => unreachable,
+        };
+    }
+
+    pub fn structFields(self: Type, builder: *const Builder) []const Type {
+        const item = builder.type_items.items[@intFromEnum(self)];
+        switch (item.tag) {
+            .structure,
+            .packed_structure,
+            => {
+                const extra = builder.typeExtraDataTrail(Type.Structure, item.data);
+                return @ptrCast(builder.type_extra.items[extra.end..][0..extra.data.fields_len]);
+            },
+            .named_structure => return builder.typeExtraData(Type.NamedStructure, item.data).body
+                .structFields(builder),
+            else => unreachable,
+        }
+    }
 
     pub const FormatData = struct {
         type: Type,
@@ -220,11 +381,11 @@ pub const Type = enum(u32) {
     ) @TypeOf(writer).Error!void {
         assert(data.type != .none);
         if (std.enums.tagName(Type, data.type)) |name| return writer.writeAll(name);
-        const type_item = data.builder.type_items.items[@intFromEnum(data.type)];
-        switch (type_item.tag) {
+        const item = data.builder.type_items.items[@intFromEnum(data.type)];
+        switch (item.tag) {
             .simple => unreachable,
             .function, .vararg_function => {
-                const extra = data.builder.typeExtraDataTrail(Type.Function, type_item.data);
+                const extra = data.builder.typeExtraDataTrail(Type.Function, item.data);
                 const params: []const Type =
                     @ptrCast(data.builder.type_extra.items[extra.end..][0..extra.data.params_len]);
                 if (!comptime std.mem.eql(u8, fmt_str, ">"))
@@ -235,7 +396,7 @@ pub const Type = enum(u32) {
                         if (index > 0) try writer.writeAll(", ");
                         try writer.print("{%}", .{param.fmt(data.builder)});
                     }
-                    switch (type_item.tag) {
+                    switch (item.tag) {
                         .function => {},
                         .vararg_function => {
                             if (params.len > 0) try writer.writeAll(", ");
@@ -246,10 +407,10 @@ pub const Type = enum(u32) {
                     try writer.writeByte(')');
                 }
             },
-            .integer => try writer.print("i{d}", .{type_item.data}),
-            .pointer => try writer.print("ptr{}", .{@as(AddrSpace, @enumFromInt(type_item.data))}),
+            .integer => try writer.print("i{d}", .{item.data}),
+            .pointer => try writer.print("ptr{}", .{@as(AddrSpace, @enumFromInt(item.data))}),
             .target => {
-                const extra = data.builder.typeExtraDataTrail(Type.Target, type_item.data);
+                const extra = data.builder.typeExtraDataTrail(Type.Target, item.data);
                 const types: []const Type =
                     @ptrCast(data.builder.type_extra.items[extra.end..][0..extra.data.types_len]);
                 const ints: []const u32 = @ptrCast(data.builder.type_extra.items[extra.end +
@@ -262,26 +423,28 @@ pub const Type = enum(u32) {
                 try writer.writeByte(')');
             },
             .vector => {
-                const extra = data.builder.typeExtraData(Type.Vector, type_item.data);
+                const extra = data.builder.typeExtraData(Type.Vector, item.data);
                 try writer.print("<{d} x {%}>", .{ extra.len, extra.child.fmt(data.builder) });
             },
             .scalable_vector => {
-                const extra = data.builder.typeExtraData(Type.Vector, type_item.data);
+                const extra = data.builder.typeExtraData(Type.Vector, item.data);
                 try writer.print("<vscale x {d} x {%}>", .{ extra.len, extra.child.fmt(data.builder) });
             },
             .small_array => {
-                const extra = data.builder.typeExtraData(Type.Vector, type_item.data);
+                const extra = data.builder.typeExtraData(Type.Vector, item.data);
                 try writer.print("[{d} x {%}]", .{ extra.len, extra.child.fmt(data.builder) });
             },
             .array => {
-                const extra = data.builder.typeExtraData(Type.Array, type_item.data);
+                const extra = data.builder.typeExtraData(Type.Array, item.data);
                 try writer.print("[{d} x {%}]", .{ extra.len(), extra.child.fmt(data.builder) });
             },
-            .structure, .packed_structure => {
-                const extra = data.builder.typeExtraDataTrail(Type.Structure, type_item.data);
+            .structure,
+            .packed_structure,
+            => {
+                const extra = data.builder.typeExtraDataTrail(Type.Structure, item.data);
                 const fields: []const Type =
                     @ptrCast(data.builder.type_extra.items[extra.end..][0..extra.data.fields_len]);
-                switch (type_item.tag) {
+                switch (item.tag) {
                     .structure => {},
                     .packed_structure => try writer.writeByte('<'),
                     else => unreachable,
@@ -292,14 +455,14 @@ pub const Type = enum(u32) {
                     try writer.print("{%}", .{field.fmt(data.builder)});
                 }
                 try writer.writeAll(" }");
-                switch (type_item.tag) {
+                switch (item.tag) {
                     .structure => {},
                     .packed_structure => try writer.writeByte('>'),
                     else => unreachable,
                 }
             },
             .named_structure => {
-                const extra = data.builder.typeExtraData(Type.NamedStructure, type_item.data);
+                const extra = data.builder.typeExtraData(Type.NamedStructure, item.data);
                 if (comptime std.mem.eql(u8, fmt_str, "%")) try writer.print("%{}", .{
                     extra.id.fmt(data.builder),
                 }) else switch (extra.body) {
@@ -323,7 +486,7 @@ pub const Type = enum(u32) {
 };
 
 pub const Linkage = enum {
-    default,
+    external,
     private,
     internal,
     available_externally,
@@ -334,7 +497,6 @@ pub const Linkage = enum {
     extern_weak,
     linkonce_odr,
     weak_odr,
-    external,
 
     pub fn format(
         self: Linkage,
@@ -342,14 +504,14 @@ pub const Linkage = enum {
         _: std.fmt.FormatOptions,
         writer: anytype,
     ) @TypeOf(writer).Error!void {
-        if (self != .default) try writer.print(" {s}", .{@tagName(self)});
+        if (self != .external) try writer.print(" {s}", .{@tagName(self)});
     }
 };
 
 pub const Preemption = enum {
-    default,
     dso_preemptable,
     dso_local,
+    implicit_dso_local,
 
     pub fn format(
         self: Preemption,
@@ -357,7 +519,7 @@ pub const Preemption = enum {
         _: std.fmt.FormatOptions,
         writer: anytype,
     ) @TypeOf(writer).Error!void {
-        if (self != .default) try writer.print(" {s}", .{@tagName(self)});
+        if (self == .dso_local) try writer.print(" {s}", .{@tagName(self)});
     }
 };
 
@@ -554,22 +716,25 @@ pub const Alignment = enum(u6) {
 };
 
 pub const Global = struct {
-    linkage: Linkage = .default,
-    preemption: Preemption = .default,
+    linkage: Linkage = .external,
+    preemption: Preemption = .dso_preemptable,
     visibility: Visibility = .default,
     dll_storage_class: DllStorageClass = .default,
     unnamed_addr: UnnamedAddr = .default,
     addr_space: AddrSpace = .default,
     externally_initialized: ExternallyInitialized = .default,
     type: Type,
+    section: String = .none,
+    partition: String = .none,
     alignment: Alignment = .default,
     kind: union(enum) {
         alias: Alias.Index,
-        object: Object.Index,
+        variable: Variable.Index,
         function: Function.Index,
     },
 
     pub const Index = enum(u32) {
+        none = std.math.maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Global {
@@ -580,11 +745,33 @@ pub const Global = struct {
             return &builder.globals.values()[@intFromEnum(self)];
         }
 
+        pub fn toConst(self: Index) Constant {
+            return @enumFromInt(@intFromEnum(Constant.first_global) + @intFromEnum(self));
+        }
+
         pub fn toLlvm(self: Index, builder: *const Builder) *llvm.Value {
             assert(builder.useLibLlvm());
             return builder.llvm_globals.items[@intFromEnum(self)];
         }
 
+        const FormatData = struct {
+            global: Index,
+            builder: *const Builder,
+        };
+        fn format(
+            data: FormatData,
+            comptime _: []const u8,
+            _: std.fmt.FormatOptions,
+            writer: anytype,
+        ) @TypeOf(writer).Error!void {
+            try writer.print("@{}", .{
+                data.builder.globals.keys()[@intFromEnum(data.global)].fmt(data.builder),
+            });
+        }
+        pub fn fmt(self: Index, builder: *const Builder) std.fmt.Formatter(format) {
+            return .{ .data = .{ .global = self, .builder = builder } };
+        }
+
         pub fn rename(self: Index, builder: *Builder, name: String) Allocator.Error!void {
             try builder.ensureUnusedCapacityGlobal(name);
             self.renameAssumeCapacity(builder, name);
@@ -618,12 +805,32 @@ pub const Global = struct {
             builder.llvm_globals.items[index].setValueName2(slice.ptr, slice.len);
         }
     };
+
+    pub fn updateAttributes(self: *Global) void {
+        switch (self.linkage) {
+            .private, .internal => {
+                self.visibility = .default;
+                self.dll_storage_class = .default;
+                self.preemption = .implicit_dso_local;
+            },
+            .extern_weak => if (self.preemption == .implicit_dso_local) {
+                self.preemption = .dso_local;
+            },
+            else => switch (self.visibility) {
+                .default => if (self.preemption == .implicit_dso_local) {
+                    self.preemption = .dso_local;
+                },
+                else => self.preemption = .implicit_dso_local,
+            },
+        }
+    }
 };
 
 pub const Alias = struct {
     global: Global.Index,
 
     pub const Index = enum(u32) {
+        none = std.math.maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Alias {
@@ -640,21 +847,22 @@ pub const Alias = struct {
     };
 };
 
-pub const Object = struct {
+pub const Variable = struct {
     global: Global.Index,
     thread_local: ThreadLocal = .default,
     mutability: enum { global, constant } = .global,
     init: Constant = .no_init,
 
     pub const Index = enum(u32) {
+        none = std.math.maxInt(u32),
         _,
 
-        pub fn ptr(self: Index, builder: *Builder) *Object {
-            return &builder.objects.items[@intFromEnum(self)];
+        pub fn ptr(self: Index, builder: *Builder) *Variable {
+            return &builder.variables.items[@intFromEnum(self)];
         }
 
-        pub fn ptrConst(self: Index, builder: *const Builder) *const Object {
-            return &builder.objects.items[@intFromEnum(self)];
+        pub fn ptrConst(self: Index, builder: *const Builder) *const Variable {
+            return &builder.variables.items[@intFromEnum(self)];
         }
 
         pub fn toLlvm(self: Index, builder: *const Builder) *llvm.Value {
@@ -670,6 +878,7 @@ pub const Function = struct {
     blocks: std.ArrayListUnmanaged(Block) = .{},
 
     pub const Index = enum(u32) {
+        none = std.math.maxInt(u32),
         _,
 
         pub fn ptr(self: Index, builder: *Builder) *Function {
@@ -693,13 +902,13 @@ pub const Function = struct {
             block,
         };
 
-        pub const Index = enum(u31) { _ };
+        pub const Index = enum(u32) { _ };
     };
 
     pub const Block = struct {
         body: std.ArrayListUnmanaged(Instruction.Index) = .{},
 
-        pub const Index = enum(u31) { _ };
+        pub const Index = enum(u32) { _ };
     };
 
     pub fn deinit(self: *Function, gpa: Allocator) void {
@@ -709,6 +918,36 @@ pub const Function = struct {
     }
 };
 
+pub const FloatCondition = enum(u4) {
+    oeq = 1,
+    ogt = 2,
+    oge = 3,
+    olt = 4,
+    ole = 5,
+    one = 6,
+    ord = 7,
+    uno = 8,
+    ueq = 9,
+    ugt = 10,
+    uge = 11,
+    ult = 12,
+    ule = 13,
+    une = 14,
+};
+
+pub const IntegerCondition = enum(u6) {
+    eq = 32,
+    ne = 33,
+    ugt = 34,
+    uge = 35,
+    ult = 36,
+    ule = 37,
+    sgt = 38,
+    sge = 39,
+    slt = 40,
+    sle = 41,
+};
+
 pub const Constant = enum(u32) {
     false,
     true,
@@ -719,15 +958,24 @@ pub const Constant = enum(u32) {
     const first_global: Constant = @enumFromInt(1 << 30);
 
     pub const Tag = enum(u6) {
-        integer_positive,
-        integer_negative,
+        positive_integer,
+        negative_integer,
+        half,
+        bfloat,
+        float,
+        double,
+        fp128,
+        x86_fp80,
+        ppc_fp128,
         null,
         none,
         structure,
+        packed_structure,
         array,
+        string,
+        string_null,
         vector,
         zeroinitializer,
-        global,
         undef,
         poison,
         blockaddress,
@@ -747,6 +995,7 @@ pub const Constant = enum(u32) {
         bitcast,
         addrspacecast,
         getelementptr,
+        @"getelementptr inbounds",
         icmp,
         fcmp,
         extractelement,
@@ -765,7 +1014,9 @@ pub const Constant = enum(u32) {
 
     pub const Item = struct {
         tag: Tag,
-        data: u32,
+        data: ExtraIndex,
+
+        const ExtraIndex = u32;
     };
 
     pub const Integer = packed struct(u64) {
@@ -775,6 +1026,80 @@ pub const Constant = enum(u32) {
         pub const limbs = @divExact(@bitSizeOf(Integer), @bitSizeOf(std.math.big.Limb));
     };
 
+    pub const Double = struct {
+        lo: u32,
+        hi: u32,
+    };
+
+    pub const Fp80 = struct {
+        lo_lo: u32,
+        lo_hi: u32,
+        hi: u32,
+    };
+
+    pub const Fp128 = struct {
+        lo_lo: u32,
+        lo_hi: u32,
+        hi_lo: u32,
+        hi_hi: u32,
+    };
+
+    pub const Aggregate = struct {
+        type: Type,
+    };
+
+    pub const BlockAddress = extern struct {
+        function: Function.Index,
+        block: Function.Block.Index,
+    };
+
+    pub const FunctionReference = struct {
+        function: Function.Index,
+    };
+
+    pub const Cast = extern struct {
+        arg: Constant,
+        type: Type,
+
+        pub const Signedness = enum { unsigned, signed, unneeded };
+    };
+
+    pub const GetElementPtr = struct {
+        type: Type,
+        base: Constant,
+        indices_len: u32,
+
+        pub const Kind = enum { normal, inbounds };
+    };
+
+    pub const Compare = struct {
+        cond: u32,
+        lhs: Constant,
+        rhs: Constant,
+    };
+
+    pub const ExtractElement = struct {
+        arg: Constant,
+        index: Constant,
+    };
+
+    pub const InsertElement = struct {
+        arg: Constant,
+        elem: Constant,
+        index: Constant,
+    };
+
+    pub const ShuffleVector = struct {
+        lhs: Constant,
+        rhs: Constant,
+        mask: Constant,
+    };
+
+    pub const Binary = extern struct {
+        lhs: Constant,
+        rhs: Constant,
+    };
+
     pub fn unwrap(self: Constant) union(enum) {
         constant: u30,
         global: Global.Index,
@@ -785,6 +1110,307 @@ pub const Constant = enum(u32) {
             .{ .global = @enumFromInt(@intFromEnum(self) - @intFromEnum(first_global)) };
     }
 
+    pub fn typeOf(self: Constant, builder: *Builder) Type {
+        switch (self.unwrap()) {
+            .constant => |constant| {
+                const item = builder.constant_items.get(constant);
+                return switch (item.tag) {
+                    .positive_integer,
+                    .negative_integer,
+                    => @as(
+                        *align(@alignOf(std.math.big.Limb)) Integer,
+                        @ptrCast(builder.constant_limbs.items[item.data..][0..Integer.limbs]),
+                    ).type,
+                    .half => .half,
+                    .bfloat => .bfloat,
+                    .float => .float,
+                    .double => .double,
+                    .fp128 => .fp128,
+                    .x86_fp80 => .x86_fp80,
+                    .ppc_fp128 => .ppc_fp128,
+                    .null,
+                    .none,
+                    .zeroinitializer,
+                    .undef,
+                    .poison,
+                    => @enumFromInt(item.data),
+                    .structure,
+                    .packed_structure,
+                    .array,
+                    .vector,
+                    => builder.constantExtraData(Aggregate, item.data).type,
+                    .string,
+                    .string_null,
+                    => builder.arrayTypeAssumeCapacity(
+                        @as(String, @enumFromInt(item.data)).toSlice(builder).?.len +
+                            @intFromBool(item.tag == .string_null),
+                        .i8,
+                    ),
+                    .blockaddress => builder.ptrTypeAssumeCapacity(
+                        builder.constantExtraData(BlockAddress, item.data)
+                            .function.ptrConst(builder).global.ptrConst(builder).addr_space,
+                    ),
+                    .dso_local_equivalent,
+                    .no_cfi,
+                    => builder.ptrTypeAssumeCapacity(
+                        builder.constantExtraData(FunctionReference, item.data)
+                            .function.ptrConst(builder).global.ptrConst(builder).addr_space,
+                    ),
+                    .trunc,
+                    .zext,
+                    .sext,
+                    .fptrunc,
+                    .fpext,
+                    .fptoui,
+                    .fptosi,
+                    .uitofp,
+                    .sitofp,
+                    .ptrtoint,
+                    .inttoptr,
+                    .bitcast,
+                    .addrspacecast,
+                    => builder.constantExtraData(Cast, item.data).type,
+                    .getelementptr,
+                    .@"getelementptr inbounds",
+                    => {
+                        const extra = builder.constantExtraDataTrail(GetElementPtr, item.data);
+                        const indices: []const Constant = @ptrCast(builder.constant_extra
+                            .items[extra.end..][0..extra.data.indices_len]);
+                        const base_ty = extra.data.base.typeOf(builder);
+                        if (!base_ty.isVector(builder)) for (indices) |index| {
+                            const index_ty = index.typeOf(builder);
+                            if (!index_ty.isVector(builder)) continue;
+                            switch (index_ty.vectorKind(builder)) {
+                                inline else => |kind| return builder.vectorTypeAssumeCapacity(
+                                    kind,
+                                    index_ty.vectorLen(builder),
+                                    base_ty,
+                                ),
+                            }
+                        };
+                        return base_ty;
+                    },
+                    .icmp, .fcmp => {
+                        const ty = builder.constantExtraData(Compare, item.data).lhs.typeOf(builder);
+                        return switch (ty) {
+                            .half,
+                            .bfloat,
+                            .float,
+                            .double,
+                            .fp128,
+                            .x86_fp80,
+                            .ppc_fp128,
+                            .i1,
+                            .i8,
+                            .i16,
+                            .i29,
+                            .i32,
+                            .i64,
+                            .i80,
+                            .i128,
+                            => ty,
+                            else => if (ty.isVector(builder)) switch (ty.vectorKind(builder)) {
+                                inline else => |kind| builder
+                                    .vectorTypeAssumeCapacity(kind, ty.vectorLen(builder), .i1),
+                            } else ty,
+                        };
+                    },
+                    .extractelement => builder.constantExtraData(ExtractElement, item.data)
+                        .arg.typeOf(builder).childType(builder),
+                    .insertelement => builder.constantExtraData(InsertElement, item.data)
+                        .arg.typeOf(builder),
+                    .shufflevector => {
+                        const extra = builder.constantExtraData(ShuffleVector, item.data);
+                        const ty = extra.lhs.typeOf(builder);
+                        return switch (ty.vectorKind(builder)) {
+                            inline else => |kind| builder.vectorTypeAssumeCapacity(
+                                kind,
+                                extra.mask.typeOf(builder).vectorLen(builder),
+                                ty.childType(builder),
+                            ),
+                        };
+                    },
+                    .add,
+                    .sub,
+                    .mul,
+                    .shl,
+                    .lshr,
+                    .ashr,
+                    .@"and",
+                    .@"or",
+                    .xor,
+                    => builder.constantExtraData(Binary, item.data).lhs.typeOf(builder),
+                };
+            },
+            .global => |global| return builder.ptrTypeAssumeCapacity(
+                global.ptrConst(builder).addr_space,
+            ),
+        }
+    }
+
+    pub fn isZeroInit(self: Constant, builder: *const Builder) bool {
+        switch (self.unwrap()) {
+            .constant => |constant| {
+                const item = builder.constant_items.get(constant);
+                return switch (item.tag) {
+                    .positive_integer => {
+                        const extra: *align(@alignOf(std.math.big.Limb)) Integer =
+                            @ptrCast(builder.constant_limbs.items[item.data..][0..Integer.limbs]);
+                        const limbs = builder.constant_limbs
+                            .items[item.data + Integer.limbs ..][0..extra.limbs_len];
+                        return std.mem.eql(std.math.big.Limb, limbs, &.{0});
+                    },
+                    .half, .bfloat, .float => item.data == 0,
+                    .double => {
+                        const extra = builder.constantExtraData(Constant.Double, item.data);
+                        return extra.lo == 0 and extra.hi == 0;
+                    },
+                    .fp128, .ppc_fp128 => {
+                        const extra = builder.constantExtraData(Constant.Fp128, item.data);
+                        return extra.lo_lo == 0 and extra.lo_hi == 0 and
+                            extra.hi_lo == 0 and extra.hi_hi == 0;
+                    },
+                    .x86_fp80 => {
+                        const extra = builder.constantExtraData(Constant.Fp80, item.data);
+                        return extra.lo_lo == 0 and extra.lo_hi == 0 and extra.hi == 0;
+                    },
+                    .vector => {
+                        const extra = builder.constantExtraDataTrail(Aggregate, item.data);
+                        const len = extra.data.type.aggregateLen(builder);
+                        const vals: []const Constant =
+                            @ptrCast(builder.constant_extra.items[extra.end..][0..len]);
+                        for (vals) |val| if (!val.isZeroInit(builder)) return false;
+                        return true;
+                    },
+                    .null, .zeroinitializer => true,
+                    else => false,
+                };
+            },
+            .global => return false,
+        }
+    }
+
+    pub const FormatData = struct {
+        constant: Constant,
+        builder: *Builder,
+    };
+    fn format(
+        data: FormatData,
+        comptime fmt_str: []const u8,
+        _: std.fmt.FormatOptions,
+        writer: anytype,
+    ) @TypeOf(writer).Error!void {
+        if (comptime std.mem.eql(u8, fmt_str, "%")) {
+            try writer.print("{%} ", .{data.constant.typeOf(data.builder).fmt(data.builder)});
+        } else if (comptime std.mem.eql(u8, fmt_str, " ")) {
+            if (data.constant == .no_init) return;
+            try writer.writeByte(' ');
+        }
+        assert(data.constant != .no_init);
+        if (std.enums.tagName(Constant, data.constant)) |name| return writer.writeAll(name);
+        switch (data.constant.unwrap()) {
+            .constant => |constant| {
+                const item = data.builder.constant_items.get(constant);
+                switch (item.tag) {
+                    .positive_integer,
+                    .negative_integer,
+                    => {
+                        const extra: *align(@alignOf(std.math.big.Limb)) Integer =
+                            @ptrCast(data.builder.constant_limbs.items[item.data..][0..Integer.limbs]);
+                        const limbs = data.builder.constant_limbs
+                            .items[item.data + Integer.limbs ..][0..extra.limbs_len];
+                        const bigint = std.math.big.int.Const{
+                            .limbs = limbs,
+                            .positive = item.tag == .positive_integer,
+                        };
+                        const ExpectedContents = extern struct {
+                            string: [(64 * 8 / std.math.log2(10)) + 2]u8,
+                            limbs: [
+                                std.math.big.int.calcToStringLimbsBufferLen(
+                                    64 / @sizeOf(std.math.big.Limb),
+                                    10,
+                                )
+                            ]std.math.big.Limb,
+                        };
+                        var stack align(@alignOf(ExpectedContents)) =
+                            std.heap.stackFallback(@sizeOf(ExpectedContents), data.builder.gpa);
+                        const allocator = stack.get();
+                        const str = bigint.toStringAlloc(allocator, 10, undefined) catch
+                            return writer.writeAll("...");
+                        defer allocator.free(str);
+                        try writer.writeAll(str);
+                    },
+                    .null,
+                    .none,
+                    .zeroinitializer,
+                    .undef,
+                    .poison,
+                    => try writer.writeAll(@tagName(item.tag)),
+                    .structure,
+                    .packed_structure,
+                    .array,
+                    .vector,
+                    => {
+                        const extra = data.builder.constantExtraDataTrail(Aggregate, item.data);
+                        const len = extra.data.type.aggregateLen(data.builder);
+                        const vals: []const Constant =
+                            @ptrCast(data.builder.constant_extra.items[extra.end..][0..len]);
+
+                        try writer.writeAll(switch (item.tag) {
+                            .structure => "{ ",
+                            .packed_structure => "<{ ",
+                            .array => "[",
+                            .vector => "<",
+                            else => unreachable,
+                        });
+                        for (vals, 0..) |val, index| {
+                            if (index > 0) try writer.writeAll(", ");
+                            try writer.print("{%}", .{val.fmt(data.builder)});
+                        }
+                        try writer.writeAll(switch (item.tag) {
+                            .structure => " }",
+                            .packed_structure => " }>",
+                            .array => "]",
+                            .vector => ">",
+                            else => unreachable,
+                        });
+                    },
+                    .string => try writer.print(
+                        \\c{"}
+                    , .{@as(String, @enumFromInt(item.data)).fmt(data.builder)}),
+                    .string_null => try writer.print(
+                        \\c{"@}
+                    , .{@as(String, @enumFromInt(item.data)).fmt(data.builder)}),
+                    .blockaddress => {
+                        const extra = data.builder.constantExtraData(BlockAddress, item.data);
+                        const function = extra.function.ptrConst(data.builder);
+                        try writer.print("{s}({}, %{d})", .{
+                            @tagName(item.tag),
+                            function.global.fmt(data.builder),
+                            @intFromEnum(extra.block), // TODO
+                        });
+                    },
+                    .dso_local_equivalent,
+                    .no_cfi,
+                    => {
+                        const extra = data.builder.constantExtraData(FunctionReference, item.data);
+                        try writer.print("{s} {}", .{
+                            @tagName(item.tag),
+                            extra.function.ptrConst(data.builder).global.fmt(data.builder),
+                        });
+                    },
+                    else => try writer.print("<{s}:0x{X}>", .{
+                        @tagName(item.tag), @intFromEnum(data.constant),
+                    }),
+                }
+            },
+            .global => |global| try writer.print("{}", .{global.fmt(data.builder)}),
+        }
+    }
+    pub fn fmt(self: Constant, builder: *Builder) std.fmt.Formatter(format) {
+        return .{ .data = .{ .constant = self, .builder = builder } };
+    }
+
     pub fn toLlvm(self: Constant, builder: *const Builder) *llvm.Value {
         assert(builder.useLibLlvm());
         return switch (self.unwrap()) {
@@ -813,7 +1439,6 @@ pub const Value = enum(u32) {
 pub fn init(self: *Builder) Allocator.Error!void {
     try self.string_indices.append(self.gpa, 0);
     assert(try self.string("") == .empty);
-    assert(try self.string("debugme") == .debugme);
 
     {
         const static_len = @typeInfo(Type).Enum.fields.len - 1;
@@ -821,10 +1446,9 @@ pub fn init(self: *Builder) Allocator.Error!void {
         try self.type_items.ensureTotalCapacity(self.gpa, static_len);
         if (self.useLibLlvm()) try self.llvm_types.ensureTotalCapacity(self.gpa, static_len);
         inline for (@typeInfo(Type.Simple).Enum.fields) |simple_field| {
-            const result = self.typeNoExtraAssumeCapacity(.{
-                .tag = .simple,
-                .data = simple_field.value,
-            });
+            const result = self.getOrPutTypeNoExtraAssumeCapacity(
+                .{ .tag = .simple, .data = simple_field.value },
+            );
             assert(result.new and result.type == @field(Type, simple_field.name));
             if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
                 @field(llvm.Context, simple_field.name ++ "Type")(self.llvm_context),
@@ -838,6 +1462,7 @@ pub fn init(self: *Builder) Allocator.Error!void {
 
     assert(try self.intConst(.i1, 0) == .false);
     assert(try self.intConst(.i1, 1) == .true);
+    assert(try self.noneConst(.token) == .none);
 }
 
 pub fn deinit(self: *Builder) void {
@@ -858,7 +1483,7 @@ pub fn deinit(self: *Builder) void {
     self.globals.deinit(self.gpa);
     self.next_unique_global_id.deinit(self.gpa);
     self.aliases.deinit(self.gpa);
-    self.objects.deinit(self.gpa);
+    self.variables.deinit(self.gpa);
     for (self.functions.items) |*function| function.deinit(self.gpa);
     self.functions.deinit(self.gpa);
 
@@ -1110,19 +1735,19 @@ pub fn fnType(
     params: []const Type,
     kind: Type.Function.Kind,
 ) Allocator.Error!Type {
-    try self.ensureUnusedCapacityTypes(1, Type.Function, params.len);
+    try self.ensureUnusedTypeCapacity(1, Type.Function, params.len);
     return switch (kind) {
         inline else => |comptime_kind| self.fnTypeAssumeCapacity(ret, params, comptime_kind),
     };
 }
 
 pub fn intType(self: *Builder, bits: u24) Allocator.Error!Type {
-    try self.ensureUnusedCapacityTypes(1, null, 0);
+    try self.ensureUnusedTypeCapacity(1, null, 0);
     return self.intTypeAssumeCapacity(bits);
 }
 
 pub fn ptrType(self: *Builder, addr_space: AddrSpace) Allocator.Error!Type {
-    try self.ensureUnusedCapacityTypes(1, null, 0);
+    try self.ensureUnusedTypeCapacity(1, null, 0);
     return self.ptrTypeAssumeCapacity(addr_space);
 }
 
@@ -1132,7 +1757,7 @@ pub fn vectorType(
     len: u32,
     child: Type,
 ) Allocator.Error!Type {
-    try self.ensureUnusedCapacityTypes(1, Type.Vector, 0);
+    try self.ensureUnusedTypeCapacity(1, Type.Vector, 0);
     return switch (kind) {
         inline else => |comptime_kind| self.vectorTypeAssumeCapacity(comptime_kind, len, child),
     };
@@ -1140,7 +1765,7 @@ pub fn vectorType(
 
 pub fn arrayType(self: *Builder, len: u64, child: Type) Allocator.Error!Type {
     comptime assert(@sizeOf(Type.Array) >= @sizeOf(Type.Vector));
-    try self.ensureUnusedCapacityTypes(1, Type.Array, 0);
+    try self.ensureUnusedTypeCapacity(1, Type.Array, 0);
     return self.arrayTypeAssumeCapacity(len, child);
 }
 
@@ -1149,7 +1774,7 @@ pub fn structType(
     kind: Type.Structure.Kind,
     fields: []const Type,
 ) Allocator.Error!Type {
-    try self.ensureUnusedCapacityTypes(1, Type.Structure, fields.len);
+    try self.ensureUnusedTypeCapacity(1, Type.Structure, fields.len);
     return switch (kind) {
         inline else => |comptime_kind| self.structTypeAssumeCapacity(comptime_kind, fields),
     };
@@ -1162,7 +1787,7 @@ pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
     try self.string_indices.ensureUnusedCapacity(self.gpa, 1);
     try self.types.ensureUnusedCapacity(self.gpa, 1);
     try self.next_unique_type_id.ensureUnusedCapacity(self.gpa, 1);
-    try self.ensureUnusedCapacityTypes(1, Type.NamedStructure, 0);
+    try self.ensureUnusedTypeCapacity(1, Type.NamedStructure, 0);
     return self.opaqueTypeAssumeCapacity(name);
 }
 
@@ -1181,8 +1806,7 @@ pub fn namedTypeSetBody(
             @ptrCast(self.type_extra.items[body_extra.end..][0..body_extra.data.fields_len]);
         const llvm_fields = try self.gpa.alloc(*llvm.Type, body_fields.len);
         defer self.gpa.free(llvm_fields);
-        for (llvm_fields, body_fields) |*llvm_field, body_field|
-            llvm_field.* = self.llvm_types.items[@intFromEnum(body_field)];
+        for (llvm_fields, body_fields) |*llvm_field, body_field| llvm_field.* = body_field.toLlvm(self);
         self.llvm_types.items[@intFromEnum(named_type)].structSetBody(
             llvm_fields.ptr,
             @intCast(llvm_fields.len),
@@ -1196,11 +1820,13 @@ pub fn namedTypeSetBody(
 }
 
 pub fn addGlobal(self: *Builder, name: String, global: Global) Allocator.Error!Global.Index {
+    try self.ensureUnusedTypeCapacity(1, null, 0);
     try self.ensureUnusedCapacityGlobal(name);
     return self.addGlobalAssumeCapacity(name, global);
 }
 
 pub fn addGlobalAssumeCapacity(self: *Builder, name: String, global: Global) Global.Index {
+    _ = self.ptrTypeAssumeCapacity(global.addr_space);
     var id = name;
     if (id == .none) {
         id = self.next_unnamed_global;
@@ -1210,6 +1836,7 @@ pub fn addGlobalAssumeCapacity(self: *Builder, name: String, global: Global) Glo
         const global_gop = self.globals.getOrPutAssumeCapacity(id);
         if (!global_gop.found_existing) {
             global_gop.value_ptr.* = global;
+            global_gop.value_ptr.updateAttributes();
             const index: Global.Index = @enumFromInt(global_gop.index);
             index.updateName(self);
             return index;
@@ -1246,6 +1873,207 @@ pub fn bigIntConst(self: *Builder, ty: Type, value: std.math.big.int.Const) Allo
     return self.bigIntConstAssumeCapacity(ty, value);
 }
 
+pub fn fpConst(self: *Builder, ty: Type, comptime val: comptime_float) Allocator.Error!Constant {
+    return switch (ty) {
+        .half => try self.halfConst(val),
+        .bfloat => try self.bfloatConst(val),
+        .float => try self.floatConst(val),
+        .double => try self.doubleConst(val),
+        .fp128 => try self.fp128Const(val),
+        .x86_fp80 => try self.x86_fp80Const(val),
+        .ppc_fp128 => try self.ppc_fp128Const(.{ val, 0 }),
+        else => unreachable,
+    };
+}
+
+pub fn halfConst(self: *Builder, val: f16) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.halfConstAssumeCapacity(val);
+}
+
+pub fn bfloatConst(self: *Builder, val: f32) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.bfloatConstAssumeCapacity(val);
+}
+
+pub fn floatConst(self: *Builder, val: f32) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.floatConstAssumeCapacity(val);
+}
+
+pub fn doubleConst(self: *Builder, val: f64) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Double, 0);
+    return self.doubleConstAssumeCapacity(val);
+}
+
+pub fn fp128Const(self: *Builder, val: f128) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Fp128, 0);
+    return self.fp128ConstAssumeCapacity(val);
+}
+
+pub fn x86_fp80Const(self: *Builder, val: f80) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Fp80, 0);
+    return self.x86_fp80ConstAssumeCapacity(val);
+}
+
+pub fn ppc_fp128Const(self: *Builder, val: [2]f64) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Fp128, 0);
+    return self.ppc_fp128ConstAssumeCapacity(val);
+}
+
+pub fn nullConst(self: *Builder, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.nullConstAssumeCapacity(ty);
+}
+
+pub fn noneConst(self: *Builder, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.noneConstAssumeCapacity(ty);
+}
+
+pub fn structConst(self: *Builder, ty: Type, vals: []const Constant) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Aggregate, vals.len);
+    return self.structConstAssumeCapacity(ty, vals);
+}
+
+pub fn arrayConst(self: *Builder, ty: Type, vals: []const Constant) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Aggregate, vals.len);
+    return self.arrayConstAssumeCapacity(ty, vals);
+}
+
+pub fn stringConst(self: *Builder, val: String) Allocator.Error!Constant {
+    try self.ensureUnusedTypeCapacity(1, Type.Array, 0);
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.stringConstAssumeCapacity(val);
+}
+
+pub fn stringNullConst(self: *Builder, val: String) Allocator.Error!Constant {
+    try self.ensureUnusedTypeCapacity(1, Type.Array, 0);
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.stringNullConstAssumeCapacity(val);
+}
+
+pub fn vectorConst(self: *Builder, ty: Type, vals: []const Constant) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Aggregate, vals.len);
+    return self.vectorConstAssumeCapacity(ty, vals);
+}
+
+pub fn zeroInitConst(self: *Builder, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.zeroInitConstAssumeCapacity(ty);
+}
+
+pub fn undefConst(self: *Builder, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.undefConstAssumeCapacity(ty);
+}
+
+pub fn poisonConst(self: *Builder, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, null, 0);
+    return self.poisonConstAssumeCapacity(ty);
+}
+
+pub fn blockAddrConst(
+    self: *Builder,
+    function: Function.Index,
+    block: Function.Block.Index,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.BlockAddress, 0);
+    return self.blockAddrConstAssumeCapacity(function, block);
+}
+
+pub fn dsoLocalEquivalentConst(self: *Builder, function: Function.Index) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.FunctionReference, 0);
+    return self.dsoLocalEquivalentConstAssumeCapacity(function);
+}
+
+pub fn noCfiConst(self: *Builder, function: Function.Index) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.FunctionReference, 0);
+    return self.noCfiConstAssumeCapacity(function);
+}
+
+pub fn convConst(
+    self: *Builder,
+    signedness: Constant.Cast.Signedness,
+    arg: Constant,
+    ty: Type,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Cast, 0);
+    return self.convConstAssumeCapacity(signedness, arg, ty);
+}
+
+pub fn castConst(self: *Builder, tag: Constant.Tag, arg: Constant, ty: Type) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Cast, 0);
+    return self.castConstAssumeCapacity(tag, arg, ty);
+}
+
+pub fn gepConst(
+    self: *Builder,
+    comptime kind: Constant.GetElementPtr.Kind,
+    ty: Type,
+    base: Constant,
+    indices: []const Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedTypeCapacity(1, Type.Vector, 0);
+    try self.ensureUnusedConstantCapacity(1, Constant.GetElementPtr, indices.len);
+    return self.gepConstAssumeCapacity(kind, ty, base, indices);
+}
+
+pub fn icmpConst(
+    self: *Builder,
+    cond: IntegerCondition,
+    lhs: Constant,
+    rhs: Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Compare, 0);
+    return self.icmpConstAssumeCapacity(cond, lhs, rhs);
+}
+
+pub fn fcmpConst(
+    self: *Builder,
+    cond: FloatCondition,
+    lhs: Constant,
+    rhs: Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Compare, 0);
+    return self.icmpConstAssumeCapacity(cond, lhs, rhs);
+}
+
+pub fn extractElementConst(self: *Builder, arg: Constant, index: Constant) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.ExtractElement, 0);
+    return self.extractElementConstAssumeCapacity(arg, index);
+}
+
+pub fn insertElementConst(
+    self: *Builder,
+    arg: Constant,
+    elem: Constant,
+    index: Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.InsertElement, 0);
+    return self.insertElementConstAssumeCapacity(arg, elem, index);
+}
+
+pub fn shuffleVectorConst(
+    self: *Builder,
+    lhs: Constant,
+    rhs: Constant,
+    mask: Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.ShuffleVector, 0);
+    return self.shuffleVectorConstAssumeCapacity(lhs, rhs, mask);
+}
+
+pub fn binConst(
+    self: *Builder,
+    tag: Constant.Tag,
+    lhs: Constant,
+    rhs: Constant,
+) Allocator.Error!Constant {
+    try self.ensureUnusedConstantCapacity(1, Constant.Binary, 0);
+    return self.binConstAssumeCapacity(tag, lhs, rhs);
+}
+
 pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {
     if (self.source_filename != .none) try writer.print(
         \\; ModuleID = '{s}'
@@ -1266,43 +2094,44 @@ pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {
         \\
     , .{ id.fmt(self), ty.fmt(self) });
     try writer.writeByte('\n');
-    for (self.objects.items) |object| {
-        const global = self.globals.entries.get(@intFromEnum(object.global));
+    for (self.variables.items) |variable| {
+        const global = self.globals.values()[@intFromEnum(variable.global)];
         try writer.print(
-            \\@{} ={}{}{}{}{}{}{}{} {s} {%}{,}
+            \\{} ={}{}{}{}{}{}{}{} {s} {%}{ }{,}
             \\
         , .{
-            global.key.fmt(self),
-            global.value.linkage,
-            global.value.preemption,
-            global.value.visibility,
-            global.value.dll_storage_class,
-            object.thread_local,
-            global.value.unnamed_addr,
-            global.value.addr_space,
-            global.value.externally_initialized,
-            @tagName(object.mutability),
-            global.value.type.fmt(self),
-            global.value.alignment,
+            variable.global.fmt(self),
+            global.linkage,
+            global.preemption,
+            global.visibility,
+            global.dll_storage_class,
+            variable.thread_local,
+            global.unnamed_addr,
+            global.addr_space,
+            global.externally_initialized,
+            @tagName(variable.mutability),
+            global.type.fmt(self),
+            variable.init.fmt(self),
+            global.alignment,
         });
     }
     try writer.writeByte('\n');
     for (self.functions.items) |function| {
-        const global = self.globals.entries.get(@intFromEnum(function.global));
-        const item = self.type_items.items[@intFromEnum(global.value.type)];
+        const global = self.globals.values()[@intFromEnum(function.global)];
+        const item = self.type_items.items[@intFromEnum(global.type)];
         const extra = self.typeExtraDataTrail(Type.Function, item.data);
         const params: []const Type =
             @ptrCast(self.type_extra.items[extra.end..][0..extra.data.params_len]);
         try writer.print(
-            \\{s} {}{}{}{}{} @{}(
+            \\{s}{}{}{}{} {} {}(
         , .{
             if (function.body) |_| "define" else "declare",
-            global.value.linkage,
-            global.value.preemption,
-            global.value.visibility,
-            global.value.dll_storage_class,
+            global.linkage,
+            global.preemption,
+            global.visibility,
+            global.dll_storage_class,
             extra.data.ret.fmt(self),
-            global.key.fmt(self),
+            function.global.fmt(self),
         });
         for (params, 0..) |param, index| {
             if (index > 0) try writer.writeAll(", ");
@@ -1316,65 +2145,36 @@ pub fn dump(self: *Builder, writer: anytype) @TypeOf(writer).Error!void {
             },
             else => unreachable,
         }
-        try writer.print(") {}{}", .{
-            global.value.unnamed_addr,
-            global.value.alignment,
-        });
+        try writer.print(") {}{}", .{ global.unnamed_addr, global.alignment });
         if (function.body) |_| try writer.print(
             \\{{
             \\  ret {%}
             \\}}
             \\
-        , .{
-            extra.data.ret.fmt(self),
-        });
+        , .{extra.data.ret.fmt(self)});
         try writer.writeByte('\n');
     }
 }
 
+fn isValidIdentifier(id: []const u8) bool {
+    for (id, 0..) |character, index| switch (character) {
+        '$', '-', '.', 'A'...'Z', '_', 'a'...'z' => {},
+        '0'...'9' => if (index == 0) return false,
+        else => return false,
+    };
+    return true;
+}
+
 fn ensureUnusedCapacityGlobal(self: *Builder, name: String) Allocator.Error!void {
     if (self.useLibLlvm()) try self.llvm_globals.ensureUnusedCapacity(self.gpa, 1);
     try self.string_map.ensureUnusedCapacity(self.gpa, 1);
-    try self.string_bytes.ensureUnusedCapacity(self.gpa, name.toSlice(self).?.len +
+    if (name.toSlice(self)) |id| try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len +
         comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)}));
     try self.string_indices.ensureUnusedCapacity(self.gpa, 1);
     try self.globals.ensureUnusedCapacity(self.gpa, 1);
     try self.next_unique_global_id.ensureUnusedCapacity(self.gpa, 1);
 }
 
-fn addTypeExtraAssumeCapacity(self: *Builder, extra: anytype) Type.ExtraIndex {
-    const result: Type.ExtraIndex = @intCast(self.type_extra.items.len);
-    inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
-        const value = @field(extra, field.name);
-        self.type_extra.appendAssumeCapacity(switch (field.type) {
-            u32 => value,
-            String, Type => @intFromEnum(value),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
-        });
-    }
-    return result;
-}
-
-fn typeExtraDataTrail(
-    self: *const Builder,
-    comptime T: type,
-    index: Type.ExtraIndex,
-) struct { data: T, end: Type.ExtraIndex } {
-    var result: T = undefined;
-    const fields = @typeInfo(T).Struct.fields;
-    inline for (fields, self.type_extra.items[index..][0..fields.len]) |field, data|
-        @field(result, field.name) = switch (field.type) {
-            u32 => data,
-            String, Type => @enumFromInt(data),
-            else => @compileError("bad field type: " ++ @typeName(field.type)),
-        };
-    return .{ .data = result, .end = index + @as(Type.ExtraIndex, @intCast(fields.len)) };
-}
-
-fn typeExtraData(self: *const Builder, comptime T: type, index: Type.ExtraIndex) T {
-    return self.typeExtraDataTrail(T, index).data;
-}
-
 fn fnTypeAssumeCapacity(
     self: *Builder,
     ret: Type,
@@ -1394,17 +2194,19 @@ fn fnTypeAssumeCapacity(
             hasher.update(std.mem.sliceAsBytes(key.params));
             return @truncate(hasher.final());
         }
-        pub fn eql(ctx: @This(), lhs: Key, _: void, rhs_index: usize) bool {
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
             const rhs_extra = ctx.builder.typeExtraDataTrail(Type.Function, rhs_data.data);
             const rhs_params: []const Type =
                 @ptrCast(ctx.builder.type_extra.items[rhs_extra.end..][0..rhs_extra.data.params_len]);
-            return rhs_data.tag == tag and lhs.ret == rhs_extra.data.ret and
-                std.mem.eql(Type, lhs.params, rhs_params);
+            return rhs_data.tag == tag and lhs_key.ret == rhs_extra.data.ret and
+                std.mem.eql(Type, lhs_key.params, rhs_params);
         }
     };
-    const data = Key{ .ret = ret, .params = params };
-    const gop = self.type_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    const gop = self.type_map.getOrPutAssumeCapacityAdapted(
+        Key{ .ret = ret, .params = params },
+        Adapter{ .builder = self },
+    );
     if (!gop.found_existing) {
         gop.key_ptr.* = {};
         gop.value_ptr.* = {};
@@ -1436,17 +2238,16 @@ fn fnTypeAssumeCapacity(
 
 fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type {
     assert(bits > 0);
-    const result = self.typeNoExtraAssumeCapacity(.{ .tag = .integer, .data = bits });
+    const result = self.getOrPutTypeNoExtraAssumeCapacity(.{ .tag = .integer, .data = bits });
     if (self.useLibLlvm() and result.new)
         self.llvm_types.appendAssumeCapacity(self.llvm_context.intType(bits));
     return result.type;
 }
 
 fn ptrTypeAssumeCapacity(self: *Builder, addr_space: AddrSpace) Type {
-    const result = self.typeNoExtraAssumeCapacity(.{
-        .tag = .pointer,
-        .data = @intFromEnum(addr_space),
-    });
+    const result = self.getOrPutTypeNoExtraAssumeCapacity(
+        .{ .tag = .pointer, .data = @intFromEnum(addr_space) },
+    );
     if (self.useLibLlvm() and result.new)
         self.llvm_types.appendAssumeCapacity(self.llvm_context.pointerType(@intFromEnum(addr_space)));
     return result.type;
@@ -1470,10 +2271,10 @@ fn vectorTypeAssumeCapacity(
                 std.mem.asBytes(&key),
             ));
         }
-        pub fn eql(ctx: @This(), lhs: Type.Vector, _: void, rhs_index: usize) bool {
+        pub fn eql(ctx: @This(), lhs_key: Type.Vector, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
             return rhs_data.tag == tag and
-                std.meta.eql(lhs, ctx.builder.typeExtraData(Type.Vector, rhs_data.data));
+                std.meta.eql(lhs_key, ctx.builder.typeExtraData(Type.Vector, rhs_data.data));
         }
     };
     const data = Type.Vector{ .len = len, .child = child };
@@ -1503,10 +2304,10 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type {
                     std.mem.asBytes(&key),
                 ));
             }
-            pub fn eql(ctx: @This(), lhs: Type.Vector, _: void, rhs_index: usize) bool {
+            pub fn eql(ctx: @This(), lhs_key: Type.Vector, _: void, rhs_index: usize) bool {
                 const rhs_data = ctx.builder.type_items.items[rhs_index];
                 return rhs_data.tag == .small_array and
-                    std.meta.eql(lhs, ctx.builder.typeExtraData(Type.Vector, rhs_data.data));
+                    std.meta.eql(lhs_key, ctx.builder.typeExtraData(Type.Vector, rhs_data.data));
             }
         };
         const data = Type.Vector{ .len = small_len, .child = child };
@@ -1532,10 +2333,10 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type {
                     std.mem.asBytes(&key),
                 ));
             }
-            pub fn eql(ctx: @This(), lhs: Type.Array, _: void, rhs_index: usize) bool {
+            pub fn eql(ctx: @This(), lhs_key: Type.Array, _: void, rhs_index: usize) bool {
                 const rhs_data = ctx.builder.type_items.items[rhs_index];
                 return rhs_data.tag == .array and
-                    std.meta.eql(lhs, ctx.builder.typeExtraData(Type.Array, rhs_data.data));
+                    std.meta.eql(lhs_key, ctx.builder.typeExtraData(Type.Array, rhs_data.data));
             }
         };
         const data = Type.Array{
@@ -1576,12 +2377,12 @@ fn structTypeAssumeCapacity(
                 std.mem.sliceAsBytes(key),
             ));
         }
-        pub fn eql(ctx: @This(), lhs: []const Type, _: void, rhs_index: usize) bool {
+        pub fn eql(ctx: @This(), lhs_key: []const Type, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
             const rhs_extra = ctx.builder.typeExtraDataTrail(Type.Structure, rhs_data.data);
             const rhs_fields: []const Type =
                 @ptrCast(ctx.builder.type_extra.items[rhs_extra.end..][0..rhs_extra.data.fields_len]);
-            return rhs_data.tag == tag and std.mem.eql(Type, lhs, rhs_fields);
+            return rhs_data.tag == tag and std.mem.eql(Type, lhs_key, rhs_fields);
         }
     };
     const gop = self.type_map.getOrPutAssumeCapacityAdapted(fields, Adapter{ .builder = self });
@@ -1596,15 +2397,14 @@ fn structTypeAssumeCapacity(
         });
         self.type_extra.appendSliceAssumeCapacity(@ptrCast(fields));
         if (self.useLibLlvm()) {
-            const ExpectedContents = [32]*llvm.Type;
+            const ExpectedContents = [expected_fields_len]*llvm.Type;
             var stack align(@alignOf(ExpectedContents)) =
                 std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
             const allocator = stack.get();
 
             const llvm_fields = try allocator.alloc(*llvm.Type, fields.len);
             defer allocator.free(llvm_fields);
-            for (llvm_fields, fields) |*llvm_field, field|
-                llvm_field.* = self.llvm_types.items[@intFromEnum(field)];
+            for (llvm_fields, fields) |*llvm_field, field| llvm_field.* = field.toLlvm(self);
 
             self.llvm_types.appendAssumeCapacity(self.llvm_context.structType(
                 llvm_fields.ptr,
@@ -1628,10 +2428,10 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
                 std.mem.asBytes(&key),
             ));
         }
-        pub fn eql(ctx: @This(), lhs: String, _: void, rhs_index: usize) bool {
+        pub fn eql(ctx: @This(), lhs_key: String, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
             return rhs_data.tag == .named_structure and
-                lhs == ctx.builder.typeExtraData(Type.NamedStructure, rhs_data.data).id;
+                lhs_key == ctx.builder.typeExtraData(Type.NamedStructure, rhs_data.data).id;
         }
     };
     var id = name;
@@ -1669,7 +2469,7 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
     }
 }
 
-fn ensureUnusedCapacityTypes(
+fn ensureUnusedTypeCapacity(
     self: *Builder,
     count: usize,
     comptime Extra: ?type,
@@ -1680,11 +2480,11 @@ fn ensureUnusedCapacityTypes(
     if (Extra) |E| try self.type_extra.ensureUnusedCapacity(
         self.gpa,
         count * (@typeInfo(E).Struct.fields.len + trail_len),
-    );
+    ) else assert(trail_len == 0);
     if (self.useLibLlvm()) try self.llvm_types.ensureUnusedCapacity(self.gpa, count);
 }
 
-fn typeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { new: bool, type: Type } {
+fn getOrPutTypeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { new: bool, type: Type } {
     const Adapter = struct {
         builder: *const Builder,
         pub fn hash(_: @This(), key: Type.Item) u32 {
@@ -1693,8 +2493,8 @@ fn typeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { new: bool
                 std.mem.asBytes(&key),
             ));
         }
-        pub fn eql(ctx: @This(), lhs: Type.Item, _: void, rhs_index: usize) bool {
-            const lhs_bits: u32 = @bitCast(lhs);
+        pub fn eql(ctx: @This(), lhs_key: Type.Item, _: void, rhs_index: usize) bool {
+            const lhs_bits: u32 = @bitCast(lhs_key);
             const rhs_bits: u32 = @bitCast(ctx.builder.type_items.items[rhs_index]);
             return lhs_bits == rhs_bits;
         }
@@ -1708,13 +2508,37 @@ fn typeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { new: bool
     return .{ .new = !gop.found_existing, .type = @enumFromInt(gop.index) };
 }
 
-fn isValidIdentifier(id: []const u8) bool {
-    for (id, 0..) |character, index| switch (character) {
-        '$', '-', '.', 'A'...'Z', '_', 'a'...'z' => {},
-        '0'...'9' => if (index == 0) return false,
-        else => return false,
-    };
-    return true;
+fn addTypeExtraAssumeCapacity(self: *Builder, extra: anytype) Type.Item.ExtraIndex {
+    const result: Type.Item.ExtraIndex = @intCast(self.type_extra.items.len);
+    inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
+        const value = @field(extra, field.name);
+        self.type_extra.appendAssumeCapacity(switch (field.type) {
+            u32 => value,
+            String, Type => @intFromEnum(value),
+            else => @compileError("bad field type: " ++ @typeName(field.type)),
+        });
+    }
+    return result;
+}
+
+fn typeExtraDataTrail(
+    self: *const Builder,
+    comptime T: type,
+    index: Type.Item.ExtraIndex,
+) struct { data: T, end: Type.Item.ExtraIndex } {
+    var result: T = undefined;
+    const fields = @typeInfo(T).Struct.fields;
+    inline for (fields, self.type_extra.items[index..][0..fields.len]) |field, data|
+        @field(result, field.name) = switch (field.type) {
+            u32 => data,
+            String, Type => @enumFromInt(data),
+            else => @compileError("bad field type: " ++ @typeName(field.type)),
+        };
+    return .{ .data = result, .end = index + @as(Type.Item.ExtraIndex, @intCast(fields.len)) };
+}
+
+fn typeExtraData(self: *const Builder, comptime T: type, index: Type.Item.ExtraIndex) T {
+    return self.typeExtraDataTrail(T, index).data;
 }
 
 fn bigIntConstAssumeCapacity(
@@ -1748,8 +2572,8 @@ fn bigIntConstAssumeCapacity(
     const ExtraPtr = *align(@alignOf(std.math.big.Limb)) Constant.Integer;
     const Key = struct { tag: Constant.Tag, type: Type, limbs: []const std.math.big.Limb };
     const tag: Constant.Tag = switch (canonical_value.positive) {
-        true => .integer_positive,
-        false => .integer_negative,
+        true => .positive_integer,
+        false => .negative_integer,
     };
     const Adapter = struct {
         builder: *const Builder,
@@ -1759,20 +2583,22 @@ fn bigIntConstAssumeCapacity(
             hasher.update(std.mem.sliceAsBytes(key.limbs));
             return @truncate(hasher.final());
         }
-        pub fn eql(ctx: @This(), lhs: Key, _: void, rhs_index: usize) bool {
-            if (lhs.tag != ctx.builder.constant_items.items(.tag)[rhs_index]) return false;
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            if (lhs_key.tag != ctx.builder.constant_items.items(.tag)[rhs_index]) return false;
             const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
-            const rhs_extra: ExtraPtr = @ptrCast(
-                ctx.builder.constant_limbs.items[rhs_data..][0..Constant.Integer.limbs],
-            );
+            const rhs_extra: ExtraPtr =
+                @ptrCast(ctx.builder.constant_limbs.items[rhs_data..][0..Constant.Integer.limbs]);
             const rhs_limbs = ctx.builder.constant_limbs
                 .items[rhs_data + Constant.Integer.limbs ..][0..rhs_extra.limbs_len];
-            return lhs.type == rhs_extra.type and std.mem.eql(std.math.big.Limb, lhs.limbs, rhs_limbs);
+            return lhs_key.type == rhs_extra.type and
+                std.mem.eql(std.math.big.Limb, lhs_key.limbs, rhs_limbs);
         }
     };
 
-    const data = Key{ .tag = tag, .type = ty, .limbs = canonical_value.limbs };
-    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(
+        Key{ .tag = tag, .type = ty, .limbs = canonical_value.limbs },
+        Adapter{ .builder = self },
+    );
     if (!gop.found_existing) {
         gop.key_ptr.* = {};
         gop.value_ptr.* = {};
@@ -1780,9 +2606,8 @@ fn bigIntConstAssumeCapacity(
             .tag = tag,
             .data = @intCast(self.constant_limbs.items.len),
         });
-        const extra: ExtraPtr = @ptrCast(
-            self.constant_limbs.addManyAsArrayAssumeCapacity(Constant.Integer.limbs),
-        );
+        const extra: ExtraPtr =
+            @ptrCast(self.constant_limbs.addManyAsArrayAssumeCapacity(Constant.Integer.limbs));
         extra.* = .{ .type = ty, .limbs_len = @intCast(canonical_value.limbs.len) };
         self.constant_limbs.appendSliceAssumeCapacity(canonical_value.limbs);
         if (self.useLibLlvm()) {
@@ -1827,6 +2652,870 @@ fn bigIntConstAssumeCapacity(
     return @enumFromInt(gop.index);
 }
 
+fn halfConstAssumeCapacity(self: *Builder, val: f16) Constant {
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .half, .data = @as(u16, @bitCast(val)) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
+        if (std.math.isSignalNan(val))
+            Type.i16.toLlvm(self).constInt(@as(u16, @bitCast(val)), .False)
+                .constBitCast(Type.half.toLlvm(self))
+        else
+            Type.half.toLlvm(self).constReal(val),
+    );
+    return result.constant;
+}
+
+fn bfloatConstAssumeCapacity(self: *Builder, val: f32) Constant {
+    assert(@as(u16, @truncate(@as(u32, @bitCast(val)))) == 0);
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .bfloat, .data = @bitCast(val) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
+        if (std.math.isSignalNan(val))
+            Type.i16.toLlvm(self).constInt(@as(u32, @bitCast(val)) >> 16, .False)
+                .constBitCast(Type.bfloat.toLlvm(self))
+        else
+            Type.bfloat.toLlvm(self).constReal(val),
+    );
+
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(Type.bfloat.toLlvm(self).constReal(val));
+    return result.constant;
+}
+
+fn floatConstAssumeCapacity(self: *Builder, val: f32) Constant {
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .float, .data = @bitCast(val) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
+        if (std.math.isSignalNan(val))
+            Type.i32.toLlvm(self).constInt(@as(u32, @bitCast(val)), .False)
+                .constBitCast(Type.float.toLlvm(self))
+        else
+            Type.float.toLlvm(self).constReal(val),
+    );
+    return result.constant;
+}
+
+fn doubleConstAssumeCapacity(self: *Builder, val: f64) Constant {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: f64) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                comptime std.hash.uint32(@intFromEnum(Constant.Tag.double)),
+                std.mem.asBytes(&key),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: f64, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != .double) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Double, rhs_data);
+            return @as(u64, @bitCast(lhs_key)) == @as(u64, rhs_extra.hi) << 32 | rhs_extra.lo;
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = .double,
+            .data = self.addConstantExtraAssumeCapacity(Constant.Double{
+                .lo = @intCast(@as(u64, @bitCast(val)) >> 32),
+                .hi = @truncate(@as(u64, @bitCast(val))),
+            }),
+        });
+        if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(
+            if (std.math.isSignalNan(val))
+                Type.i64.toLlvm(self).constInt(@as(u64, @bitCast(val)), .False)
+                    .constBitCast(Type.double.toLlvm(self))
+            else
+                Type.double.toLlvm(self).constReal(val),
+        );
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: f128) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                comptime std.hash.uint32(@intFromEnum(Constant.Tag.fp128)),
+                std.mem.asBytes(&key),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: f128, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != .fp128) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Fp128, rhs_data);
+            return @as(u128, @bitCast(lhs_key)) == @as(u128, rhs_extra.hi_hi) << 96 |
+                @as(u128, rhs_extra.hi_lo) << 64 | @as(u128, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo;
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = .fp128,
+            .data = self.addConstantExtraAssumeCapacity(Constant.Fp128{
+                .lo_lo = @truncate(@as(u128, @bitCast(val))),
+                .lo_hi = @truncate(@as(u128, @bitCast(val)) >> 32),
+                .hi_lo = @truncate(@as(u128, @bitCast(val)) >> 64),
+                .hi_hi = @intCast(@as(u128, @bitCast(val)) >> 96),
+            }),
+        });
+        if (self.useLibLlvm()) {
+            const llvm_limbs = [_]u64{
+                @truncate(@as(u128, @bitCast(val))),
+                @intCast(@as(u128, @bitCast(val)) >> 64),
+            };
+            self.llvm_constants.appendAssumeCapacity(
+                Type.i128.toLlvm(self)
+                    .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), &llvm_limbs)
+                    .constBitCast(Type.fp128.toLlvm(self)),
+            );
+        }
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: f80) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                comptime std.hash.uint32(@intFromEnum(Constant.Tag.x86_fp80)),
+                std.mem.asBytes(&key)[0..10],
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: f80, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != .x86_fp80) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Fp80, rhs_data);
+            return @as(u80, @bitCast(lhs_key)) == @as(u80, rhs_extra.hi) << 64 |
+                @as(u80, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo;
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = .x86_fp80,
+            .data = self.addConstantExtraAssumeCapacity(Constant.Fp80{
+                .lo_lo = @truncate(@as(u80, @bitCast(val))),
+                .lo_hi = @truncate(@as(u80, @bitCast(val)) >> 32),
+                .hi = @intCast(@as(u80, @bitCast(val)) >> 64),
+            }),
+        });
+        if (self.useLibLlvm()) {
+            const llvm_limbs = [_]u64{
+                @truncate(@as(u80, @bitCast(val))),
+                @intCast(@as(u80, @bitCast(val)) >> 64),
+            };
+            self.llvm_constants.appendAssumeCapacity(
+                Type.i80.toLlvm(self)
+                    .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), &llvm_limbs)
+                    .constBitCast(Type.x86_fp80.toLlvm(self)),
+            );
+        }
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: [2]f64) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                comptime std.hash.uint32(@intFromEnum(Constant.Tag.ppc_fp128)),
+                std.mem.asBytes(&key),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: [2]f64, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != .ppc_fp128) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Fp128, rhs_data);
+            return @as(u64, @bitCast(lhs_key[0])) == @as(u64, rhs_extra.lo_hi) << 32 | rhs_extra.lo_lo and
+                @as(u64, @bitCast(lhs_key[1])) == @as(u64, rhs_extra.hi_hi) << 32 | rhs_extra.hi_lo;
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(val, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = .ppc_fp128,
+            .data = self.addConstantExtraAssumeCapacity(Constant.Fp128{
+                .lo_lo = @truncate(@as(u64, @bitCast(val[0]))),
+                .lo_hi = @intCast(@as(u64, @bitCast(val[0])) >> 32),
+                .hi_lo = @truncate(@as(u64, @bitCast(val[1]))),
+                .hi_hi = @intCast(@as(u64, @bitCast(val[1])) >> 32),
+            }),
+        });
+        if (self.useLibLlvm()) {
+            const llvm_limbs: *const [2]u64 = @ptrCast(&val);
+            self.llvm_constants.appendAssumeCapacity(
+                Type.i128.toLlvm(self)
+                    .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), llvm_limbs)
+                    .constBitCast(Type.ppc_fp128.toLlvm(self)),
+            );
+        }
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn nullConstAssumeCapacity(self: *Builder, ty: Type) Constant {
+    assert(self.type_items.items[@intFromEnum(ty)].tag == .pointer);
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .null, .data = @intFromEnum(ty) },
+    );
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
+    return result.constant;
+}
+
+fn noneConstAssumeCapacity(self: *Builder, ty: Type) Constant {
+    assert(ty == .token);
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .none, .data = @intFromEnum(ty) },
+    );
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
+    return result.constant;
+}
+
+fn structConstAssumeCapacity(
+    self: *Builder,
+    ty: Type,
+    vals: []const Constant,
+) if (build_options.have_llvm) Allocator.Error!Constant else Constant {
+    const type_item = self.type_items.items[@intFromEnum(ty)];
+    const extra = self.typeExtraDataTrail(Type.Structure, switch (type_item.tag) {
+        .structure, .packed_structure => type_item.data,
+        .named_structure => data: {
+            const body_ty = self.typeExtraData(Type.NamedStructure, type_item.data).body;
+            const body_item = self.type_items.items[@intFromEnum(body_ty)];
+            switch (body_item.tag) {
+                .structure, .packed_structure => break :data body_item.data,
+                else => unreachable,
+            }
+        },
+        else => unreachable,
+    });
+    const fields: []const Type =
+        @ptrCast(self.type_extra.items[extra.end..][0..extra.data.fields_len]);
+    for (fields, vals) |field, val| assert(field == val.typeOf(self));
+
+    for (vals) |val| {
+        if (!val.isZeroInit(self)) break;
+    } else return self.zeroInitConstAssumeCapacity(ty);
+
+    const tag: Constant.Tag = switch (ty.unnamedTag(self)) {
+        .structure => .structure,
+        .packed_structure => .packed_structure,
+        else => unreachable,
+    };
+    const result = self.getOrPutConstantAggregateAssumeCapacity(tag, ty, vals);
+    if (self.useLibLlvm() and result.new) {
+        const ExpectedContents = [expected_fields_len]*llvm.Value;
+        var stack align(@alignOf(ExpectedContents)) =
+            std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
+        const allocator = stack.get();
+
+        const llvm_vals = try allocator.alloc(*llvm.Value, vals.len);
+        defer allocator.free(llvm_vals);
+        for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
+
+        self.llvm_constants.appendAssumeCapacity(
+            ty.toLlvm(self).constNamedStruct(llvm_vals.ptr, @intCast(llvm_vals.len)),
+        );
+    }
+    return result.constant;
+}
+
+fn arrayConstAssumeCapacity(
+    self: *Builder,
+    ty: Type,
+    vals: []const Constant,
+) if (build_options.have_llvm) Allocator.Error!Constant else Constant {
+    const type_item = self.type_items.items[@intFromEnum(ty)];
+    const type_extra: struct { len: u64, child: Type } = switch (type_item.tag) {
+        .small_array => extra: {
+            const extra = self.typeExtraData(Type.Vector, type_item.data);
+            break :extra .{ .len = extra.len, .child = extra.child };
+        },
+        .array => extra: {
+            const extra = self.typeExtraData(Type.Array, type_item.data);
+            break :extra .{ .len = extra.len(), .child = extra.child };
+        },
+        else => unreachable,
+    };
+    assert(type_extra.len == vals.len);
+    for (vals) |val| assert(type_extra.child == val.typeOf(self));
+
+    for (vals) |val| {
+        if (!val.isZeroInit(self)) break;
+    } else return self.zeroInitConstAssumeCapacity(ty);
+
+    const result = self.getOrPutConstantAggregateAssumeCapacity(.array, ty, vals);
+    if (self.useLibLlvm() and result.new) {
+        const ExpectedContents = [expected_fields_len]*llvm.Value;
+        var stack align(@alignOf(ExpectedContents)) =
+            std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
+        const allocator = stack.get();
+
+        const llvm_vals = try allocator.alloc(*llvm.Value, vals.len);
+        defer allocator.free(llvm_vals);
+        for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
+
+        self.llvm_constants.appendAssumeCapacity(
+            type_extra.child.toLlvm(self).constArray(llvm_vals.ptr, @intCast(llvm_vals.len)),
+        );
+    }
+    return result.constant;
+}
+
+fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {
+    const slice = val.toSlice(self).?;
+    const ty = self.arrayTypeAssumeCapacity(slice.len, .i8);
+    if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .string, .data = @intFromEnum(val) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
+        self.llvm_context.constString(slice.ptr, @intCast(slice.len), .True),
+    );
+    return result.constant;
+}
+
+fn stringNullConstAssumeCapacity(self: *Builder, val: String) Constant {
+    const slice = val.toSlice(self).?;
+    const ty = self.arrayTypeAssumeCapacity(slice.len + 1, .i8);
+    if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .string_null, .data = @intFromEnum(val) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
+        self.llvm_context.constString(slice.ptr, @intCast(slice.len + 1), .True),
+    );
+    return result.constant;
+}
+
+fn vectorConstAssumeCapacity(
+    self: *Builder,
+    ty: Type,
+    vals: []const Constant,
+) if (build_options.have_llvm) Allocator.Error!Constant else Constant {
+    if (std.debug.runtime_safety) {
+        const type_item = self.type_items.items[@intFromEnum(ty)];
+        assert(type_item.tag == .vector);
+        const extra = self.typeExtraData(Type.Vector, type_item.data);
+        assert(extra.len == vals.len);
+        for (vals) |val| assert(extra.child == val.typeOf(self));
+    }
+
+    for (vals) |val| {
+        if (!val.isZeroInit(self)) break;
+    } else return self.zeroInitConstAssumeCapacity(ty);
+
+    const result = self.getOrPutConstantAggregateAssumeCapacity(.vector, ty, vals);
+    if (self.useLibLlvm() and result.new) {
+        const ExpectedContents = [expected_fields_len]*llvm.Value;
+        var stack align(@alignOf(ExpectedContents)) =
+            std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
+        const allocator = stack.get();
+
+        const llvm_vals = try allocator.alloc(*llvm.Value, vals.len);
+        defer allocator.free(llvm_vals);
+        for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
+
+        self.llvm_constants.appendAssumeCapacity(
+            llvm.constVector(llvm_vals.ptr, @intCast(llvm_vals.len)),
+        );
+    }
+    return result.constant;
+}
+
+fn zeroInitConstAssumeCapacity(self: *Builder, ty: Type) Constant {
+    switch (self.type_items.items[@intFromEnum(ty)].tag) {
+        .simple,
+        .function,
+        .vararg_function,
+        .integer,
+        .pointer,
+        => unreachable,
+        .target,
+        .vector,
+        .scalable_vector,
+        .small_array,
+        .array,
+        .structure,
+        .packed_structure,
+        .named_structure,
+        => {},
+    }
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .zeroinitializer, .data = @intFromEnum(ty) },
+    );
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
+    return result.constant;
+}
+
+fn undefConstAssumeCapacity(self: *Builder, ty: Type) Constant {
+    switch (self.type_items.items[@intFromEnum(ty)].tag) {
+        .simple => switch (ty) {
+            .void, .label => unreachable,
+            else => {},
+        },
+        .function, .vararg_function => unreachable,
+        else => {},
+    }
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .undef, .data = @intFromEnum(ty) },
+    );
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
+    return result.constant;
+}
+
+fn poisonConstAssumeCapacity(self: *Builder, ty: Type) Constant {
+    switch (self.type_items.items[@intFromEnum(ty)].tag) {
+        .simple => switch (ty) {
+            .void, .label => unreachable,
+            else => {},
+        },
+        .function, .vararg_function => unreachable,
+        else => {},
+    }
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .poison, .data = @intFromEnum(ty) },
+    );
+    if (self.useLibLlvm() and result.new)
+        self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
+    return result.constant;
+}
+
+fn blockAddrConstAssumeCapacity(
+    self: *Builder,
+    function: Function.Index,
+    block: Function.Block.Index,
+) Constant {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Constant.BlockAddress) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                comptime std.hash.uint32(@intFromEnum(Constant.Tag.blockaddress)),
+                std.mem.asBytes(&key),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: Constant.BlockAddress, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != .blockaddress) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.BlockAddress, rhs_data);
+            return std.meta.eql(lhs_key, rhs_extra);
+        }
+    };
+    const data = Constant.BlockAddress{ .function = function, .block = block };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = .blockaddress,
+            .data = self.addConstantExtraAssumeCapacity(data),
+        });
+        if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(
+            function.toLlvm(self).blockAddress(block.toValue(self, function).toLlvm(self, function)),
+        );
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn dsoLocalEquivalentConstAssumeCapacity(self: *Builder, function: Function.Index) Constant {
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .dso_local_equivalent, .data = @intFromEnum(function) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(undefined);
+    return result.constant;
+}
+
+fn noCfiConstAssumeCapacity(self: *Builder, function: Function.Index) Constant {
+    const result = self.getOrPutConstantNoExtraAssumeCapacity(
+        .{ .tag = .no_cfi, .data = @intFromEnum(function) },
+    );
+    if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(undefined);
+    return result.constant;
+}
+
+fn convConstAssumeCapacity(
+    self: *Builder,
+    signedness: Constant.Cast.Signedness,
+    arg: Constant,
+    ty: Type,
+) Constant {
+    const arg_ty = arg.typeOf(self);
+    if (arg_ty == ty) return arg;
+    return self.castConstAssumeCapacity(switch (arg_ty.scalarTag(self)) {
+        .simple => switch (ty.scalarTag(self)) {
+            .simple => switch (std.math.order(arg_ty.scalarBits(self), ty.scalarBits(self))) {
+                .lt => .fpext,
+                .eq => unreachable,
+                .gt => .fptrunc,
+            },
+            .integer => switch (signedness) {
+                .unsigned => .fptoui,
+                .signed => .fptosi,
+                .unneeded => unreachable,
+            },
+            else => unreachable,
+        },
+        .integer => switch (ty.tag(self)) {
+            .simple => switch (signedness) {
+                .unsigned => .uitofp,
+                .signed => .sitofp,
+                .unneeded => unreachable,
+            },
+            .integer => switch (std.math.order(arg_ty.scalarBits(self), ty.scalarBits(self))) {
+                .lt => switch (signedness) {
+                    .unsigned => .zext,
+                    .signed => .sext,
+                    .unneeded => unreachable,
+                },
+                .eq => unreachable,
+                .gt => .trunc,
+            },
+            .pointer => .inttoptr,
+            else => unreachable,
+        },
+        .pointer => switch (ty.tag(self)) {
+            .integer => .ptrtoint,
+            .pointer => .addrspacecast,
+            else => unreachable,
+        },
+        else => unreachable,
+    }, arg, ty);
+}
+
+fn castConstAssumeCapacity(self: *Builder, tag: Constant.Tag, arg: Constant, ty: Type) Constant {
+    const Key = struct { tag: Constant.Tag, cast: Constant.Cast };
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Key) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                std.hash.uint32(@intFromEnum(key.tag)),
+                std.mem.asBytes(&key.cast),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            if (lhs_key.tag != ctx.builder.constant_items.items(.tag)[rhs_index]) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Cast, rhs_data);
+            return std.meta.eql(lhs_key.cast, rhs_extra);
+        }
+    };
+    const data = Key{ .tag = tag, .cast = .{ .arg = arg, .type = ty } };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = tag,
+            .data = self.addConstantExtraAssumeCapacity(data.cast),
+        });
+        if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(switch (tag) {
+            .trunc => &llvm.Value.constTrunc,
+            .zext => &llvm.Value.constZExt,
+            .sext => &llvm.Value.constSExt,
+            .fptrunc => &llvm.Value.constFPTrunc,
+            .fpext => &llvm.Value.constFPExt,
+            .fptoui => &llvm.Value.constFPToUI,
+            .fptosi => &llvm.Value.constFPToSI,
+            .uitofp => &llvm.Value.constUIToFP,
+            .sitofp => &llvm.Value.constSIToFP,
+            .ptrtoint => &llvm.Value.constPtrToInt,
+            .inttoptr => &llvm.Value.constIntToPtr,
+            .bitcast => &llvm.Value.constBitCast,
+            else => unreachable,
+        }(arg.toLlvm(self), ty.toLlvm(self)));
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn gepConstAssumeCapacity(
+    self: *Builder,
+    comptime kind: Constant.GetElementPtr.Kind,
+    ty: Type,
+    base: Constant,
+    indices: []const Constant,
+) if (build_options.have_llvm) Allocator.Error!Constant else Constant {
+    const tag: Constant.Tag = switch (kind) {
+        .normal => .getelementptr,
+        .inbounds => .@"getelementptr inbounds",
+    };
+    const base_ty = base.typeOf(self);
+    const base_is_vector = base_ty.isVector(self);
+
+    const VectorInfo = struct {
+        kind: Type.Vector.Kind,
+        len: u32,
+
+        fn init(vector_ty: Type, builder: *const Builder) @This() {
+            return .{ .kind = vector_ty.vectorKind(builder), .len = vector_ty.vectorLen(builder) };
+        }
+    };
+    var vector_info: ?VectorInfo = if (base_is_vector) VectorInfo.init(base_ty, self) else null;
+    for (indices) |index| {
+        const index_ty = index.typeOf(self);
+        switch (index_ty.tag(self)) {
+            .integer => {},
+            .vector, .scalable_vector => {
+                const index_info = VectorInfo.init(index_ty, self);
+                if (vector_info) |info|
+                    assert(std.meta.eql(info, index_info))
+                else
+                    vector_info = index_info;
+            },
+            else => unreachable,
+        }
+    }
+    if (!base_is_vector) if (vector_info) |info| switch (info.kind) {
+        inline else => |vector_kind| _ = self.vectorTypeAssumeCapacity(vector_kind, info.len, base_ty),
+    };
+
+    const Key = struct { type: Type, base: Constant, indices: []const Constant };
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Key) u32 {
+            var hasher = std.hash.Wyhash.init(comptime std.hash.uint32(@intFromEnum(tag)));
+            hasher.update(std.mem.asBytes(&key.type));
+            hasher.update(std.mem.asBytes(&key.base));
+            hasher.update(std.mem.sliceAsBytes(key.indices));
+            return @truncate(hasher.final());
+        }
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            if (ctx.builder.constant_items.items(.tag)[rhs_index] != tag) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraDataTrail(Constant.GetElementPtr, rhs_data);
+            const rhs_indices: []const Constant = @ptrCast(ctx.builder.constant_extra
+                .items[rhs_extra.end..][0..rhs_extra.data.indices_len]);
+            return lhs_key.type == rhs_extra.data.type and lhs_key.base == rhs_extra.data.base and
+                std.mem.eql(Constant, lhs_key.indices, rhs_indices);
+        }
+    };
+    const data = Key{ .type = ty, .base = base, .indices = indices };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = tag,
+            .data = self.addConstantExtraAssumeCapacity(Constant.GetElementPtr{
+                .type = ty,
+                .base = base,
+                .indices_len = @intCast(indices.len),
+            }),
+        });
+        self.constant_extra.appendSliceAssumeCapacity(@ptrCast(indices));
+        if (self.useLibLlvm()) {
+            const ExpectedContents = [expected_gep_indices_len]*llvm.Value;
+            var stack align(@alignOf(ExpectedContents)) =
+                std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
+            const allocator = stack.get();
+
+            const llvm_indices = try allocator.alloc(*llvm.Value, indices.len);
+            defer allocator.free(llvm_indices);
+            for (llvm_indices, indices) |*llvm_index, index| llvm_index.* = index.toLlvm(self);
+
+            self.llvm_constants.appendAssumeCapacity(switch (kind) {
+                .normal => &llvm.Type.constGEP,
+                .inbounds => &llvm.Type.constInBoundsGEP,
+            }(ty.toLlvm(self), base.toLlvm(self), llvm_indices.ptr, @intCast(indices.len)));
+        }
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn binConstAssumeCapacity(
+    self: *Builder,
+    tag: Constant.Tag,
+    lhs: Constant,
+    rhs: Constant,
+) Constant {
+    switch (tag) {
+        .add, .sub, .mul, .shl, .lshr, .ashr, .@"and", .@"or", .xor => {},
+        else => unreachable,
+    }
+    const Key = struct { tag: Constant.Tag, bin: Constant.Binary };
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Key) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                std.hash.uint32(@intFromEnum(key.tag)),
+                std.mem.asBytes(&key.bin),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            if (lhs_key.tag != ctx.builder.constant_items.items(.tag)[rhs_index]) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraData(Constant.Binary, rhs_data);
+            return std.meta.eql(lhs_key.bin, rhs_extra);
+        }
+    };
+    const data = Key{ .tag = tag, .bin = .{ .lhs = lhs, .rhs = rhs } };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = tag,
+            .data = self.addConstantExtraAssumeCapacity(data.bin),
+        });
+        if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(switch (tag) {
+            .add => &llvm.Value.constAdd,
+            .sub => &llvm.Value.constSub,
+            .mul => &llvm.Value.constMul,
+            .shl => &llvm.Value.constShl,
+            .lshr => &llvm.Value.constLShr,
+            .ashr => &llvm.Value.constAShr,
+            .@"and" => &llvm.Value.constAnd,
+            .@"or" => &llvm.Value.constOr,
+            .xor => &llvm.Value.constXor,
+            else => unreachable,
+        }(lhs.toLlvm(self), rhs.toLlvm(self)));
+    }
+    return @enumFromInt(gop.index);
+}
+
+fn ensureUnusedConstantCapacity(
+    self: *Builder,
+    count: usize,
+    comptime Extra: ?type,
+    trail_len: usize,
+) Allocator.Error!void {
+    try self.constant_map.ensureUnusedCapacity(self.gpa, count);
+    try self.constant_items.ensureUnusedCapacity(self.gpa, count);
+    if (Extra) |E| try self.constant_extra.ensureUnusedCapacity(
+        self.gpa,
+        count * (@typeInfo(E).Struct.fields.len + trail_len),
+    ) else assert(trail_len == 0);
+    if (self.useLibLlvm()) try self.llvm_constants.ensureUnusedCapacity(self.gpa, count);
+}
+
+fn getOrPutConstantNoExtraAssumeCapacity(
+    self: *Builder,
+    item: Constant.Item,
+) struct { new: bool, constant: Constant } {
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Constant.Item) u32 {
+            return @truncate(std.hash.Wyhash.hash(
+                std.hash.uint32(@intFromEnum(key.tag)),
+                std.mem.asBytes(&key.data),
+            ));
+        }
+        pub fn eql(ctx: @This(), lhs_key: Constant.Item, _: void, rhs_index: usize) bool {
+            return std.meta.eql(lhs_key, ctx.builder.constant_items.get(rhs_index));
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(item, Adapter{ .builder = self });
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(item);
+    }
+    return .{ .new = !gop.found_existing, .constant = @enumFromInt(gop.index) };
+}
+
+fn getOrPutConstantAggregateAssumeCapacity(
+    self: *Builder,
+    tag: Constant.Tag,
+    ty: Type,
+    vals: []const Constant,
+) struct { new: bool, constant: Constant } {
+    switch (tag) {
+        .structure, .packed_structure, .array, .vector => {},
+        else => unreachable,
+    }
+    const Key = struct { tag: Constant.Tag, type: Type, vals: []const Constant };
+    const Adapter = struct {
+        builder: *const Builder,
+        pub fn hash(_: @This(), key: Key) u32 {
+            var hasher = std.hash.Wyhash.init(std.hash.uint32(@intFromEnum(key.tag)));
+            hasher.update(std.mem.asBytes(&key.type));
+            hasher.update(std.mem.sliceAsBytes(key.vals));
+            return @truncate(hasher.final());
+        }
+        pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
+            if (lhs_key.tag != ctx.builder.constant_items.items(.tag)[rhs_index]) return false;
+            const rhs_data = ctx.builder.constant_items.items(.data)[rhs_index];
+            const rhs_extra = ctx.builder.constantExtraDataTrail(Constant.Aggregate, rhs_data);
+            if (lhs_key.type != rhs_extra.data.type) return false;
+            const rhs_vals: []const Constant =
+                @ptrCast(ctx.builder.constant_extra.items[rhs_extra.end..][0..lhs_key.vals.len]);
+            return std.mem.eql(Constant, lhs_key.vals, rhs_vals);
+        }
+    };
+    const gop = self.constant_map.getOrPutAssumeCapacityAdapted(
+        Key{ .tag = tag, .type = ty, .vals = vals },
+        Adapter{ .builder = self },
+    );
+    if (!gop.found_existing) {
+        gop.key_ptr.* = {};
+        gop.value_ptr.* = {};
+        self.constant_items.appendAssumeCapacity(.{
+            .tag = tag,
+            .data = self.addConstantExtraAssumeCapacity(Constant.Aggregate{ .type = ty }),
+        });
+        self.constant_extra.appendSliceAssumeCapacity(@ptrCast(vals));
+    }
+    return .{ .new = !gop.found_existing, .constant = @enumFromInt(gop.index) };
+}
+
+fn addConstantExtraAssumeCapacity(self: *Builder, extra: anytype) Constant.Item.ExtraIndex {
+    const result: Constant.Item.ExtraIndex = @intCast(self.constant_extra.items.len);
+    inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
+        const value = @field(extra, field.name);
+        self.constant_extra.appendAssumeCapacity(switch (field.type) {
+            u32 => value,
+            Type,
+            Constant,
+            Function.Index,
+            Function.Block.Index,
+            => @intFromEnum(value),
+            else => @compileError("bad field type: " ++ @typeName(field.type)),
+        });
+    }
+    return result;
+}
+
+fn constantExtraDataTrail(
+    self: *const Builder,
+    comptime T: type,
+    index: Constant.Item.ExtraIndex,
+) struct { data: T, end: Constant.Item.ExtraIndex } {
+    var result: T = undefined;
+    const fields = @typeInfo(T).Struct.fields;
+    inline for (fields, self.constant_extra.items[index..][0..fields.len]) |field, data|
+        @field(result, field.name) = switch (field.type) {
+            u32 => data,
+            Type,
+            Constant,
+            Function.Index,
+            Function.Block.Index,
+            => @enumFromInt(data),
+            else => @compileError("bad field type: " ++ @typeName(field.type)),
+        };
+    return .{ .data = result, .end = index + @as(Constant.Item.ExtraIndex, @intCast(fields.len)) };
+}
+
+fn constantExtraData(self: *const Builder, comptime T: type, index: Constant.Item.ExtraIndex) T {
+    return self.constantExtraDataTrail(T, index).data;
+}
+
 inline fn useLibLlvm(self: *const Builder) bool {
     return build_options.have_llvm and self.use_lib_llvm;
 }

src/codegen/llvm/bindings.zig

@@ -168,23 +168,41 @@ pub const Value = opaque {
     pub const setAliasee = LLVMAliasSetAliasee;
     extern fn LLVMAliasSetAliasee(Alias: *Value, Aliasee: *Value) void;
 
-    pub const constBitCast = LLVMConstBitCast;
-    extern fn LLVMConstBitCast(ConstantVal: *Value, ToType: *Type) *Value;
+    pub const constTrunc = LLVMConstTrunc;
+    extern fn LLVMConstTrunc(ConstantVal: *Value, ToType: *Type) *Value;
 
-    pub const constIntToPtr = LLVMConstIntToPtr;
-    extern fn LLVMConstIntToPtr(ConstantVal: *Value, ToType: *Type) *Value;
+    pub const constSExt = LLVMConstSExt;
+    extern fn LLVMConstSExt(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constZExt = LLVMConstZExt;
+    extern fn LLVMConstZExt(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constFPTrunc = LLVMConstFPTrunc;
+    extern fn LLVMConstFPTrunc(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constFPExt = LLVMConstFPExt;
+    extern fn LLVMConstFPExt(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constUIToFP = LLVMConstUIToFP;
+    extern fn LLVMConstUIToFP(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constSIToFP = LLVMConstSIToFP;
+    extern fn LLVMConstSIToFP(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constFPToUI = LLVMConstFPToUI;
+    extern fn LLVMConstFPToUI(ConstantVal: *Value, ToType: *Type) *Value;
+
+    pub const constFPToSI = LLVMConstFPToSI;
+    extern fn LLVMConstFPToSI(ConstantVal: *Value, ToType: *Type) *Value;
 
     pub const constPtrToInt = LLVMConstPtrToInt;
     extern fn LLVMConstPtrToInt(ConstantVal: *Value, ToType: *Type) *Value;
 
-    pub const constShl = LLVMConstShl;
-    extern fn LLVMConstShl(LHSConstant: *Value, RHSConstant: *Value) *Value;
+    pub const constIntToPtr = LLVMConstIntToPtr;
+    extern fn LLVMConstIntToPtr(ConstantVal: *Value, ToType: *Type) *Value;
 
-    pub const constOr = LLVMConstOr;
-    extern fn LLVMConstOr(LHSConstant: *Value, RHSConstant: *Value) *Value;
-
-    pub const constZExt = LLVMConstZExt;
-    extern fn LLVMConstZExt(ConstantVal: *Value, ToType: *Type) *Value;
+    pub const constBitCast = LLVMConstBitCast;
+    extern fn LLVMConstBitCast(ConstantVal: *Value, ToType: *Type) *Value;
 
     pub const constZExtOrBitCast = LLVMConstZExtOrBitCast;
     extern fn LLVMConstZExtOrBitCast(ConstantVal: *Value, ToType: *Type) *Value;
@@ -195,6 +213,30 @@ pub const Value = opaque {
     pub const constAdd = LLVMConstAdd;
     extern fn LLVMConstAdd(LHSConstant: *Value, RHSConstant: *Value) *Value;
 
+    pub const constSub = LLVMConstSub;
+    extern fn LLVMConstSub(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constMul = LLVMConstMul;
+    extern fn LLVMConstMul(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constAnd = LLVMConstAnd;
+    extern fn LLVMConstAnd(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constOr = LLVMConstOr;
+    extern fn LLVMConstOr(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constXor = LLVMConstXor;
+    extern fn LLVMConstXor(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constShl = LLVMConstShl;
+    extern fn LLVMConstShl(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constLShr = LLVMConstLShr;
+    extern fn LLVMConstLShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
+    pub const constAShr = LLVMConstAShr;
+    extern fn LLVMConstAShr(LHSConstant: *Value, RHSConstant: *Value) *Value;
+
     pub const constAddrSpaceCast = LLVMConstAddrSpaceCast;
     extern fn LLVMConstAddrSpaceCast(ConstantVal: *Value, ToType: *Type) *Value;
 
@@ -281,6 +323,9 @@ pub const Value = opaque {
     pub const attachMetaData = ZigLLVMAttachMetaData;
     extern fn ZigLLVMAttachMetaData(GlobalVar: *Value, DIG: *DIGlobalVariableExpression) void;
 
+    pub const blockAddress = LLVMBlockAddress;
+    extern fn LLVMBlockAddress(F: *Value, BB: *BasicBlock) *Value;
+
     pub const dump = LLVMDumpValue;
     extern fn LLVMDumpValue(Val: *Value) void;
 };
@@ -349,6 +394,14 @@ pub const Type = opaque {
     pub const isSized = LLVMTypeIsSized;
     extern fn LLVMTypeIsSized(Ty: *Type) Bool;
 
+    pub const constGEP = LLVMConstGEP2;
+    extern fn LLVMConstGEP2(
+        Ty: *Type,
+        ConstantVal: *Value,
+        ConstantIndices: [*]const *Value,
+        NumIndices: c_uint,
+    ) *Value;
+
     pub const constInBoundsGEP = LLVMConstInBoundsGEP2;
     extern fn LLVMConstInBoundsGEP2(
         Ty: *Type,