Commit aa44f8f0fd1a4af9df65a9b9bfc5fe6fa0d31b9f | zig

author	Jacob Young <jacobly@ziglang.org> 2023-07-21 00:51:50-04:00
committer	Jacob Young <jacobly@ziglang.org> 2023-07-23 23:48:18-04:00
log	aa44f8f0fd1a4af9df65a9b9bfc5fe6fa0d31b9f
tree	0f57991e2e463e963e117e0046f87efcf2aa6be5
parent	23a806102a5a3d5b28b2e5ab5ec30e191daea6f4

llvm: convert attributes and non-intrinsic calls

4 files changed, 1880 insertions(+), 332 deletions(-)

src
- codegen
  - llvm.zig
  - llvm
    Builder.zig
    bindings.zig
- zig_llvm.cpp

src/codegen/llvm.zig+449-268

 @@ -359,7 +359,7 @@ const DataLayoutBuilder = struct {
                     .macho => 'o', // Mach-O mangling: Private symbols get `L` prefix.
                     // Other symbols get a `_` prefix.
                     .coff => switch (self.target.os.tag) {
-                        .windows => switch (self.target.cpu.arch) {
+                        .uefi, .windows => switch (self.target.cpu.arch) {
                             .x86 => 'x', // Windows x86 COFF mangling: Private symbols get the usual
                             // prefix. Regular C symbols get a `_` prefix. Functions with `__stdcall`,
                             //`__fastcall`, and `__vectorcall` have custom mangling that appends `@N`
 @@ -794,7 +794,7 @@ pub const Object = struct {
                 builder.llvm.di_compile_unit = builder.llvm.di_builder.?.createCompileUnit(
                     DW.LANG.C99,
                     builder.llvm.di_builder.?.createFile(options.root_name, compile_unit_dir_z),
-                    producer.toSlice(&builder).?,
+                    producer.slice(&builder).?,
                     options.optimize_mode != .Debug,
                     "", // flags
                     0, // runtime version
 @@ -830,7 +830,7 @@ pub const Object = struct {
             target_machine = llvm.TargetMachine.create(
                 builder.llvm.target.?,
-                builder.target_triple.toSlice(&builder).?,
+                builder.target_triple.slice(&builder).?,
                 if (options.target.cpu.model.llvm_name) |s| s.ptr else null,
                 options.llvm_cpu_features,
                 opt_level,
 @@ -861,7 +861,7 @@ pub const Object = struct {
                 defer llvm.disposeMessage(rep);
                 std.testing.expectEqualStrings(
                     std.mem.span(rep),
-                    builder.data_layout.toSlice(&builder).?,
+                    builder.data_layout.slice(&builder).?,
                 ) catch unreachable;
             }
         }
 @@ -963,7 +963,7 @@ pub const Object = struct {
             llvm_error.* = try o.builder.structConst(llvm_slice_ty, &.{
                 global_index.toConst(),
-                try o.builder.intConst(llvm_usize_ty, name.toSlice(&o.builder).?.len),
+                try o.builder.intConst(llvm_usize_ty, name.slice(&o.builder).?.len),
             });
         }
 @@ -1223,6 +1223,7 @@ pub const Object = struct {
         const func = mod.funcInfo(func_index);
         const decl_index = func.owner_decl;
         const decl = mod.declPtr(decl_index);
+        const fn_info = mod.typeToFunc(decl.ty).?;
         const target = mod.getTarget();
         const ip = &mod.intern_pool;
 @@ -1237,28 +1238,43 @@ pub const Object = struct {
         const global = function.ptrConst(&o.builder).global;
         const llvm_func = global.toLlvm(&o.builder);
+        var attributes = try function.ptrConst(&o.builder).attributes.toWip(&o.builder);
+        defer attributes.deinit(&o.builder);
         if (func.analysis(ip).is_noinline) {
+            try attributes.addFnAttr(.@"noinline", &o.builder);
             o.addFnAttr(llvm_func, "noinline");
         } else {
+            _ = try attributes.removeFnAttr(.@"noinline");
             Object.removeFnAttr(llvm_func, "noinline");
         }
         if (func.analysis(ip).stack_alignment.toByteUnitsOptional()) |alignment| {
+            try attributes.addFnAttr(.{ .alignstack = Builder.Alignment.fromByteUnits(alignment) }, &o.builder);
+            try attributes.addFnAttr(.@"noinline", &o.builder);
             o.addFnAttrInt(llvm_func, "alignstack", alignment);
             o.addFnAttr(llvm_func, "noinline");
         } else {
+            _ = try attributes.removeFnAttr(.alignstack);
             Object.removeFnAttr(llvm_func, "alignstack");
         }
         if (func.analysis(ip).is_cold) {
+            try attributes.addFnAttr(.cold, &o.builder);
             o.addFnAttr(llvm_func, "cold");
         } else {
+            _ = try attributes.removeFnAttr(.cold);
             Object.removeFnAttr(llvm_func, "cold");
         }
         // TODO: disable this if safety is off for the function scope
         const ssp_buf_size = mod.comp.bin_file.options.stack_protector;
         if (ssp_buf_size != 0) {
+            try attributes.addFnAttr(.sspstrong, &o.builder);
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("stack-protector-buffer-size"),
+                .value = try o.builder.fmt("{d}", .{ssp_buf_size}),
+            } }, &o.builder);
             var buf: [12]u8 = undefined;
             const arg = std.fmt.bufPrintZ(&buf, "{d}", .{ssp_buf_size}) catch unreachable;
             o.addFnAttr(llvm_func, "sspstrong");
 @@ -1267,8 +1283,16 @@ pub const Object = struct {
         // TODO: disable this if safety is off for the function scope
         if (mod.comp.bin_file.options.stack_check) {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("probe-stack"),
+                .value = try o.builder.string("__zig_probe_stack"),
+            } }, &o.builder);
             o.addFnAttrString(llvm_func, "probe-stack", "__zig_probe_stack");
         } else if (target.os.tag == .uefi) {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("no-stack-arg-probe"),
+                .value = .empty,
+            } }, &o.builder);
             o.addFnAttrString(llvm_func, "no-stack-arg-probe", "");
         }
 @@ -1286,18 +1310,22 @@ pub const Object = struct {
         var llvm_arg_i: u32 = 0;
         // This gets the LLVM values from the function and stores them in `dg.args`.
-        const fn_info = mod.typeToFunc(decl.ty).?;
         const sret = firstParamSRet(fn_info, mod);
         const ret_ptr: Builder.Value = if (sret) param: {
             const param = wip.arg(llvm_arg_i);
             llvm_arg_i += 1;
             break :param param;
         } else .none;
-        const gpa = o.gpa;
         if (ccAbiPromoteInt(fn_info.cc, mod, fn_info.return_type.toType())) |s| switch (s) {
-            .signed => o.addAttr(llvm_func, 0, "signext"),
+            .signed => {
-            .unsigned => o.addAttr(llvm_func, 0, "zeroext"),
+                try attributes.addRetAttr(.signext, &o.builder);
+                o.addAttr(llvm_func, 0, "signext");
+            },
+            .unsigned => {
+                try attributes.addRetAttr(.zeroext, &o.builder);
+                o.addAttr(llvm_func, 0, "zeroext");
+            },
         };
         const err_return_tracing = fn_info.return_type.toType().isError(mod) and
 @@ -1312,6 +1340,7 @@ pub const Object = struct {
         // This is the list of args we will use that correspond directly to the AIR arg
         // instructions. Depending on the calling convention, this list is not necessarily
         // a bijection with the actual LLVM parameters of the function.
+        const gpa = o.gpa;
         var args: std.ArrayListUnmanaged(Builder.Value) = .{};
         defer args.deinit(gpa);
 @@ -1337,7 +1366,7 @@ pub const Object = struct {
                         } else {
                             args.appendAssumeCapacity(param);
-                            o.addByValParamAttrs(llvm_func, param_ty, param_index, fn_info, @intCast(llvm_arg_i));
+                            try o.addByValParamAttrsOld(&attributes, llvm_func, param_ty, param_index, fn_info, llvm_arg_i);
                         }
                         llvm_arg_i += 1;
                     },
 @@ -1347,7 +1376,7 @@ pub const Object = struct {
                         const param = wip.arg(llvm_arg_i);
                         const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
-                        o.addByRefParamAttrs(llvm_func, @intCast(llvm_arg_i), @intCast(alignment.toByteUnits() orelse 0), it.byval_attr, param_llvm_ty);
+                        try o.addByRefParamAttrsOld(&attributes, llvm_func, llvm_arg_i, alignment, it.byval_attr, param_llvm_ty);
                         llvm_arg_i += 1;
                         if (isByRef(param_ty, mod)) {
 @@ -1362,7 +1391,8 @@ pub const Object = struct {
                         const param = wip.arg(llvm_arg_i);
                         const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
-                        o.addArgAttr(llvm_func, @intCast(llvm_arg_i), "noundef");
+                        try attributes.addParamAttr(llvm_arg_i, .noundef, &o.builder);
+                        o.addArgAttr(llvm_func, llvm_arg_i, "noundef");
                         llvm_arg_i += 1;
                         if (isByRef(param_ty, mod)) {
 @@ -1398,21 +1428,28 @@ pub const Object = struct {
                         if (math.cast(u5, it.zig_index - 1)) |i| {
                             if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
-                                o.addArgAttr(llvm_func, @intCast(llvm_arg_i), "noalias");
+                                try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
+                                o.addArgAttr(llvm_func, llvm_arg_i, "noalias");
                             }
                         }
                         if (param_ty.zigTypeTag(mod) != .Optional) {
-                            o.addArgAttr(llvm_func, @intCast(llvm_arg_i), "nonnull");
+                            try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+                            o.addArgAttr(llvm_func, llvm_arg_i, "nonnull");
                         }
                         if (ptr_info.flags.is_const) {
-                            o.addArgAttr(llvm_func, @intCast(llvm_arg_i), "readonly");
+                            try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
+                            o.addArgAttr(llvm_func, llvm_arg_i, "readonly");
                         }
-                        const elem_align = ptr_info.flags.alignment.toByteUnitsOptional() orelse
+                        const elem_align = Builder.Alignment.fromByteUnits(
-                            @max(ptr_info.child.toType().abiAlignment(mod), 1);
+                            ptr_info.flags.alignment.toByteUnitsOptional() orelse
-                        o.addArgAttrInt(llvm_func, @intCast(llvm_arg_i), "align", elem_align);
+                                @max(ptr_info.child.toType().abiAlignment(mod), 1),
-                        const ptr_param = wip.arg(llvm_arg_i + 0);
+                        );
-                        const len_param = wip.arg(llvm_arg_i + 1);
+                        try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
-                        llvm_arg_i += 2;
+                        o.addArgAttrInt(llvm_func, llvm_arg_i, "align", elem_align.toByteUnits() orelse 0);
+                        const ptr_param = wip.arg(llvm_arg_i);
+                        llvm_arg_i += 1;
+                        const len_param = wip.arg(llvm_arg_i);
+                        llvm_arg_i += 1;
                         const slice_llvm_ty = try o.lowerType(param_ty);
                         args.appendAssumeCapacity(
 @@ -1482,6 +1519,8 @@ pub const Object = struct {
             }
         }
+        function.ptr(&o.builder).attributes = try attributes.finish(&o.builder);
         var di_file: ?*llvm.DIFile = null;
         var di_scope: ?*llvm.DIScope = null;
 @@ -1618,7 +1657,7 @@ pub const Object = struct {
                 llvm_global.setDLLStorageClass(.Default);
             }
             if (self.di_map.get(decl)) |di_node| {
-                const decl_name_slice = decl_name.toSlice(&self.builder).?;
+                const decl_name_slice = decl_name.slice(&self.builder).?;
                 if (try decl.isFunction(mod)) {
                     const di_func: *llvm.DISubprogram = @ptrCast(di_node);
                     const linkage_name = llvm.MDString.get(self.builder.llvm.context, decl_name_slice.ptr, decl_name_slice.len);
 @@ -1655,7 +1694,7 @@ pub const Object = struct {
                 llvm_global.setDLLStorageClass(.DLLExport);
             }
             if (self.di_map.get(decl)) |di_node| {
-                const exp_name_slice = exp_name.toSlice(&self.builder).?;
+                const exp_name_slice = exp_name.slice(&self.builder).?;
                 if (try decl.isFunction(mod)) {
                     const di_func: *llvm.DISubprogram = @ptrCast(di_node);
                     const linkage_name = llvm.MDString.get(self.builder.llvm.context, exp_name_slice.ptr, exp_name_slice.len);
 @@ -2816,7 +2855,7 @@ pub const Object = struct {
         const fqn = try o.builder.string(ip.stringToSlice(try decl.getFullyQualifiedName(mod)));
         const llvm_addrspace = toLlvmAddressSpace(decl.@"addrspace", target);
-        const llvm_fn = o.llvm_module.addFunctionInAddressSpace(fqn.toSlice(&o.builder).?, fn_type.toLlvm(&o.builder), @intFromEnum(llvm_addrspace));
+        const llvm_fn = o.llvm_module.addFunctionInAddressSpace(fqn.slice(&o.builder).?, fn_type.toLlvm(&o.builder), @intFromEnum(llvm_addrspace));
         var global = Builder.Global{
             .type = fn_type,
 @@ -2826,6 +2865,9 @@ pub const Object = struct {
             .global = @enumFromInt(o.builder.globals.count()),
         };
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         const is_extern = decl.isExtern(mod);
         if (!is_extern) {
             global.linkage = .internal;
 @@ -2834,43 +2876,64 @@ pub const Object = struct {
             llvm_fn.setUnnamedAddr(.True);
         } else {
             if (target.isWasm()) {
+                try attributes.addFnAttr(.{ .string = .{
+                    .kind = try o.builder.string("wasm-import-name"),
+                    .value = try o.builder.string(ip.stringToSlice(decl.name)),
+                } }, &o.builder);
                 o.addFnAttrString(llvm_fn, "wasm-import-name", ip.stringToSlice(decl.name));
                 if (ip.stringToSliceUnwrap(decl.getOwnedExternFunc(mod).?.lib_name)) |lib_name| {
                     if (!std.mem.eql(u8, lib_name, "c")) {
+                        try attributes.addFnAttr(.{ .string = .{
+                            .kind = try o.builder.string("wasm-import-module"),
+                            .value = try o.builder.string(lib_name),
+                        } }, &o.builder);
                         o.addFnAttrString(llvm_fn, "wasm-import-module", lib_name);
                     }
                 }
             }
         }
+        var llvm_arg_i: u32 = 0;
         if (sret) {
-            o.addArgAttr(llvm_fn, 0, "nonnull"); // Sret pointers must not be address 0
+            // Sret pointers must not be address 0
-            o.addArgAttr(llvm_fn, 0, "noalias");
+            try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+            try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
+            o.addArgAttr(llvm_fn, llvm_arg_i, "nonnull"); // Sret pointers must not be address 0
+            o.addArgAttr(llvm_fn, llvm_arg_i, "noalias");
+            const raw_llvm_ret_ty = try o.lowerType(fn_info.return_type.toType());
+            try attributes.addParamAttr(llvm_arg_i, .{ .sret = raw_llvm_ret_ty }, &o.builder);
+            llvm_fn.addSretAttr(raw_llvm_ret_ty.toLlvm(&o.builder));
-            const raw_llvm_ret_ty = (try o.lowerType(fn_info.return_type.toType())).toLlvm(&o.builder);
+            llvm_arg_i += 1;
-            llvm_fn.addSretAttr(raw_llvm_ret_ty);
         }
         const err_return_tracing = fn_info.return_type.toType().isError(mod) and
             mod.comp.bin_file.options.error_return_tracing;
         if (err_return_tracing) {
-            o.addArgAttr(llvm_fn, @intFromBool(sret), "nonnull");
+            try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+            o.addArgAttr(llvm_fn, llvm_arg_i, "nonnull");
+            llvm_arg_i += 1;
         }
         switch (fn_info.cc) {
             .Unspecified, .Inline => {
+                function.call_conv = .fastcc;
                 llvm_fn.setFunctionCallConv(.Fast);
             },
             .Naked => {
+                try attributes.addFnAttr(.naked, &o.builder);
                 o.addFnAttr(llvm_fn, "naked");
             },
             .Async => {
+                function.call_conv = .fastcc;
                 llvm_fn.setFunctionCallConv(.Fast);
                 @panic("TODO: LLVM backend lower async function");
             },
             else => {
-                llvm_fn.setFunctionCallConv(toLlvmCallConv(fn_info.cc, target));
+                function.call_conv = toLlvmCallConv(fn_info.cc, target);
+                llvm_fn.setFunctionCallConv(@enumFromInt(@intFromEnum(function.call_conv)));
             },
         }
 @@ -2880,9 +2943,10 @@ pub const Object = struct {
         }
         // Function attributes that are independent of analysis results of the function body.
-        o.addCommonFnAttributes(llvm_fn);
+        try o.addCommonFnAttributes(&attributes, llvm_fn);
         if (fn_info.return_type == .noreturn_type) {
+            try attributes.addFnAttr(.noreturn, &o.builder);
             o.addFnAttr(llvm_fn, "noreturn");
         }
 @@ -2890,23 +2954,24 @@ pub const Object = struct {
         // because functions with bodies are handled in `updateFunc`.
         if (is_extern) {
             var it = iterateParamTypes(o, fn_info);
-            it.llvm_index += @intFromBool(sret);
+            it.llvm_index = llvm_arg_i;
-            it.llvm_index += @intFromBool(err_return_tracing);
             while (try it.next()) |lowering| switch (lowering) {
                 .byval => {
                     const param_index = it.zig_index - 1;
                     const param_ty = fn_info.param_types.get(ip)[param_index].toType();
                     if (!isByRef(param_ty, mod)) {
-                        o.addByValParamAttrs(llvm_fn, param_ty, param_index, fn_info, it.llvm_index - 1);
+                        try o.addByValParamAttrsOld(&attributes, llvm_fn, param_ty, param_index, fn_info, it.llvm_index - 1);
                     }
                 },
                 .byref => {
                     const param_ty = fn_info.param_types.get(ip)[it.zig_index - 1];
                     const param_llvm_ty = try o.lowerType(param_ty.toType());
-                    const alignment = param_ty.toType().abiAlignment(mod);
+                    const alignment =
-                    o.addByRefParamAttrs(llvm_fn, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
+                        Builder.Alignment.fromByteUnits(param_ty.toType().abiAlignment(mod));
+                    try o.addByRefParamAttrsOld(&attributes, llvm_fn, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
                 },
                 .byref_mut => {
+                    try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder);
                     o.addArgAttr(llvm_fn, it.llvm_index - 1, "noundef");
                 },
                 // No attributes needed for these.
 @@ -2924,25 +2989,42 @@ pub const Object = struct {
             };
         }
+        function.attributes = try attributes.finish(&o.builder);
         try o.builder.llvm.globals.append(o.gpa, llvm_fn);
         gop.value_ptr.* = try o.builder.addGlobal(fqn, global);
         try o.builder.functions.append(o.gpa, function);
         return global.kind.function;
     }
-    fn addCommonFnAttributes(o: *Object, llvm_fn: *llvm.Value) void {
+    fn addCommonFnAttributes(
+        o: *Object,
+        attributes: *Builder.FunctionAttributes.Wip,
+        llvm_fn: *llvm.Value,
+    ) Allocator.Error!void {
         const comp = o.module.comp;
         if (!comp.bin_file.options.red_zone) {
+            try attributes.addFnAttr(.noredzone, &o.builder);
             o.addFnAttr(llvm_fn, "noredzone");
         }
         if (comp.bin_file.options.omit_frame_pointer) {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("frame-pointer"),
+                .value = try o.builder.string("none"),
+            } }, &o.builder);
             o.addFnAttrString(llvm_fn, "frame-pointer", "none");
         } else {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("frame-pointer"),
+                .value = try o.builder.string("all"),
+            } }, &o.builder);
             o.addFnAttrString(llvm_fn, "frame-pointer", "all");
         }
+        try attributes.addFnAttr(.nounwind, &o.builder);
         o.addFnAttr(llvm_fn, "nounwind");
         if (comp.unwind_tables) {
+            try attributes.addFnAttr(.{ .uwtable = Builder.Attribute.UwTable.default }, &o.builder);
             o.addFnAttrInt(llvm_fn, "uwtable", 2);
         }
         if (comp.bin_file.options.skip_linker_dependencies or
 @@ -2953,22 +3035,38 @@ pub const Object = struct {
             // and llvm detects that the body is equivalent to memcpy, it may replace the
             // body of memcpy with a call to memcpy, which would then cause a stack
             // overflow instead of performing memcpy.
+            try attributes.addFnAttr(.nobuiltin, &o.builder);
             o.addFnAttr(llvm_fn, "nobuiltin");
         }
         if (comp.bin_file.options.optimize_mode == .ReleaseSmall) {
+            try attributes.addFnAttr(.minsize, &o.builder);
+            try attributes.addFnAttr(.optsize, &o.builder);
             o.addFnAttr(llvm_fn, "minsize");
             o.addFnAttr(llvm_fn, "optsize");
         }
         if (comp.bin_file.options.tsan) {
+            try attributes.addFnAttr(.sanitize_thread, &o.builder);
             o.addFnAttr(llvm_fn, "sanitize_thread");
         }
         if (comp.getTarget().cpu.model.llvm_name) |s| {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("target-cpu"),
+                .value = try o.builder.string(s),
+            } }, &o.builder);
             llvm_fn.addFunctionAttr("target-cpu", s);
         }
         if (comp.bin_file.options.llvm_cpu_features) |s| {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("target-features"),
+                .value = try o.builder.string(std.mem.span(s)),
+            } }, &o.builder);
             llvm_fn.addFunctionAttr("target-features", s);
         }
         if (comp.getTarget().cpu.arch.isBpf()) {
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("no-builtins"),
+                .value = .empty,
+            } }, &o.builder);
             llvm_fn.addFunctionAttr("no-builtins", "");
         }
     }
 @@ -3002,7 +3100,7 @@ pub const Object = struct {
             fqn;
         const llvm_global = o.llvm_module.addGlobalInAddressSpace(
             global.type.toLlvm(&o.builder),
-            fqn.toSlice(&o.builder).?,
+            fqn.slice(&o.builder).?,
             @intFromEnum(global.addr_space),
         );
 @@ -4403,47 +4501,114 @@ pub const Object = struct {
     fn addByValParamAttrs(
         o: *Object,
+        attributes: *Builder.FunctionAttributes.Wip,
+        param_ty: Type,
+        param_index: u32,
+        fn_info: InternPool.Key.FuncType,
+        llvm_arg_i: u32,
+    ) Allocator.Error!void {
+        const mod = o.module;
+        if (param_ty.isPtrAtRuntime(mod)) {
+            const ptr_info = param_ty.ptrInfo(mod);
+            if (math.cast(u5, param_index)) |i| {
+                if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
+                    try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
+                }
+            }
+            if (!param_ty.isPtrLikeOptional(mod) and !ptr_info.flags.is_allowzero) {
+                try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+            }
+            if (ptr_info.flags.is_const) {
+                try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
+            }
+            const elem_align = Builder.Alignment.fromByteUnits(
+                ptr_info.flags.alignment.toByteUnitsOptional() orelse
+                    @max(ptr_info.child.toType().abiAlignment(mod), 1),
+            );
+            try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
+        } else if (ccAbiPromoteInt(fn_info.cc, mod, param_ty)) |s| switch (s) {
+            .signed => try attributes.addParamAttr(llvm_arg_i, .signext, &o.builder),
+            .unsigned => try attributes.addParamAttr(llvm_arg_i, .zeroext, &o.builder),
+        };
+    }
+    fn addByRefParamAttrs(
+        o: *Object,
+        attributes: *Builder.FunctionAttributes.Wip,
+        llvm_arg_i: u32,
+        alignment: Builder.Alignment,
+        byval_attr: bool,
+        param_llvm_ty: Builder.Type,
+    ) Allocator.Error!void {
+        try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+        try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
+        try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = alignment }, &o.builder);
+        if (byval_attr) {
+            try attributes.addParamAttr(llvm_arg_i, .{ .byval = param_llvm_ty }, &o.builder);
+        }
+    }
+    fn addByValParamAttrsOld(
+        o: *Object,
+        attributes: *Builder.FunctionAttributes.Wip,
         llvm_fn: *llvm.Value,
         param_ty: Type,
         param_index: u32,
         fn_info: InternPool.Key.FuncType,
         llvm_arg_i: u32,
-    ) void {
+    ) Allocator.Error!void {
         const mod = o.module;
         if (param_ty.isPtrAtRuntime(mod)) {
             const ptr_info = param_ty.ptrInfo(mod);
             if (math.cast(u5, param_index)) |i| {
                 if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
+                    try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
                     o.addArgAttr(llvm_fn, llvm_arg_i, "noalias");
                 }
             }
             if (!param_ty.isPtrLikeOptional(mod) and !ptr_info.flags.is_allowzero) {
+                try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
                 o.addArgAttr(llvm_fn, llvm_arg_i, "nonnull");
             }
             if (ptr_info.flags.is_const) {
+                try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
                 o.addArgAttr(llvm_fn, llvm_arg_i, "readonly");
             }
-            const elem_align = ptr_info.flags.alignment.toByteUnitsOptional() orelse
+            const elem_align = Builder.Alignment.fromByteUnits(
-                @max(ptr_info.child.toType().abiAlignment(mod), 1);
+                ptr_info.flags.alignment.toByteUnitsOptional() orelse
-            o.addArgAttrInt(llvm_fn, llvm_arg_i, "align", elem_align);
+                    @max(ptr_info.child.toType().abiAlignment(mod), 1),
+            );
+            try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
+            o.addArgAttrInt(llvm_fn, llvm_arg_i, "align", elem_align.toByteUnits() orelse 0);
         } else if (ccAbiPromoteInt(fn_info.cc, mod, param_ty)) |s| switch (s) {
-            .signed => o.addArgAttr(llvm_fn, llvm_arg_i, "signext"),
+            .signed => {
-            .unsigned => o.addArgAttr(llvm_fn, llvm_arg_i, "zeroext"),
+                try attributes.addParamAttr(llvm_arg_i, .signext, &o.builder);
+                o.addArgAttr(llvm_fn, llvm_arg_i, "signext");
+            },
+            .unsigned => {
+                try attributes.addParamAttr(llvm_arg_i, .zeroext, &o.builder);
+                o.addArgAttr(llvm_fn, llvm_arg_i, "zeroext");
+            },
         };
     }
-    fn addByRefParamAttrs(
+    fn addByRefParamAttrsOld(
         o: *Object,
+        attributes: *Builder.FunctionAttributes.Wip,
         llvm_fn: *llvm.Value,
         llvm_arg_i: u32,
-        alignment: u32,
+        alignment: Builder.Alignment,
         byval_attr: bool,
         param_llvm_ty: Builder.Type,
-    ) void {
+    ) Allocator.Error!void {
+        try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
+        try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
+        try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = alignment }, &o.builder);
         o.addArgAttr(llvm_fn, llvm_arg_i, "nonnull");
         o.addArgAttr(llvm_fn, llvm_arg_i, "readonly");
-        o.addArgAttrInt(llvm_fn, llvm_arg_i, "align", alignment);
+        o.addArgAttrInt(llvm_fn, llvm_arg_i, "align", alignment.toByteUnits() orelse 0);
         if (byval_attr) {
+            try attributes.addParamAttr(llvm_arg_i, .{ .byval = param_llvm_ty }, &o.builder);
             llvm_fn.addByValAttr(llvm_arg_i, param_llvm_ty.toLlvm(&o.builder));
         }
     }
 @@ -4841,10 +5006,10 @@ pub const FuncGen = struct {
                 .slice_ptr      => try self.airSliceField(inst, 0),
                 .slice_len      => try self.airSliceField(inst, 1),
-                .call              => try self.airCall(inst, .Auto),
+                .call              => try self.airCall(inst, .auto),
-                .call_always_tail  => try self.airCall(inst, .AlwaysTail),
+                .call_always_tail  => try self.airCall(inst, .always_tail),
-                .call_never_tail   => try self.airCall(inst, .NeverTail),
+                .call_never_tail   => try self.airCall(inst, .never_tail),
-                .call_never_inline => try self.airCall(inst, .NeverInline),
+                .call_never_inline => try self.airCall(inst, .never_inline),
                 .ptr_slice_ptr_ptr => try self.airPtrSliceFieldPtr(inst, 0),
                 .ptr_slice_len_ptr => try self.airPtrSliceFieldPtr(inst, 1),
 @@ -4953,7 +5118,15 @@ pub const FuncGen = struct {
         }
     }
-    fn airCall(self: *FuncGen, inst: Air.Inst.Index, attr: llvm.CallAttr) !Builder.Value {
+    pub const CallAttr = enum {
+        Auto,
+        NeverTail,
+        NeverInline,
+        AlwaysTail,
+        AlwaysInline,
+    };
+    fn airCall(self: *FuncGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier) !Builder.Value {
         const pl_op = self.air.instructions.items(.data)[inst].pl_op;
         const extra = self.air.extraData(Air.Call, pl_op.payload);
         const args: []const Air.Inst.Ref = @ptrCast(self.air.extra[extra.end..][0..extra.data.args_len]);
 @@ -4972,14 +5145,25 @@ pub const FuncGen = struct {
         const target = mod.getTarget();
         const sret = firstParamSRet(fn_info, mod);
-        var llvm_args = std.ArrayList(*llvm.Value).init(self.gpa);
+        var llvm_args = std.ArrayList(Builder.Value).init(self.gpa);
         defer llvm_args.deinit();
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
+        switch (modifier) {
+            .auto, .never_tail, .always_tail => {},
+            .never_inline => try attributes.addFnAttr(.@"noinline", &o.builder),
+            .async_kw, .no_async, .always_inline, .compile_time => unreachable,
+        }
         const ret_ptr = if (!sret) null else blk: {
             const llvm_ret_ty = try o.lowerType(return_type);
+            try attributes.addParamAttr(0, .{ .sret = llvm_ret_ty }, &o.builder);
             const alignment = Builder.Alignment.fromByteUnits(return_type.abiAlignment(mod));
             const ret_ptr = try self.buildAlloca(llvm_ret_ty, alignment);
-            try llvm_args.append(ret_ptr.toLlvm(&self.wip));
+            try llvm_args.append(ret_ptr);
             break :blk ret_ptr;
         };
 @@ -4987,7 +5171,7 @@ pub const FuncGen = struct {
             o.module.comp.bin_file.options.error_return_tracing;
         if (err_return_tracing) {
             assert(self.err_ret_trace != .none);
-            try llvm_args.append(self.err_ret_trace.toLlvm(&self.wip));
+            try llvm_args.append(self.err_ret_trace);
         }
         var it = iterateParamTypes(o, fn_info);
 @@ -5001,9 +5185,9 @@ pub const FuncGen = struct {
                 if (isByRef(param_ty, mod)) {
                     const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
                     const loaded = try self.wip.load(.normal, llvm_param_ty, llvm_arg, alignment, "");
-                    try llvm_args.append(loaded.toLlvm(&self.wip));
+                    try llvm_args.append(loaded);
                 } else {
-                    try llvm_args.append(llvm_arg.toLlvm(&self.wip));
+                    try llvm_args.append(llvm_arg);
                 }
             },
             .byref => {
 @@ -5011,13 +5195,13 @@ pub const FuncGen = struct {
                 const param_ty = self.typeOf(arg);
                 const llvm_arg = try self.resolveInst(arg);
                 if (isByRef(param_ty, mod)) {
-                    try llvm_args.append(llvm_arg.toLlvm(&self.wip));
+                    try llvm_args.append(llvm_arg);
                 } else {
                     const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
                     const param_llvm_ty = llvm_arg.typeOfWip(&self.wip);
                     const arg_ptr = try self.buildAlloca(param_llvm_ty, alignment);
                     _ = try self.wip.store(.normal, llvm_arg, arg_ptr, alignment);
-                    try llvm_args.append(arg_ptr.toLlvm(&self.wip));
+                    try llvm_args.append(arg_ptr);
                 }
             },
             .byref_mut => {
 @@ -5034,7 +5218,7 @@ pub const FuncGen = struct {
                 } else {
                     _ = try self.wip.store(.normal, llvm_arg, arg_ptr, alignment);
                 }
-                try llvm_args.append(arg_ptr.toLlvm(&self.wip));
+                try llvm_args.append(arg_ptr);
             },
             .abi_sized_int => {
                 const arg = args[it.zig_index - 1];
 @@ -5045,7 +5229,7 @@ pub const FuncGen = struct {
                 if (isByRef(param_ty, mod)) {
                     const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
                     const loaded = try self.wip.load(.normal, int_llvm_ty, llvm_arg, alignment, "");
-                    try llvm_args.append(loaded.toLlvm(&self.wip));
+                    try llvm_args.append(loaded);
                 } else {
                     // LLVM does not allow bitcasting structs so we must allocate
                     // a local, store as one type, and then load as another type.
 @@ -5056,7 +5240,7 @@ pub const FuncGen = struct {
                     const int_ptr = try self.buildAlloca(int_llvm_ty, alignment);
                     _ = try self.wip.store(.normal, llvm_arg, int_ptr, alignment);
                     const loaded = try self.wip.load(.normal, int_llvm_ty, int_ptr, alignment, "");
-                    try llvm_args.append(loaded.toLlvm(&self.wip));
+                    try llvm_args.append(loaded);
                 }
             },
             .slice => {
 @@ -5064,7 +5248,7 @@ pub const FuncGen = struct {
                 const llvm_arg = try self.resolveInst(arg);
                 const ptr = try self.wip.extractValue(llvm_arg, &.{0}, "");
                 const len = try self.wip.extractValue(llvm_arg, &.{1}, "");
-                try llvm_args.appendSlice(&.{ ptr.toLlvm(&self.wip), len.toLlvm(&self.wip) });
+                try llvm_args.appendSlice(&.{ ptr, len });
             },
             .multiple_llvm_types => {
                 const arg = args[it.zig_index - 1];
 @@ -5086,14 +5270,14 @@ pub const FuncGen = struct {
                         Builder.Alignment.fromByteUnits(@divExact(target.ptrBitWidth(), 8));
                     const field_ptr = try self.wip.gepStruct(llvm_ty, arg_ptr, i, "");
                     const loaded = try self.wip.load(.normal, field_ty, field_ptr, alignment, "");
-                    llvm_args.appendAssumeCapacity(loaded.toLlvm(&self.wip));
+                    llvm_args.appendAssumeCapacity(loaded);
                 }
             },
             .as_u16 => {
                 const arg = args[it.zig_index - 1];
                 const llvm_arg = try self.resolveInst(arg);
                 const casted = try self.wip.cast(.bitcast, llvm_arg, .i16, "");
-                try llvm_args.append(casted.toLlvm(&self.wip));
+                try llvm_args.append(casted);
             },
             .float_array => |count| {
                 const arg = args[it.zig_index - 1];
 @@ -5110,7 +5294,7 @@ pub const FuncGen = struct {
                 const array_ty = try o.builder.arrayType(count, float_ty);
                 const loaded = try self.wip.load(.normal, array_ty, llvm_arg, alignment, "");
-                try llvm_args.append(loaded.toLlvm(&self.wip));
+                try llvm_args.append(loaded);
             },
             .i32_array, .i64_array => |arr_len| {
                 const elem_size: u8 = if (lowering == .i32_array) 32 else 64;
 @@ -5127,24 +5311,10 @@ pub const FuncGen = struct {
                 const array_ty =
                     try o.builder.arrayType(arr_len, try o.builder.intType(@intCast(elem_size)));
                 const loaded = try self.wip.load(.normal, array_ty, llvm_arg, alignment, "");
-                try llvm_args.append(loaded.toLlvm(&self.wip));
+                try llvm_args.append(loaded);
             },
         };
-        const llvm_fn_ty = try o.lowerType(zig_fn_ty);
-        const call = (try self.wip.unimplemented(llvm_fn_ty.functionReturn(&o.builder), "")).finish(
-            self.builder.buildCall(
-                llvm_fn_ty.toLlvm(&o.builder),
-                llvm_fn.toLlvm(&self.wip),
-                llvm_args.items.ptr,
-                @intCast(llvm_args.items.len),
-                toLlvmCallConv(fn_info.cc, target),
-                attr,
-                "",
-            ),
-            &self.wip,
-        );
         if (callee_ty.zigTypeTag(mod) == .Pointer) {
             // Add argument attributes for function pointer calls.
             it = iterateParamTypes(o, fn_info);
 @@ -5155,19 +5325,17 @@ pub const FuncGen = struct {
                     const param_index = it.zig_index - 1;
                     const param_ty = fn_info.param_types.get(ip)[param_index].toType();
                     if (!isByRef(param_ty, mod)) {
-                        o.addByValParamAttrs(call.toLlvm(&self.wip), param_ty, param_index, fn_info, it.llvm_index - 1);
+                        try o.addByValParamAttrs(&attributes, param_ty, param_index, fn_info, it.llvm_index - 1);
                     }
                 },
                 .byref => {
                     const param_index = it.zig_index - 1;
                     const param_ty = fn_info.param_types.get(ip)[param_index].toType();
                     const param_llvm_ty = try o.lowerType(param_ty);
-                    const alignment = param_ty.abiAlignment(mod);
+                    const alignment = Builder.Alignment.fromByteUnits(param_ty.abiAlignment(mod));
-                    o.addByRefParamAttrs(call.toLlvm(&self.wip), it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
+                    try o.addByRefParamAttrs(&attributes, it.llvm_index - 1, alignment, it.byval_attr, param_llvm_ty);
-                },
-                .byref_mut => {
-                    o.addArgAttr(call.toLlvm(&self.wip), it.llvm_index - 1, "noundef");
                 },
+                .byref_mut => try attributes.addParamAttr(it.llvm_index - 1, .noundef, &o.builder),
                 // No attributes needed for these.
                 .no_bits,
                 .abi_sized_int,
 @@ -5186,23 +5354,40 @@ pub const FuncGen = struct {
                     if (math.cast(u5, it.zig_index - 1)) |i| {
                         if (@as(u1, @truncate(fn_info.noalias_bits >> i)) != 0) {
-                            o.addArgAttr(call.toLlvm(&self.wip), llvm_arg_i, "noalias");
+                            try attributes.addParamAttr(llvm_arg_i, .@"noalias", &o.builder);
                         }
                     }
                     if (param_ty.zigTypeTag(mod) != .Optional) {
-                        o.addArgAttr(call.toLlvm(&self.wip), llvm_arg_i, "nonnull");
+                        try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
                     }
                     if (ptr_info.flags.is_const) {
-                        o.addArgAttr(call.toLlvm(&self.wip), llvm_arg_i, "readonly");
+                        try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
                     }
-                    const elem_align = ptr_info.flags.alignment.toByteUnitsOptional() orelse
+                    const elem_align = Builder.Alignment.fromByteUnits(
-                        @max(ptr_info.child.toType().abiAlignment(mod), 1);
+                        ptr_info.flags.alignment.toByteUnitsOptional() orelse
-                    o.addArgAttrInt(call.toLlvm(&self.wip), llvm_arg_i, "align", elem_align);
+                            @max(ptr_info.child.toType().abiAlignment(mod), 1),
+                    );
+                    try attributes.addParamAttr(llvm_arg_i, .{ .@"align" = elem_align }, &o.builder);
                 },
             };
         }
-        if (fn_info.return_type == .noreturn_type and attr != .AlwaysTail) {
+        const call = try self.wip.call(
+            switch (modifier) {
+                .auto, .never_inline => .normal,
+                .never_tail => .notail,
+                .always_tail => .musttail,
+                .async_kw, .no_async, .always_inline, .compile_time => unreachable,
+            },
+            toLlvmCallConv(fn_info.cc, target),
+            try attributes.finish(&o.builder),
+            try o.lowerType(zig_fn_ty),
+            llvm_fn,
+            llvm_args.items,
+            "",
+        );
+        if (fn_info.return_type == .noreturn_type and modifier != .always_tail) {
             return .none;
         }
 @@ -5211,9 +5396,7 @@ pub const FuncGen = struct {
         }
         const llvm_ret_ty = try o.lowerType(return_type);
         if (ret_ptr) |rp| {
-            call.toLlvm(&self.wip).setCallSret(llvm_ret_ty.toLlvm(&o.builder));
             if (isByRef(return_type, mod)) {
                 return rp;
             } else {
 @@ -5269,25 +5452,24 @@ pub const FuncGen = struct {
         //   ptr null,                                               ; stack trace
         //   ptr @2,                                                 ; addr (null ?usize)
         // )
-        const args = [4]*llvm.Value{
-            msg_ptr.toLlvm(&o.builder),
-            (try o.builder.intConst(llvm_usize, msg_len)).toLlvm(&o.builder),
-            (try o.builder.nullConst(.ptr)).toLlvm(&o.builder),
-            null_opt_addr_global.toLlvm(&o.builder),
-        };
         const panic_func = mod.funcInfo(mod.panic_func_index);
         const panic_decl = mod.declPtr(panic_func.owner_decl);
         const fn_info = mod.typeToFunc(panic_decl.ty).?;
         const panic_global = try o.resolveLlvmFunction(panic_func.owner_decl);
-        _ = (try fg.wip.unimplemented(.void, "")).finish(fg.builder.buildCall(
+        _ = try fg.wip.call(
-            (try o.lowerType(panic_decl.ty)).toLlvm(&o.builder),
+            .normal,
-            panic_global.toLlvm(&o.builder),
-            &args,
-            args.len,
             toLlvmCallConv(fn_info.cc, target),
-            .Auto,
+            .none,
+            panic_global.typeOf(&o.builder),
+            panic_global.toValue(&o.builder),
+            &.{
+                msg_ptr.toValue(),
+                try o.builder.intValue(llvm_usize, msg_len),
+                try o.builder.nullValue(.ptr),
+                null_opt_addr_global.toValue(),
+            },
             "",
-        ), &fg.wip);
+        );
         _ = try fg.wip.@"unreachable"();
     }
 @@ -5395,7 +5577,7 @@ pub const FuncGen = struct {
             o.llvm_module.addFunction(llvm_fn_name, llvm_fn_ty.toLlvm(&o.builder));
         const args: [2]*llvm.Value = .{ dest_list.toLlvm(&self.wip), src_list.toLlvm(&self.wip) };
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -5422,7 +5604,7 @@ pub const FuncGen = struct {
             o.llvm_module.addFunction(llvm_fn_name, llvm_fn_ty.toLlvm(&o.builder));
         const args: [1]*llvm.Value = .{list.toLlvm(&self.wip)};
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -5449,7 +5631,7 @@ pub const FuncGen = struct {
             o.llvm_module.addFunction(llvm_fn_name, llvm_fn_ty.toLlvm(&o.builder));
         const args: [1]*llvm.Value = .{list.toLlvm(&self.wip)};
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -5495,16 +5677,15 @@ pub const FuncGen = struct {
         const un_op = self.air.instructions.items(.data)[inst].un_op;
         const operand = try self.resolveInst(un_op);
         const llvm_fn = try self.getCmpLtErrorsLenFunction();
-        const args: [1]*llvm.Value = .{operand.toLlvm(&self.wip)};
+        return self.wip.call(
-        return (try self.wip.unimplemented(.i1, "")).finish(self.builder.buildCall(
+            .normal,
-            llvm_fn.typeOf(&o.builder).toLlvm(&o.builder),
+            .fastcc,
-            llvm_fn.toLlvm(&o.builder),
+            .none,
-            &args,
+            llvm_fn.typeOf(&o.builder),
-            args.len,
+            llvm_fn.toValue(&o.builder),
-            .Fast,
+            &.{operand},
-            .Auto,
             "",
-        ), &self.wip);
+        );
     }
     fn cmp(
 @@ -5953,16 +6134,15 @@ pub const FuncGen = struct {
         }
         const libc_fn = try self.getLibcFunction(fn_name, &.{param_type}, dest_llvm_ty);
-        const params = [1]*llvm.Value{extended.toLlvm(&self.wip)};
+        return self.wip.call(
-        return (try self.wip.unimplemented(dest_llvm_ty, "")).finish(self.builder.buildCall(
+            .normal,
-            libc_fn.typeOf(&o.builder).toLlvm(&o.builder),
+            .ccc,
-            libc_fn.toLlvm(&o.builder),
+            .none,
-            &params,
+            libc_fn.typeOf(&o.builder),
-            params.len,
+            libc_fn.toValue(&o.builder),
-            .C,
+            &.{extended},
-            .Auto,
             "",
-        ), &self.wip);
+        );
     }
     fn airIntFromFloat(self: *FuncGen, inst: Air.Inst.Index, want_fast_math: bool) !Builder.Value {
 @@ -6013,16 +6193,15 @@ pub const FuncGen = struct {
         const operand_llvm_ty = try o.lowerType(operand_ty);
         const libc_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, libc_ret_ty);
-        const params = [1]*llvm.Value{operand.toLlvm(&self.wip)};
+        var result = try self.wip.call(
-        var result = (try self.wip.unimplemented(libc_ret_ty, "")).finish(self.builder.buildCall(
+            .normal,
-            libc_fn.typeOf(&o.builder).toLlvm(&o.builder),
+            .ccc,
-            libc_fn.toLlvm(&o.builder),
+            .none,
-            &params,
+            libc_fn.typeOf(&o.builder),
-            params.len,
+            libc_fn.toValue(&o.builder),
-            .C,
+            &.{operand},
-            .Auto,
             "",
-        ), &self.wip);
+        );
         if (libc_ret_ty != ret_ty) result = try self.wip.cast(.bitcast, result, ret_ty, "");
         if (ret_ty != dest_llvm_ty) result = try self.wip.cast(.trunc, result, dest_llvm_ty, "");
 @@ -6843,6 +7022,9 @@ pub const FuncGen = struct {
             }
         }
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         const ret_llvm_ty = switch (return_count) {
             0 => .void,
             1 => llvm_ret_types[0],
 @@ -6861,7 +7043,7 @@ pub const FuncGen = struct {
             .ATT,
             .False,
         );
-        const call = (try self.wip.unimplemented(ret_llvm_ty, "")).finish(self.builder.buildCall(
+        const call = (try self.wip.unimplemented(ret_llvm_ty, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             asm_fn,
             llvm_param_values.ptr,
 @@ -6872,6 +7054,7 @@ pub const FuncGen = struct {
         ), &self.wip);
         for (llvm_param_attrs[0..param_count], 0..) |llvm_elem_ty, i| {
             if (llvm_elem_ty != .none) {
+                try attributes.addParamAttr(i, .{ .elementtype = llvm_elem_ty }, &o.builder);
                 llvm.setCallElemTypeAttr(call.toLlvm(&self.wip), i, llvm_elem_ty.toLlvm(&o.builder));
             }
         }
 @@ -7287,7 +7470,7 @@ pub const FuncGen = struct {
         const args: [1]*llvm.Value = .{
             (try o.builder.intConst(.i32, index)).toLlvm(&o.builder),
         };
-        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCall(
+        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.i32, &.{.i32}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -7308,7 +7491,7 @@ pub const FuncGen = struct {
             (try o.builder.intConst(.i32, index)).toLlvm(&o.builder),
             operand.toLlvm(&self.wip),
         };
-        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCall(
+        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.i32, &.{ .i32, .i32 }, .normal)).toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -7425,7 +7608,7 @@ pub const FuncGen = struct {
         });
         const llvm_fn_ty = try o.builder.fnType(llvm_ret_ty, &.{ llvm_inst_ty, llvm_inst_ty }, .normal);
         const llvm_fn = try fg.getIntrinsic(intrinsic_name, &.{llvm_inst_ty});
-        const result_struct = (try fg.wip.unimplemented(llvm_ret_ty, "")).finish(fg.builder.buildCall(
+        const result_struct = (try fg.wip.unimplemented(llvm_ret_ty, "")).finish(fg.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             llvm_fn,
             &[_]*llvm.Value{ lhs.toLlvm(&fg.wip), rhs.toLlvm(&fg.wip) },
 @@ -7768,7 +7951,7 @@ pub const FuncGen = struct {
         );
         const llvm_fn_ty = try o.builder.fnType(llvm_ret_ty, &.{ llvm_lhs_ty, llvm_lhs_ty }, .normal);
         const result_struct = (try self.wip.unimplemented(llvm_ret_ty, "")).finish(
-            self.builder.buildCall(
+            self.builder.buildCallOld(
                 llvm_fn_ty.toLlvm(&o.builder),
                 llvm_fn,
                 &[_]*llvm.Value{ lhs.toLlvm(&self.wip), rhs.toLlvm(&self.wip) },
 @@ -7818,29 +8001,23 @@ pub const FuncGen = struct {
         const o = self.dg.object;
         assert(args_vectors.len <= 3);
-        const llvm_fn_ty = llvm_fn.typeOf(&o.builder);
-        const llvm_scalar_ty = llvm_fn_ty.functionReturn(&o.builder);
         var i: usize = 0;
         var result = result_vector;
         while (i < vector_len) : (i += 1) {
             const index_i32 = try o.builder.intValue(.i32, i);
-            var args: [3]*llvm.Value = undefined;
+            var args: [3]Builder.Value = undefined;
             for (args[0..args_vectors.len], args_vectors) |*arg_elem, arg_vector| {
-                arg_elem.* = (try self.wip.extractElement(arg_vector, index_i32, "")).toLlvm(&self.wip);
+                arg_elem.* = try self.wip.extractElement(arg_vector, index_i32, "");
             }
-            const result_elem = (try self.wip.unimplemented(llvm_scalar_ty, "")).finish(
+            const result_elem = try self.wip.call(
-                self.builder.buildCall(
+                .normal,
-                    llvm_fn_ty.toLlvm(&o.builder),
+                .ccc,
-                    llvm_fn.toLlvm(&o.builder),
+                .none,
-                    &args,
+                llvm_fn.typeOf(&o.builder),
-                    @intCast(args_vectors.len),
+                llvm_fn.toValue(&o.builder),
-                    .C,
+                args[0..args_vectors.len],
-                    .Auto,
+                "",
-                    "",
-                ),
-                &self.wip,
             );
             result = try self.wip.insertElement(result, result_elem, index_i32, "");
         }
 @@ -7861,7 +8038,7 @@ pub const FuncGen = struct {
         };
         const fn_type = try o.builder.fnType(return_type, param_types, .normal);
-        const f = o.llvm_module.addFunction(fn_name.toSlice(&o.builder).?, fn_type.toLlvm(&o.builder));
+        const f = o.llvm_module.addFunction(fn_name.slice(&o.builder).?, fn_type.toLlvm(&o.builder));
         var global = Builder.Global{
             .type = fn_type,
 @@ -7942,20 +8119,15 @@ pub const FuncGen = struct {
             return self.wip.icmp(int_cond, result, zero_vector, "");
         }
-        const llvm_fn_ty = libc_fn.typeOf(&o.builder);
+        const result = try self.wip.call(
-        const llvm_params = [2]*llvm.Value{ params[0].toLlvm(&self.wip), params[1].toLlvm(&self.wip) };
+            .normal,
-        const result = (try self.wip.unimplemented(
+            .ccc,
-            llvm_fn_ty.functionReturn(&o.builder),
+            .none,
-            "",
+            libc_fn.typeOf(&o.builder),
-        )).finish(self.builder.buildCall(
+            libc_fn.toValue(&o.builder),
-            libc_fn.typeOf(&o.builder).toLlvm(&o.builder),
+            &params,
-            libc_fn.toLlvm(&o.builder),
-            &llvm_params,
-            llvm_params.len,
-            .C,
-            .Auto,
             "",
-        ), &self.wip);
+        );
         return self.wip.icmp(int_cond, result, zero.toValue(), "");
     }
 @@ -8085,7 +8257,7 @@ pub const FuncGen = struct {
         );
         var llvm_params: [params_len]*llvm.Value = undefined;
         for (&llvm_params, params) |*llvm_param, param| llvm_param.* = param.toLlvm(&self.wip);
-        return (try self.wip.unimplemented(llvm_ty, "")).finish(self.builder.buildCall(
+        return (try self.wip.unimplemented(llvm_ty, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             llvm_fn,
             &llvm_params,
 @@ -8311,17 +8483,16 @@ pub const FuncGen = struct {
                 compilerRtFloatAbbrev(src_bits), compilerRtFloatAbbrev(dest_bits),
             });
-            const llvm_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, dest_llvm_ty);
+            const libc_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, dest_llvm_ty);
-            const params = [1]*llvm.Value{operand.toLlvm(&self.wip)};
+            return self.wip.call(
-            return (try self.wip.unimplemented(dest_llvm_ty, "")).finish(self.builder.buildCall(
+                .normal,
-                llvm_fn.typeOf(&o.builder).toLlvm(&o.builder),
+                .ccc,
-                llvm_fn.toLlvm(&o.builder),
+                .none,
-                &params,
+                libc_fn.typeOf(&o.builder),
-                params.len,
+                libc_fn.toValue(&o.builder),
-                .C,
+                &.{operand},
-                .Auto,
                 "",
-            ), &self.wip);
+            );
         }
     }
 @@ -8346,17 +8517,16 @@ pub const FuncGen = struct {
                 compilerRtFloatAbbrev(src_bits), compilerRtFloatAbbrev(dest_bits),
             });
-            const llvm_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, dest_llvm_ty);
+            const libc_fn = try self.getLibcFunction(fn_name, &.{operand_llvm_ty}, dest_llvm_ty);
-            const params = [1]*llvm.Value{operand.toLlvm(&self.wip)};
+            return self.wip.call(
-            return (try self.wip.unimplemented(dest_llvm_ty, "")).finish(self.builder.buildCall(
+                .normal,
-                llvm_fn.typeOf(&o.builder).toLlvm(&o.builder),
+                .ccc,
-                llvm_fn.toLlvm(&o.builder),
+                .none,
-                &params,
+                libc_fn.typeOf(&o.builder),
-                params.len,
+                libc_fn.toValue(&o.builder),
-                .C,
+                &.{operand},
-                .Auto,
                 "",
-            ), &self.wip);
+            );
         }
     }
 @@ -8657,7 +8827,7 @@ pub const FuncGen = struct {
         _ = inst;
         const o = self.dg.object;
         const llvm_fn = try self.getIntrinsic("llvm.trap", &.{});
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.void, &.{}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             undefined,
 @@ -8674,7 +8844,7 @@ pub const FuncGen = struct {
         _ = inst;
         const o = self.dg.object;
         const llvm_fn = try self.getIntrinsic("llvm.debugtrap", &.{});
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.void, &.{}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             undefined,
 @@ -8701,7 +8871,7 @@ pub const FuncGen = struct {
         const params = [_]*llvm.Value{
             (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
         };
-        const ptr_val = (try self.wip.unimplemented(.ptr, "")).finish(self.builder.buildCall(
+        const ptr_val = (try self.wip.unimplemented(.ptr, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.ptr, &.{.i32}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             &params,
 @@ -8727,7 +8897,7 @@ pub const FuncGen = struct {
             (try o.builder.intConst(.i32, 0)).toLlvm(&o.builder),
         };
         const ptr_val = (try self.wip.unimplemented(llvm_fn_ty.functionReturn(&o.builder), "")).finish(
-            self.builder.buildCall(
+            self.builder.buildCallOld(
                 llvm_fn_ty.toLlvm(&o.builder),
                 llvm_fn,
                 &params,
 @@ -9256,7 +9426,7 @@ pub const FuncGen = struct {
             Builder.Constant.false.toLlvm(&o.builder),
         };
         const wrong_size_result = (try self.wip.unimplemented(llvm_operand_ty, "")).finish(
-            self.builder.buildCall(
+            self.builder.buildCallOld(
                 llvm_fn_ty.toLlvm(&o.builder),
                 fn_val,
                 &params,
 @@ -9283,7 +9453,7 @@ pub const FuncGen = struct {
         const params = [_]*llvm.Value{operand.toLlvm(&self.wip)};
         const wrong_size_result = (try self.wip.unimplemented(llvm_operand_ty, "")).finish(
-            self.builder.buildCall(
+            self.builder.buildCallOld(
                 llvm_fn_ty.toLlvm(&o.builder),
                 fn_val,
                 &params,
 @@ -9331,7 +9501,7 @@ pub const FuncGen = struct {
         const params = [_]*llvm.Value{operand.toLlvm(&self.wip)};
         const wrong_size_result = (try self.wip.unimplemented(llvm_operand_ty, "")).finish(
-            self.builder.buildCall(
+            self.builder.buildCallOld(
                 llvm_fn_ty.toLlvm(&o.builder),
                 fn_val,
                 &params,
 @@ -9389,16 +9559,15 @@ pub const FuncGen = struct {
         const enum_ty = self.typeOf(un_op);
         const llvm_fn = try self.getIsNamedEnumValueFunction(enum_ty);
-        const params = [_]*llvm.Value{operand.toLlvm(&self.wip)};
+        return self.wip.call(
-        return (try self.wip.unimplemented(.i1, "")).finish(self.builder.buildCall(
+            .normal,
-            llvm_fn.typeOf(&o.builder).toLlvm(&o.builder),
+            .fastcc,
-            llvm_fn.toLlvm(&o.builder),
+            .none,
-            &params,
+            llvm_fn.typeOf(&o.builder),
-            params.len,
+            llvm_fn.toValue(&o.builder),
-            .Fast,
+            &.{operand},
-            .Auto,
             "",
-        ), &self.wip);
+        );
     }
     fn getIsNamedEnumValueFunction(self: *FuncGen, enum_ty: Type) !Builder.Function.Index {
 @@ -9416,13 +9585,16 @@ pub const FuncGen = struct {
             fqn.fmt(&mod.intern_pool),
         });
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         const fn_type = try o.builder.fnType(.i1, &.{
             try o.lowerType(enum_type.tag_ty.toType()),
         }, .normal);
-        const fn_val = o.llvm_module.addFunction(llvm_fn_name.toSlice(&o.builder).?, fn_type.toLlvm(&o.builder));
+        const fn_val = o.llvm_module.addFunction(llvm_fn_name.slice(&o.builder).?, fn_type.toLlvm(&o.builder));
         fn_val.setLinkage(.Internal);
         fn_val.setFunctionCallConv(.Fast);
-        o.addCommonFnAttributes(fn_val);
+        try o.addCommonFnAttributes(&attributes, fn_val);
         var global = Builder.Global{
             .linkage = .internal,
 @@ -9431,6 +9603,8 @@ pub const FuncGen = struct {
         };
         var function = Builder.Function{
             .global = @enumFromInt(o.builder.globals.count()),
+            .call_conv = .fastcc,
+            .attributes = try attributes.finish(&o.builder),
         };
         try o.builder.llvm.globals.append(self.gpa, fn_val);
         _ = try o.builder.addGlobal(llvm_fn_name, global);
 @@ -9470,19 +9644,14 @@ pub const FuncGen = struct {
         const enum_ty = self.typeOf(un_op);
         const llvm_fn = try self.getEnumTagNameFunction(enum_ty);
-        const llvm_fn_ty = llvm_fn.typeOf(&o.builder);
+        return self.wip.call(
-        const params = [_]*llvm.Value{operand.toLlvm(&self.wip)};
+            .normal,
-        return (try self.wip.unimplemented(llvm_fn_ty.functionReturn(&o.builder), "")).finish(
+            .fastcc,
-            self.builder.buildCall(
+            .none,
-                llvm_fn_ty.toLlvm(&o.builder),
+            llvm_fn.typeOf(&o.builder),
-                llvm_fn.toLlvm(&o.builder),
+            llvm_fn.toValue(&o.builder),
-                &params,
+            &.{operand},
-                params.len,
+            "",
-                .Fast,
-                .Auto,
-                "",
-            ),
-            &self.wip,
         );
     }
 @@ -9499,16 +9668,19 @@ pub const FuncGen = struct {
         const fqn = try mod.declPtr(enum_type.decl).getFullyQualifiedName(mod);
         const llvm_fn_name = try o.builder.fmt("__zig_tag_name_{}", .{fqn.fmt(&mod.intern_pool)});
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         const ret_ty = try o.lowerType(Type.slice_const_u8_sentinel_0);
         const usize_ty = try o.lowerType(Type.usize);
         const fn_type = try o.builder.fnType(ret_ty, &.{
             try o.lowerType(enum_type.tag_ty.toType()),
         }, .normal);
-        const fn_val = o.llvm_module.addFunction(llvm_fn_name.toSlice(&o.builder).?, fn_type.toLlvm(&o.builder));
+        const fn_val = o.llvm_module.addFunction(llvm_fn_name.slice(&o.builder).?, fn_type.toLlvm(&o.builder));
         fn_val.setLinkage(.Internal);
         fn_val.setFunctionCallConv(.Fast);
-        o.addCommonFnAttributes(fn_val);
+        try o.addCommonFnAttributes(&attributes, fn_val);
         var global = Builder.Global{
             .linkage = .internal,
 @@ -9517,6 +9689,8 @@ pub const FuncGen = struct {
         };
         var function = Builder.Function{
             .global = @enumFromInt(o.builder.globals.count()),
+            .call_conv = .fastcc,
+            .attributes = try attributes.finish(&o.builder),
         };
         try o.builder.llvm.globals.append(self.gpa, fn_val);
         gop.value_ptr.* = try o.builder.addGlobal(llvm_fn_name, global);
 @@ -9561,7 +9735,7 @@ pub const FuncGen = struct {
             const slice_val = try o.builder.structValue(ret_ty, &.{
                 global_index.toConst(),
-                try o.builder.intConst(usize_ty, name.toSlice(&o.builder).?.len),
+                try o.builder.intConst(usize_ty, name.slice(&o.builder).?.len),
             });
             const return_block = try wip.block(1, "Name");
 @@ -9590,11 +9764,14 @@ pub const FuncGen = struct {
         // Function signature: fn (anyerror) bool
         const fn_type = try o.builder.fnType(.i1, &.{Builder.Type.err_int}, .normal);
-        const llvm_fn = o.llvm_module.addFunction(name.toSlice(&o.builder).?, fn_type.toLlvm(&o.builder));
+        const llvm_fn = o.llvm_module.addFunction(name.slice(&o.builder).?, fn_type.toLlvm(&o.builder));
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         llvm_fn.setLinkage(.Internal);
         llvm_fn.setFunctionCallConv(.Fast);
-        o.addCommonFnAttributes(llvm_fn);
+        try o.addCommonFnAttributes(&attributes, llvm_fn);
         var global = Builder.Global{
             .linkage = .internal,
 @@ -9603,6 +9780,8 @@ pub const FuncGen = struct {
         };
         var function = Builder.Function{
             .global = @enumFromInt(o.builder.globals.count()),
+            .call_conv = .fastcc,
+            .attributes = try attributes.finish(&o.builder),
         };
         try o.builder.llvm.globals.append(self.gpa, llvm_fn);
 @@ -9731,18 +9910,14 @@ pub const FuncGen = struct {
                 // accum = f(accum, vec[i]);
                 const accum = try self.wip.load(.normal, llvm_result_ty, accum_ptr, .default, "");
                 const element = try self.wip.extractElement(operand_vector, i, "");
-                const params = [2]*llvm.Value{ accum.toLlvm(&self.wip), element.toLlvm(&self.wip) };
+                const new_accum = try self.wip.call(
-                const new_accum = (try self.wip.unimplemented(llvm_result_ty, "")).finish(
+                    .normal,
-                    self.builder.buildCall(
+                    .ccc,
-                        llvm_fn.typeOf(&o.builder).toLlvm(&o.builder),
+                    .none,
-                        llvm_fn.toLlvm(&o.builder),
+                    llvm_fn.typeOf(&o.builder),
-                        &params,
+                    llvm_fn.toValue(&o.builder),
-                        params.len,
+                    &.{ accum, element },
-                        .C,
+                    "",
-                        .Auto,
-                        "",
-                    ),
-                    &self.wip,
                 );
                 _ = try self.wip.store(.normal, new_accum, accum_ptr, .default);
 @@ -10190,7 +10365,7 @@ pub const FuncGen = struct {
             (try o.builder.intConst(.i32, prefetch.locality)).toLlvm(&o.builder),
             (try o.builder.intConst(.i32, @intFromEnum(prefetch.cache))).toLlvm(&o.builder),
         };
-        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCall(
+        _ = (try self.wip.unimplemented(.void, "")).finish(self.builder.buildCallOld(
             llvm_fn_ty.toLlvm(&o.builder),
             fn_val,
             &params,
 @@ -10222,7 +10397,7 @@ pub const FuncGen = struct {
         const args: [0]*llvm.Value = .{};
         const llvm_fn = try self.getIntrinsic(llvm_fn_name, &.{});
-        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCall(
+        return (try self.wip.unimplemented(.i32, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(.i32, &.{}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -10252,12 +10427,15 @@ pub const FuncGen = struct {
         const dimension = pl_op.payload;
         if (dimension >= 3) return o.builder.intValue(.i32, 1);
+        var attributes: Builder.FunctionAttributes.Wip = .{};
+        defer attributes.deinit(&o.builder);
         // Fetch the dispatch pointer, which points to this structure:
         // https://github.com/RadeonOpenCompute/ROCR-Runtime/blob/adae6c61e10d371f7cbc3d0e94ae2c070cab18a4/src/inc/hsa.h#L2913
         const llvm_fn = try self.getIntrinsic("llvm.amdgcn.dispatch.ptr", &.{});
         const args: [0]*llvm.Value = .{};
         const llvm_ret_ty = try o.builder.ptrType(Builder.AddrSpace.amdgpu.constant);
-        const dispatch_ptr = (try self.wip.unimplemented(llvm_ret_ty, "")).finish(self.builder.buildCall(
+        const dispatch_ptr = (try self.wip.unimplemented(llvm_ret_ty, "")).finish(self.builder.buildCallOld(
             (try o.builder.fnType(llvm_ret_ty, &.{}, .normal)).toLlvm(&o.builder),
             llvm_fn,
             &args,
 @@ -10266,6 +10444,9 @@ pub const FuncGen = struct {
             .Auto,
             "",
         ), &self.wip);
+        try attributes.addRetAttr(.{
+            .@"align" = comptime Builder.Alignment.fromByteUnits(4),
+        }, &o.builder);
         o.addAttrInt(dispatch_ptr.toLlvm(&self.wip), 0, "align", 4);
         // Load the work_group_* member from the struct as u16.
 @@ -10298,7 +10479,7 @@ pub const FuncGen = struct {
         const undef_init = try o.builder.undefConst(.ptr); // TODO: Address space
         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).?);
+        const error_name_table_global = o.llvm_module.addGlobal(Builder.Type.ptr.toLlvm(&o.builder), name.slice(&o.builder).?);
         error_name_table_global.setInitializer(undef_init.toLlvm(&o.builder));
         error_name_table_global.setLinkage(.Private);
         error_name_table_global.setGlobalConstant(.True);
 @@ -10751,7 +10932,7 @@ pub const FuncGen = struct {
         );
         const call = (try fg.wip.unimplemented(llvm_usize, "")).finish(
-            fg.builder.buildCall(fn_llvm_ty, asm_fn, &args, args.len, .C, .Auto, ""),
+            fg.builder.buildCallOld(fn_llvm_ty, asm_fn, &args, args.len, .C, .Auto, ""),
             &fg.wip,
         );
         return call;
 @@ -10991,33 +11172,33 @@ fn toLlvmAtomicRmwBinOp(
     };
 }
-fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) llvm.CallConv {
+fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) Builder.CallConv {
     return switch (cc) {
-        .Unspecified, .Inline, .Async => .Fast,
+        .Unspecified, .Inline, .Async => .fastcc,
-        .C, .Naked => .C,
+        .C, .Naked => .ccc,
-        .Stdcall => .X86_StdCall,
+        .Stdcall => .x86_stdcallcc,
-        .Fastcall => .X86_FastCall,
+        .Fastcall => .x86_fastcallcc,
         .Vectorcall => return switch (target.cpu.arch) {
-            .x86, .x86_64 => .X86_VectorCall,
+            .x86, .x86_64 => .x86_vectorcallcc,
-            .aarch64, .aarch64_be, .aarch64_32 => .AArch64_VectorCall,
+            .aarch64, .aarch64_be, .aarch64_32 => .aarch64_vector_pcs,
             else => unreachable,
         },
-        .Thiscall => .X86_ThisCall,
+        .Thiscall => .x86_thiscallcc,
-        .APCS => .ARM_APCS,
+        .APCS => .arm_apcscc,
-        .AAPCS => .ARM_AAPCS,
+        .AAPCS => .arm_aapcscc,
-        .AAPCSVFP => .ARM_AAPCS_VFP,
+        .AAPCSVFP => .arm_aapcs_vfpcc,
         .Interrupt => return switch (target.cpu.arch) {
-            .x86, .x86_64 => .X86_INTR,
+            .x86, .x86_64 => .x86_intrcc,
-            .avr => .AVR_INTR,
+            .avr => .avr_intrcc,
-            .msp430 => .MSP430_INTR,
+            .msp430 => .msp430_intrcc,
             else => unreachable,
         },
-        .Signal => .AVR_SIGNAL,
+        .Signal => .avr_signalcc,
-        .SysV => .X86_64_SysV,
+        .SysV => .x86_64_sysvcc,
-        .Win64 => .Win64,
+        .Win64 => .win64cc,
         .Kernel => return switch (target.cpu.arch) {
-            .nvptx, .nvptx64 => .PTX_Kernel,
+            .nvptx, .nvptx64 => .ptx_kernel,
-            .amdgcn => .AMDGPU_KERNEL,
+            .amdgcn => .amdgpu_kernel,
             else => unreachable,
         },
     };

src/codegen/llvm/Builder.zig+1395-52

...	@@ -4,13 +4,15 @@ strip: bool,	...	@@ -4,13 +4,15 @@ strip: bool,
4		4
5	llvm: if (build_options.have_llvm) struct {	5	llvm: if (build_options.have_llvm) struct {
6	context: *llvm.Context,	6	context: *llvm.Context,
7	module: ?*llvm.Module = null,	7	module: ?*llvm.Module,
8	target: ?*llvm.Target = null,	8	target: ?*llvm.Target,
9	di_builder: ?*llvm.DIBuilder = null,	9	di_builder: ?*llvm.DIBuilder,
10	di_compile_unit: ?*llvm.DICompileUnit = null,	10	di_compile_unit: ?*llvm.DICompileUnit,
11	types: std.ArrayListUnmanaged(*llvm.Type) = .{},	11	attribute_kind_ids: ?*[Attribute.Kind.len]c_uint,
12	globals: std.ArrayListUnmanaged(*llvm.Value) = .{},	12	attributes: std.ArrayListUnmanaged(*llvm.Attribute),
13	constants: std.ArrayListUnmanaged(*llvm.Value) = .{},	13	types: std.ArrayListUnmanaged(*llvm.Type),
		14	globals: std.ArrayListUnmanaged(*llvm.Value),
		15	constants: std.ArrayListUnmanaged(*llvm.Value),
14	} else void,	16	} else void,
15		17
16	source_filename: String,	18	source_filename: String,
...	@@ -18,8 +20,8 @@ data_layout: String,	...	@@ -18,8 +20,8 @@ data_layout: String,
18	target_triple: String,	20	target_triple: String,
19		21
20	string_map: std.AutoArrayHashMapUnmanaged(void, void),	22	string_map: std.AutoArrayHashMapUnmanaged(void, void),
21	string_bytes: std.ArrayListUnmanaged(u8),
22	string_indices: std.ArrayListUnmanaged(u32),	23	string_indices: std.ArrayListUnmanaged(u32),
		24	string_bytes: std.ArrayListUnmanaged(u8),
23		25
24	types: std.AutoArrayHashMapUnmanaged(String, Type),	26	types: std.AutoArrayHashMapUnmanaged(String, Type),
25	next_unnamed_type: String,	27	next_unnamed_type: String,
...	@@ -28,6 +30,11 @@ type_map: std.AutoArrayHashMapUnmanaged(void, void),	...	@@ -28,6 +30,11 @@ type_map: std.AutoArrayHashMapUnmanaged(void, void),
28	type_items: std.ArrayListUnmanaged(Type.Item),	30	type_items: std.ArrayListUnmanaged(Type.Item),
29	type_extra: std.ArrayListUnmanaged(u32),	31	type_extra: std.ArrayListUnmanaged(u32),
30		32
		33	attributes: std.AutoArrayHashMapUnmanaged(Attribute.Storage, void),
		34	attributes_map: std.AutoArrayHashMapUnmanaged(void, void),
		35	attributes_indices: std.ArrayListUnmanaged(u32),
		36	attributes_extra: std.ArrayListUnmanaged(u32),
		37
31	globals: std.AutoArrayHashMapUnmanaged(String, Global),	38	globals: std.AutoArrayHashMapUnmanaged(String, Global),
32	next_unnamed_global: String,	39	next_unnamed_global: String,
33	next_replaced_global: String,	40	next_replaced_global: String,
...	@@ -41,6 +48,7 @@ constant_items: std.MultiArrayList(Constant.Item),	...	@@ -41,6 +48,7 @@ constant_items: std.MultiArrayList(Constant.Item),
41	constant_extra: std.ArrayListUnmanaged(u32),	48	constant_extra: std.ArrayListUnmanaged(u32),
42	constant_limbs: std.ArrayListUnmanaged(std.math.big.Limb),	49	constant_limbs: std.ArrayListUnmanaged(std.math.big.Limb),
43		50
		51	pub const expected_args_len = 16;
44	pub const expected_fields_len = 32;	52	pub const expected_fields_len = 32;
45	pub const expected_gep_indices_len = 8;	53	pub const expected_gep_indices_len = 8;
46	pub const expected_cases_len = 8;	54	pub const expected_cases_len = 8;
...	@@ -65,7 +73,7 @@ pub const String = enum(u32) {	...	@@ -65,7 +73,7 @@ pub const String = enum(u32) {
65	return self.toIndex() == null;	73	return self.toIndex() == null;
66	}	74	}
67		75
68	pub fn toSlice(self: String, b: *const Builder) ?[:0]const u8 {	76	pub fn slice(self: String, b: *const Builder) ?[:0]const u8 {
69	const index = self.toIndex() orelse return null;	77	const index = self.toIndex() orelse return null;
70	const start = b.string_indices.items[index];	78	const start = b.string_indices.items[index];
71	const end = b.string_indices.items[index + 1];	79	const end = b.string_indices.items[index + 1];
...	@@ -85,9 +93,9 @@ pub const String = enum(u32) {	...	@@ -85,9 +93,9 @@ pub const String = enum(u32) {
85	if (comptime std.mem.indexOfNone(u8, fmt_str, "@\"")) \|_\|	93	if (comptime std.mem.indexOfNone(u8, fmt_str, "@\"")) \|_\|
86	@compileError("invalid format string: '" ++ fmt_str ++ "'");	94	@compileError("invalid format string: '" ++ fmt_str ++ "'");
87	assert(data.string != .none);	95	assert(data.string != .none);
88	const slice = data.string.toSlice(data.builder) orelse	96	const sentinel_slice = data.string.slice(data.builder) orelse
89	return writer.print("{d}", .{@intFromEnum(data.string)});	97	return writer.print("{d}", .{@intFromEnum(data.string)});
90	const full_slice = slice[0 .. slice.len + comptime @intFromBool(	98	const full_slice = sentinel_slice[0 .. sentinel_slice.len + comptime @intFromBool(
91	std.mem.indexOfScalar(u8, fmt_str, '@') != null,	99	std.mem.indexOfScalar(u8, fmt_str, '@') != null,
92	)];	100	)];
93	const need_quotes = (comptime std.mem.indexOfScalar(u8, fmt_str, '"') != null) or	101	const need_quotes = (comptime std.mem.indexOfScalar(u8, fmt_str, '"') != null) or
...	@@ -108,6 +116,7 @@ pub const String = enum(u32) {	...	@@ -108,6 +116,7 @@ pub const String = enum(u32) {
108	return @enumFromInt(@as(u32, @intCast((index orelse return .none) +	116	return @enumFromInt(@as(u32, @intCast((index orelse return .none) +
109	@intFromEnum(String.empty))));	117	@intFromEnum(String.empty))));
110	}	118	}
		119
111	fn toIndex(self: String) ?usize {	120	fn toIndex(self: String) ?usize {
112	return std.math.sub(u32, @intFromEnum(self), @intFromEnum(String.empty)) catch null;	121	return std.math.sub(u32, @intFromEnum(self), @intFromEnum(String.empty)) catch null;
113	}	122	}
...	@@ -118,7 +127,7 @@ pub const String = enum(u32) {	...	@@ -118,7 +127,7 @@ pub const String = enum(u32) {
118	return @truncate(std.hash.Wyhash.hash(0, key));	127	return @truncate(std.hash.Wyhash.hash(0, key));
119	}	128	}
120	pub fn eql(ctx: Adapter, lhs_key: []const u8, _: void, rhs_index: usize) bool {	129	pub fn eql(ctx: Adapter, lhs_key: []const u8, _: void, rhs_index: usize) bool {
121	return std.mem.eql(u8, lhs_key, String.fromIndex(rhs_index).toSlice(ctx.builder).?);	130	return std.mem.eql(u8, lhs_key, String.fromIndex(rhs_index).slice(ctx.builder).?);
122	}	131	}
123	};	132	};
124	};	133	};
...	@@ -290,6 +299,17 @@ pub const Type = enum(u32) {	...	@@ -290,6 +299,17 @@ pub const Type = enum(u32) {
290	};	299	};
291	}	300	}
292		301
		302	pub fn pointerAddrSpace(self: Type, builder: *const Builder) AddrSpace {
		303	switch (self) {
		304	.ptr => return .default,
		305	else => {
		306	const item = builder.type_items.items[@intFromEnum(self)];
		307	assert(item.tag == .pointer);
		308	return @enumFromInt(item.data);
		309	},
		310	}
		311	}
		312
293	pub fn isFunction(self: Type, builder: *const Builder) bool {	313	pub fn isFunction(self: Type, builder: *const Builder) bool {
294	return switch (self.tag(builder)) {	314	return switch (self.tag(builder)) {
295	.function, .vararg_function => true,	315	.function, .vararg_function => true,
...	@@ -606,7 +626,7 @@ pub const Type = enum(u32) {	...	@@ -606,7 +626,7 @@ pub const Type = enum(u32) {
606	var extra = data.builder.typeExtraDataTrail(Type.Target, item.data);	626	var extra = data.builder.typeExtraDataTrail(Type.Target, item.data);
607	const types = extra.trail.next(extra.data.types_len, Type, data.builder);	627	const types = extra.trail.next(extra.data.types_len, Type, data.builder);
608	const ints = extra.trail.next(extra.data.ints_len, u32, data.builder);	628	const ints = extra.trail.next(extra.data.ints_len, u32, data.builder);
609	try writer.print("t{s}", .{extra.data.name.toSlice(data.builder).?});	629	try writer.print("t{s}", .{extra.data.name.slice(data.builder).?});
610	for (types) \|ty\| try writer.print("_{m}", .{ty.fmt(data.builder)});	630	for (types) \|ty\| try writer.print("_{m}", .{ty.fmt(data.builder)});
611	for (ints) \|int\| try writer.print("_{d}", .{int});	631	for (ints) \|int\| try writer.print("_{d}", .{int});
612	try writer.writeByte('t');	632	try writer.writeByte('t');
...	@@ -641,7 +661,7 @@ pub const Type = enum(u32) {	...	@@ -641,7 +661,7 @@ pub const Type = enum(u32) {
641	.named_structure => {	661	.named_structure => {
642	const extra = data.builder.typeExtraData(Type.NamedStructure, item.data);	662	const extra = data.builder.typeExtraData(Type.NamedStructure, item.data);
643	try writer.writeAll("s_");	663	try writer.writeAll("s_");
644	if (extra.id.toSlice(data.builder)) \|id\| try writer.writeAll(id);	664	if (extra.id.slice(data.builder)) \|id\| try writer.writeAll(id);
645	},	665	},
646	}	666	}
647	return;	667	return;
...	@@ -823,6 +843,789 @@ pub const Type = enum(u32) {	...	@@ -823,6 +843,789 @@ pub const Type = enum(u32) {
823	}	843	}
824	};	844	};
825		845
		846	pub const Attribute = union(Kind) {
		847	// Parameter Attributes
		848	zeroext,
		849	signext,
		850	inreg,
		851	byval: Type,
		852	byref: Type,
		853	preallocated: Type,
		854	inalloca: Type,
		855	sret: Type,
		856	elementtype: Type,
		857	@"align": Alignment,
		858	@"noalias",
		859	nocapture,
		860	nofree,
		861	nest,
		862	returned,
		863	nonnull,
		864	dereferenceable: u32,
		865	dereferenceable_or_null: u32,
		866	swiftself,
		867	swiftasync,
		868	swifterror,
		869	immarg,
		870	noundef,
		871	nofpclass: FpClass,
		872	alignstack: Alignment,
		873	allocalign,
		874	allocptr,
		875	readnone,
		876	readonly,
		877	writeonly,
		878
		879	// Function Attributes
		880	//alignstack: Alignment,
		881	allockind: AllocKind,
		882	allocsize: AllocSize,
		883	alwaysinline,
		884	builtin,
		885	cold,
		886	convergent,
		887	disable_sanitizer_information,
		888	fn_ret_thunk_extern,
		889	hot,
		890	inlinehint,
		891	jumptable,
		892	memory: Memory,
		893	minsize,
		894	naked,
		895	nobuiltin,
		896	nocallback,
		897	noduplicate,
		898	//nofree,
		899	noimplicitfloat,
		900	@"noinline",
		901	nomerge,
		902	nonlazybind,
		903	noprofile,
		904	skipprofile,
		905	noredzone,
		906	noreturn,
		907	norecurse,
		908	willreturn,
		909	nosync,
		910	nounwind,
		911	nosanitize_bounds,
		912	nosanitize_coverage,
		913	null_pointer_is_valid,
		914	optforfuzzing,
		915	optnone,
		916	optsize,
		917	//preallocated: Type,
		918	returns_twice,
		919	safestack,
		920	sanitize_address,
		921	sanitize_memory,
		922	sanitize_thread,
		923	sanitize_hwaddress,
		924	sanitize_memtag,
		925	speculative_load_hardening,
		926	speculatable,
		927	ssp,
		928	sspstrong,
		929	sspreq,
		930	strictfp,
		931	uwtable: UwTable,
		932	nocf_check,
		933	shadowcallstack,
		934	mustprogress,
		935	vscale_range: VScaleRange,
		936
		937	// Global Attributes
		938	no_sanitize_address,
		939	no_sanitize_hwaddress,
		940	//sanitize_memtag,
		941	sanitize_address_dyninit,
		942
		943	string: struct { kind: String, value: String },
		944	none: noreturn,
		945
		946	pub const Index = enum(u32) {
		947	_,
		948
		949	pub fn getKind(self: Index, builder: *const Builder) Kind {
		950	return self.toStorage(builder).kind;
		951	}
		952
		953	pub fn toAttribute(self: Index, builder: *const Builder) Attribute {
		954	@setEvalBranchQuota(2_000);
		955	const storage = self.toStorage(builder);
		956	if (storage.kind.toString()) \|kind\| return .{ .string = .{
		957	.kind = kind,
		958	.value = @enumFromInt(storage.value),
		959	} } else return switch (storage.kind) {
		960	inline .zeroext,
		961	.signext,
		962	.inreg,
		963	.byval,
		964	.byref,
		965	.preallocated,
		966	.inalloca,
		967	.sret,
		968	.elementtype,
		969	.@"align",
		970	.@"noalias",
		971	.nocapture,
		972	.nofree,
		973	.nest,
		974	.returned,
		975	.nonnull,
		976	.dereferenceable,
		977	.dereferenceable_or_null,
		978	.swiftself,
		979	.swiftasync,
		980	.swifterror,
		981	.immarg,
		982	.noundef,
		983	.nofpclass,
		984	.alignstack,
		985	.allocalign,
		986	.allocptr,
		987	.readnone,
		988	.readonly,
		989	.writeonly,
		990	//.alignstack,
		991	.allockind,
		992	.allocsize,
		993	.alwaysinline,
		994	.builtin,
		995	.cold,
		996	.convergent,
		997	.disable_sanitizer_information,
		998	.fn_ret_thunk_extern,
		999	.hot,
		1000	.inlinehint,
		1001	.jumptable,
		1002	.memory,
		1003	.minsize,
		1004	.naked,
		1005	.nobuiltin,
		1006	.nocallback,
		1007	.noduplicate,
		1008	//.nofree,
		1009	.noimplicitfloat,
		1010	.@"noinline",
		1011	.nomerge,
		1012	.nonlazybind,
		1013	.noprofile,
		1014	.skipprofile,
		1015	.noredzone,
		1016	.noreturn,
		1017	.norecurse,
		1018	.willreturn,
		1019	.nosync,
		1020	.nounwind,
		1021	.nosanitize_bounds,
		1022	.nosanitize_coverage,
		1023	.null_pointer_is_valid,
		1024	.optforfuzzing,
		1025	.optnone,
		1026	.optsize,
		1027	//.preallocated,
		1028	.returns_twice,
		1029	.safestack,
		1030	.sanitize_address,
		1031	.sanitize_memory,
		1032	.sanitize_thread,
		1033	.sanitize_hwaddress,
		1034	.sanitize_memtag,
		1035	.speculative_load_hardening,
		1036	.speculatable,
		1037	.ssp,
		1038	.sspstrong,
		1039	.sspreq,
		1040	.strictfp,
		1041	.uwtable,
		1042	.nocf_check,
		1043	.shadowcallstack,
		1044	.mustprogress,
		1045	.vscale_range,
		1046	.no_sanitize_address,
		1047	.no_sanitize_hwaddress,
		1048	.sanitize_address_dyninit,
		1049	=> \|kind\| {
		1050	const field = @typeInfo(Attribute).Union.fields[@intFromEnum(kind)];
		1051	comptime assert(std.mem.eql(u8, @tagName(kind), field.name));
		1052	return @unionInit(Attribute, field.name, switch (field.type) {
		1053	void => {},
		1054	u32 => storage.value,
		1055	Alignment, String, Type, UwTable => @enumFromInt(storage.value),
		1056	AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(storage.value),
		1057	else => @compileError("bad payload type: " ++ @typeName(field.type)),
		1058	});
		1059	},
		1060	.string, .none => unreachable,
		1061	_ => unreachable,
		1062	};
		1063	}
		1064
		1065	const FormatData = struct {
		1066	attribute_index: Index,
		1067	builder: *const Builder,
		1068	};
		1069	fn format(
		1070	data: FormatData,
		1071	comptime fmt_str: []const u8,
		1072	_: std.fmt.FormatOptions,
		1073	writer: anytype,
		1074	) @TypeOf(writer).Error!void {
		1075	if (comptime std.mem.indexOfNone(u8, fmt_str, "\"")) \|_\|
		1076	@compileError("invalid format string: '" ++ fmt_str ++ "'");
		1077	const attribute = data.attribute_index.toAttribute(data.builder);
		1078	switch (attribute) {
		1079	.zeroext,
		1080	.signext,
		1081	.inreg,
		1082	.@"noalias",
		1083	.nocapture,
		1084	.nofree,
		1085	.nest,
		1086	.returned,
		1087	.nonnull,
		1088	.swiftself,
		1089	.swiftasync,
		1090	.swifterror,
		1091	.immarg,
		1092	.noundef,
		1093	.allocalign,
		1094	.allocptr,
		1095	.readnone,
		1096	.readonly,
		1097	.writeonly,
		1098	.alwaysinline,
		1099	.builtin,
		1100	.cold,
		1101	.convergent,
		1102	.disable_sanitizer_information,
		1103	.fn_ret_thunk_extern,
		1104	.hot,
		1105	.inlinehint,
		1106	.jumptable,
		1107	.minsize,
		1108	.naked,
		1109	.nobuiltin,
		1110	.nocallback,
		1111	.noduplicate,
		1112	.noimplicitfloat,
		1113	.@"noinline",
		1114	.nomerge,
		1115	.nonlazybind,
		1116	.noprofile,
		1117	.skipprofile,
		1118	.noredzone,
		1119	.noreturn,
		1120	.norecurse,
		1121	.willreturn,
		1122	.nosync,
		1123	.nounwind,
		1124	.nosanitize_bounds,
		1125	.nosanitize_coverage,
		1126	.null_pointer_is_valid,
		1127	.optforfuzzing,
		1128	.optnone,
		1129	.optsize,
		1130	.returns_twice,
		1131	.safestack,
		1132	.sanitize_address,
		1133	.sanitize_memory,
		1134	.sanitize_thread,
		1135	.sanitize_hwaddress,
		1136	.sanitize_memtag,
		1137	.speculative_load_hardening,
		1138	.speculatable,
		1139	.ssp,
		1140	.sspstrong,
		1141	.sspreq,
		1142	.strictfp,
		1143	.nocf_check,
		1144	.shadowcallstack,
		1145	.mustprogress,
		1146	.no_sanitize_address,
		1147	.no_sanitize_hwaddress,
		1148	.sanitize_address_dyninit,
		1149	=> try writer.print(" {s}", .{@tagName(attribute)}),
		1150	.byval,
		1151	.byref,
		1152	.preallocated,
		1153	.inalloca,
		1154	.sret,
		1155	.elementtype,
		1156	=> \|ty\| try writer.print(" {s}({%})", .{ @tagName(attribute), ty.fmt(data.builder) }),
		1157	.@"align" => @panic("todo"),
		1158	.dereferenceable,
		1159	.dereferenceable_or_null,
		1160	=> @panic("todo"),
		1161	.nofpclass => @panic("todo"),
		1162	.alignstack => @panic("todo"),
		1163	.allockind => @panic("todo"),
		1164	.allocsize => @panic("todo"),
		1165	.memory => @panic("todo"),
		1166	.uwtable => @panic("todo"),
		1167	.vscale_range => @panic("todo"),
		1168	.string => \|string_attr\| if (comptime std.mem.indexOfScalar(u8, fmt_str, '"') != null) {
		1169	try writer.print(" {\"}", .{string_attr.kind.fmt(data.builder)});
		1170	if (string_attr.value != .empty)
		1171	try writer.print("={\"}", .{string_attr.value.fmt(data.builder)});
		1172	},
		1173	.none => unreachable,
		1174	}
		1175	}
		1176	pub fn fmt(self: Index, builder: *const Builder) std.fmt.Formatter(format) {
		1177	return .{ .data = .{ .attribute_index = self, .builder = builder } };
		1178	}
		1179
		1180	fn toStorage(self: Index, builder: *const Builder) Storage {
		1181	return builder.attributes.keys()[@intFromEnum(self)];
		1182	}
		1183
		1184	fn toLlvm(self: Index, builder: const Builder) llvm.Attribute {
		1185	assert(builder.useLibLlvm());
		1186	return builder.llvm.attributes.items[@intFromEnum(self)];
		1187	}
		1188	};
		1189
		1190	pub const Kind = enum(u32) {
		1191	// Parameter Attributes
		1192	zeroext,
		1193	signext,
		1194	inreg,
		1195	byval,
		1196	byref,
		1197	preallocated,
		1198	inalloca,
		1199	sret,
		1200	elementtype,
		1201	@"align",
		1202	@"noalias",
		1203	nocapture,
		1204	nofree,
		1205	nest,
		1206	returned,
		1207	nonnull,
		1208	dereferenceable,
		1209	dereferenceable_or_null,
		1210	swiftself,
		1211	swiftasync,
		1212	swifterror,
		1213	immarg,
		1214	noundef,
		1215	nofpclass,
		1216	alignstack,
		1217	allocalign,
		1218	allocptr,
		1219	readnone,
		1220	readonly,
		1221	writeonly,
		1222
		1223	// Function Attributes
		1224	//alignstack,
		1225	allockind,
		1226	allocsize,
		1227	alwaysinline,
		1228	builtin,
		1229	cold,
		1230	convergent,
		1231	disable_sanitizer_information,
		1232	fn_ret_thunk_extern,
		1233	hot,
		1234	inlinehint,
		1235	jumptable,
		1236	memory,
		1237	minsize,
		1238	naked,
		1239	nobuiltin,
		1240	nocallback,
		1241	noduplicate,
		1242	//nofree,
		1243	noimplicitfloat,
		1244	@"noinline",
		1245	nomerge,
		1246	nonlazybind,
		1247	noprofile,
		1248	skipprofile,
		1249	noredzone,
		1250	noreturn,
		1251	norecurse,
		1252	willreturn,
		1253	nosync,
		1254	nounwind,
		1255	nosanitize_bounds,
		1256	nosanitize_coverage,
		1257	null_pointer_is_valid,
		1258	optforfuzzing,
		1259	optnone,
		1260	optsize,
		1261	//preallocated,
		1262	returns_twice,
		1263	safestack,
		1264	sanitize_address,
		1265	sanitize_memory,
		1266	sanitize_thread,
		1267	sanitize_hwaddress,
		1268	sanitize_memtag,
		1269	speculative_load_hardening,
		1270	speculatable,
		1271	ssp,
		1272	sspstrong,
		1273	sspreq,
		1274	strictfp,
		1275	uwtable,
		1276	nocf_check,
		1277	shadowcallstack,
		1278	mustprogress,
		1279	vscale_range,
		1280
		1281	// Global Attributes
		1282	no_sanitize_address,
		1283	no_sanitize_hwaddress,
		1284	//sanitize_memtag,
		1285	sanitize_address_dyninit,
		1286
		1287	string = std.math.maxInt(u31) - 1,
		1288	none = std.math.maxInt(u31),
		1289	_,
		1290
		1291	pub const len = @typeInfo(Kind).Enum.fields.len - 2;
		1292
		1293	pub fn fromString(str: String) Kind {
		1294	assert(!str.isAnon());
		1295	return @enumFromInt(@intFromEnum(str));
		1296	}
		1297
		1298	fn toString(self: Kind) ?String {
		1299	const str: String = @enumFromInt(@intFromEnum(self));
		1300	return if (str.isAnon()) null else str;
		1301	}
		1302	};
		1303
		1304	pub const FpClass = packed struct(u32) {
		1305	signaling_nan: bool = false,
		1306	quiet_nan: bool = false,
		1307	negative_infinity: bool = false,
		1308	negative_normal: bool = false,
		1309	negative_subnormal: bool = false,
		1310	negative_zero: bool = false,
		1311	positive_zero: bool = false,
		1312	positive_subnormal: bool = false,
		1313	positive_normal: bool = false,
		1314	positive_infinity: bool = false,
		1315	_: u22 = 0,
		1316
		1317	pub const nan = FpClass{ .signaling_nan = true, .quiet_nan = true };
		1318	pub const inf = FpClass{ .negative_infinity = true, .positive_infinity = true };
		1319	pub const norm = FpClass{ .positive_normal = true, .negative_normal = true };
		1320	pub const sub = FpClass{ .positive_subnormal = true, .negative_subnormal = true };
		1321	pub const zero = FpClass{ .positive_zero = true, .negative_zero = true };
		1322	pub const all = FpClass{
		1323	.signaling_nan = true,
		1324	.quiet_nan = true,
		1325	.negative_infinity = true,
		1326	.negative_normal = true,
		1327	.negative_subnormal = true,
		1328	.negative_zero = true,
		1329	.positive_zero = true,
		1330	.positive_subnormal = true,
		1331	.positive_normal = true,
		1332	.positive_infinity = true,
		1333	};
		1334	pub const snan = FpClass{ .signaling_nan = true };
		1335	pub const qnan = FpClass{ .quiet_nan = true };
		1336	pub const ninf = FpClass{ .negative_infinity = true };
		1337	pub const nnorm = FpClass{ .negative_normal = true };
		1338	pub const nsub = FpClass{ .negative_subnormal = true };
		1339	pub const nzero = FpClass{ .negative_zero = true };
		1340	pub const pzero = FpClass{ .positive_zero = true };
		1341	pub const psub = FpClass{ .positive_subnormal = true };
		1342	pub const pnorm = FpClass{ .positive_normal = true };
		1343	pub const pinf = FpClass{ .positive_infinity = true };
		1344	};
		1345
		1346	pub const AllocKind = packed struct(u32) {
		1347	alloc: bool,
		1348	realloc: bool,
		1349	free: bool,
		1350	uninitialized: bool,
		1351	zeroed: bool,
		1352	aligned: bool,
		1353	_: u26 = 0,
		1354	};
		1355
		1356	pub const AllocSize = packed struct(u32) {
		1357	elem_size: u16,
		1358	num_elems: u16,
		1359
		1360	pub const none = std.math.maxInt(u16);
		1361
		1362	fn toLlvm(self: AllocSize) packed struct(u64) { num_elems: u32, elem_size: u32 } {
		1363	return .{ .num_elems = switch (self.num_elems) {
		1364	else => self.num_elems,
		1365	none => std.math.maxInt(u32),
		1366	}, .elem_size = self.elem_size };
		1367	}
		1368	};
		1369
		1370	pub const Memory = packed struct(u32) {
		1371	argmem: Effect,
		1372	inaccessiblemem: Effect,
		1373	other: Effect,
		1374	_: u26 = 0,
		1375
		1376	pub const Effect = enum(u2) { none, read, write, readwrite };
		1377	};
		1378
		1379	pub const UwTable = enum(u32) {
		1380	none,
		1381	sync,
		1382	@"async",
		1383
		1384	pub const default = UwTable.@"async";
		1385	};
		1386
		1387	pub const VScaleRange = packed struct(u32) {
		1388	min: Alignment,
		1389	max: Alignment,
		1390	_: u20 = 0,
		1391
		1392	fn toLlvm(self: VScaleRange) packed struct(u64) { max: u32, min: u32 } {
		1393	return .{
		1394	.max = @intCast(self.max.toByteUnits() orelse 0),
		1395	.min = @intCast(self.min.toByteUnits().?),
		1396	};
		1397	}
		1398	};
		1399
		1400	pub fn getKind(self: Attribute) Kind {
		1401	return switch (self) {
		1402	else => self,
		1403	.string => \|string_attr\| Kind.fromString(string_attr.kind),
		1404	};
		1405	}
		1406
		1407	const Storage = extern struct {
		1408	kind: Kind,
		1409	value: u32,
		1410	};
		1411
		1412	fn toStorage(self: Attribute) Storage {
		1413	return switch (self) {
		1414	inline else => \|value\| .{ .kind = @as(Kind, self), .value = switch (@TypeOf(value)) {
		1415	void => 0,
		1416	u32 => value,
		1417	Alignment, String, Type, UwTable => @intFromEnum(value),
		1418	AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(value),
		1419	else => @compileError("bad payload type: " ++ @typeName(@TypeOf(value))),
		1420	} },
		1421	.string => \|string_attr\| .{
		1422	.kind = Kind.fromString(string_attr.kind),
		1423	.value = @intFromEnum(string_attr.value),
		1424	},
		1425	.none => unreachable,
		1426	};
		1427	}
		1428	};
		1429
		1430	pub const Attributes = enum(u32) {
		1431	none,
		1432	_,
		1433
		1434	pub fn slice(self: Attributes, builder: *const Builder) []const Attribute.Index {
		1435	const start = builder.attributes_indices.items[@intFromEnum(self)];
		1436	const end = builder.attributes_indices.items[@intFromEnum(self) + 1];
		1437	return @ptrCast(builder.attributes_extra.items[start..end]);
		1438	}
		1439
		1440	const FormatData = struct {
		1441	attributes: Attributes,
		1442	builder: *const Builder,
		1443	};
		1444	fn format(
		1445	data: FormatData,
		1446	comptime fmt_str: []const u8,
		1447	fmt_opts: std.fmt.FormatOptions,
		1448	writer: anytype,
		1449	) @TypeOf(writer).Error!void {
		1450	for (data.attributes.slice(data.builder)) \|attribute_index\| try Attribute.Index.format(.{
		1451	.attribute_index = attribute_index,
		1452	.builder = data.builder,
		1453	}, fmt_str, fmt_opts, writer);
		1454	}
		1455	pub fn fmt(self: Attributes, builder: *const Builder) std.fmt.Formatter(format) {
		1456	return .{ .data = .{ .attributes = self, .builder = builder } };
		1457	}
		1458	};
		1459
		1460	pub const FunctionAttributes = enum(u32) {
		1461	none,
		1462	_,
		1463
		1464	const function_index = 0;
		1465	const return_index = 1;
		1466	const params_index = 2;
		1467
		1468	pub const Wip = struct {
		1469	maps: Maps = .{},
		1470
		1471	const Map = std.AutoArrayHashMapUnmanaged(Attribute.Kind, Attribute.Index);
		1472	const Maps = std.ArrayListUnmanaged(Map);
		1473
		1474	pub fn deinit(self: Wip, builder: const Builder) void {
		1475	for (self.maps.items) \|*map\| map.deinit(builder.gpa);
		1476	self.maps.deinit(builder.gpa);
		1477	self.* = undefined;
		1478	}
		1479
		1480	pub fn addFnAttr(self: Wip, attribute: Attribute, builder: Builder) Allocator.Error!void {
		1481	try self.addAttr(function_index, attribute, builder);
		1482	}
		1483
		1484	pub fn addFnAttrIndex(
		1485	self: *Wip,
		1486	attribute_index: Attribute.Index,
		1487	builder: *const Builder,
		1488	) Allocator.Error!void {
		1489	try self.addAttrIndex(function_index, attribute_index, builder);
		1490	}
		1491
		1492	pub fn removeFnAttr(self: *Wip, attribute_kind: Attribute.Kind) Allocator.Error!bool {
		1493	return self.removeAttr(function_index, attribute_kind);
		1494	}
		1495
		1496	pub fn addRetAttr(self: Wip, attribute: Attribute, builder: Builder) Allocator.Error!void {
		1497	try self.addAttr(return_index, attribute, builder);
		1498	}
		1499
		1500	pub fn addRetAttrIndex(
		1501	self: *Wip,
		1502	attribute_index: Attribute.Index,
		1503	builder: *const Builder,
		1504	) Allocator.Error!void {
		1505	try self.addAttrIndex(return_index, attribute_index, builder);
		1506	}
		1507
		1508	pub fn removeRetAttr(self: *Wip, attribute_kind: Attribute.Kind) Allocator.Error!bool {
		1509	return self.removeAttr(return_index, attribute_kind);
		1510	}
		1511
		1512	pub fn addParamAttr(
		1513	self: *Wip,
		1514	param_index: usize,
		1515	attribute: Attribute,
		1516	builder: *Builder,
		1517	) Allocator.Error!void {
		1518	try self.addAttr(params_index + param_index, attribute, builder);
		1519	}
		1520
		1521	pub fn addParamAttrIndex(
		1522	self: *Wip,
		1523	param_index: usize,
		1524	attribute_index: Attribute.Index,
		1525	builder: *const Builder,
		1526	) Allocator.Error!void {
		1527	try self.addAttrIndex(params_index + param_index, attribute_index, builder);
		1528	}
		1529
		1530	pub fn removeParamAttr(
		1531	self: *Wip,
		1532	param_index: usize,
		1533	attribute_kind: Attribute.Kind,
		1534	) Allocator.Error!bool {
		1535	return self.removeAttr(params_index + param_index, attribute_kind);
		1536	}
		1537
		1538	pub fn finish(self: const Wip, builder: Builder) Allocator.Error!FunctionAttributes {
		1539	const attributes = try builder.gpa.alloc(Attributes, self.maps.items.len);
		1540	defer builder.gpa.free(attributes);
		1541	for (attributes, self.maps.items) \|*attribute, map\|
		1542	attribute.* = try builder.attrs(map.values());
		1543	return builder.fnAttrs(attributes);
		1544	}
		1545
		1546	fn addAttr(
		1547	self: *Wip,
		1548	index: usize,
		1549	attribute: Attribute,
		1550	builder: *Builder,
		1551	) Allocator.Error!void {
		1552	const map = try self.getOrPutMap(builder.gpa, index);
		1553	try map.put(builder.gpa, attribute.getKind(), try builder.attr(attribute));
		1554	}
		1555
		1556	fn addAttrIndex(
		1557	self: *Wip,
		1558	index: usize,
		1559	attribute_index: Attribute.Index,
		1560	builder: *const Builder,
		1561	) Allocator.Error!void {
		1562	const map = try self.getOrPutMap(builder.gpa, index);
		1563	try map.put(builder.gpa, attribute_index.getKind(builder), attribute_index);
		1564	}
		1565
		1566	fn removeAttr(self: *Wip, index: usize, attribute_kind: Attribute.Kind) Allocator.Error!bool {
		1567	const map = self.getMap(index) orelse return false;
		1568	return map.swapRemove(attribute_kind);
		1569	}
		1570
		1571	fn getOrPutMap(self: Wip, allocator: Allocator, index: usize) Allocator.Error!Map {
		1572	if (index >= self.maps.items.len)
		1573	try self.maps.appendNTimes(allocator, .{}, index + 1 - self.maps.items.len);
		1574	return &self.maps.items[index];
		1575	}
		1576
		1577	fn getMap(self: Wip, index: usize) ?Map {
		1578	return if (index >= self.maps.items.len) null else &self.maps.items[index];
		1579	}
		1580
		1581	fn ensureTotalLength(self: *Wip, new_len: usize) Allocator.Error!void {
		1582	try self.maps.appendNTimes(
		1583	.{},
		1584	std.math.sub(usize, new_len, self.maps.items.len) catch return,
		1585	);
		1586	}
		1587	};
		1588
		1589	pub fn func(self: FunctionAttributes, builder: *const Builder) Attributes {
		1590	return self.get(function_index, builder);
		1591	}
		1592
		1593	pub fn ret(self: FunctionAttributes, builder: *const Builder) Attributes {
		1594	return self.get(return_index, builder);
		1595	}
		1596
		1597	pub fn param(self: FunctionAttributes, param_index: usize, builder: *const Builder) Attributes {
		1598	return self.get(params_index + param_index, builder);
		1599	}
		1600
		1601	pub fn toWip(self: FunctionAttributes, builder: *const Builder) Allocator.Error!Wip {
		1602	var wip: Wip = .{};
		1603	errdefer wip.deinit(builder);
		1604	const attributes_slice = self.slice(builder);
		1605	try wip.maps.ensureTotalCapacityPrecise(builder.gpa, attributes_slice.len);
		1606	for (attributes_slice) \|attributes\| {
		1607	const map = wip.maps.addOneAssumeCapacity();
		1608	map.* = .{};
		1609	const attribute_slice = attributes.slice(builder);
		1610	try map.ensureTotalCapacity(builder.gpa, attribute_slice.len);
		1611	for (attributes.slice(builder)) \|attribute\|
		1612	map.putAssumeCapacityNoClobber(attribute.getKind(builder), attribute);
		1613	}
		1614	return wip;
		1615	}
		1616
		1617	fn get(self: FunctionAttributes, index: usize, builder: *const Builder) Attributes {
		1618	const attribute_slice = self.slice(builder);
		1619	return if (index < attribute_slice.len) attribute_slice[index] else .none;
		1620	}
		1621
		1622	fn slice(self: FunctionAttributes, builder: *const Builder) []const Attributes {
		1623	const start = builder.attributes_indices.items[@intFromEnum(self)];
		1624	const end = builder.attributes_indices.items[@intFromEnum(self) + 1];
		1625	return @ptrCast(builder.attributes_extra.items[start..end]);
		1626	}
		1627	};
		1628
826	pub const Linkage = enum {	1629	pub const Linkage = enum {
827	external,	1630	external,
828	private,	1631	private,
...	@@ -1053,6 +1856,127 @@ pub const Alignment = enum(u6) {	...	@@ -1053,6 +1856,127 @@ pub const Alignment = enum(u6) {
1053	}	1856	}
1054	};	1857	};
1055		1858
		1859	pub const CallConv = enum(u10) {
		1860	ccc,
		1861
		1862	fastcc = 8,
		1863	coldcc,
		1864	ghccc,
		1865
		1866	webkit_jscc = 12,
		1867	anyregcc,
		1868	preserve_mostcc,
		1869	preserve_allcc,
		1870	swiftcc,
		1871	cxx_fast_tlscc,
		1872	tailcc,
		1873	cfguard_checkcc,
		1874	swifttailcc,
		1875
		1876	x86_stdcallcc = 64,
		1877	x86_fastcallcc,
		1878	arm_apcscc,
		1879	arm_aapcscc,
		1880	arm_aapcs_vfpcc,
		1881	msp430_intrcc,
		1882	x86_thiscallcc,
		1883	ptx_kernel,
		1884	ptx_device,
		1885
		1886	spir_func = 75,
		1887	spir_kernel,
		1888	intel_ocl_bicc,
		1889	x86_64_sysvcc,
		1890	win64cc,
		1891	x86_vectorcallcc,
		1892	hhvmcc,
		1893	hhvm_ccc,
		1894	x86_intrcc,
		1895	avr_intrcc,
		1896	avr_signalcc,
		1897
		1898	amdgpu_vs = 87,
		1899	amdgpu_gs,
		1900	amdgpu_ps,
		1901	amdgpu_cs,
		1902	amdgpu_kernel,
		1903	x86_regcallcc,
		1904	amdgpu_hs,
		1905
		1906	amdgpu_ls = 95,
		1907	amdgpu_es,
		1908	aarch64_vector_pcs,
		1909	aarch64_sve_vector_pcs,
		1910
		1911	amdgpu_gfx = 100,
		1912
		1913	aarch64_sme_preservemost_from_x0 = 102,
		1914	aarch64_sme_preservemost_from_x2,
		1915
		1916	_,
		1917
		1918	pub const default = CallConv.ccc;
		1919
		1920	pub fn format(
		1921	self: CallConv,
		1922	comptime _: []const u8,
		1923	_: std.fmt.FormatOptions,
		1924	writer: anytype,
		1925	) @TypeOf(writer).Error!void {
		1926	switch (self) {
		1927	.ccc => {},
		1928	.fastcc,
		1929	.coldcc,
		1930	.ghccc,
		1931	.webkit_jscc,
		1932	.anyregcc,
		1933	.preserve_mostcc,
		1934	.preserve_allcc,
		1935	.swiftcc,
		1936	.cxx_fast_tlscc,
		1937	.tailcc,
		1938	.cfguard_checkcc,
		1939	.swifttailcc,
		1940	.x86_stdcallcc,
		1941	.x86_fastcallcc,
		1942	.arm_apcscc,
		1943	.arm_aapcscc,
		1944	.arm_aapcs_vfpcc,
		1945	.msp430_intrcc,
		1946	.x86_thiscallcc,
		1947	.ptx_kernel,
		1948	.ptx_device,
		1949	.spir_func,
		1950	.spir_kernel,
		1951	.intel_ocl_bicc,
		1952	.x86_64_sysvcc,
		1953	.win64cc,
		1954	.x86_vectorcallcc,
		1955	.hhvmcc,
		1956	.hhvm_ccc,
		1957	.x86_intrcc,
		1958	.avr_intrcc,
		1959	.avr_signalcc,
		1960	.amdgpu_vs,
		1961	.amdgpu_gs,
		1962	.amdgpu_ps,
		1963	.amdgpu_cs,
		1964	.amdgpu_kernel,
		1965	.x86_regcallcc,
		1966	.amdgpu_hs,
		1967	.amdgpu_ls,
		1968	.amdgpu_es,
		1969	.aarch64_vector_pcs,
		1970	.aarch64_sve_vector_pcs,
		1971	.amdgpu_gfx,
		1972	.aarch64_sme_preservemost_from_x0,
		1973	.aarch64_sme_preservemost_from_x2,
		1974	=> try writer.print(" {s}", .{@tagName(self)}),
		1975	_ => try writer.print(" cc{d}", .{@intFromEnum(self)}),
		1976	}
		1977	}
		1978	};
		1979
1056	pub const Global = struct {	1980	pub const Global = struct {
1057	linkage: Linkage = .external,	1981	linkage: Linkage = .external,
1058	preemption: Preemption = .dso_preemptable,	1982	preemption: Preemption = .dso_preemptable,
...	@@ -1170,7 +2094,7 @@ pub const Global = struct {	...	@@ -1170,7 +2094,7 @@ pub const Global = struct {
1170	fn updateName(self: Index, builder: *const Builder) void {	2094	fn updateName(self: Index, builder: *const Builder) void {
1171	if (!builder.useLibLlvm()) return;	2095	if (!builder.useLibLlvm()) return;
1172	const index = @intFromEnum(self.unwrap(builder));	2096	const index = @intFromEnum(self.unwrap(builder));
1173	const name_slice = self.name(builder).toSlice(builder) orelse "";	2097	const name_slice = self.name(builder).slice(builder) orelse "";
1174	builder.llvm.globals.items[index].setValueName2(name_slice.ptr, name_slice.len);	2098	builder.llvm.globals.items[index].setValueName2(name_slice.ptr, name_slice.len);
1175	}	2099	}
1176		2100
...	@@ -1301,6 +2225,8 @@ pub const Variable = struct {	...	@@ -1301,6 +2225,8 @@ pub const Variable = struct {
1301		2225
1302	pub const Function = struct {	2226	pub const Function = struct {
1303	global: Global.Index,	2227	global: Global.Index,
		2228	call_conv: CallConv = CallConv.default,
		2229	attributes: FunctionAttributes = .none,
1304	section: String = .none,	2230	section: String = .none,
1305	alignment: Alignment = .default,	2231	alignment: Alignment = .default,
1306	blocks: []const Block = &.{},	2232	blocks: []const Block = &.{},
...	@@ -1364,6 +2290,8 @@ pub const Function = struct {	...	@@ -1364,6 +2290,8 @@ pub const Function = struct {
1364	block,	2290	block,
1365	br,	2291	br,
1366	br_cond,	2292	br_cond,
		2293	call,
		2294	@"call fast",
1367	extractelement,	2295	extractelement,
1368	extractvalue,	2296	extractvalue,
1369	fadd,	2297	fadd,
...	@@ -1454,6 +2382,10 @@ pub const Function = struct {	...	@@ -1454,6 +2382,10 @@ pub const Function = struct {
1454	@"mul nsw",	2382	@"mul nsw",
1455	@"mul nuw",	2383	@"mul nuw",
1456	@"mul nuw nsw",	2384	@"mul nuw nsw",
		2385	@"musttail call",
		2386	@"musttail call fast",
		2387	@"notail call",
		2388	@"notail call fast",
1457	@"or",	2389	@"or",
1458	phi,	2390	phi,
1459	@"phi fast",	2391	@"phi fast",
...	@@ -1481,6 +2413,8 @@ pub const Function = struct {	...	@@ -1481,6 +2413,8 @@ pub const Function = struct {
1481	@"sub nuw",	2413	@"sub nuw",
1482	@"sub nuw nsw",	2414	@"sub nuw nsw",
1483	@"switch",	2415	@"switch",
		2416	@"tail call",
		2417	@"tail call fast",
1484	trunc,	2418	trunc,
1485	udiv,	2419	udiv,
1486	@"udiv exact",	2420	@"udiv exact",
...	@@ -1530,6 +2464,15 @@ pub const Function = struct {	...	@@ -1530,6 +2464,15 @@ pub const Function = struct {
1530	.@"store volatile",	2464	.@"store volatile",
1531	.@"unreachable",	2465	.@"unreachable",
1532	=> false,	2466	=> false,
		2467	.call,
		2468	.@"call fast",
		2469	.@"musttail call",
		2470	.@"musttail call fast",
		2471	.@"notail call",
		2472	.@"notail call fast",
		2473	.@"tail call",
		2474	.@"tail call fast",
		2475	=> self.typeOfWip(wip) != .void,
1533	else => true,	2476	else => true,
1534	};	2477	};
1535	}	2478	}
...	@@ -1625,6 +2568,15 @@ pub const Function = struct {	...	@@ -1625,6 +2568,15 @@ pub const Function = struct {
1625	.@"switch",	2568	.@"switch",
1626	.@"unreachable",	2569	.@"unreachable",
1627	=> .none,	2570	=> .none,
		2571	.call,
		2572	.@"call fast",
		2573	.@"musttail call",
		2574	.@"musttail call fast",
		2575	.@"notail call",
		2576	.@"notail call fast",
		2577	.@"tail call",
		2578	.@"tail call fast",
		2579	=> wip.extraData(Call, instruction.data).ty.functionReturn(wip.builder),
1628	.extractelement => wip.extraData(ExtractElement, instruction.data)	2580	.extractelement => wip.extraData(ExtractElement, instruction.data)
1629	.val.typeOfWip(wip).childType(wip.builder),	2581	.val.typeOfWip(wip).childType(wip.builder),
1630	.extractvalue => {	2582	.extractvalue => {
...	@@ -1813,6 +2765,15 @@ pub const Function = struct {	...	@@ -1813,6 +2765,15 @@ pub const Function = struct {
1813	.@"switch",	2765	.@"switch",
1814	.@"unreachable",	2766	.@"unreachable",
1815	=> .none,	2767	=> .none,
		2768	.call,
		2769	.@"call fast",
		2770	.@"musttail call",
		2771	.@"musttail call fast",
		2772	.@"notail call",
		2773	.@"notail call fast",
		2774	.@"tail call",
		2775	.@"tail call fast",
		2776	=> function.extraData(Call, instruction.data).ty.functionReturn(builder),
1816	.extractelement => function.extraData(ExtractElement, instruction.data)	2777	.extractelement => function.extraData(ExtractElement, instruction.data)
1817	.val.typeOf(function_index, builder).childType(builder),	2778	.val.typeOf(function_index, builder).childType(builder),
1818	.extractvalue => {	2779	.extractvalue => {
...	@@ -1955,7 +2916,7 @@ pub const Function = struct {	...	@@ -1955,7 +2916,7 @@ pub const Function = struct {
1955	return if (wip.builder.strip)	2916	return if (wip.builder.strip)
1956	""	2917	""
1957	else	2918	else
1958	wip.names.items[@intFromEnum(self)].toSlice(wip.builder).?;	2919	wip.names.items[@intFromEnum(self)].slice(wip.builder).?;
1959	}	2920	}
1960	};	2921	};
1961		2922
...	@@ -2063,6 +3024,30 @@ pub const Function = struct {	...	@@ -2063,6 +3024,30 @@ pub const Function = struct {
2063	rhs: Value,	3024	rhs: Value,
2064	};	3025	};
2065		3026
		3027	pub const Call = struct {
		3028	info: Info,
		3029	attributes: FunctionAttributes,
		3030	ty: Type,
		3031	callee: Value,
		3032	args_len: u32,
		3033	//args: [args_len]Value,
		3034
		3035	pub const Kind = enum {
		3036	normal,
		3037	fast,
		3038	musttail,
		3039	musttail_fast,
		3040	notail,
		3041	notail_fast,
		3042	tail,
		3043	tail_fast,
		3044	};
		3045	pub const Info = packed struct(u32) {
		3046	call_conv: CallConv,
		3047	_: u22 = undefined,
		3048	};
		3049	};
		3050
2066	pub const VaArg = struct {	3051	pub const VaArg = struct {
2067	list: Value,	3052	list: Value,
2068	type: Type,	3053	type: Type,
...	@@ -2117,8 +3102,17 @@ pub const Function = struct {	...	@@ -2117,8 +3102,17 @@ pub const Function = struct {
2117	inline for (fields, self.extra[index..][0..fields.len]) \|field, value\|	3102	inline for (fields, self.extra[index..][0..fields.len]) \|field, value\|
2118	@field(result, field.name) = switch (field.type) {	3103	@field(result, field.name) = switch (field.type) {
2119	u32 => value,	3104	u32 => value,
2120	Alignment, AtomicOrdering, Block.Index, Type, Value => @enumFromInt(value),	3105	Alignment,
2121	MemoryAccessInfo, Instruction.Alloca.Info => @bitCast(value),	3106	AtomicOrdering,
		3107	Block.Index,
		3108	FunctionAttributes,
		3109	Type,
		3110	Value,
		3111	=> @enumFromInt(value),
		3112	MemoryAccessInfo,
		3113	Instruction.Alloca.Info,
		3114	Instruction.Call.Info,
		3115	=> @bitCast(value),
2122	else => @compileError("bad field type: " ++ @typeName(field.type)),	3116	else => @compileError("bad field type: " ++ @typeName(field.type)),
2123	};	3117	};
2124	return .{	3118	return .{
...	@@ -2243,7 +3237,7 @@ pub const WipFunction = struct {	...	@@ -2243,7 +3237,7 @@ pub const WipFunction = struct {
2243	if (self.builder.useLibLlvm()) self.llvm.blocks.appendAssumeCapacity(	3237	if (self.builder.useLibLlvm()) self.llvm.blocks.appendAssumeCapacity(
2244	self.builder.llvm.context.appendBasicBlock(	3238	self.builder.llvm.context.appendBasicBlock(
2245	self.function.toLlvm(self.builder),	3239	self.function.toLlvm(self.builder),
2246	final_name.toSlice(self.builder).?,	3240	final_name.slice(self.builder).?,
2247	),	3241	),
2248	);	3242	);
2249	return index;	3243	return index;
...	@@ -3162,6 +4156,88 @@ pub const WipFunction = struct {	...	@@ -3162,6 +4156,88 @@ pub const WipFunction = struct {
3162	return self.selectTag(.@"select fast", cond, lhs, rhs, name);	4156	return self.selectTag(.@"select fast", cond, lhs, rhs, name);
3163	}	4157	}
3164		4158
		4159	pub fn call(
		4160	self: *WipFunction,
		4161	kind: Instruction.Call.Kind,
		4162	call_conv: CallConv,
		4163	function_attributes: FunctionAttributes,
		4164	ty: Type,
		4165	callee: Value,
		4166	args: []const Value,
		4167	name: []const u8,
		4168	) if (build_options.have_llvm) Allocator.Error!Value else Value {
		4169	const ret_ty = ty.functionReturn(self.builder);
		4170	assert(ty.isFunction(self.builder));
		4171	assert(callee.typeOfWip(self).isPointer(self.builder));
		4172	const params = ty.functionParameters(self.builder);
		4173	for (params, args[0..params.len]) \|param, arg_val\| assert(param == arg_val.typeOfWip(self));
		4174
		4175	try self.ensureUnusedExtraCapacity(1, Instruction.Call, args.len);
		4176	const instruction = try self.addInst(switch (ret_ty) {
		4177	.void => null,
		4178	else => name,
		4179	}, .{
		4180	.tag = .call,
		4181	.data = self.addExtraAssumeCapacity(Instruction.Call{
		4182	.info = .{ .call_conv = call_conv },
		4183	.attributes = function_attributes,
		4184	.ty = ty,
		4185	.callee = callee,
		4186	.args_len = @intCast(args.len),
		4187	}),
		4188	});
		4189	self.extra.appendSliceAssumeCapacity(@ptrCast(args));
		4190	if (self.builder.useLibLlvm()) {
		4191	const ExpectedContents = [expected_args_len]*llvm.Value;
		4192	var stack align(@alignOf(ExpectedContents)) =
		4193	std.heap.stackFallback(@sizeOf(ExpectedContents), self.builder.gpa);
		4194	const allocator = stack.get();
		4195
		4196	const llvm_args = try allocator.alloc(*llvm.Value, args.len);
		4197	defer allocator.free(llvm_args);
		4198	for (llvm_args, args) \|llvm_arg, arg_val\| llvm_arg. = arg_val.toLlvm(self);
		4199
		4200	switch (kind) {
		4201	.normal,
		4202	.musttail,
		4203	.notail,
		4204	.tail,
		4205	=> self.llvm.builder.setFastMath(false),
		4206	.fast,
		4207	.musttail_fast,
		4208	.notail_fast,
		4209	.tail_fast,
		4210	=> self.llvm.builder.setFastMath(true),
		4211	}
		4212	const llvm_instruction = self.llvm.builder.buildCall(
		4213	ty.toLlvm(self.builder),
		4214	callee.toLlvm(self),
		4215	llvm_args.ptr,
		4216	@intCast(llvm_args.len),
		4217	switch (ret_ty) {
		4218	.void => "",
		4219	else => instruction.llvmName(self),
		4220	},
		4221	);
		4222	llvm_instruction.setInstructionCallConv(@enumFromInt(@intFromEnum(call_conv)));
		4223	llvm_instruction.setTailCallKind(switch (kind) {
		4224	.normal, .fast => .None,
		4225	.musttail, .musttail_fast => .MustTail,
		4226	.notail, .notail_fast => .NoTail,
		4227	.tail, .tail_fast => .Tail,
		4228	});
		4229	for (0.., function_attributes.slice(self.builder)) \|index, attributes\| {
		4230	const attribute_index = @as(llvm.AttributeIndex, @intCast(index)) -% 1;
		4231	for (attributes.slice(self.builder)) \|attribute\| llvm_instruction.addCallSiteAttribute(
		4232	attribute_index,
		4233	attribute.toLlvm(self.builder),
		4234	);
		4235	}
		4236	self.llvm.instructions.appendAssumeCapacity(llvm_instruction);
		4237	}
		4238	return instruction.toValue();
		4239	}
		4240
3165	pub fn vaArg(self: *WipFunction, list: Value, ty: Type, name: []const u8) Allocator.Error!Value {	4241	pub fn vaArg(self: *WipFunction, list: Value, ty: Type, name: []const u8) Allocator.Error!Value {
3166	try self.ensureUnusedExtraCapacity(1, Instruction.VaArg, 0);	4242	try self.ensureUnusedExtraCapacity(1, Instruction.VaArg, 0);
3167	const instruction = try self.addInst(name, .{	4243	const instruction = try self.addInst(name, .{
...	@@ -3246,8 +4322,17 @@ pub const WipFunction = struct {	...	@@ -3246,8 +4322,17 @@ pub const WipFunction = struct {
3246	const value = @field(extra, field.name);	4322	const value = @field(extra, field.name);
3247	wip_extra.items[wip_extra.index] = switch (field.type) {	4323	wip_extra.items[wip_extra.index] = switch (field.type) {
3248	u32 => value,	4324	u32 => value,
3249	Alignment, AtomicOrdering, Block.Index, Type, Value => @intFromEnum(value),	4325	Alignment,
3250	MemoryAccessInfo, Instruction.Alloca.Info => @bitCast(value),	4326	AtomicOrdering,
		4327	Block.Index,
		4328	FunctionAttributes,
		4329	Type,
		4330	Value,
		4331	=> @intFromEnum(value),
		4332	MemoryAccessInfo,
		4333	Instruction.Alloca.Info,
		4334	Instruction.Call.Info,
		4335	=> @bitCast(value),
3251	else => @compileError("bad field type: " ++ @typeName(field.type)),	4336	else => @compileError("bad field type: " ++ @typeName(field.type)),
3252	};	4337	};
3253	wip_extra.index += 1;	4338	wip_extra.index += 1;
...	@@ -3256,13 +4341,14 @@ pub const WipFunction = struct {	...	@@ -3256,13 +4341,14 @@ pub const WipFunction = struct {
3256	}	4341	}
3257		4342
3258	fn appendSlice(wip_extra: *@This(), slice: anytype) void {	4343	fn appendSlice(wip_extra: *@This(), slice: anytype) void {
3259	if (@typeInfo(@TypeOf(slice)).Pointer.child == Value) @compileError("use appendValues");	4344	if (@typeInfo(@TypeOf(slice)).Pointer.child == Value)
		4345	@compileError("use appendMappedValues");
3260	const data: []const u32 = @ptrCast(slice);	4346	const data: []const u32 = @ptrCast(slice);
3261	@memcpy(wip_extra.items[wip_extra.index..][0..data.len], data);	4347	@memcpy(wip_extra.items[wip_extra.index..][0..data.len], data);
3262	wip_extra.index += @intCast(data.len);	4348	wip_extra.index += @intCast(data.len);
3263	}	4349	}
3264		4350
3265	fn appendValues(wip_extra: *@This(), vals: []const Value, ctx: anytype) void {	4351	fn appendMappedValues(wip_extra: *@This(), vals: []const Value, ctx: anytype) void {
3266	for (wip_extra.items[wip_extra.index..][0..vals.len], vals) \|*extra, val\|	4352	for (wip_extra.items[wip_extra.index..][0..vals.len], vals) \|*extra, val\|
3267	extra.* = @intFromEnum(ctx.map(val));	4353	extra.* = @intFromEnum(ctx.map(val));
3268	wip_extra.index += @intCast(vals.len);	4354	wip_extra.index += @intCast(vals.len);
...	@@ -3494,6 +4580,26 @@ pub const WipFunction = struct {	...	@@ -3494,6 +4580,26 @@ pub const WipFunction = struct {
3494	.@"else" = extra.@"else",	4580	.@"else" = extra.@"else",
3495	});	4581	});
3496	},	4582	},
		4583	.call,
		4584	.@"call fast",
		4585	.@"musttail call",
		4586	.@"musttail call fast",
		4587	.@"notail call",
		4588	.@"notail call fast",
		4589	.@"tail call",
		4590	.@"tail call fast",
		4591	=> {
		4592	var extra = self.extraDataTrail(Instruction.Call, instruction.data);
		4593	const args = extra.trail.next(extra.data.args_len, Value, self);
		4594	instruction.data = wip_extra.addExtra(Instruction.Call{
		4595	.info = extra.data.info,
		4596	.attributes = extra.data.attributes,
		4597	.ty = extra.data.ty,
		4598	.callee = instructions.map(extra.data.callee),
		4599	.args_len = extra.data.args_len,
		4600	});
		4601	wip_extra.appendMappedValues(args, instructions);
		4602	},
3497	.extractvalue => {	4603	.extractvalue => {
3498	var extra = self.extraDataTrail(Instruction.ExtractValue, instruction.data);	4604	var extra = self.extraDataTrail(Instruction.ExtractValue, instruction.data);
3499	const indices = extra.trail.next(extra.data.indices_len, u32, self);	4605	const indices = extra.trail.next(extra.data.indices_len, u32, self);
...	@@ -3517,7 +4623,7 @@ pub const WipFunction = struct {	...	@@ -3517,7 +4623,7 @@ pub const WipFunction = struct {
3517	.base = instructions.map(extra.data.base),	4623	.base = instructions.map(extra.data.base),
3518	.indices_len = extra.data.indices_len,	4624	.indices_len = extra.data.indices_len,
3519	});	4625	});
3520	wip_extra.appendValues(indices, instructions);	4626	wip_extra.appendMappedValues(indices, instructions);
3521	},	4627	},
3522	.insertelement => {	4628	.insertelement => {
3523	const extra = self.extraData(Instruction.InsertElement, instruction.data);	4629	const extra = self.extraData(Instruction.InsertElement, instruction.data);
...	@@ -3559,7 +4665,7 @@ pub const WipFunction = struct {	...	@@ -3559,7 +4665,7 @@ pub const WipFunction = struct {
3559	instruction.data = wip_extra.addExtra(Instruction.Phi{	4665	instruction.data = wip_extra.addExtra(Instruction.Phi{
3560	.type = extra.data.type,	4666	.type = extra.data.type,
3561	});	4667	});
3562	wip_extra.appendValues(incoming_vals, instructions);	4668	wip_extra.appendMappedValues(incoming_vals, instructions);
3563	wip_extra.appendSlice(incoming_blocks);	4669	wip_extra.appendSlice(incoming_blocks);
3564	},	4670	},
3565	.select,	4671	.select,
...	@@ -3932,8 +5038,17 @@ pub const WipFunction = struct {	...	@@ -3932,8 +5038,17 @@ pub const WipFunction = struct {
3932	const value = @field(extra, field.name);	5038	const value = @field(extra, field.name);
3933	self.extra.appendAssumeCapacity(switch (field.type) {	5039	self.extra.appendAssumeCapacity(switch (field.type) {
3934	u32 => value,	5040	u32 => value,
3935	Alignment, AtomicOrdering, Block.Index, Type, Value => @intFromEnum(value),	5041	Alignment,
3936	MemoryAccessInfo, Instruction.Alloca.Info => @bitCast(value),	5042	AtomicOrdering,
		5043	Block.Index,
		5044	FunctionAttributes,
		5045	Type,
		5046	Value,
		5047	=> @intFromEnum(value),
		5048	MemoryAccessInfo,
		5049	Instruction.Alloca.Info,
		5050	Instruction.Call.Info,
		5051	=> @bitCast(value),
3937	else => @compileError("bad field type: " ++ @typeName(field.type)),	5052	else => @compileError("bad field type: " ++ @typeName(field.type)),
3938	});	5053	});
3939	}	5054	}
...	@@ -3971,8 +5086,17 @@ pub const WipFunction = struct {	...	@@ -3971,8 +5086,17 @@ pub const WipFunction = struct {
3971	inline for (fields, self.extra.items[index..][0..fields.len]) \|field, value\|	5086	inline for (fields, self.extra.items[index..][0..fields.len]) \|field, value\|
3972	@field(result, field.name) = switch (field.type) {	5087	@field(result, field.name) = switch (field.type) {
3973	u32 => value,	5088	u32 => value,
3974	Alignment, AtomicOrdering, Block.Index, Type, Value => @enumFromInt(value),	5089	Alignment,
3975	MemoryAccessInfo, Instruction.Alloca.Info => @bitCast(value),	5090	AtomicOrdering,
		5091	Block.Index,
		5092	FunctionAttributes,
		5093	Type,
		5094	Value,
		5095	=> @enumFromInt(value),
		5096	MemoryAccessInfo,
		5097	Instruction.Alloca.Info,
		5098	Instruction.Call.Info,
		5099	=> @bitCast(value),
3976	else => @compileError("bad field type: " ++ @typeName(field.type)),	5100	else => @compileError("bad field type: " ++ @typeName(field.type)),
3977	};	5101	};
3978	return .{	5102	return .{
...	@@ -4294,7 +5418,7 @@ pub const Constant = enum(u32) {	...	@@ -4294,7 +5418,7 @@ pub const Constant = enum(u32) {
4294	.string,	5418	.string,
4295	.string_null,	5419	.string_null,
4296	=> builder.arrayTypeAssumeCapacity(	5420	=> builder.arrayTypeAssumeCapacity(
4297	@as(String, @enumFromInt(item.data)).toSlice(builder).?.len +	5421	@as(String, @enumFromInt(item.data)).slice(builder).?.len +
4298	@intFromBool(item.tag == .string_null),	5422	@intFromBool(item.tag == .string_null),
4299	.i8,	5423	.i8,
4300	),	5424	),
...	@@ -4821,8 +5945,8 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4821,8 +5945,8 @@ pub fn init(options: Options) InitError!Builder {
4821	.target_triple = .none,	5945	.target_triple = .none,
4822		5946
4823	.string_map = .{},	5947	.string_map = .{},
4824	.string_bytes = .{},
4825	.string_indices = .{},	5948	.string_indices = .{},
		5949	.string_bytes = .{},
4826		5950
4827	.types = .{},	5951	.types = .{},
4828	.next_unnamed_type = @enumFromInt(0),	5952	.next_unnamed_type = @enumFromInt(0),
...	@@ -4831,6 +5955,11 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4831,6 +5955,11 @@ pub fn init(options: Options) InitError!Builder {
4831	.type_items = .{},	5955	.type_items = .{},
4832	.type_extra = .{},	5956	.type_extra = .{},
4833		5957
		5958	.attributes = .{},
		5959	.attributes_map = .{},
		5960	.attributes_indices = .{},
		5961	.attributes_extra = .{},
		5962
4834	.globals = .{},	5963	.globals = .{},
4835	.next_unnamed_global = @enumFromInt(0),	5964	.next_unnamed_global = @enumFromInt(0),
4836	.next_replaced_global = .none,	5965	.next_replaced_global = .none,
...	@@ -4844,7 +5973,18 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4844,7 +5973,18 @@ pub fn init(options: Options) InitError!Builder {
4844	.constant_extra = .{},	5973	.constant_extra = .{},
4845	.constant_limbs = .{},	5974	.constant_limbs = .{},
4846	};	5975	};
4847	if (self.useLibLlvm()) self.llvm = .{ .context = llvm.Context.create() };	5976	if (self.useLibLlvm()) self.llvm = .{
		5977	.context = llvm.Context.create(),
		5978	.module = null,
		5979	.target = null,
		5980	.di_builder = null,
		5981	.di_compile_unit = null,
		5982	.attribute_kind_ids = null,
		5983	.attributes = .{},
		5984	.types = .{},
		5985	.globals = .{},
		5986	.constants = .{},
		5987	};
4848	errdefer self.deinit();	5988	errdefer self.deinit();
4849		5989
4850	try self.string_indices.append(self.gpa, 0);	5990	try self.string_indices.append(self.gpa, 0);
...	@@ -4853,7 +5993,7 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4853,7 +5993,7 @@ pub fn init(options: Options) InitError!Builder {
4853	if (options.name.len > 0) self.source_filename = try self.string(options.name);	5993	if (options.name.len > 0) self.source_filename = try self.string(options.name);
4854	self.initializeLLVMTarget(options.target.cpu.arch);	5994	self.initializeLLVMTarget(options.target.cpu.arch);
4855	if (self.useLibLlvm()) self.llvm.module = llvm.Module.createWithName(	5995	if (self.useLibLlvm()) self.llvm.module = llvm.Module.createWithName(
4856	(self.source_filename.toSlice(&self) orelse "").ptr,	5996	(self.source_filename.slice(&self) orelse "").ptr,
4857	self.llvm.context,	5997	self.llvm.context,
4858	);	5998	);
4859		5999
...	@@ -4864,20 +6004,20 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4864,20 +6004,20 @@ pub fn init(options: Options) InitError!Builder {
4864	var error_message: [*:0]const u8 = undefined;	6004	var error_message: [*:0]const u8 = undefined;
4865	var target: *llvm.Target = undefined;	6005	var target: *llvm.Target = undefined;
4866	if (llvm.Target.getFromTriple(	6006	if (llvm.Target.getFromTriple(
4867	self.target_triple.toSlice(&self).?,	6007	self.target_triple.slice(&self).?,
4868	&target,	6008	&target,
4869	&error_message,	6009	&error_message,
4870	).toBool()) {	6010	).toBool()) {
4871	defer llvm.disposeMessage(error_message);	6011	defer llvm.disposeMessage(error_message);
4872		6012
4873	log.err("LLVM failed to parse '{s}': {s}", .{	6013	log.err("LLVM failed to parse '{s}': {s}", .{
4874	self.target_triple.toSlice(&self).?,	6014	self.target_triple.slice(&self).?,
4875	error_message,	6015	error_message,
4876	});	6016	});
4877	return InitError.InvalidLlvmTriple;	6017	return InitError.InvalidLlvmTriple;
4878	}	6018	}
4879	self.llvm.target = target;	6019	self.llvm.target = target;
4880	self.llvm.module.?.setTarget(self.target_triple.toSlice(&self).?);	6020	self.llvm.module.?.setTarget(self.target_triple.slice(&self).?);
4881	}	6021	}
4882	}	6022	}
4883		6023
...	@@ -4902,6 +6042,16 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4902,6 +6042,16 @@ pub fn init(options: Options) InitError!Builder {
4902	assert(self.ptrTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);	6042	assert(self.ptrTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);
4903	}	6043	}
4904		6044
		6045	{
		6046	if (self.useLibLlvm()) {
		6047	self.llvm.attribute_kind_ids = try self.gpa.create([Attribute.Kind.len]c_uint);
		6048	@memset(self.llvm.attribute_kind_ids.?, 0);
		6049	}
		6050	try self.attributes_indices.append(self.gpa, 0);
		6051	assert(try self.attrs(&.{}) == .none);
		6052	assert(try self.fnAttrs(&.{}) == .none);
		6053	}
		6054
4905	assert(try self.intConst(.i1, 0) == .false);	6055	assert(try self.intConst(.i1, 0) == .false);
4906	assert(try self.intConst(.i1, 1) == .true);	6056	assert(try self.intConst(.i1, 1) == .true);
4907	assert(try self.noneConst(.token) == .none);	6057	assert(try self.noneConst(.token) == .none);
...	@@ -4911,8 +6061,8 @@ pub fn init(options: Options) InitError!Builder {	...	@@ -4911,8 +6061,8 @@ pub fn init(options: Options) InitError!Builder {
4911		6061
4912	pub fn deinit(self: *Builder) void {	6062	pub fn deinit(self: *Builder) void {
4913	self.string_map.deinit(self.gpa);	6063	self.string_map.deinit(self.gpa);
4914	self.string_bytes.deinit(self.gpa);
4915	self.string_indices.deinit(self.gpa);	6064	self.string_indices.deinit(self.gpa);
		6065	self.string_bytes.deinit(self.gpa);
4916		6066
4917	self.types.deinit(self.gpa);	6067	self.types.deinit(self.gpa);
4918	self.next_unique_type_id.deinit(self.gpa);	6068	self.next_unique_type_id.deinit(self.gpa);
...	@@ -4920,6 +6070,11 @@ pub fn deinit(self: *Builder) void {	...	@@ -4920,6 +6070,11 @@ pub fn deinit(self: *Builder) void {
4920	self.type_items.deinit(self.gpa);	6070	self.type_items.deinit(self.gpa);
4921	self.type_extra.deinit(self.gpa);	6071	self.type_extra.deinit(self.gpa);
4922		6072
		6073	self.attributes.deinit(self.gpa);
		6074	self.attributes_map.deinit(self.gpa);
		6075	self.attributes_indices.deinit(self.gpa);
		6076	self.attributes_extra.deinit(self.gpa);
		6077
4923	self.globals.deinit(self.gpa);	6078	self.globals.deinit(self.gpa);
4924	self.next_unique_global_id.deinit(self.gpa);	6079	self.next_unique_global_id.deinit(self.gpa);
4925	self.aliases.deinit(self.gpa);	6080	self.aliases.deinit(self.gpa);
...	@@ -4936,6 +6091,8 @@ pub fn deinit(self: *Builder) void {	...	@@ -4936,6 +6091,8 @@ pub fn deinit(self: *Builder) void {
4936	self.llvm.constants.deinit(self.gpa);	6091	self.llvm.constants.deinit(self.gpa);
4937	self.llvm.globals.deinit(self.gpa);	6092	self.llvm.globals.deinit(self.gpa);
4938	self.llvm.types.deinit(self.gpa);	6093	self.llvm.types.deinit(self.gpa);
		6094	self.llvm.attributes.deinit(self.gpa);
		6095	if (self.llvm.attribute_kind_ids) \|attribute_kind_ids\| self.gpa.destroy(attribute_kind_ids);
4939	if (self.llvm.di_builder) \|di_builder\| di_builder.dispose();	6096	if (self.llvm.di_builder) \|di_builder\| di_builder.dispose();
4940	if (self.llvm.module) \|module\| module.dispose();	6097	if (self.llvm.module) \|module\| module.dispose();
4941	self.llvm.context.dispose();	6098	self.llvm.context.dispose();
...	@@ -5230,7 +6387,7 @@ pub fn structType(	...	@@ -5230,7 +6387,7 @@ pub fn structType(
5230		6387
5231	pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {	6388	pub fn opaqueType(self: *Builder, name: String) Allocator.Error!Type {
5232	try self.string_map.ensureUnusedCapacity(self.gpa, 1);	6389	try self.string_map.ensureUnusedCapacity(self.gpa, 1);
5233	if (name.toSlice(self)) \|id\| {	6390	if (name.slice(self)) \|id\| {
5234	const count: usize = comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)});	6391	const count: usize = comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)});
5235	try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);	6392	try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);
5236	}	6393	}
...	@@ -5268,6 +6425,99 @@ pub fn namedTypeSetBody(	...	@@ -5268,6 +6425,99 @@ pub fn namedTypeSetBody(
5268	}	6425	}
5269	}	6426	}
5270		6427
		6428	pub fn attr(self: *Builder, attribute: Attribute) Allocator.Error!Attribute.Index {
		6429	try self.attributes.ensureUnusedCapacity(self.gpa, 1);
		6430	if (self.useLibLlvm()) try self.llvm.attributes.ensureUnusedCapacity(self.gpa, 1);
		6431
		6432	const gop = self.attributes.getOrPutAssumeCapacity(attribute.toStorage());
		6433	if (!gop.found_existing) {
		6434	gop.value_ptr.* = {};
		6435	if (self.useLibLlvm()) self.llvm.attributes.appendAssumeCapacity(switch (attribute) {
		6436	else => llvm_attr: {
		6437	const kind_id = &self.llvm.attribute_kind_ids.?[@intFromEnum(attribute)];
		6438	if (kind_id.* == 0) {
		6439	const name = @tagName(attribute);
		6440	kind_id.* = llvm.getEnumAttributeKindForName(name.ptr, name.len);
		6441	assert(kind_id.* != 0);
		6442	}
		6443	break :llvm_attr switch (attribute) {
		6444	else => switch (attribute) {
		6445	inline else => \|value\| self.llvm.context.createEnumAttribute(
		6446	kind_id.*,
		6447	switch (@TypeOf(value)) {
		6448	void => 0,
		6449	u32 => value,
		6450	Attribute.FpClass,
		6451	Attribute.AllocKind,
		6452	Attribute.Memory,
		6453	=> @as(u32, @bitCast(value)),
		6454	Alignment => value.toByteUnits() orelse 0,
		6455	Attribute.AllocSize,
		6456	Attribute.VScaleRange,
		6457	=> @bitCast(value.toLlvm()),
		6458	Attribute.UwTable => @intFromEnum(value),
		6459	else => @compileError(
		6460	"bad payload type: " ++ @typeName(@TypeOf(value)),
		6461	),
		6462	},
		6463	),
		6464	.byval,
		6465	.byref,
		6466	.preallocated,
		6467	.inalloca,
		6468	.sret,
		6469	.elementtype,
		6470	.string,
		6471	.none,
		6472	=> unreachable,
		6473	},
		6474	.byval,
		6475	.byref,
		6476	.preallocated,
		6477	.inalloca,
		6478	.sret,
		6479	.elementtype,
		6480	=> \|ty\| self.llvm.context.createTypeAttribute(kind_id.*, ty.toLlvm(self)),
		6481	.string, .none => unreachable,
		6482	};
		6483	},
		6484	.string => \|string_attr\| llvm_attr: {
		6485	const kind = string_attr.kind.slice(self).?;
		6486	const value = string_attr.value.slice(self).?;
		6487	break :llvm_attr self.llvm.context.createStringAttribute(
		6488	kind.ptr,
		6489	@intCast(kind.len),
		6490	value.ptr,
		6491	@intCast(value.len),
		6492	);
		6493	},
		6494	.none => unreachable,
		6495	});
		6496	}
		6497	return @enumFromInt(gop.index);
		6498	}
		6499
		6500	pub fn attrs(self: *Builder, attributes: []Attribute.Index) Allocator.Error!Attributes {
		6501	std.sort.heap(Attribute.Index, attributes, self, struct {
		6502	pub fn lessThan(builder: *const Builder, lhs: Attribute.Index, rhs: Attribute.Index) bool {
		6503	const lhs_kind = lhs.getKind(builder);
		6504	const rhs_kind = rhs.getKind(builder);
		6505	assert(lhs_kind != rhs_kind);
		6506	return @intFromEnum(lhs_kind) < @intFromEnum(rhs_kind);
		6507	}
		6508	}.lessThan);
		6509	return @enumFromInt(try self.attrGeneric(@ptrCast(attributes)));
		6510	}
		6511
		6512	pub fn fnAttrs(self: *Builder, fn_attributes: []const Attributes) Allocator.Error!FunctionAttributes {
		6513	return @enumFromInt(try self.attrGeneric(@ptrCast(
		6514	fn_attributes[0..if (std.mem.lastIndexOfNone(Attributes, fn_attributes, &.{.none})) \|last\|
		6515	last + 1
		6516	else
		6517	0],
		6518	)));
		6519	}
		6520
5271	pub fn addGlobal(self: *Builder, name: String, global: Global) Allocator.Error!Global.Index {	6521	pub fn addGlobal(self: *Builder, name: String, global: Global) Allocator.Error!Global.Index {
5272	assert(!name.isAnon());	6522	assert(!name.isAnon());
5273	try self.ensureUnusedTypeCapacity(1, NoExtra, 0);	6523	try self.ensureUnusedTypeCapacity(1, NoExtra, 0);
...	@@ -5295,7 +6545,7 @@ pub fn addGlobalAssumeCapacity(self: *Builder, name: String, global: Global) Glo	...	@@ -5295,7 +6545,7 @@ pub fn addGlobalAssumeCapacity(self: *Builder, name: String, global: Global) Glo
5295		6545
5296	const unique_gop = self.next_unique_global_id.getOrPutAssumeCapacity(name);	6546	const unique_gop = self.next_unique_global_id.getOrPutAssumeCapacity(name);
5297	if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;	6547	if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;
5298	id = self.fmtAssumeCapacity("{s}.{d}", .{ name.toSlice(self).?, unique_gop.value_ptr.* });	6548	id = self.fmtAssumeCapacity("{s}.{d}", .{ name.slice(self).?, unique_gop.value_ptr.* });
5299	unique_gop.value_ptr.* += 1;	6549	unique_gop.value_ptr.* += 1;
5300	}	6550	}
5301	}	6551	}
...	@@ -5309,8 +6559,9 @@ pub fn intConst(self: *Builder, ty: Type, value: anytype) Allocator.Error!Consta	...	@@ -5309,8 +6559,9 @@ pub fn intConst(self: *Builder, ty: Type, value: anytype) Allocator.Error!Consta
5309	switch (@typeInfo(@TypeOf(value))) {	6559	switch (@typeInfo(@TypeOf(value))) {
5310	.Int => \|info\| std.math.big.int.calcTwosCompLimbCount(info.bits),	6560	.Int => \|info\| std.math.big.int.calcTwosCompLimbCount(info.bits),
5311	.ComptimeInt => std.math.big.int.calcLimbLen(value),	6561	.ComptimeInt => std.math.big.int.calcLimbLen(value),
5312	else => @compileError("intConst expected an integral value, got " ++	6562	else => @compileError(
5313	@typeName(@TypeOf(value))),	6563	"intConst expected an integral value, got " ++ @typeName(@TypeOf(value)),
		6564	),
5314	}	6565	}
5315	]std.math.big.Limb = undefined;	6566	]std.math.big.Limb = undefined;
5316	return self.bigIntConst(ty, std.math.big.int.Mutable.init(&limbs, value).toConst());	6567	return self.bigIntConst(ty, std.math.big.int.Mutable.init(&limbs, value).toConst());
...	@@ -5770,7 +7021,7 @@ pub fn printUnbuffered(	...	@@ -5770,7 +7021,7 @@ pub fn printUnbuffered(
5770	\\; ModuleID = '{s}'	7021	\\; ModuleID = '{s}'
5771	\\source_filename = {"}	7022	\\source_filename = {"}
5772	\\	7023	\\
5773	, .{ self.source_filename.toSlice(self).?, self.source_filename.fmt(self) });	7024	, .{ self.source_filename.slice(self).?, self.source_filename.fmt(self) });
5774	if (self.data_layout != .none) try writer.print(	7025	if (self.data_layout != .none) try writer.print(
5775	\\target datalayout = {"}	7026	\\target datalayout = {"}
5776	\\	7027	\\
...	@@ -5780,11 +7031,13 @@ pub fn printUnbuffered(	...	@@ -5780,11 +7031,13 @@ pub fn printUnbuffered(
5780	\\	7031	\\
5781	, .{self.target_triple.fmt(self)});	7032	, .{self.target_triple.fmt(self)});
5782	try writer.writeByte('\n');	7033	try writer.writeByte('\n');
		7034
5783	for (self.types.keys(), self.types.values()) \|id, ty\| try writer.print(	7035	for (self.types.keys(), self.types.values()) \|id, ty\| try writer.print(
5784	\\%{} = type {}	7036	\\%{} = type {}
5785	\\	7037	\\
5786	, .{ id.fmt(self), ty.fmt(self) });	7038	, .{ id.fmt(self), ty.fmt(self) });
5787	try writer.writeByte('\n');	7039	try writer.writeByte('\n');
		7040
5788	for (self.variables.items) \|variable\| {	7041	for (self.variables.items) \|variable\| {
5789	if (variable.global.getReplacement(self) != .none) continue;	7042	if (variable.global.getReplacement(self) != .none) continue;
5790	const global = variable.global.ptrConst(self);	7043	const global = variable.global.ptrConst(self);
...	@@ -5808,28 +7061,42 @@ pub fn printUnbuffered(	...	@@ -5808,28 +7061,42 @@ pub fn printUnbuffered(
5808	});	7061	});
5809	}	7062	}
5810	try writer.writeByte('\n');	7063	try writer.writeByte('\n');
		7064
		7065	var attribute_groups: std.AutoArrayHashMapUnmanaged(Attributes, void) = .{};
		7066	defer attribute_groups.deinit(self.gpa);
5811	for (0.., self.functions.items) \|function_i, function\| {	7067	for (0.., self.functions.items) \|function_i, function\| {
5812	const function_index: Function.Index = @enumFromInt(function_i);	7068	const function_index: Function.Index = @enumFromInt(function_i);
5813	if (function.global.getReplacement(self) != .none) continue;	7069	if (function.global.getReplacement(self) != .none) continue;
5814	const global = function.global.ptrConst(self);	7070	const global = function.global.ptrConst(self);
5815	const params_len = global.type.functionParameters(self).len;	7071	const params_len = global.type.functionParameters(self).len;
		7072	const function_attributes = function.attributes.func(self);
		7073	if (function_attributes != .none) try writer.print(
		7074	\\; Function Attrs:{}
		7075	\\
		7076	, .{function_attributes.fmt(self)});
5816	try writer.print(	7077	try writer.print(
5817	\\{s}{}{}{}{} {} {}(	7078	\\{s}{}{}{}{}{}{"} {} {}(
5818	, .{	7079	, .{
5819	if (function.instructions.len > 0) "define" else "declare",	7080	if (function.instructions.len > 0) "define" else "declare",
5820	global.linkage,	7081	global.linkage,
5821	global.preemption,	7082	global.preemption,
5822	global.visibility,	7083	global.visibility,
5823	global.dll_storage_class,	7084	global.dll_storage_class,
		7085	function.call_conv,
		7086	function.attributes.ret(self).fmt(self),
5824	global.type.functionReturn(self).fmt(self),	7087	global.type.functionReturn(self).fmt(self),
5825	function.global.fmt(self),	7088	function.global.fmt(self),
5826	});	7089	});
5827	for (0..params_len) \|arg\| {	7090	for (0..params_len) \|arg\| {
5828	if (arg > 0) try writer.writeAll(", ");	7091	if (arg > 0) try writer.writeAll(", ");
		7092	try writer.print(
		7093	\\{%}{"}
		7094	, .{
		7095	global.type.functionParameters(self)[arg].fmt(self),
		7096	function.attributes.param(arg, self).fmt(self),
		7097	});
5829	if (function.instructions.len > 0)	7098	if (function.instructions.len > 0)
5830	try writer.print("{%}", .{function.arg(@intCast(arg)).fmt(function_index, self)})	7099	try writer.print(" {}", .{function.arg(@intCast(arg)).fmt(function_index, self)});
5831	else
5832	try writer.print("{%}", .{global.type.functionParameters(self)[arg].fmt(self)});
5833	}	7100	}
5834	switch (global.type.functionKind(self)) {	7101	switch (global.type.functionKind(self)) {
5835	.normal => {},	7102	.normal => {},
...	@@ -5838,7 +7105,11 @@ pub fn printUnbuffered(	...	@@ -5838,7 +7105,11 @@ pub fn printUnbuffered(
5838	try writer.writeAll("...");	7105	try writer.writeAll("...");
5839	},	7106	},
5840	}	7107	}
5841	try writer.print("){}{}", .{ global.unnamed_addr, function.alignment });	7108	try writer.print("){}{}", .{ global.unnamed_addr, global.addr_space });
		7109	if (function_attributes != .none) try writer.print(" #{d}", .{
		7110	(try attribute_groups.getOrPutValue(self.gpa, function_attributes, {})).index,
		7111	});
		7112	try writer.print("{}", .{function.alignment});
5842	if (function.instructions.len > 0) {	7113	if (function.instructions.len > 0) {
5843	var block_incoming_len: u32 = undefined;	7114	var block_incoming_len: u32 = undefined;
5844	try writer.writeAll(" {\n");	7115	try writer.writeAll(" {\n");
...	@@ -5992,6 +7263,48 @@ pub fn printUnbuffered(	...	@@ -5992,6 +7263,48 @@ pub fn printUnbuffered(
5992	extra.@"else".toInst(&function).fmt(function_index, self),	7263	extra.@"else".toInst(&function).fmt(function_index, self),
5993	});	7264	});
5994	},	7265	},
		7266	.call,
		7267	.@"call fast",
		7268	.@"musttail call",
		7269	.@"musttail call fast",
		7270	.@"notail call",
		7271	.@"notail call fast",
		7272	.@"tail call",
		7273	.@"tail call fast",
		7274	=> \|tag\| {
		7275	var extra =
		7276	function.extraDataTrail(Function.Instruction.Call, instruction.data);
		7277	const args = extra.trail.next(extra.data.args_len, Value, &function);
		7278	try writer.writeAll(" ");
		7279	const ret_ty = extra.data.ty.functionReturn(self);
		7280	switch (ret_ty) {
		7281	.void => {},
		7282	else => try writer.print("%{} = ", .{
		7283	instruction_index.name(&function).fmt(self),
		7284	}),
		7285	.none => unreachable,
		7286	}
		7287	try writer.print("{s}{}{}{} {%} {}(", .{
		7288	@tagName(tag),
		7289	extra.data.info.call_conv,
		7290	extra.data.attributes.ret(self).fmt(self),
		7291	extra.data.callee.typeOf(function_index, self).pointerAddrSpace(self),
		7292	switch (extra.data.ty.functionKind(self)) {
		7293	.normal => ret_ty,
		7294	.vararg => extra.data.ty,
		7295	}.fmt(self),
		7296	extra.data.callee.fmt(function_index, self),
		7297	});
		7298	for (0.., args) \|arg_index, arg\| {
		7299	if (arg_index > 0) try writer.writeAll(", ");
		7300	try writer.print("{%}{} {}", .{
		7301	arg.typeOf(function_index, self).fmt(self),
		7302	extra.data.attributes.param(arg_index, self).fmt(self),
		7303	arg.fmt(function_index, self),
		7304	});
		7305	}
		7306	try writer.print("){}\n", .{extra.data.attributes.func(self).fmt(self)});
		7307	},
5995	.extractelement => \|tag\| {	7308	.extractelement => \|tag\| {
5996	const extra =	7309	const extra =
5997	function.extraData(Function.Instruction.ExtractElement, instruction.data);	7310	function.extraData(Function.Instruction.ExtractElement, instruction.data);
...	@@ -6218,6 +7531,12 @@ pub fn printUnbuffered(	...	@@ -6218,6 +7531,12 @@ pub fn printUnbuffered(
6218	}	7531	}
6219	try writer.writeAll("\n\n");	7532	try writer.writeAll("\n\n");
6220	}	7533	}
		7534
		7535	for (0.., attribute_groups.keys()) \|attribute_group_index, attribute_group\|
		7536	try writer.print(
		7537	\\attribute #{d} = {{{"} }}
		7538	\\
		7539	, .{ attribute_group_index, attribute_group.fmt(self) });
6221	}	7540	}
6222		7541
6223	pub inline fn useLibLlvm(self: *const Builder) bool {	7542	pub inline fn useLibLlvm(self: *const Builder) bool {
...	@@ -6238,7 +7557,7 @@ fn isValidIdentifier(id: []const u8) bool {	...	@@ -6238,7 +7557,7 @@ fn isValidIdentifier(id: []const u8) bool {
6238	fn ensureUnusedGlobalCapacity(self: *Builder, name: String) Allocator.Error!void {	7557	fn ensureUnusedGlobalCapacity(self: *Builder, name: String) Allocator.Error!void {
6239	if (self.useLibLlvm()) try self.llvm.globals.ensureUnusedCapacity(self.gpa, 1);	7558	if (self.useLibLlvm()) try self.llvm.globals.ensureUnusedCapacity(self.gpa, 1);
6240	try self.string_map.ensureUnusedCapacity(self.gpa, 1);	7559	try self.string_map.ensureUnusedCapacity(self.gpa, 1);
6241	if (name.toSlice(self)) \|id\| {	7560	if (name.slice(self)) \|id\| {
6242	const count: usize = comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)});	7561	const count: usize = comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)});
6243	try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);	7562	try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len + count);
6244	}	7563	}
...	@@ -6528,14 +7847,14 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {	...	@@ -6528,14 +7847,14 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
6528	const result: Type = @enumFromInt(gop.index);	7847	const result: Type = @enumFromInt(gop.index);
6529	type_gop.value_ptr.* = result;	7848	type_gop.value_ptr.* = result;
6530	if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(	7849	if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(
6531	self.llvm.context.structCreateNamed(id.toSlice(self) orelse ""),	7850	self.llvm.context.structCreateNamed(id.slice(self) orelse ""),
6532	);	7851	);
6533	return result;	7852	return result;
6534	}	7853	}
6535		7854
6536	const unique_gop = self.next_unique_type_id.getOrPutAssumeCapacity(name);	7855	const unique_gop = self.next_unique_type_id.getOrPutAssumeCapacity(name);
6537	if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;	7856	if (!unique_gop.found_existing) unique_gop.value_ptr.* = 2;
6538	id = self.fmtAssumeCapacity("{s}.{d}", .{ name.toSlice(self).?, unique_gop.value_ptr.* });	7857	id = self.fmtAssumeCapacity("{s}.{d}", .{ name.slice(self).?, unique_gop.value_ptr.* });
6539	unique_gop.value_ptr.* += 1;	7858	unique_gop.value_ptr.* += 1;
6540	}	7859	}
6541	}	7860	}
...	@@ -6636,6 +7955,30 @@ fn typeExtraData(self: *const Builder, comptime T: type, index: Type.Item.ExtraI	...	@@ -6636,6 +7955,30 @@ fn typeExtraData(self: *const Builder, comptime T: type, index: Type.Item.ExtraI
6636	return self.typeExtraDataTrail(T, index).data;	7955	return self.typeExtraDataTrail(T, index).data;
6637	}	7956	}
6638		7957
		7958	fn attrGeneric(self: *Builder, data: []const u32) Allocator.Error!u32 {
		7959	try self.attributes_map.ensureUnusedCapacity(self.gpa, 1);
		7960	try self.attributes_indices.ensureUnusedCapacity(self.gpa, 1);
		7961	try self.attributes_extra.ensureUnusedCapacity(self.gpa, data.len);
		7962
		7963	const Adapter = struct {
		7964	builder: *const Builder,
		7965	pub fn hash(_: @This(), key: []const u32) u32 {
		7966	return @truncate(std.hash.Wyhash.hash(1, std.mem.sliceAsBytes(key)));
		7967	}
		7968	pub fn eql(ctx: @This(), lhs_key: []const u32, _: void, rhs_index: usize) bool {
		7969	const start = ctx.builder.attributes_indices.items[rhs_index];
		7970	const end = ctx.builder.attributes_indices.items[rhs_index + 1];
		7971	return std.mem.eql(u32, lhs_key, ctx.builder.attributes_extra.items[start..end]);
		7972	}
		7973	};
		7974	const gop = self.attributes_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self });
		7975	if (!gop.found_existing) {
		7976	self.attributes_extra.appendSliceAssumeCapacity(data);
		7977	self.attributes_indices.appendAssumeCapacity(@intCast(self.attributes_extra.items.len));
		7978	}
		7979	return @intCast(gop.index);
		7980	}
		7981
6639	fn bigIntConstAssumeCapacity(	7982	fn bigIntConstAssumeCapacity(
6640	self: *Builder,	7983	self: *Builder,
6641	ty: Type,	7984	ty: Type,
...	@@ -7073,7 +8416,7 @@ fn arrayConstAssumeCapacity(	...	@@ -7073,7 +8416,7 @@ fn arrayConstAssumeCapacity(
7073	}	8416	}
7074		8417
7075	fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {	8418	fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {
7076	const slice = val.toSlice(self).?;	8419	const slice = val.slice(self).?;
7077	const ty = self.arrayTypeAssumeCapacity(slice.len, .i8);	8420	const ty = self.arrayTypeAssumeCapacity(slice.len, .i8);
7078	if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);	8421	if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);
7079	const result = self.getOrPutConstantNoExtraAssumeCapacity(	8422	const result = self.getOrPutConstantNoExtraAssumeCapacity(
...	@@ -7086,7 +8429,7 @@ fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {	...	@@ -7086,7 +8429,7 @@ fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {
7086	}	8429	}
7087		8430
7088	fn stringNullConstAssumeCapacity(self: *Builder, val: String) Constant {	8431	fn stringNullConstAssumeCapacity(self: *Builder, val: String) Constant {
7089	const slice = val.toSlice(self).?;	8432	const slice = val.slice(self).?;
7090	const ty = self.arrayTypeAssumeCapacity(slice.len + 1, .i8);	8433	const ty = self.arrayTypeAssumeCapacity(slice.len + 1, .i8);
7091	if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);	8434	if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty);
7092	const result = self.getOrPutConstantNoExtraAssumeCapacity(	8435	const result = self.getOrPutConstantNoExtraAssumeCapacity(

src/codegen/llvm/bindings.zig+32-6

 @@ -26,10 +26,13 @@ pub const Context = opaque {
     extern fn LLVMContextDispose(C: *Context) void;
     pub const createEnumAttribute = LLVMCreateEnumAttribute;
-    extern fn LLVMCreateEnumAttribute(*Context, KindID: c_uint, Val: u64) *Attribute;
+    extern fn LLVMCreateEnumAttribute(C: *Context, KindID: c_uint, Val: u64) *Attribute;
+    pub const createTypeAttribute = LLVMCreateTypeAttribute;
+    extern fn LLVMCreateTypeAttribute(C: *Context, KindID: c_uint, Type: *Type) *Attribute;
     pub const createStringAttribute = LLVMCreateStringAttribute;
-    extern fn LLVMCreateStringAttribute(*Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *Attribute;
+    extern fn LLVMCreateStringAttribute(C: *Context, Key: [*]const u8, Key_Len: c_uint, Value: [*]const u8, Value_Len: c_uint) *Attribute;
     pub const pointerType = LLVMPointerTypeInContext;
     extern fn LLVMPointerTypeInContext(C: *Context, AddressSpace: c_uint) *Type;
 @@ -309,12 +312,18 @@ pub const Value = opaque {
     pub const setAlignment = LLVMSetAlignment;
     extern fn LLVMSetAlignment(V: *Value, Bytes: c_uint) void;
-    pub const getFunctionCallConv = LLVMGetFunctionCallConv;
-    extern fn LLVMGetFunctionCallConv(Fn: *Value) CallConv;
     pub const setFunctionCallConv = LLVMSetFunctionCallConv;
     extern fn LLVMSetFunctionCallConv(Fn: *Value, CC: CallConv) void;
+    pub const setInstructionCallConv = LLVMSetInstructionCallConv;
+    extern fn LLVMSetInstructionCallConv(Instr: *Value, CC: CallConv) void;
+    pub const setTailCallKind = ZigLLVMSetTailCallKind;
+    extern fn ZigLLVMSetTailCallKind(CallInst: *Value, TailCallKind: TailCallKind) void;
+    pub const addCallSiteAttribute = LLVMAddCallSiteAttribute;
+    extern fn LLVMAddCallSiteAttribute(C: *Value, Idx: AttributeIndex, A: *Attribute) void;
     pub const fnSetSubprogram = ZigLLVMFnSetSubprogram;
     extern fn ZigLLVMFnSetSubprogram(f: *Value, subprogram: *DISubprogram) void;
 @@ -642,7 +651,17 @@ pub const Builder = opaque {
         Name: [*:0]const u8,
     ) *Value;
-    pub const buildCall = ZigLLVMBuildCall;
+    pub const buildCall = LLVMBuildCall2;
+    extern fn LLVMBuildCall2(
+        *Builder,
+        *Type,
+        Fn: *Value,
+        Args: [*]const *Value,
+        NumArgs: c_uint,
+        Name: [*:0]const u8,
+    ) *Value;
+    pub const buildCallOld = ZigLLVMBuildCall;
     extern fn ZigLLVMBuildCall(
         *Builder,
         *Type,
 @@ -1605,6 +1624,13 @@ pub const CallAttr = enum(c_int) {
     AlwaysInline,
 };
+pub const TailCallKind = enum(c_uint) {
+    None,
+    Tail,
+    MustTail,
+    NoTail,
+};
 pub const DLLStorageClass = enum(c_uint) {
     Default,
     DLLImport,

src/zig_llvm.cpp+4-6

 @@ -453,6 +453,10 @@ LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
     return wrap(call_inst);
 }
+ZIG_EXTERN_C void ZigLLVMSetTailCallKind(LLVMValueRef Call, CallInst::TailCallKind TailCallKind) {
+    unwrap<CallInst>(Call)->setTailCallKind(TailCallKind);
+}
 void ZigLLVMAddAttributeAtIndex(LLVMValueRef Val, unsigned Idx, LLVMAttributeRef A) {
     if (isa<Function>(unwrap(Val))) {
         unwrap<Function>(Val)->addAttributeAtIndex(Idx, unwrap(A));
 @@ -461,7 +465,6 @@ void ZigLLVMAddAttributeAtIndex(LLVMValueRef Val, unsigned Idx, LLVMAttributeRef
     }
 }
 LLVMValueRef ZigLLVMBuildMemCpy(LLVMBuilderRef B, LLVMValueRef Dst, unsigned DstAlign,
         LLVMValueRef Src, unsigned SrcAlign, LLVMValueRef Size, bool isVolatile)
 {
 @@ -1116,11 +1119,6 @@ void ZigLLVMAddFunctionAttr(LLVMValueRef fn_ref, const char *attr_name, const ch
     func->addFnAttr(attr_name, attr_value);
 }
-void ZigLLVMAddFunctionAttrCold(LLVMValueRef fn_ref) {
-    Function *func = unwrap<Function>(fn_ref);
-    func->addFnAttr(Attribute::Cold);
-}
 void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
     cl::ParseCommandLineOptions(argc, argv);
 }