authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-07-10 20:30:15-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-07-19 23:38:40-04:00
log7ec7fe53597a70a3f2c9f040d7da978ae3a52a6b
treed5a50df9e0d541a0300967b3d1a02752f35b6054
parentff8a49448c70ffe73826c7987522ed63fddd654f

llvm: cleanup init

2 files changed, 259 insertions(+), 223 deletions(-)

src/codegen/llvm.zig+129-157
......@@ -35,7 +35,7 @@ const compilerRtIntAbbrev = target_util.compilerRtIntAbbrev;
3535
3636const Error = error{ OutOfMemory, CodegenFail };
3737
38pub fn targetTriple(allocator: Allocator, target: std.Target) ![:0]u8 {
38pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
3939 var llvm_triple = std.ArrayList(u8).init(allocator);
4040 defer llvm_triple.deinit();
4141
......@@ -208,7 +208,7 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![:0]u8 {
208208 };
209209 try llvm_triple.appendSlice(llvm_abi);
210210
211 return llvm_triple.toOwnedSliceSentinel(0);
211 return llvm_triple.toOwnedSlice();
212212}
213213
214214pub fn targetOs(os_tag: std.Target.Os.Tag) llvm.OSType {
......@@ -602,160 +602,137 @@ pub const Object = struct {
602602 }
603603
604604 pub fn init(gpa: Allocator, options: link.Options) !Object {
605 var builder = Builder{
606 .gpa = gpa,
607 .use_lib_llvm = options.use_lib_llvm,
608
609 .llvm_context = llvm.Context.create(),
610 .llvm_module = undefined,
611 };
612 errdefer builder.llvm_context.dispose();
613
614 builder.initializeLLVMTarget(options.target.cpu.arch);
615
616 builder.llvm_module = llvm.Module.createWithName(options.root_name.ptr, builder.llvm_context);
617 errdefer builder.llvm_module.dispose();
618
619605 const llvm_target_triple = try targetTriple(gpa, options.target);
620606 defer gpa.free(llvm_target_triple);
621607
622 var error_message: [*:0]const u8 = undefined;
623 var target: *llvm.Target = undefined;
624 if (llvm.Target.getFromTriple(llvm_target_triple.ptr, &target, &error_message).toBool()) {
625 defer llvm.disposeMessage(error_message);
626
627 log.err("LLVM failed to parse '{s}': {s}", .{ llvm_target_triple, error_message });
628 return error.InvalidLlvmTriple;
629 }
630
631 builder.llvm_module.setTarget(llvm_target_triple.ptr);
632 var opt_di_builder: ?*llvm.DIBuilder = null;
633 errdefer if (opt_di_builder) |di_builder| di_builder.dispose();
608 var builder = try Builder.init(.{
609 .allocator = gpa,
610 .use_lib_llvm = options.use_lib_llvm,
611 .name = options.root_name,
612 .target = options.target,
613 .triple = llvm_target_triple,
614 });
615 errdefer builder.deinit();
634616
635 var di_compile_unit: ?*llvm.DICompileUnit = null;
617 var target_machine: *llvm.TargetMachine = undefined;
618 var target_data: *llvm.TargetData = undefined;
619 if (builder.useLibLlvm()) {
620 if (!options.strip) {
621 switch (options.target.ofmt) {
622 .coff => builder.llvm.module.?.addModuleCodeViewFlag(),
623 else => builder.llvm.module.?.addModuleDebugInfoFlag(options.dwarf_format == std.dwarf.Format.@"64"),
624 }
625 builder.llvm.di_builder = builder.llvm.module.?.createDIBuilder(true);
626
627 // Don't use the version string here; LLVM misparses it when it
628 // includes the git revision.
629 const producer = try builder.fmt("zig {d}.{d}.{d}", .{
630 build_options.semver.major,
631 build_options.semver.minor,
632 build_options.semver.patch,
633 });
636634
637 if (!options.strip) {
638 switch (options.target.ofmt) {
639 .coff => builder.llvm_module.addModuleCodeViewFlag(),
640 else => builder.llvm_module.addModuleDebugInfoFlag(options.dwarf_format == std.dwarf.Format.@"64"),
641 }
642 const di_builder = builder.llvm_module.createDIBuilder(true);
643 opt_di_builder = di_builder;
644
645 // Don't use the version string here; LLVM misparses it when it
646 // includes the git revision.
647 const producer = try std.fmt.allocPrintZ(gpa, "zig {d}.{d}.{d}", .{
648 build_options.semver.major,
649 build_options.semver.minor,
650 build_options.semver.patch,
651 });
652 defer gpa.free(producer);
653
654 // We fully resolve all paths at this point to avoid lack of source line info in stack
655 // traces or lack of debugging information which, if relative paths were used, would
656 // be very location dependent.
657 // TODO: the only concern I have with this is WASI as either host or target, should
658 // we leave the paths as relative then?
659 var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
660 const compile_unit_dir = blk: {
661 const path = d: {
662 const mod = options.module orelse break :d ".";
663 break :d mod.root_pkg.root_src_directory.path orelse ".";
635 // We fully resolve all paths at this point to avoid lack of source line info in stack
636 // traces or lack of debugging information which, if relative paths were used, would
637 // be very location dependent.
638 // TODO: the only concern I have with this is WASI as either host or target, should
639 // we leave the paths as relative then?
640 var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
641 const compile_unit_dir = blk: {
642 const path = d: {
643 const mod = options.module orelse break :d ".";
644 break :d mod.root_pkg.root_src_directory.path orelse ".";
645 };
646 if (std.fs.path.isAbsolute(path)) break :blk path;
647 break :blk std.os.realpath(path, &buf) catch path; // If realpath fails, fallback to whatever path was
664648 };
665 if (std.fs.path.isAbsolute(path)) break :blk path;
666 break :blk std.os.realpath(path, &buf) catch path; // If realpath fails, fallback to whatever path was
667 };
668 const compile_unit_dir_z = try gpa.dupeZ(u8, compile_unit_dir);
669 defer gpa.free(compile_unit_dir_z);
670
671 di_compile_unit = di_builder.createCompileUnit(
672 DW.LANG.C99,
673 di_builder.createFile(options.root_name, compile_unit_dir_z),
674 producer,
675 options.optimize_mode != .Debug,
676 "", // flags
677 0, // runtime version
678 "", // split name
679 0, // dwo id
680 true, // emit debug info
681 );
682 }
683
684 const opt_level: llvm.CodeGenOptLevel = if (options.optimize_mode == .Debug)
685 .None
686 else
687 .Aggressive;
649 const compile_unit_dir_z = try builder.gpa.dupeZ(u8, compile_unit_dir);
650 defer builder.gpa.free(compile_unit_dir_z);
651
652 builder.llvm.di_compile_unit = builder.llvm.di_builder.?.createCompileUnit(
653 DW.LANG.C99,
654 builder.llvm.di_builder.?.createFile(options.root_name, compile_unit_dir_z),
655 producer.toSlice(&builder).?,
656 options.optimize_mode != .Debug,
657 "", // flags
658 0, // runtime version
659 "", // split name
660 0, // dwo id
661 true, // emit debug info
662 );
663 }
688664
689 const reloc_mode: llvm.RelocMode = if (options.pic)
690 .PIC
691 else if (options.link_mode == .Dynamic)
692 llvm.RelocMode.DynamicNoPIC
693 else
694 .Static;
695
696 const code_model: llvm.CodeModel = switch (options.machine_code_model) {
697 .default => .Default,
698 .tiny => .Tiny,
699 .small => .Small,
700 .kernel => .Kernel,
701 .medium => .Medium,
702 .large => .Large,
703 };
665 const opt_level: llvm.CodeGenOptLevel = if (options.optimize_mode == .Debug)
666 .None
667 else
668 .Aggressive;
704669
705 // TODO handle float ABI better- it should depend on the ABI portion of std.Target
706 const float_abi: llvm.ABIType = .Default;
707
708 const target_machine = llvm.TargetMachine.create(
709 target,
710 llvm_target_triple.ptr,
711 if (options.target.cpu.model.llvm_name) |s| s.ptr else null,
712 options.llvm_cpu_features,
713 opt_level,
714 reloc_mode,
715 code_model,
716 options.function_sections,
717 float_abi,
718 if (target_util.llvmMachineAbi(options.target)) |s| s.ptr else null,
719 );
720 errdefer target_machine.dispose();
670 const reloc_mode: llvm.RelocMode = if (options.pic)
671 .PIC
672 else if (options.link_mode == .Dynamic)
673 llvm.RelocMode.DynamicNoPIC
674 else
675 .Static;
676
677 const code_model: llvm.CodeModel = switch (options.machine_code_model) {
678 .default => .Default,
679 .tiny => .Tiny,
680 .small => .Small,
681 .kernel => .Kernel,
682 .medium => .Medium,
683 .large => .Large,
684 };
721685
722 const target_data = target_machine.createTargetDataLayout();
723 errdefer target_data.dispose();
686 // TODO handle float ABI better- it should depend on the ABI portion of std.Target
687 const float_abi: llvm.ABIType = .Default;
688
689 target_machine = llvm.TargetMachine.create(
690 builder.llvm.target.?,
691 builder.target_triple.toSlice(&builder).?.ptr,
692 if (options.target.cpu.model.llvm_name) |s| s.ptr else null,
693 options.llvm_cpu_features,
694 opt_level,
695 reloc_mode,
696 code_model,
697 options.function_sections,
698 float_abi,
699 if (target_util.llvmMachineAbi(options.target)) |s| s.ptr else null,
700 );
701 errdefer target_machine.dispose();
724702
725 builder.llvm_module.setModuleDataLayout(target_data);
703 target_data = target_machine.createTargetDataLayout();
704 errdefer target_data.dispose();
726705
727 if (options.pic) builder.llvm_module.setModulePICLevel();
728 if (options.pie) builder.llvm_module.setModulePIELevel();
729 if (code_model != .Default) builder.llvm_module.setModuleCodeModel(code_model);
706 builder.llvm.module.?.setModuleDataLayout(target_data);
730707
731 if (options.opt_bisect_limit >= 0) {
732 builder.llvm_context.setOptBisectLimit(std.math.lossyCast(c_int, options.opt_bisect_limit));
733 }
708 if (options.pic) builder.llvm.module.?.setModulePICLevel();
709 if (options.pie) builder.llvm.module.?.setModulePIELevel();
710 if (code_model != .Default) builder.llvm.module.?.setModuleCodeModel(code_model);
734711
735 try builder.init();
736 errdefer builder.deinit();
737 builder.source_filename = try builder.string(options.root_name);
738 builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = options.target }});
739 builder.target_triple = try builder.string(llvm_target_triple);
712 if (options.opt_bisect_limit >= 0) {
713 builder.llvm.context.setOptBisectLimit(std.math.lossyCast(c_int, options.opt_bisect_limit));
714 }
740715
741 if (std.debug.runtime_safety) {
742 const rep = target_data.stringRep();
743 defer llvm.disposeMessage(rep);
744 std.testing.expectEqualStrings(
745 std.mem.span(rep),
746 builder.data_layout.toSlice(&builder).?,
747 ) catch unreachable;
716 builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = options.target }});
717 if (std.debug.runtime_safety) {
718 const rep = target_data.stringRep();
719 defer llvm.disposeMessage(rep);
720 std.testing.expectEqualStrings(
721 std.mem.span(rep),
722 builder.data_layout.toSlice(&builder).?,
723 ) catch unreachable;
724 }
748725 }
749726
750 return Object{
727 return .{
751728 .gpa = gpa,
752729 .builder = builder,
753730 .module = options.module.?,
754 .llvm_module = builder.llvm_module,
731 .llvm_module = builder.llvm.module.?,
755732 .di_map = .{},
756 .di_builder = opt_di_builder,
757 .di_compile_unit = di_compile_unit,
758 .context = builder.llvm_context,
733 .di_builder = builder.llvm.di_builder,
734 .di_compile_unit = builder.llvm.di_compile_unit,
735 .context = builder.llvm.context,
759736 .target_machine = target_machine,
760737 .target_data = target_data,
761738 .target = options.target,
......@@ -770,15 +747,10 @@ pub const Object = struct {
770747 }
771748
772749 pub fn deinit(self: *Object, gpa: Allocator) void {
773 if (self.di_builder) |dib| {
774 dib.dispose();
775 self.di_map.deinit(gpa);
776 self.di_type_map.deinit(gpa);
777 }
750 self.di_map.deinit(gpa);
751 self.di_type_map.deinit(gpa);
778752 self.target_data.dispose();
779753 self.target_machine.dispose();
780 self.llvm_module.dispose();
781 self.context.dispose();
782754 self.decl_map.deinit(gpa);
783755 self.named_enum_map.deinit(gpa);
784756 self.type_map.deinit(gpa);
......@@ -845,7 +817,7 @@ pub const Object = struct {
845817 .mutability = .constant,
846818 .init = str_init,
847819 };
848 try o.builder.llvm_globals.append(o.gpa, str_global);
820 try o.builder.llvm.globals.append(o.gpa, str_global);
849821 const str_global_index = try o.builder.addGlobal(.none, global);
850822 try o.builder.variables.append(o.gpa, variable);
851823
......@@ -875,7 +847,7 @@ pub const Object = struct {
875847 .mutability = .constant,
876848 .init = error_name_table_init,
877849 };
878 try o.builder.llvm_globals.append(o.gpa, error_name_table_global);
850 try o.builder.llvm.globals.append(o.gpa, error_name_table_global);
879851 _ = try o.builder.addGlobal(.none, global);
880852 try o.builder.variables.append(o.gpa, variable);
881853
......@@ -941,7 +913,7 @@ pub const Object = struct {
941913
942914 llvm_global.replaceAllUsesWith(other_llvm_global);
943915 deleteLlvmGlobal(llvm_global);
944 object.builder.llvm_globals.items[@intFromEnum(global)] = other_llvm_global;
916 object.builder.llvm.globals.items[@intFromEnum(global)] = other_llvm_global;
945917 }
946918 object.extern_collisions.clearRetainingCapacity();
947919
......@@ -960,7 +932,7 @@ pub const Object = struct {
960932 other_llvm_global.replaceAllUsesWith(llvm_global);
961933 try global.takeName(&object.builder, other_global);
962934 deleteLlvmGlobal(other_llvm_global);
963 object.builder.llvm_globals.items[@intFromEnum(other_global)] = llvm_global;
935 object.builder.llvm.globals.items[@intFromEnum(other_global)] = llvm_global;
964936 // Problem: now we need to replace in the decl_map that
965937 // the extern decl index points to this new global. However we don't
966938 // know the decl index.
......@@ -2765,7 +2737,7 @@ pub const Object = struct {
27652737 .global = @enumFromInt(o.builder.globals.count()),
27662738 .init = llvm_init,
27672739 };
2768 try o.builder.llvm_globals.append(o.gpa, llvm_global);
2740 try o.builder.llvm.globals.append(o.gpa, llvm_global);
27692741 _ = try o.builder.addGlobal(.none, global);
27702742 try o.builder.variables.append(o.gpa, variable);
27712743
......@@ -2908,7 +2880,7 @@ pub const Object = struct {
29082880 };
29092881 }
29102882
2911 try o.builder.llvm_globals.append(o.gpa, llvm_fn);
2883 try o.builder.llvm.globals.append(o.gpa, llvm_fn);
29122884 gop.value_ptr.* = try o.builder.addGlobal(fqn, global);
29132885 try o.builder.functions.append(o.gpa, function);
29142886 return global.kind.function;
......@@ -3017,7 +2989,7 @@ pub const Object = struct {
30172989 llvm_global.setUnnamedAddr(.True);
30182990 }
30192991
3020 try o.builder.llvm_globals.append(o.gpa, llvm_global);
2992 try o.builder.llvm.globals.append(o.gpa, llvm_global);
30212993 gop.value_ptr.* = try o.builder.addGlobal(name, global);
30222994 try o.builder.variables.append(o.gpa, variable);
30232995 return global.kind.variable;
......@@ -4553,7 +4525,7 @@ pub const DeclGen = struct {
45534525 // TODO: How should this work then the address space of a global changed?
45544526 llvm_global.replaceAllUsesWith(new_global);
45554527 new_global.takeName(llvm_global);
4556 o.builder.llvm_globals.items[@intFromEnum(object.ptrConst(&o.builder).global)] =
4528 o.builder.llvm.globals.items[@intFromEnum(object.ptrConst(&o.builder).global)] =
45574529 new_global;
45584530 llvm_global.deleteGlobal();
45594531 llvm_global = new_global;
......@@ -4699,7 +4671,7 @@ pub const FuncGen = struct {
46994671 .mutability = .constant,
47004672 .init = llvm_val,
47014673 };
4702 try o.builder.llvm_globals.append(o.gpa, llvm_global);
4674 try o.builder.llvm.globals.append(o.gpa, llvm_global);
47034675 _ = try o.builder.addGlobal(.none, global);
47044676 try o.builder.variables.append(o.gpa, variable);
47054677
......@@ -7855,7 +7827,7 @@ pub const FuncGen = struct {
78557827 .global = @enumFromInt(o.builder.globals.count()),
78567828 };
78577829
7858 try o.builder.llvm_globals.append(self.gpa, f);
7830 try o.builder.llvm.globals.append(self.gpa, f);
78597831 _ = try o.builder.addGlobal(fn_name, global);
78607832 try o.builder.functions.append(self.gpa, function);
78617833 break :b f;
......@@ -9372,7 +9344,7 @@ pub const FuncGen = struct {
93729344 self.builder.positionBuilderAtEnd(unnamed_block);
93739345 _ = self.builder.buildRet(Builder.Constant.false.toLlvm(&o.builder));
93749346
9375 try o.builder.llvm_globals.append(self.gpa, fn_val);
9347 try o.builder.llvm.globals.append(self.gpa, fn_val);
93769348 _ = try o.builder.addGlobal(llvm_fn_name, global);
93779349 try o.builder.functions.append(self.gpa, function);
93789350 gop.value_ptr.* = global.kind.function;
......@@ -9484,7 +9456,7 @@ pub const FuncGen = struct {
94849456 self.builder.positionBuilderAtEnd(bad_value_block);
94859457 _ = self.builder.buildUnreachable();
94869458
9487 try o.builder.llvm_globals.append(self.gpa, fn_val);
9459 try o.builder.llvm.globals.append(self.gpa, fn_val);
94889460 gop.value_ptr.* = try o.builder.addGlobal(llvm_fn_name, global);
94899461 try o.builder.functions.append(self.gpa, function);
94909462 return fn_val;
......@@ -9515,7 +9487,7 @@ pub const FuncGen = struct {
95159487 .global = @enumFromInt(o.builder.globals.count()),
95169488 };
95179489
9518 try o.builder.llvm_globals.append(self.gpa, llvm_fn);
9490 try o.builder.llvm.globals.append(self.gpa, llvm_fn);
95199491 _ = try o.builder.addGlobal(try o.builder.string(lt_errors_fn_name), global);
95209492 try o.builder.functions.append(self.gpa, function);
95219493 return llvm_fn;
......@@ -10156,7 +10128,7 @@ pub const FuncGen = struct {
1015610128 .mutability = .constant,
1015710129 .init = undef_init,
1015810130 };
10159 try o.builder.llvm_globals.append(o.gpa, error_name_table_global);
10131 try o.builder.llvm.globals.append(o.gpa, error_name_table_global);
1016010132 _ = try o.builder.addGlobal(name, global);
1016110133 try o.builder.variables.append(o.gpa, variable);
1016210134
src/codegen/llvm/Builder.zig+130-66
......@@ -1,12 +1,16 @@
11gpa: Allocator,
22use_lib_llvm: bool,
33
4llvm_context: *llvm.Context,
5llvm_module: *llvm.Module,
6di_builder: ?*llvm.DIBuilder = null,
7llvm_types: std.ArrayListUnmanaged(*llvm.Type) = .{},
8llvm_globals: std.ArrayListUnmanaged(*llvm.Value) = .{},
9llvm_constants: std.ArrayListUnmanaged(*llvm.Value) = .{},
4llvm: if (build_options.have_llvm) struct {
5 context: *llvm.Context,
6 module: ?*llvm.Module = null,
7 target: ?*llvm.Target = null,
8 di_builder: ?*llvm.DIBuilder = null,
9 di_compile_unit: ?*llvm.DICompileUnit = null,
10 types: std.ArrayListUnmanaged(*llvm.Type) = .{},
11 globals: std.ArrayListUnmanaged(*llvm.Value) = .{},
12 constants: std.ArrayListUnmanaged(*llvm.Value) = .{},
13} else void,
1014
1115source_filename: String = .none,
1216data_layout: String = .none,
......@@ -38,6 +42,14 @@ constant_limbs: std.ArrayListUnmanaged(std.math.big.Limb) = .{},
3842pub const expected_fields_len = 32;
3943pub const expected_gep_indices_len = 8;
4044
45pub const Options = struct {
46 allocator: Allocator,
47 use_lib_llvm: bool = false,
48 name: []const u8 = &.{},
49 target: std.Target = builtin.target,
50 triple: []const u8 = &.{},
51};
52
4153pub const String = enum(u32) {
4254 none = std.math.maxInt(u31),
4355 empty,
......@@ -481,7 +493,7 @@ pub const Type = enum(u32) {
481493
482494 pub fn toLlvm(self: Type, builder: *const Builder) *llvm.Type {
483495 assert(builder.useLibLlvm());
484 return builder.llvm_types.items[@intFromEnum(self)];
496 return builder.llvm.types.items[@intFromEnum(self)];
485497 }
486498};
487499
......@@ -751,7 +763,7 @@ pub const Global = struct {
751763
752764 pub fn toLlvm(self: Index, builder: *const Builder) *llvm.Value {
753765 assert(builder.useLibLlvm());
754 return builder.llvm_globals.items[@intFromEnum(self)];
766 return builder.llvm.globals.items[@intFromEnum(self)];
755767 }
756768
757769 const FormatData = struct {
......@@ -780,9 +792,9 @@ pub const Global = struct {
780792 pub fn renameAssumeCapacity(self: Index, builder: *Builder, name: String) void {
781793 const index = @intFromEnum(self);
782794 if (builder.globals.keys()[index] == name) return;
783 if (builder.useLibLlvm()) builder.llvm_globals.appendAssumeCapacity(builder.llvm_globals.items[index]);
795 if (builder.useLibLlvm()) builder.llvm.globals.appendAssumeCapacity(builder.llvm.globals.items[index]);
784796 _ = builder.addGlobalAssumeCapacity(name, builder.globals.values()[index]);
785 if (builder.useLibLlvm()) _ = builder.llvm_globals.pop();
797 if (builder.useLibLlvm()) _ = builder.llvm.globals.pop();
786798 builder.globals.swapRemoveAt(index);
787799 self.updateName(builder);
788800 }
......@@ -802,7 +814,7 @@ pub const Global = struct {
802814 if (!builder.useLibLlvm()) return;
803815 const index = @intFromEnum(self);
804816 const slice = builder.globals.keys()[index].toSlice(builder) orelse "";
805 builder.llvm_globals.items[index].setValueName2(slice.ptr, slice.len);
817 builder.llvm.globals.items[index].setValueName2(slice.ptr, slice.len);
806818 }
807819 };
808820
......@@ -1414,7 +1426,7 @@ pub const Constant = enum(u32) {
14141426 pub fn toLlvm(self: Constant, builder: *const Builder) *llvm.Value {
14151427 assert(builder.useLibLlvm());
14161428 return switch (self.unwrap()) {
1417 .constant => |constant| builder.llvm_constants.items[constant],
1429 .constant => |constant| builder.llvm.constants.items[constant],
14181430 .global => |global| global.toLlvm(builder),
14191431 };
14201432 }
......@@ -1436,26 +1448,70 @@ pub const Value = enum(u32) {
14361448 }
14371449};
14381450
1439pub fn init(self: *Builder) Allocator.Error!void {
1451pub const InitError = error{
1452 InvalidLlvmTriple,
1453} || Allocator.Error;
1454
1455pub fn init(options: Options) InitError!Builder {
1456 var self = Builder{
1457 .gpa = options.allocator,
1458 .use_lib_llvm = options.use_lib_llvm,
1459 .llvm = undefined,
1460 };
1461 if (self.useLibLlvm()) self.llvm = .{ .context = llvm.Context.create() };
1462 errdefer self.deinit();
1463
14401464 try self.string_indices.append(self.gpa, 0);
14411465 assert(try self.string("") == .empty);
14421466
1467 if (options.name.len > 0) self.source_filename = try self.string(options.name);
1468 self.initializeLLVMTarget(options.target.cpu.arch);
1469 if (self.useLibLlvm()) self.llvm.module = llvm.Module.createWithName(
1470 (self.source_filename.toSlice(&self) orelse "").ptr,
1471 self.llvm.context,
1472 );
1473
1474 if (options.triple.len > 0) {
1475 self.target_triple = try self.string(options.triple);
1476
1477 if (self.useLibLlvm()) {
1478 var error_message: [*:0]const u8 = undefined;
1479 var target: *llvm.Target = undefined;
1480 if (llvm.Target.getFromTriple(
1481 self.target_triple.toSlice(&self).?.ptr,
1482 &target,
1483 &error_message,
1484 ).toBool()) {
1485 defer llvm.disposeMessage(error_message);
1486
1487 log.err("LLVM failed to parse '{s}': {s}", .{
1488 self.target_triple.toSlice(&self).?,
1489 error_message,
1490 });
1491 return InitError.InvalidLlvmTriple;
1492 }
1493 self.llvm.target = target;
1494 self.llvm.module.?.setTarget(self.target_triple.toSlice(&self).?.ptr);
1495 }
1496 }
1497
14431498 {
14441499 const static_len = @typeInfo(Type).Enum.fields.len - 1;
14451500 try self.type_map.ensureTotalCapacity(self.gpa, static_len);
14461501 try self.type_items.ensureTotalCapacity(self.gpa, static_len);
1447 if (self.useLibLlvm()) try self.llvm_types.ensureTotalCapacity(self.gpa, static_len);
1502 if (self.useLibLlvm()) try self.llvm.types.ensureTotalCapacity(self.gpa, static_len);
14481503 inline for (@typeInfo(Type.Simple).Enum.fields) |simple_field| {
14491504 const result = self.getOrPutTypeNoExtraAssumeCapacity(
14501505 .{ .tag = .simple, .data = simple_field.value },
14511506 );
14521507 assert(result.new and result.type == @field(Type, simple_field.name));
1453 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
1454 @field(llvm.Context, simple_field.name ++ "Type")(self.llvm_context),
1508 if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(
1509 @field(llvm.Context, simple_field.name ++ "Type")(self.llvm.context),
14551510 );
14561511 }
1457 inline for (.{ 1, 8, 16, 29, 32, 64, 80, 128 }) |bits| assert(self.intTypeAssumeCapacity(bits) ==
1458 @field(Type, std.fmt.comptimePrint("i{d}", .{bits})));
1512 inline for (.{ 1, 8, 16, 29, 32, 64, 80, 128 }) |bits|
1513 assert(self.intTypeAssumeCapacity(bits) ==
1514 @field(Type, std.fmt.comptimePrint("i{d}", .{bits})));
14591515 inline for (.{0}) |addr_space|
14601516 assert(self.ptrTypeAssumeCapacity(@enumFromInt(addr_space)) == .ptr);
14611517 }
......@@ -1463,13 +1519,11 @@ pub fn init(self: *Builder) Allocator.Error!void {
14631519 assert(try self.intConst(.i1, 0) == .false);
14641520 assert(try self.intConst(.i1, 1) == .true);
14651521 assert(try self.noneConst(.token) == .none);
1522
1523 return self;
14661524}
14671525
14681526pub fn deinit(self: *Builder) void {
1469 self.llvm_types.deinit(self.gpa);
1470 self.llvm_globals.deinit(self.gpa);
1471 self.llvm_constants.deinit(self.gpa);
1472
14731527 self.string_map.deinit(self.gpa);
14741528 self.string_bytes.deinit(self.gpa);
14751529 self.string_indices.deinit(self.gpa);
......@@ -1492,6 +1546,14 @@ pub fn deinit(self: *Builder) void {
14921546 self.constant_extra.deinit(self.gpa);
14931547 self.constant_limbs.deinit(self.gpa);
14941548
1549 if (self.useLibLlvm()) {
1550 self.llvm.constants.deinit(self.gpa);
1551 self.llvm.globals.deinit(self.gpa);
1552 self.llvm.types.deinit(self.gpa);
1553 if (self.llvm.di_builder) |di_builder| di_builder.dispose();
1554 if (self.llvm.module) |module| module.dispose();
1555 self.llvm.context.dispose();
1556 }
14951557 self.* = undefined;
14961558}
14971559
......@@ -1807,7 +1869,7 @@ pub fn namedTypeSetBody(
18071869 const llvm_fields = try self.gpa.alloc(*llvm.Type, body_fields.len);
18081870 defer self.gpa.free(llvm_fields);
18091871 for (llvm_fields, body_fields) |*llvm_field, body_field| llvm_field.* = body_field.toLlvm(self);
1810 self.llvm_types.items[@intFromEnum(named_type)].structSetBody(
1872 self.llvm.types.items[@intFromEnum(named_type)].structSetBody(
18111873 llvm_fields.ptr,
18121874 @intCast(llvm_fields.len),
18131875 switch (body_item.tag) {
......@@ -1869,7 +1931,7 @@ pub fn bigIntConst(self: *Builder, ty: Type, value: std.math.big.int.Const) Allo
18691931 try self.constant_map.ensureUnusedCapacity(self.gpa, 1);
18701932 try self.constant_items.ensureUnusedCapacity(self.gpa, 1);
18711933 try self.constant_limbs.ensureUnusedCapacity(self.gpa, Constant.Integer.limbs + value.limbs.len);
1872 if (self.useLibLlvm()) try self.llvm_constants.ensureUnusedCapacity(self.gpa, 1);
1934 if (self.useLibLlvm()) try self.llvm.constants.ensureUnusedCapacity(self.gpa, 1);
18731935 return self.bigIntConstAssumeCapacity(ty, value);
18741936}
18751937
......@@ -2166,7 +2228,7 @@ fn isValidIdentifier(id: []const u8) bool {
21662228}
21672229
21682230fn ensureUnusedCapacityGlobal(self: *Builder, name: String) Allocator.Error!void {
2169 if (self.useLibLlvm()) try self.llvm_globals.ensureUnusedCapacity(self.gpa, 1);
2231 if (self.useLibLlvm()) try self.llvm.globals.ensureUnusedCapacity(self.gpa, 1);
21702232 try self.string_map.ensureUnusedCapacity(self.gpa, 1);
21712233 if (name.toSlice(self)) |id| try self.string_bytes.ensureUnusedCapacity(self.gpa, id.len +
21722234 comptime std.fmt.count("{d}" ++ .{0}, .{std.math.maxInt(u32)}));
......@@ -2222,7 +2284,7 @@ fn fnTypeAssumeCapacity(
22222284 const llvm_params = try self.gpa.alloc(*llvm.Type, params.len);
22232285 defer self.gpa.free(llvm_params);
22242286 for (llvm_params, params) |*llvm_param, param| llvm_param.* = param.toLlvm(self);
2225 self.llvm_types.appendAssumeCapacity(llvm.functionType(
2287 self.llvm.types.appendAssumeCapacity(llvm.functionType(
22262288 ret.toLlvm(self),
22272289 llvm_params.ptr,
22282290 @intCast(llvm_params.len),
......@@ -2240,7 +2302,7 @@ fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type {
22402302 assert(bits > 0);
22412303 const result = self.getOrPutTypeNoExtraAssumeCapacity(.{ .tag = .integer, .data = bits });
22422304 if (self.useLibLlvm() and result.new)
2243 self.llvm_types.appendAssumeCapacity(self.llvm_context.intType(bits));
2305 self.llvm.types.appendAssumeCapacity(self.llvm.context.intType(bits));
22442306 return result.type;
22452307}
22462308
......@@ -2249,7 +2311,7 @@ fn ptrTypeAssumeCapacity(self: *Builder, addr_space: AddrSpace) Type {
22492311 .{ .tag = .pointer, .data = @intFromEnum(addr_space) },
22502312 );
22512313 if (self.useLibLlvm() and result.new)
2252 self.llvm_types.appendAssumeCapacity(self.llvm_context.pointerType(@intFromEnum(addr_space)));
2314 self.llvm.types.appendAssumeCapacity(self.llvm.context.pointerType(@intFromEnum(addr_space)));
22532315 return result.type;
22542316}
22552317
......@@ -2286,7 +2348,7 @@ fn vectorTypeAssumeCapacity(
22862348 .tag = tag,
22872349 .data = self.addTypeExtraAssumeCapacity(data),
22882350 });
2289 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(switch (kind) {
2351 if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(switch (kind) {
22902352 .normal => &llvm.Type.vectorType,
22912353 .scalable => &llvm.Type.scalableVectorType,
22922354 }(child.toLlvm(self), @intCast(len)));
......@@ -2319,7 +2381,7 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type {
23192381 .tag = .small_array,
23202382 .data = self.addTypeExtraAssumeCapacity(data),
23212383 });
2322 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
2384 if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(
23232385 child.toLlvm(self).arrayType(@intCast(len)),
23242386 );
23252387 }
......@@ -2352,7 +2414,7 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type {
23522414 .tag = .array,
23532415 .data = self.addTypeExtraAssumeCapacity(data),
23542416 });
2355 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
2417 if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(
23562418 child.toLlvm(self).arrayType(@intCast(len)),
23572419 );
23582420 }
......@@ -2406,7 +2468,7 @@ fn structTypeAssumeCapacity(
24062468 defer allocator.free(llvm_fields);
24072469 for (llvm_fields, fields) |*llvm_field, field| llvm_field.* = field.toLlvm(self);
24082470
2409 self.llvm_types.appendAssumeCapacity(self.llvm_context.structType(
2471 self.llvm.types.appendAssumeCapacity(self.llvm.context.structType(
24102472 llvm_fields.ptr,
24112473 @intCast(llvm_fields.len),
24122474 switch (kind) {
......@@ -2456,8 +2518,8 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type {
24562518 });
24572519 const result: Type = @enumFromInt(gop.index);
24582520 type_gop.value_ptr.* = result;
2459 if (self.useLibLlvm()) self.llvm_types.appendAssumeCapacity(
2460 self.llvm_context.structCreateNamed(id.toSlice(self) orelse ""),
2521 if (self.useLibLlvm()) self.llvm.types.appendAssumeCapacity(
2522 self.llvm.context.structCreateNamed(id.toSlice(self) orelse ""),
24612523 );
24622524 return result;
24632525 }
......@@ -2481,7 +2543,7 @@ fn ensureUnusedTypeCapacity(
24812543 self.gpa,
24822544 count * (@typeInfo(E).Struct.fields.len + trail_len),
24832545 ) else assert(trail_len == 0);
2484 if (self.useLibLlvm()) try self.llvm_types.ensureUnusedCapacity(self.gpa, count);
2546 if (self.useLibLlvm()) try self.llvm.types.ensureUnusedCapacity(self.gpa, count);
24852547}
24862548
24872549fn getOrPutTypeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { new: bool, type: Type } {
......@@ -2613,9 +2675,9 @@ fn bigIntConstAssumeCapacity(
26132675 if (self.useLibLlvm()) {
26142676 const llvm_type = ty.toLlvm(self);
26152677 if (canonical_value.to(c_longlong)) |small| {
2616 self.llvm_constants.appendAssumeCapacity(llvm_type.constInt(@bitCast(small), .True));
2678 self.llvm.constants.appendAssumeCapacity(llvm_type.constInt(@bitCast(small), .True));
26172679 } else |_| if (canonical_value.to(c_ulonglong)) |small| {
2618 self.llvm_constants.appendAssumeCapacity(llvm_type.constInt(small, .False));
2680 self.llvm.constants.appendAssumeCapacity(llvm_type.constInt(small, .False));
26192681 } else |_| {
26202682 const llvm_limbs = try allocator.alloc(u64, std.math.divCeil(
26212683 usize,
......@@ -2643,7 +2705,7 @@ fn bigIntConstAssumeCapacity(
26432705 }
26442706 result_limb.* = llvm_limb;
26452707 }
2646 self.llvm_constants.appendAssumeCapacity(
2708 self.llvm.constants.appendAssumeCapacity(
26472709 llvm_type.constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), llvm_limbs.ptr),
26482710 );
26492711 }
......@@ -2656,7 +2718,7 @@ fn halfConstAssumeCapacity(self: *Builder, val: f16) Constant {
26562718 const result = self.getOrPutConstantNoExtraAssumeCapacity(
26572719 .{ .tag = .half, .data = @as(u16, @bitCast(val)) },
26582720 );
2659 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
2721 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(
26602722 if (std.math.isSignalNan(val))
26612723 Type.i16.toLlvm(self).constInt(@as(u16, @bitCast(val)), .False)
26622724 .constBitCast(Type.half.toLlvm(self))
......@@ -2671,7 +2733,7 @@ fn bfloatConstAssumeCapacity(self: *Builder, val: f32) Constant {
26712733 const result = self.getOrPutConstantNoExtraAssumeCapacity(
26722734 .{ .tag = .bfloat, .data = @bitCast(val) },
26732735 );
2674 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
2736 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(
26752737 if (std.math.isSignalNan(val))
26762738 Type.i16.toLlvm(self).constInt(@as(u32, @bitCast(val)) >> 16, .False)
26772739 .constBitCast(Type.bfloat.toLlvm(self))
......@@ -2680,7 +2742,7 @@ fn bfloatConstAssumeCapacity(self: *Builder, val: f32) Constant {
26802742 );
26812743
26822744 if (self.useLibLlvm() and result.new)
2683 self.llvm_constants.appendAssumeCapacity(Type.bfloat.toLlvm(self).constReal(val));
2745 self.llvm.constants.appendAssumeCapacity(Type.bfloat.toLlvm(self).constReal(val));
26842746 return result.constant;
26852747}
26862748
......@@ -2688,7 +2750,7 @@ fn floatConstAssumeCapacity(self: *Builder, val: f32) Constant {
26882750 const result = self.getOrPutConstantNoExtraAssumeCapacity(
26892751 .{ .tag = .float, .data = @bitCast(val) },
26902752 );
2691 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
2753 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(
26922754 if (std.math.isSignalNan(val))
26932755 Type.i32.toLlvm(self).constInt(@as(u32, @bitCast(val)), .False)
26942756 .constBitCast(Type.float.toLlvm(self))
......@@ -2725,7 +2787,7 @@ fn doubleConstAssumeCapacity(self: *Builder, val: f64) Constant {
27252787 .hi = @truncate(@as(u64, @bitCast(val))),
27262788 }),
27272789 });
2728 if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(
2790 if (self.useLibLlvm()) self.llvm.constants.appendAssumeCapacity(
27292791 if (std.math.isSignalNan(val))
27302792 Type.i64.toLlvm(self).constInt(@as(u64, @bitCast(val)), .False)
27312793 .constBitCast(Type.double.toLlvm(self))
......@@ -2771,7 +2833,7 @@ fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant {
27712833 @truncate(@as(u128, @bitCast(val))),
27722834 @intCast(@as(u128, @bitCast(val)) >> 64),
27732835 };
2774 self.llvm_constants.appendAssumeCapacity(
2836 self.llvm.constants.appendAssumeCapacity(
27752837 Type.i128.toLlvm(self)
27762838 .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), &llvm_limbs)
27772839 .constBitCast(Type.fp128.toLlvm(self)),
......@@ -2815,7 +2877,7 @@ fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant {
28152877 @truncate(@as(u80, @bitCast(val))),
28162878 @intCast(@as(u80, @bitCast(val)) >> 64),
28172879 };
2818 self.llvm_constants.appendAssumeCapacity(
2880 self.llvm.constants.appendAssumeCapacity(
28192881 Type.i80.toLlvm(self)
28202882 .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), &llvm_limbs)
28212883 .constBitCast(Type.x86_fp80.toLlvm(self)),
......@@ -2857,7 +2919,7 @@ fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant {
28572919 });
28582920 if (self.useLibLlvm()) {
28592921 const llvm_limbs: *const [2]u64 = @ptrCast(&val);
2860 self.llvm_constants.appendAssumeCapacity(
2922 self.llvm.constants.appendAssumeCapacity(
28612923 Type.i128.toLlvm(self)
28622924 .constIntOfArbitraryPrecision(@intCast(llvm_limbs.len), llvm_limbs)
28632925 .constBitCast(Type.ppc_fp128.toLlvm(self)),
......@@ -2873,7 +2935,7 @@ fn nullConstAssumeCapacity(self: *Builder, ty: Type) Constant {
28732935 .{ .tag = .null, .data = @intFromEnum(ty) },
28742936 );
28752937 if (self.useLibLlvm() and result.new)
2876 self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
2938 self.llvm.constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
28772939 return result.constant;
28782940}
28792941
......@@ -2883,7 +2945,7 @@ fn noneConstAssumeCapacity(self: *Builder, ty: Type) Constant {
28832945 .{ .tag = .none, .data = @intFromEnum(ty) },
28842946 );
28852947 if (self.useLibLlvm() and result.new)
2886 self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
2948 self.llvm.constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
28872949 return result.constant;
28882950}
28892951
......@@ -2929,7 +2991,7 @@ fn structConstAssumeCapacity(
29292991 defer allocator.free(llvm_vals);
29302992 for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
29312993
2932 self.llvm_constants.appendAssumeCapacity(
2994 self.llvm.constants.appendAssumeCapacity(
29332995 ty.toLlvm(self).constNamedStruct(llvm_vals.ptr, @intCast(llvm_vals.len)),
29342996 );
29352997 }
......@@ -2971,7 +3033,7 @@ fn arrayConstAssumeCapacity(
29713033 defer allocator.free(llvm_vals);
29723034 for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
29733035
2974 self.llvm_constants.appendAssumeCapacity(
3036 self.llvm.constants.appendAssumeCapacity(
29753037 type_extra.child.toLlvm(self).constArray(llvm_vals.ptr, @intCast(llvm_vals.len)),
29763038 );
29773039 }
......@@ -2985,8 +3047,8 @@ fn stringConstAssumeCapacity(self: *Builder, val: String) Constant {
29853047 const result = self.getOrPutConstantNoExtraAssumeCapacity(
29863048 .{ .tag = .string, .data = @intFromEnum(val) },
29873049 );
2988 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
2989 self.llvm_context.constString(slice.ptr, @intCast(slice.len), .True),
3050 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(
3051 self.llvm.context.constString(slice.ptr, @intCast(slice.len), .True),
29903052 );
29913053 return result.constant;
29923054}
......@@ -2998,8 +3060,8 @@ fn stringNullConstAssumeCapacity(self: *Builder, val: String) Constant {
29983060 const result = self.getOrPutConstantNoExtraAssumeCapacity(
29993061 .{ .tag = .string_null, .data = @intFromEnum(val) },
30003062 );
3001 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(
3002 self.llvm_context.constString(slice.ptr, @intCast(slice.len + 1), .True),
3063 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(
3064 self.llvm.context.constString(slice.ptr, @intCast(slice.len + 1), .True),
30033065 );
30043066 return result.constant;
30053067}
......@@ -3032,7 +3094,7 @@ fn vectorConstAssumeCapacity(
30323094 defer allocator.free(llvm_vals);
30333095 for (llvm_vals, vals) |*llvm_val, val| llvm_val.* = val.toLlvm(self);
30343096
3035 self.llvm_constants.appendAssumeCapacity(
3097 self.llvm.constants.appendAssumeCapacity(
30363098 llvm.constVector(llvm_vals.ptr, @intCast(llvm_vals.len)),
30373099 );
30383100 }
......@@ -3061,7 +3123,7 @@ fn zeroInitConstAssumeCapacity(self: *Builder, ty: Type) Constant {
30613123 .{ .tag = .zeroinitializer, .data = @intFromEnum(ty) },
30623124 );
30633125 if (self.useLibLlvm() and result.new)
3064 self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
3126 self.llvm.constants.appendAssumeCapacity(ty.toLlvm(self).constNull());
30653127 return result.constant;
30663128}
30673129
......@@ -3078,7 +3140,7 @@ fn undefConstAssumeCapacity(self: *Builder, ty: Type) Constant {
30783140 .{ .tag = .undef, .data = @intFromEnum(ty) },
30793141 );
30803142 if (self.useLibLlvm() and result.new)
3081 self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
3143 self.llvm.constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
30823144 return result.constant;
30833145}
30843146
......@@ -3095,7 +3157,7 @@ fn poisonConstAssumeCapacity(self: *Builder, ty: Type) Constant {
30953157 .{ .tag = .poison, .data = @intFromEnum(ty) },
30963158 );
30973159 if (self.useLibLlvm() and result.new)
3098 self.llvm_constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
3160 self.llvm.constants.appendAssumeCapacity(ty.toLlvm(self).getUndef());
30993161 return result.constant;
31003162}
31013163
......@@ -3128,7 +3190,7 @@ fn blockAddrConstAssumeCapacity(
31283190 .tag = .blockaddress,
31293191 .data = self.addConstantExtraAssumeCapacity(data),
31303192 });
3131 if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(
3193 if (self.useLibLlvm()) self.llvm.constants.appendAssumeCapacity(
31323194 function.toLlvm(self).blockAddress(block.toValue(self, function).toLlvm(self, function)),
31333195 );
31343196 }
......@@ -3139,7 +3201,7 @@ fn dsoLocalEquivalentConstAssumeCapacity(self: *Builder, function: Function.Inde
31393201 const result = self.getOrPutConstantNoExtraAssumeCapacity(
31403202 .{ .tag = .dso_local_equivalent, .data = @intFromEnum(function) },
31413203 );
3142 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(undefined);
3204 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(undefined);
31433205 return result.constant;
31443206}
31453207
......@@ -3147,7 +3209,7 @@ fn noCfiConstAssumeCapacity(self: *Builder, function: Function.Index) Constant {
31473209 const result = self.getOrPutConstantNoExtraAssumeCapacity(
31483210 .{ .tag = .no_cfi, .data = @intFromEnum(function) },
31493211 );
3150 if (self.useLibLlvm() and result.new) self.llvm_constants.appendAssumeCapacity(undefined);
3212 if (self.useLibLlvm() and result.new) self.llvm.constants.appendAssumeCapacity(undefined);
31513213 return result.constant;
31523214}
31533215
......@@ -3226,7 +3288,7 @@ fn castConstAssumeCapacity(self: *Builder, tag: Constant.Tag, arg: Constant, ty:
32263288 .tag = tag,
32273289 .data = self.addConstantExtraAssumeCapacity(data.cast),
32283290 });
3229 if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(switch (tag) {
3291 if (self.useLibLlvm()) self.llvm.constants.appendAssumeCapacity(switch (tag) {
32303292 .trunc => &llvm.Value.constTrunc,
32313293 .zext => &llvm.Value.constZExt,
32323294 .sext => &llvm.Value.constSExt,
......@@ -3330,7 +3392,7 @@ fn gepConstAssumeCapacity(
33303392 defer allocator.free(llvm_indices);
33313393 for (llvm_indices, indices) |*llvm_index, index| llvm_index.* = index.toLlvm(self);
33323394
3333 self.llvm_constants.appendAssumeCapacity(switch (kind) {
3395 self.llvm.constants.appendAssumeCapacity(switch (kind) {
33343396 .normal => &llvm.Type.constGEP,
33353397 .inbounds => &llvm.Type.constInBoundsGEP,
33363398 }(ty.toLlvm(self), base.toLlvm(self), llvm_indices.ptr, @intCast(indices.len)));
......@@ -3374,7 +3436,7 @@ fn binConstAssumeCapacity(
33743436 .tag = tag,
33753437 .data = self.addConstantExtraAssumeCapacity(data.bin),
33763438 });
3377 if (self.useLibLlvm()) self.llvm_constants.appendAssumeCapacity(switch (tag) {
3439 if (self.useLibLlvm()) self.llvm.constants.appendAssumeCapacity(switch (tag) {
33783440 .add => &llvm.Value.constAdd,
33793441 .sub => &llvm.Value.constSub,
33803442 .mul => &llvm.Value.constMul,
......@@ -3402,7 +3464,7 @@ fn ensureUnusedConstantCapacity(
34023464 self.gpa,
34033465 count * (@typeInfo(E).Struct.fields.len + trail_len),
34043466 ) else assert(trail_len == 0);
3405 if (self.useLibLlvm()) try self.llvm_constants.ensureUnusedCapacity(self.gpa, count);
3467 if (self.useLibLlvm()) try self.llvm.constants.ensureUnusedCapacity(self.gpa, count);
34063468}
34073469
34083470fn getOrPutConstantNoExtraAssumeCapacity(
......@@ -3516,13 +3578,15 @@ fn constantExtraData(self: *const Builder, comptime T: type, index: Constant.Ite
35163578 return self.constantExtraDataTrail(T, index).data;
35173579}
35183580
3519inline fn useLibLlvm(self: *const Builder) bool {
3581pub inline fn useLibLlvm(self: *const Builder) bool {
35203582 return build_options.have_llvm and self.use_lib_llvm;
35213583}
35223584
35233585const assert = std.debug.assert;
35243586const build_options = @import("build_options");
3587const builtin = @import("builtin");
35253588const llvm = @import("bindings.zig");
3589const log = std.log.scoped(.llvm);
35263590const std = @import("std");
35273591
35283592const Allocator = std.mem.Allocator;