Commit 3743c3e39c6bb645db7403fd446953d43ac7c7dc | zig

src/Compilation.zig+31-41

 @@ -2188,14 +2188,10 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             },
         }
-        // Handle the case of e.g. -fno-emit-bin -femit-llvm-ir.
+        if (use_llvm) {
-        if (options.emit_bin == null and (comp.verbose_llvm_ir != null or
+            if (opt_zcu) |zcu| {
-            comp.verbose_llvm_bc != null or
+                zcu.llvm_object = try LlvmObject.create(arena, comp);
-            (use_llvm and comp.emit_asm != null) or
+            }
-            comp.emit_llvm_ir != null or
-            comp.emit_llvm_bc != null))
-        {
-            if (opt_zcu) |zcu| zcu.llvm_object = try LlvmObject.create(arena, comp);
         }
         break :comp comp;
 @@ -2945,6 +2941,33 @@ fn flush(
     tid: Zcu.PerThread.Id,
     prog_node: std.Progress.Node,
 ) !void {
+    if (comp.zcu) |zcu| {
+        if (zcu.llvm_object) |llvm_object| {
+            // Emit the ZCU object from LLVM now; it's required to flush the output file.
+            // If there's an output file, it wants to decide where the LLVM object goes!
+            const zcu_obj_emit_loc: ?EmitLoc = if (comp.bin_file) |lf| .{
+                .directory = null,
+                .basename = lf.zcu_object_sub_path.?,
+            } else null;
+            const sub_prog_node = prog_node.start("LLVM Emit Object", 0);
+            defer sub_prog_node.end();
+            try llvm_object.emit(.{
+                .pre_ir_path = comp.verbose_llvm_ir,
+                .pre_bc_path = comp.verbose_llvm_bc,
+                .bin_path = try resolveEmitLoc(arena, default_artifact_directory, zcu_obj_emit_loc),
+                .asm_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_asm),
+                .post_ir_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_ir),
+                .post_bc_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_bc),
+                .is_debug = comp.root_mod.optimize_mode == .Debug,
+                .is_small = comp.root_mod.optimize_mode == .ReleaseSmall,
+                .time_report = comp.time_report,
+                .sanitize_thread = comp.config.any_sanitize_thread,
+                .fuzz = comp.config.any_fuzz,
+                .lto = comp.config.lto,
+            });
+        }
+    }
     if (comp.bin_file) |lf| {
         // This is needed before reading the error flags.
         lf.flush(arena, tid, prog_node) catch |err| switch (err) {
 @@ -2952,13 +2975,8 @@ fn flush(
             error.OutOfMemory => return error.OutOfMemory,
         };
     }
     if (comp.zcu) |zcu| {
         try link.File.C.flushEmitH(zcu);
-        if (zcu.llvm_object) |llvm_object| {
-            try emitLlvmObject(comp, arena, default_artifact_directory, null, llvm_object, prog_node);
-        }
     }
 }
 @@ -3233,34 +3251,6 @@ fn emitOthers(comp: *Compilation) void {
     }
 }
-pub fn emitLlvmObject(
-    comp: *Compilation,
-    arena: Allocator,
-    default_artifact_directory: Cache.Path,
-    bin_emit_loc: ?EmitLoc,
-    llvm_object: LlvmObject.Ptr,
-    prog_node: std.Progress.Node,
-) !void {
-    const sub_prog_node = prog_node.start("LLVM Emit Object", 0);
-    defer sub_prog_node.end();
-    try llvm_object.emit(.{
-        .pre_ir_path = comp.verbose_llvm_ir,
-        .pre_bc_path = comp.verbose_llvm_bc,
-        .bin_path = try resolveEmitLoc(arena, default_artifact_directory, bin_emit_loc),
-        .asm_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_asm),
-        .post_ir_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_ir),
-        .post_bc_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_bc),
-        .is_debug = comp.root_mod.optimize_mode == .Debug,
-        .is_small = comp.root_mod.optimize_mode == .ReleaseSmall,
-        .time_report = comp.time_report,
-        .sanitize_thread = comp.config.any_sanitize_thread,
-        .fuzz = comp.config.any_fuzz,
-        .lto = comp.config.lto,
-    });
-}
 fn resolveEmitLoc(
     arena: Allocator,
     default_artifact_directory: Cache.Path,

src/Zcu.zig+2-13

 @@ -56,9 +56,8 @@ comptime {
 /// General-purpose allocator. Used for both temporary and long-term storage.
 gpa: Allocator,
 comp: *Compilation,
-/// Usually, the LlvmObject is managed by linker code, however, in the case
+/// If the ZCU is emitting an LLVM object (i.e. we are using the LLVM backend), then this is the
-/// that -fno-emit-bin is specified, the linker code never executes, so we
+/// `LlvmObject` we are emitting to.
-/// store the LlvmObject here.
 llvm_object: ?LlvmObject.Ptr,
 /// Pointer to externally managed resource.
 @@ -267,16 +266,6 @@ resolved_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) = n
 /// Reset to `false` at the start of each update in `Compilation.update`.
 skip_analysis_this_update: bool = false,
-stage1_flags: packed struct {
-    have_winmain: bool = false,
-    have_wwinmain: bool = false,
-    have_winmain_crt_startup: bool = false,
-    have_wwinmain_crt_startup: bool = false,
-    have_dllmain_crt_startup: bool = false,
-    have_c_main: bool = false,
-    reserved: u2 = 0,
-} = .{},
 test_functions: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
 global_assembly: std.AutoArrayHashMapUnmanaged(AnalUnit, []u8) = .empty,

src/Zcu/PerThread.zig+9-12

 @@ -1784,8 +1784,12 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: *A
         };
     }
-    if (comp.bin_file) |lf| {
+    if (zcu.llvm_object) |llvm_object| {
-        lf.updateFunc(pt, func_index, air.*, liveness) catch |err| switch (err) {
+        llvm_object.updateFunc(pt, func_index, air.*, liveness) catch |err| switch (err) {
+            error.OutOfMemory => return error.OutOfMemory,
+        };
+    } else if (comp.bin_file) |lf| {
+        lf.updateFunc(pt, func_index, air, liveness) catch |err| switch (err) {
             error.OutOfMemory => return error.OutOfMemory,
             error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),
             error.Overflow, error.RelocationNotByteAligned => {
 @@ -1798,10 +1802,6 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: *A
                 // Not a retryable failure.
             },
         };
-    } else if (zcu.llvm_object) |llvm_object| {
-        llvm_object.updateFunc(pt, func_index, air.*, liveness) catch |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
-        };
     }
 }
 @@ -1877,7 +1877,6 @@ fn createFileRootStruct(
     try pt.scanNamespace(namespace_index, decls);
     try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (file.mod.?.strip) break :codegen_type;
         // This job depends on any resolve_type_fully jobs queued up before it.
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
 @@ -3309,10 +3308,10 @@ fn processExportsInner(
         .uav => {},
     }
-    if (zcu.comp.bin_file) |lf| {
+    if (zcu.llvm_object) |llvm_object| {
-        try zcu.handleUpdateExports(export_indices, lf.updateExports(pt, exported, export_indices));
-    } else if (zcu.llvm_object) |llvm_object| {
         try zcu.handleUpdateExports(export_indices, llvm_object.updateExports(pt, exported, export_indices));
+    } else if (zcu.comp.bin_file) |lf| {
+        try zcu.handleUpdateExports(export_indices, lf.updateExports(pt, exported, export_indices));
     }
 }
 @@ -4064,7 +4063,6 @@ fn recreateStructType(
     try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (file.mod.?.strip) break :codegen_type;
         // This job depends on any resolve_type_fully jobs queued up before it.
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });
 @@ -4157,7 +4155,6 @@ fn recreateUnionType(
     try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
     codegen_type: {
-        if (zcu.comp.config.use_llvm) break :codegen_type;
         if (file.mod.?.strip) break :codegen_type;
         // This job depends on any resolve_type_fully jobs queued up before it.
         try zcu.comp.queueJob(.{ .link_type = wip_ty.index });

src/codegen/llvm.zig+18

...	@@ -1586,6 +1586,24 @@ pub const Object = struct {	...	@@ -1586,6 +1586,24 @@ pub const Object = struct {
1586	const global_index = self.nav_map.get(nav_index).?;	1586	const global_index = self.nav_map.get(nav_index).?;
1587	const comp = zcu.comp;	1587	const comp = zcu.comp;
1588		1588
		1589	// If we're on COFF and linking with LLD, the linker cares about our exports to determine the subsystem in use.
		1590	if (comp.bin_file != null and
		1591	comp.bin_file.?.tag == .coff and
		1592	zcu.comp.config.use_lld and
		1593	ip.isFunctionType(ip.getNav(nav_index).typeOf(ip)))
		1594	{
		1595	const flags = &comp.bin_file.?.cast(.coff).?.lld_export_flags;
		1596	for (export_indices) \|export_index\| {
		1597	const name = export_index.ptr(zcu).opts.name;
		1598	if (name.eqlSlice("main", ip)) flags.c_main = true;
		1599	if (name.eqlSlice("WinMain", ip)) flags.winmain = true;
		1600	if (name.eqlSlice("wWinMain", ip)) flags.wwinmain = true;
		1601	if (name.eqlSlice("WinMainCRTStartup", ip)) flags.winmain_crt_startup = true;
		1602	if (name.eqlSlice("wWinMainCRTStartup", ip)) flags.wwinmain_crt_startup = true;
		1603	if (name.eqlSlice("DllMainCRTStartup", ip)) flags.dllmain_crt_startup = true;
		1604	}
		1605	}
		1606
1589	if (export_indices.len != 0) {	1607	if (export_indices.len != 0) {
1590	return updateExportedGlobal(self, zcu, global_index, export_indices);	1608	return updateExportedGlobal(self, zcu, global_index, export_indices);
1591	} else {	1609	} else {

src/codegen/spirv/Section.zig-2

...	@@ -386,8 +386,6 @@ test "SPIR-V Section emit() - string" {	...	@@ -386,8 +386,6 @@ test "SPIR-V Section emit() - string" {
386	}	386	}
387		387
388	test "SPIR-V Section emit() - extended mask" {	388	test "SPIR-V Section emit() - extended mask" {
389	if (@import("builtin").zig_backend == .stage1) return error.SkipZigTest;
390
391	var section = Section{};	389	var section = Section{};
392	defer section.deinit(std.testing.allocator);	390	defer section.deinit(std.testing.allocator);
393		391

src/link.zig+48-37

...	@@ -19,7 +19,6 @@ const Zcu = @import("Zcu.zig");	...	@@ -19,7 +19,6 @@ const Zcu = @import("Zcu.zig");
19	const InternPool = @import("InternPool.zig");	19	const InternPool = @import("InternPool.zig");
20	const Type = @import("Type.zig");	20	const Type = @import("Type.zig");
21	const Value = @import("Value.zig");	21	const Value = @import("Value.zig");
22	const LlvmObject = @import("codegen/llvm.zig").Object;
23	const lldMain = @import("main.zig").lldMain;	22	const lldMain = @import("main.zig").lldMain;
24	const Package = @import("Package.zig");	23	const Package = @import("Package.zig");
25	const dev = @import("dev.zig");	24	const dev = @import("dev.zig");
...	@@ -704,7 +703,9 @@ pub const File = struct {	...	@@ -704,7 +703,9 @@ pub const File = struct {
704	}	703	}
705		704
706	/// May be called before or after updateExports for any given Nav.	705	/// May be called before or after updateExports for any given Nav.
		706	/// Asserts that the ZCU is not using the LLVM backend.
707	fn updateNav(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) UpdateNavError!void {	707	fn updateNav(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) UpdateNavError!void {
		708	assert(base.comp.zcu.?.llvm_object == null);
708	const nav = pt.zcu.intern_pool.getNav(nav_index);	709	const nav = pt.zcu.intern_pool.getNav(nav_index);
709	assert(nav.status == .fully_resolved);	710	assert(nav.status == .fully_resolved);
710	switch (base.tag) {	711	switch (base.tag) {
...	@@ -721,7 +722,9 @@ pub const File = struct {	...	@@ -721,7 +722,9 @@ pub const File = struct {
721	TypeFailureReported,	722	TypeFailureReported,
722	};	723	};
723		724
		725	/// Never called when LLVM is codegenning the ZCU.
724	fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateContainerTypeError!void {	726	fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateContainerTypeError!void {
		727	assert(base.comp.zcu.?.llvm_object == null);
725	switch (base.tag) {	728	switch (base.tag) {
726	else => {},	729	else => {},
727	inline .elf => \|tag\| {	730	inline .elf => \|tag\| {
...	@@ -733,6 +736,7 @@ pub const File = struct {	...	@@ -733,6 +736,7 @@ pub const File = struct {
733		736
734	/// May be called before or after updateExports for any given Decl.	737	/// May be called before or after updateExports for any given Decl.
735	/// TODO: currently `pub` because `Zcu.PerThread` is calling this.	738	/// TODO: currently `pub` because `Zcu.PerThread` is calling this.
		739	/// Never called when LLVM is codegenning the ZCU.
736	pub fn updateFunc(	740	pub fn updateFunc(
737	base: *File,	741	base: *File,
738	pt: Zcu.PerThread,	742	pt: Zcu.PerThread,
...	@@ -740,6 +744,7 @@ pub const File = struct {	...	@@ -740,6 +744,7 @@ pub const File = struct {
740	air: Air,	744	air: Air,
741	liveness: Air.Liveness,	745	liveness: Air.Liveness,
742	) UpdateNavError!void {	746	) UpdateNavError!void {
		747	assert(base.comp.zcu.?.llvm_object == null);
743	switch (base.tag) {	748	switch (base.tag) {
744	inline else => \|tag\| {	749	inline else => \|tag\| {
745	dev.check(tag.devFeature());	750	dev.check(tag.devFeature());
...	@@ -756,7 +761,9 @@ pub const File = struct {	...	@@ -756,7 +761,9 @@ pub const File = struct {
756		761
757	/// On an incremental update, fixup the line number of all `Nav`s at the given `TrackedInst`, because	762	/// On an incremental update, fixup the line number of all `Nav`s at the given `TrackedInst`, because
758	/// its line number has changed. The ZIR instruction `ti_id` has tag `.declaration`.	763	/// its line number has changed. The ZIR instruction `ti_id` has tag `.declaration`.
		764	/// Never called when LLVM is codegenning the ZCU.
759	fn updateLineNumber(base: *File, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) UpdateLineNumberError!void {	765	fn updateLineNumber(base: *File, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) UpdateLineNumberError!void {
		766	assert(base.comp.zcu.?.llvm_object == null);
760	{	767	{
761	const ti = ti_id.resolveFull(&pt.zcu.intern_pool).?;	768	const ti = ti_id.resolveFull(&pt.zcu.intern_pool).?;
762	const file = pt.zcu.fileByIndex(ti.file);	769	const file = pt.zcu.fileByIndex(ti.file);
...	@@ -846,11 +853,13 @@ pub const File = struct {	...	@@ -846,11 +853,13 @@ pub const File = struct {
846		853
847	/// Commit pending changes and write headers. Works based on `effectiveOutputMode`	854	/// Commit pending changes and write headers. Works based on `effectiveOutputMode`
848	/// rather than final output mode.	855	/// rather than final output mode.
849	pub fn flushModule(base: *File, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) FlushError!void {	856	/// Never called when LLVM is codegenning the ZCU.
		857	fn flushZcu(base: *File, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) FlushError!void {
		858	assert(base.comp.zcu.?.llvm_object == null);
850	switch (base.tag) {	859	switch (base.tag) {
851	inline else => \|tag\| {	860	inline else => \|tag\| {
852	dev.check(tag.devFeature());	861	dev.check(tag.devFeature());
853	return @as(*tag.Type(), @fieldParentPtr("base", base)).flushModule(arena, tid, prog_node);	862	return @as(*tag.Type(), @fieldParentPtr("base", base)).flushZcu(arena, tid, prog_node);
854	},	863	},
855	}	864	}
856	}	865	}
...	@@ -864,12 +873,14 @@ pub const File = struct {	...	@@ -864,12 +873,14 @@ pub const File = struct {
864	/// a list of size 1, meaning that `exported` is exported once. However, it is possible	873	/// a list of size 1, meaning that `exported` is exported once. However, it is possible
865	/// to export the same thing with multiple different symbol names (aliases).	874	/// to export the same thing with multiple different symbol names (aliases).
866	/// May be called before or after updateDecl for any given Decl.	875	/// May be called before or after updateDecl for any given Decl.
		876	/// Never called when LLVM is codegenning the ZCU.
867	pub fn updateExports(	877	pub fn updateExports(
868	base: *File,	878	base: *File,
869	pt: Zcu.PerThread,	879	pt: Zcu.PerThread,
870	exported: Zcu.Exported,	880	exported: Zcu.Exported,
871	export_indices: []const Zcu.Export.Index,	881	export_indices: []const Zcu.Export.Index,
872	) UpdateExportsError!void {	882	) UpdateExportsError!void {
		883	assert(base.comp.zcu.?.llvm_object == null);
873	switch (base.tag) {	884	switch (base.tag) {
874	inline else => \|tag\| {	885	inline else => \|tag\| {
875	dev.check(tag.devFeature());	886	dev.check(tag.devFeature());
...	@@ -896,7 +907,9 @@ pub const File = struct {	...	@@ -896,7 +907,9 @@ pub const File = struct {
896	/// `Nav`'s address was not yet resolved, or the containing atom gets moved in virtual memory.	907	/// `Nav`'s address was not yet resolved, or the containing atom gets moved in virtual memory.
897	/// May be called before or after updateFunc/updateNav therefore it is up to the linker to allocate	908	/// May be called before or after updateFunc/updateNav therefore it is up to the linker to allocate
898	/// the block/atom.	909	/// the block/atom.
		910	/// Never called when LLVM is codegenning the ZCU.
899	pub fn getNavVAddr(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index, reloc_info: RelocInfo) !u64 {	911	pub fn getNavVAddr(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index, reloc_info: RelocInfo) !u64 {
		912	assert(base.comp.zcu.?.llvm_object == null);
900	switch (base.tag) {	913	switch (base.tag) {
901	.c => unreachable,	914	.c => unreachable,
902	.spirv => unreachable,	915	.spirv => unreachable,
...	@@ -909,6 +922,7 @@ pub const File = struct {	...	@@ -909,6 +922,7 @@ pub const File = struct {
909	}	922	}
910	}	923	}
911		924
		925	/// Never called when LLVM is codegenning the ZCU.
912	pub fn lowerUav(	926	pub fn lowerUav(
913	base: *File,	927	base: *File,
914	pt: Zcu.PerThread,	928	pt: Zcu.PerThread,
...	@@ -916,6 +930,7 @@ pub const File = struct {	...	@@ -916,6 +930,7 @@ pub const File = struct {
916	decl_align: InternPool.Alignment,	930	decl_align: InternPool.Alignment,
917	src_loc: Zcu.LazySrcLoc,	931	src_loc: Zcu.LazySrcLoc,
918	) !codegen.GenResult {	932	) !codegen.GenResult {
		933	assert(base.comp.zcu.?.llvm_object == null);
919	switch (base.tag) {	934	switch (base.tag) {
920	.c => unreachable,	935	.c => unreachable,
921	.spirv => unreachable,	936	.spirv => unreachable,
...	@@ -928,7 +943,9 @@ pub const File = struct {	...	@@ -928,7 +943,9 @@ pub const File = struct {
928	}	943	}
929	}	944	}
930		945
		946	/// Never called when LLVM is codegenning the ZCU.
931	pub fn getUavVAddr(base: *File, decl_val: InternPool.Index, reloc_info: RelocInfo) !u64 {	947	pub fn getUavVAddr(base: *File, decl_val: InternPool.Index, reloc_info: RelocInfo) !u64 {
		948	assert(base.comp.zcu.?.llvm_object == null);
932	switch (base.tag) {	949	switch (base.tag) {
933	.c => unreachable,	950	.c => unreachable,
934	.spirv => unreachable,	951	.spirv => unreachable,
...	@@ -941,11 +958,13 @@ pub const File = struct {	...	@@ -941,11 +958,13 @@ pub const File = struct {
941	}	958	}
942	}	959	}
943		960
		961	/// Never called when LLVM is codegenning the ZCU.
944	pub fn deleteExport(	962	pub fn deleteExport(
945	base: *File,	963	base: *File,
946	exported: Zcu.Exported,	964	exported: Zcu.Exported,
947	name: InternPool.NullTerminatedString,	965	name: InternPool.NullTerminatedString,
948	) void {	966	) void {
		967	assert(base.comp.zcu.?.llvm_object == null);
949	switch (base.tag) {	968	switch (base.tag) {
950	.plan9,	969	.plan9,
951	.spirv,	970	.spirv,
...	@@ -1077,7 +1096,7 @@ pub const File = struct {	...	@@ -1077,7 +1096,7 @@ pub const File = struct {
1077	}	1096	}
1078	}	1097	}
1079		1098
1080	pub fn linkAsArchive(base: *File, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) FlushError!void {	1099	fn linkAsArchive(base: *File, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) FlushError!void {
1081	dev.check(.lld_linker);	1100	dev.check(.lld_linker);
1082		1101
1083	const tracy = trace(@src());	1102	const tracy = trace(@src());
...	@@ -1103,9 +1122,12 @@ pub const File = struct {	...	@@ -1103,9 +1122,12 @@ pub const File = struct {
1103		1122
1104	// If there is no Zig code to compile, then we should skip flushing the output file	1123	// If there is no Zig code to compile, then we should skip flushing the output file
1105	// because it will not be part of the linker line anyway.	1124	// because it will not be part of the linker line anyway.
1106	const zcu_obj_path: ?[]const u8 = if (opt_zcu != null) blk: {	1125	const zcu_obj_path: ?[]const u8 = if (opt_zcu) \|zcu\| blk: {
1107	try base.flushModule(arena, tid, prog_node);	1126	if (zcu.llvm_object == null) {
1108		1127	try base.flushZcu(arena, tid, prog_node);
		1128	} else {
		1129	// `Compilation.flush` has already made LLVM emit this object file for us.
		1130	}
1109	const dirname = fs.path.dirname(full_out_path_z) orelse ".";	1131	const dirname = fs.path.dirname(full_out_path_z) orelse ".";
1110	break :blk try fs.path.join(arena, &.{ dirname, base.zcu_object_sub_path.? });	1132	break :blk try fs.path.join(arena, &.{ dirname, base.zcu_object_sub_path.? });
1111	} else null;	1133	} else null;
...	@@ -1346,21 +1368,6 @@ pub const File = struct {	...	@@ -1346,21 +1368,6 @@ pub const File = struct {
1346	return output_mode == .Lib and !self.isStatic();	1368	return output_mode == .Lib and !self.isStatic();
1347	}	1369	}
1348		1370
1349	pub fn emitLlvmObject(
1350	base: File,
1351	arena: Allocator,
1352	llvm_object: LlvmObject.Ptr,
1353	prog_node: std.Progress.Node,
1354	) !void {
1355	return base.comp.emitLlvmObject(arena, .{
1356	.root_dir = base.emit.root_dir,
1357	.sub_path = std.fs.path.dirname(base.emit.sub_path) orelse "",
1358	}, .{
1359	.directory = null,
1360	.basename = base.zcu_object_sub_path.?,
1361	}, llvm_object, prog_node);
1362	}
1363
1364	pub fn cgFail(	1371	pub fn cgFail(
1365	base: *File,	1372	base: *File,
1366	nav_index: InternPool.Nav.Index,	1373	nav_index: InternPool.Nav.Index,
...	@@ -1600,7 +1607,11 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {	...	@@ -1600,7 +1607,11 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {
1600	// on the failed type, so when it is changed the `Nav` will be updated.	1607	// on the failed type, so when it is changed the `Nav` will be updated.
1601	return;	1608	return;
1602	}	1609	}
1603	if (comp.bin_file) \|lf\| {	1610	if (zcu.llvm_object) \|llvm_object\| {
		1611	llvm_object.updateNav(pt, nav_index) catch \|err\| switch (err) {
		1612	error.OutOfMemory => diags.setAllocFailure(),
		1613	};
		1614	} else if (comp.bin_file) \|lf\| {
1604	lf.updateNav(pt, nav_index) catch \|err\| switch (err) {	1615	lf.updateNav(pt, nav_index) catch \|err\| switch (err) {
1605	error.OutOfMemory => diags.setAllocFailure(),	1616	error.OutOfMemory => diags.setAllocFailure(),
1606	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),	1617	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),
...	@@ -1616,10 +1627,6 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {	...	@@ -1616,10 +1627,6 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {
1616	// Not a retryable failure.	1627	// Not a retryable failure.
1617	},	1628	},
1618	};	1629	};
1619	} else if (zcu.llvm_object) \|llvm_object\| {
1620	llvm_object.updateNav(pt, nav_index) catch \|err\| switch (err) {
1621	error.OutOfMemory => diags.setAllocFailure(),
1622	};
1623	}	1630	}
1624	},	1631	},
1625	.link_func => \|func\| {	1632	.link_func => \|func\| {
...	@@ -1650,11 +1657,13 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {	...	@@ -1650,11 +1657,13 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {
1650	// on the failed type, so when that is changed, this type will be updated.	1657	// on the failed type, so when that is changed, this type will be updated.
1651	return;	1658	return;
1652	}	1659	}
1653	if (comp.bin_file) \|lf\| {	1660	if (zcu.llvm_object == null) {
1654	lf.updateContainerType(pt, ty) catch \|err\| switch (err) {	1661	if (comp.bin_file) \|lf\| {
1655	error.OutOfMemory => diags.setAllocFailure(),	1662	lf.updateContainerType(pt, ty) catch \|err\| switch (err) {
1656	error.TypeFailureReported => assert(zcu.failed_types.contains(ty)),	1663	error.OutOfMemory => diags.setAllocFailure(),
1657	};	1664	error.TypeFailureReported => assert(zcu.failed_types.contains(ty)),
		1665	};
		1666	}
1658	}	1667	}
1659	},	1668	},
1660	.update_line_number => \|ti\| {	1669	.update_line_number => \|ti\| {
...	@@ -1664,11 +1673,13 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {	...	@@ -1664,11 +1673,13 @@ pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {
1664	}	1673	}
1665	const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));	1674	const pt: Zcu.PerThread = .activate(comp.zcu.?, @enumFromInt(tid));
1666	defer pt.deactivate();	1675	defer pt.deactivate();
1667	if (comp.bin_file) \|lf\| {	1676	if (pt.zcu.llvm_object == null) {
1668	lf.updateLineNumber(pt, ti) catch \|err\| switch (err) {	1677	if (comp.bin_file) \|lf\| {
1669	error.OutOfMemory => diags.setAllocFailure(),	1678	lf.updateLineNumber(pt, ti) catch \|err\| switch (err) {
1670	else => \|e\| log.err("update line number failed: {s}", .{@errorName(e)}),	1679	error.OutOfMemory => diags.setAllocFailure(),
1671	};	1680	else => \|e\| log.err("update line number failed: {s}", .{@errorName(e)}),
		1681	};
		1682	}
1672	}	1683	}
1673	},	1684	},
1674	}	1685	}

src/link/C.zig+2-2

...	@@ -382,7 +382,7 @@ pub fn updateLineNumber(self: *C, pt: Zcu.PerThread, ti_id: InternPool.TrackedIn	...	@@ -382,7 +382,7 @@ pub fn updateLineNumber(self: *C, pt: Zcu.PerThread, ti_id: InternPool.TrackedIn
382	}	382	}
383		383
384	pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	384	pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
385	return self.flushModule(arena, tid, prog_node);	385	return self.flushZcu(arena, tid, prog_node);
386	}	386	}
387		387
388	fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {	388	fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
...	@@ -400,7 +400,7 @@ fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {	...	@@ -400,7 +400,7 @@ fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
400	return defines;	400	return defines;
401	}	401	}
402		402
403	pub fn flushModule(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	403	pub fn flushZcu(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
404	_ = arena; // Has the same lifetime as the call to Compilation.update.	404	_ = arena; // Has the same lifetime as the call to Compilation.update.
405		405
406	const tracy = trace(@src());	406	const tracy = trace(@src());

src/link/Coff.zig+30-84

 @@ -3,9 +3,6 @@
 //! LLD for traditional linking (linking relocatable object files).
 //! LLD is also the default linker for LLVM.
-/// If this is not null, an object file is created by LLVM and emitted to zcu_object_sub_path.
-llvm_object: ?LlvmObject.Ptr = null,
 base: link.File,
 image_base: u64,
 subsystem: ?std.Target.SubSystem,
 @@ -87,6 +84,16 @@ base_relocs: BaseRelocationTable = .{},
 /// Hot-code swapping state.
 hot_state: if (is_hot_update_compatible) HotUpdateState else struct {} = .{},
+/// When linking with LLD, these flags are used to determine the subsystem to pass on the LLD command line.
+lld_export_flags: struct {
+    c_main: bool = false,
+    winmain: bool = false,
+    wwinmain: bool = false,
+    winmain_crt_startup: bool = false,
+    wwinmain_crt_startup: bool = false,
+    dllmain_crt_startup: bool = false,
+} = .{},
 const is_hot_update_compatible = switch (builtin.target.os.tag) {
     .windows => true,
     else => false,
 @@ -302,9 +309,6 @@ pub fn createEmpty(
         .pdb_out_path = options.pdb_out_path,
         .repro = options.repro,
     };
-    if (use_llvm and comp.config.have_zcu) {
-        coff.llvm_object = try LlvmObject.create(arena, comp);
-    }
     errdefer coff.base.destroy();
     if (use_lld and (use_llvm or !comp.config.have_zcu)) {
 @@ -322,7 +326,6 @@ pub fn createEmpty(
         .mode = link.File.determineMode(use_lld, output_mode, link_mode),
     });
-    assert(coff.llvm_object == null);
     const gpa = comp.gpa;
     try coff.strtab.buffer.ensureUnusedCapacity(gpa, @sizeOf(u32));
 @@ -428,8 +431,6 @@ pub fn open(
 pub fn deinit(coff: *Coff) void {
     const gpa = coff.base.comp.gpa;
-    if (coff.llvm_object) |llvm_object| llvm_object.deinit();
     for (coff.sections.items(.free_list)) |*free_list| {
         free_list.deinit(gpa);
     }
 @@ -1103,9 +1104,6 @@ pub fn updateFunc(
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (coff.llvm_object) |llvm_object| {
-        return llvm_object.updateFunc(pt, func_index, air, liveness);
-    }
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1205,7 +1203,6 @@ pub fn updateNav(
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (coff.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav_index);
     const tracy = trace(@src());
     defer tracy.end();
 @@ -1330,7 +1327,7 @@ pub fn getOrCreateAtomForLazySymbol(
     }
     state_ptr.* = .pending_flush;
     const atom = atom_ptr.*;
-    // anyerror needs to be deferred until flushModule
+    // anyerror needs to be deferred until flushZcu
     if (lazy_sym.ty != .anyerror_type) try coff.updateLazySymbolAtom(pt, lazy_sym, atom, switch (lazy_sym.kind) {
         .code => coff.text_section_index.?,
         .const_data => coff.rdata_section_index.?,
 @@ -1463,8 +1460,6 @@ fn updateNavCode(
 }
 pub fn freeNav(coff: *Coff, nav_index: InternPool.NavIndex) void {
-    if (coff.llvm_object) |llvm_object| return llvm_object.freeNav(nav_index);
     const gpa = coff.base.comp.gpa;
     if (coff.decls.fetchOrderedRemove(nav_index)) |const_kv| {
 @@ -1485,50 +1480,7 @@ pub fn updateExports(
     }
     const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
+    const gpa = zcu.gpa;
-    const comp = coff.base.comp;
-    const target = comp.root_mod.resolved_target.result;
-    if (comp.config.use_llvm) {
-        // Even in the case of LLVM, we need to notice certain exported symbols in order to
-        // detect the default subsystem.
-        for (export_indices) |export_idx| {
-            const exp = export_idx.ptr(zcu);
-            const exported_nav_index = switch (exp.exported) {
-                .nav => |nav| nav,
-                .uav => continue,
-            };
-            const exported_nav = ip.getNav(exported_nav_index);
-            const exported_ty = exported_nav.typeOf(ip);
-            if (!ip.isFunctionType(exported_ty)) continue;
-            const c_cc = target.cCallingConvention().?;
-            const winapi_cc: std.builtin.CallingConvention = switch (target.cpu.arch) {
-                .x86 => .{ .x86_stdcall = .{} },
-                else => c_cc,
-            };
-            const exported_cc = Type.fromInterned(exported_ty).fnCallingConvention(zcu);
-            const CcTag = std.builtin.CallingConvention.Tag;
-            if (@as(CcTag, exported_cc) == @as(CcTag, c_cc) and exp.opts.name.eqlSlice("main", ip) and comp.config.link_libc) {
-                zcu.stage1_flags.have_c_main = true;
-            } else if (@as(CcTag, exported_cc) == @as(CcTag, winapi_cc) and target.os.tag == .windows) {
-                if (exp.opts.name.eqlSlice("WinMain", ip)) {
-                    zcu.stage1_flags.have_winmain = true;
-                } else if (exp.opts.name.eqlSlice("wWinMain", ip)) {
-                    zcu.stage1_flags.have_wwinmain = true;
-                } else if (exp.opts.name.eqlSlice("WinMainCRTStartup", ip)) {
-                    zcu.stage1_flags.have_winmain_crt_startup = true;
-                } else if (exp.opts.name.eqlSlice("wWinMainCRTStartup", ip)) {
-                    zcu.stage1_flags.have_wwinmain_crt_startup = true;
-                } else if (exp.opts.name.eqlSlice("DllMainCRTStartup", ip)) {
-                    zcu.stage1_flags.have_dllmain_crt_startup = true;
-                }
-            }
-        }
-    }
-    if (coff.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
-    const gpa = comp.gpa;
     const metadata = switch (exported) {
         .nav => |nav| blk: {
 @@ -1621,7 +1573,6 @@ pub fn deleteExport(
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    if (coff.llvm_object) |_| return;
     const metadata = switch (exported) {
         .nav => |nav| coff.navs.getPtr(nav),
         .uav => |uav| coff.uavs.getPtr(uav),
 @@ -1692,7 +1643,7 @@ pub fn flush(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: st
         };
     }
     switch (comp.config.output_mode) {
-        .Exe, .Obj => return coff.flushModule(arena, tid, prog_node),
+        .Exe, .Obj => return coff.flushZcu(arena, tid, prog_node),
         .Lib => return diags.fail("writing lib files not yet implemented for COFF", .{}),
     }
 }
 @@ -1711,8 +1662,12 @@ fn linkWithLLD(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
     // If there is no Zig code to compile, then we should skip flushing the output file because it
     // will not be part of the linker line anyway.
-    const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
+    const module_obj_path: ?[]const u8 = if (comp.zcu) |zcu| blk: {
-        try coff.flushModule(arena, tid, prog_node);
+        if (zcu.llvm_object == null) {
+            try coff.flushZcu(arena, tid, prog_node);
+        } else {
+            // `Compilation.flush` has already made LLVM emit this object file for us.
+        }
         if (fs.path.dirname(full_out_path)) |dirname| {
             break :blk try fs.path.join(arena, &.{ dirname, coff.base.zcu_object_sub_path.? });
 @@ -1998,16 +1953,16 @@ fn linkWithLLD(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             if (coff.subsystem) |explicit| break :blk explicit;
             switch (target.os.tag) {
                 .windows => {
-                    if (comp.zcu) |module| {
+                    if (comp.zcu != null) {
-                        if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
+                        if (coff.lld_export_flags.dllmain_crt_startup or is_dyn_lib)
                             break :blk null;
-                        if (module.stage1_flags.have_c_main or comp.config.is_test or
+                        if (coff.lld_export_flags.c_main or comp.config.is_test or
-                            module.stage1_flags.have_winmain_crt_startup or
+                            coff.lld_export_flags.winmain_crt_startup or
-                            module.stage1_flags.have_wwinmain_crt_startup)
+                            coff.lld_export_flags.wwinmain_crt_startup)
                         {
                             break :blk .Console;
                         }
-                        if (module.stage1_flags.have_winmain or module.stage1_flags.have_wwinmain)
+                        if (coff.lld_export_flags.winmain or coff.lld_export_flags.wwinmain)
                             break :blk .Windows;
                     }
                 },
 @@ -2136,8 +2091,8 @@ fn linkWithLLD(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 } else {
                     try argv.append("-NODEFAULTLIB");
                     if (!is_lib and entry_name == null) {
-                        if (comp.zcu) |module| {
+                        if (comp.zcu != null) {
-                            if (module.stage1_flags.have_winmain_crt_startup) {
+                            if (coff.lld_export_flags.winmain_crt_startup) {
                                 try argv.append("-ENTRY:WinMainCRTStartup");
                             } else {
                                 try argv.append("-ENTRY:wWinMainCRTStartup");
 @@ -2244,7 +2199,7 @@ fn findLib(arena: Allocator, name: []const u8, lib_directories: []const Director
     return null;
 }
-pub fn flushModule(
+pub fn flushZcu(
     coff: *Coff,
     arena: Allocator,
     tid: Zcu.PerThread.Id,
 @@ -2256,22 +2211,17 @@ pub fn flushModule(
     const comp = coff.base.comp;
     const diags = &comp.link_diags;
-    if (coff.llvm_object) |llvm_object| {
-        try coff.base.emitLlvmObject(arena, llvm_object, prog_node);
-        return;
-    }
     const sub_prog_node = prog_node.start("COFF Flush", 0);
     defer sub_prog_node.end();
-    return flushModuleInner(coff, arena, tid) catch |err| switch (err) {
+    return flushZcuInner(coff, arena, tid) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         error.LinkFailure => return error.LinkFailure,
         else => |e| return diags.fail("COFF flush failed: {s}", .{@errorName(e)}),
     };
 }
-fn flushModuleInner(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id) !void {
+fn flushZcuInner(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id) !void {
     _ = arena;
     const comp = coff.base.comp;
 @@ -2397,7 +2347,6 @@ pub fn getNavVAddr(
     nav_index: InternPool.Nav.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    assert(coff.llvm_object == null);
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
 @@ -2483,8 +2432,6 @@ pub fn getUavVAddr(
     uav: InternPool.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    assert(coff.llvm_object == null);
     const this_atom_index = coff.uavs.get(uav).?.atom;
     const sym_index = coff.getAtom(this_atom_index).getSymbolIndex().?;
     const atom_index = coff.getAtomIndexForSymbol(.{
 @@ -3798,7 +3745,6 @@ const trace = @import("../tracy.zig").trace;
 const Air = @import("../Air.zig");
 const Compilation = @import("../Compilation.zig");
-const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");
 const TableSection = @import("table_section.zig").TableSection;

src/link/Dwarf.zig+1-1

...	@@ -4391,7 +4391,7 @@ fn refAbbrevCode(dwarf: *Dwarf, abbrev_code: AbbrevCode) UpdateError!@typeInfo(A	...	@@ -4391,7 +4391,7 @@ fn refAbbrevCode(dwarf: *Dwarf, abbrev_code: AbbrevCode) UpdateError!@typeInfo(A
4391	return @intFromEnum(abbrev_code);	4391	return @intFromEnum(abbrev_code);
4392	}	4392	}
4393		4393
4394	pub fn flushModule(dwarf: *Dwarf, pt: Zcu.PerThread) FlushError!void {	4394	pub fn flushZcu(dwarf: *Dwarf, pt: Zcu.PerThread) FlushError!void {
4395	const zcu = pt.zcu;	4395	const zcu = pt.zcu;
4396	const ip = &zcu.intern_pool;	4396	const ip = &zcu.intern_pool;
4397		4397

src/link/Elf.zig+10-30

 @@ -32,9 +32,6 @@ entry_name: ?[]const u8,
 ptr_width: PtrWidth,
-/// If this is not null, an object file is created by LLVM and emitted to zcu_object_sub_path.
-llvm_object: ?LlvmObject.Ptr = null,
 /// A list of all input files.
 /// First index is a special "null file". Order is otherwise not observed.
 files: std.MultiArrayList(File.Entry) = .{},
 @@ -344,9 +341,6 @@ pub fn createEmpty(
         .print_map = options.print_map,
         .dump_argv_list = .empty,
     };
-    if (use_llvm and comp.config.have_zcu) {
-        self.llvm_object = try LlvmObject.create(arena, comp);
-    }
     errdefer self.base.destroy();
     if (use_lld and (use_llvm or !comp.config.have_zcu)) {
 @@ -457,8 +451,6 @@ pub fn open(
 pub fn deinit(self: *Elf) void {
     const gpa = self.base.comp.gpa;
-    if (self.llvm_object) |llvm_object| llvm_object.deinit();
     for (self.file_handles.items) |fh| {
         fh.close();
     }
 @@ -515,7 +507,6 @@ pub fn deinit(self: *Elf) void {
 }
 pub fn getNavVAddr(self: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index, reloc_info: link.File.RelocInfo) !u64 {
-    assert(self.llvm_object == null);
     return self.zigObjectPtr().?.getNavVAddr(self, pt, nav_index, reloc_info);
 }
 @@ -530,7 +521,6 @@ pub fn lowerUav(
 }
 pub fn getUavVAddr(self: *Elf, uav: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 {
-    assert(self.llvm_object == null);
     return self.zigObjectPtr().?.getUavVAddr(self, uav, reloc_info);
 }
 @@ -805,35 +795,29 @@ pub fn flush(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std
             else => |e| return diags.fail("failed to link with LLD: {s}", .{@errorName(e)}),
         };
     }
-    try self.flushModule(arena, tid, prog_node);
+    try self.flushZcu(arena, tid, prog_node);
 }
-pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
+pub fn flushZcu(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const tracy = trace(@src());
     defer tracy.end();
     const comp = self.base.comp;
     const diags = &comp.link_diags;
-    if (self.llvm_object) |llvm_object| {
-        try self.base.emitLlvmObject(arena, llvm_object, prog_node);
-        const use_lld = build_options.have_llvm and comp.config.use_lld;
-        if (use_lld) return;
-    }
     if (comp.verbose_link) Compilation.dump_argv(self.dump_argv_list.items);
     const sub_prog_node = prog_node.start("ELF Flush", 0);
     defer sub_prog_node.end();
-    return flushModuleInner(self, arena, tid) catch |err| switch (err) {
+    return flushZcuInner(self, arena, tid) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         error.LinkFailure => return error.LinkFailure,
         else => |e| return diags.fail("ELF flush failed: {s}", .{@errorName(e)}),
     };
 }
-fn flushModuleInner(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id) !void {
+fn flushZcuInner(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id) !void {
     const comp = self.base.comp;
     const gpa = comp.gpa;
     const diags = &comp.link_diags;
 @@ -1523,8 +1507,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     // If there is no Zig code to compile, then we should skip flushing the output file because it
     // will not be part of the linker line anyway.
-    const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
+    const module_obj_path: ?[]const u8 = if (comp.zcu) |zcu| blk: {
-        try self.flushModule(arena, tid, prog_node);
+        if (zcu.llvm_object == null) {
+            try self.flushZcu(arena, tid, prog_node);
+        } else {
+            // `Compilation.flush` has already made LLVM emit this object file for us.
+        }
         if (fs.path.dirname(full_out_path)) |dirname| {
             break :blk try fs.path.join(arena, &.{ dirname, self.base.zcu_object_sub_path.? });
 @@ -2385,7 +2373,6 @@ pub fn writeElfHeader(self: *Elf) !void {
 }
 pub fn freeNav(self: *Elf, nav: InternPool.Nav.Index) void {
-    if (self.llvm_object) |llvm_object| return llvm_object.freeNav(nav);
     return self.zigObjectPtr().?.freeNav(self, nav);
 }
 @@ -2399,7 +2386,6 @@ pub fn updateFunc(
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateFunc(pt, func_index, air, liveness);
     return self.zigObjectPtr().?.updateFunc(self, pt, func_index, air, liveness);
 }
 @@ -2411,7 +2397,6 @@ pub fn updateNav(
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav);
     return self.zigObjectPtr().?.updateNav(self, pt, nav);
 }
 @@ -2423,7 +2408,6 @@ pub fn updateContainerType(
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |_| return;
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     return self.zigObjectPtr().?.updateContainerType(pt, ty) catch |err| switch (err) {
 @@ -2449,12 +2433,10 @@ pub fn updateExports(
     if (build_options.skip_non_native and builtin.object_format != .elf) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
     return self.zigObjectPtr().?.updateExports(self, pt, exported, export_indices);
 }
 pub fn updateLineNumber(self: *Elf, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) !void {
-    if (self.llvm_object) |_| return;
     return self.zigObjectPtr().?.updateLineNumber(pt, ti_id);
 }
 @@ -2463,7 +2445,6 @@ pub fn deleteExport(
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    if (self.llvm_object) |_| return;
     return self.zigObjectPtr().?.deleteExport(self, exported, name);
 }
 @@ -5332,7 +5313,6 @@ const GotSection = synthetic_sections.GotSection;
 const GotPltSection = synthetic_sections.GotPltSection;
 const HashSection = synthetic_sections.HashSection;
 const LinkerDefined = @import("Elf/LinkerDefined.zig");
-const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Zcu = @import("../Zcu.zig");
 const Object = @import("Elf/Object.zig");
 const InternPool = @import("../InternPool.zig");

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

src/link/Goff.zig+22-24

...	@@ -17,10 +17,8 @@ const link = @import("../link.zig");	...	@@ -17,10 +17,8 @@ const link = @import("../link.zig");
17	const trace = @import("../tracy.zig").trace;	17	const trace = @import("../tracy.zig").trace;
18	const build_options = @import("build_options");	18	const build_options = @import("build_options");
19	const Air = @import("../Air.zig");	19	const Air = @import("../Air.zig");
20	const LlvmObject = @import("../codegen/llvm.zig").Object;
21		20
22	base: link.File,	21	base: link.File,
23	llvm_object: LlvmObject.Ptr,
24		22
25	pub fn createEmpty(	23	pub fn createEmpty(
26	arena: Allocator,	24	arena: Allocator,
...	@@ -36,7 +34,6 @@ pub fn createEmpty(	...	@@ -36,7 +34,6 @@ pub fn createEmpty(
36	assert(!use_lld); // Caught by Compilation.Config.resolve.	34	assert(!use_lld); // Caught by Compilation.Config.resolve.
37	assert(target.os.tag == .zos); // Caught by Compilation.Config.resolve.	35	assert(target.os.tag == .zos); // Caught by Compilation.Config.resolve.
38		36
39	const llvm_object = try LlvmObject.create(arena, comp);
40	const goff = try arena.create(Goff);	37	const goff = try arena.create(Goff);
41	goff.* = .{	38	goff.* = .{
42	.base = .{	39	.base = .{
...	@@ -52,7 +49,6 @@ pub fn createEmpty(	...	@@ -52,7 +49,6 @@ pub fn createEmpty(
52	.disable_lld_caching = options.disable_lld_caching,	49	.disable_lld_caching = options.disable_lld_caching,
53	.build_id = options.build_id,	50	.build_id = options.build_id,
54	},	51	},
55	.llvm_object = llvm_object,
56	};	52	};
57		53
58	return goff;	54	return goff;
...	@@ -70,7 +66,7 @@ pub fn open(	...	@@ -70,7 +66,7 @@ pub fn open(
70	}	66	}
71		67
72	pub fn deinit(self: *Goff) void {	68	pub fn deinit(self: *Goff) void {
73	self.llvm_object.deinit();	69	_ = self;
74	}	70	}
75		71
76	pub fn updateFunc(	72	pub fn updateFunc(
...	@@ -80,17 +76,19 @@ pub fn updateFunc(	...	@@ -80,17 +76,19 @@ pub fn updateFunc(
80	air: Air,	76	air: Air,
81	liveness: Air.Liveness,	77	liveness: Air.Liveness,
82	) link.File.UpdateNavError!void {	78	) link.File.UpdateNavError!void {
83	if (build_options.skip_non_native and builtin.object_format != .goff)	79	_ = self;
84	@panic("Attempted to compile for object format that was disabled by build configuration");	80	_ = pt;
85		81	_ = func_index;
86	try self.llvm_object.updateFunc(pt, func_index, air, liveness);	82	_ = air;
		83	_ = liveness;
		84	unreachable; // we always use llvm
87	}	85	}
88		86
89	pub fn updateNav(self: *Goff, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {	87	pub fn updateNav(self: *Goff, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {
90	if (build_options.skip_non_native and builtin.object_format != .goff)	88	_ = self;
91	@panic("Attempted to compile for object format that was disabled by build configuration");	89	_ = pt;
92		90	_ = nav;
93	return self.llvm_object.updateNav(pt, nav);	91	unreachable; // we always use llvm
94	}	92	}
95		93
96	pub fn updateExports(	94	pub fn updateExports(
...	@@ -99,21 +97,21 @@ pub fn updateExports(	...	@@ -99,21 +97,21 @@ pub fn updateExports(
99	exported: Zcu.Exported,	97	exported: Zcu.Exported,
100	export_indices: []const Zcu.Export.Index,	98	export_indices: []const Zcu.Export.Index,
101	) !void {	99	) !void {
102	if (build_options.skip_non_native and builtin.object_format != .goff)	100	_ = self;
103	@panic("Attempted to compile for object format that was disabled by build configuration");	101	_ = pt;
104		102	_ = exported;
105	return self.llvm_object.updateExports(pt, exported, export_indices);	103	_ = export_indices;
		104	unreachable; // we always use llvm
106	}	105	}
107		106
108	pub fn flush(self: *Goff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	107	pub fn flush(self: *Goff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
109	return self.flushModule(arena, tid, prog_node);	108	return self.flushZcu(arena, tid, prog_node);
110	}	109	}
111		110
112	pub fn flushModule(self: *Goff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	111	pub fn flushZcu(self: *Goff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
113	if (build_options.skip_non_native and builtin.object_format != .goff)	112	_ = self;
114	@panic("Attempted to compile for object format that was disabled by build configuration");	113	_ = arena;
115
116	_ = tid;	114	_ = tid;
117		115	_ = prog_node;
118	try self.base.emitLlvmObject(arena, self.llvm_object, prog_node);	116	unreachable; // we always use llvm
119	}	117	}

src/link/MachO.zig+4-25

 @@ -6,9 +6,6 @@ base: link.File,
 rpath_list: []const []const u8,
-/// If this is not null, an object file is created by LLVM and emitted to zcu_object_sub_path.
-llvm_object: ?LlvmObject.Ptr = null,
 /// Debug symbols bundle (or dSym).
 d_sym: ?DebugSymbols = null,
 @@ -225,9 +222,6 @@ pub fn createEmpty(
         .force_load_objc = options.force_load_objc,
         .discard_local_symbols = options.discard_local_symbols,
     };
-    if (use_llvm and comp.config.have_zcu) {
-        self.llvm_object = try LlvmObject.create(arena, comp);
-    }
     errdefer self.base.destroy();
     self.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
 @@ -280,8 +274,6 @@ pub fn open(
 pub fn deinit(self: *MachO) void {
     const gpa = self.base.comp.gpa;
-    if (self.llvm_object) |llvm_object| llvm_object.deinit();
     if (self.d_sym) |*d_sym| {
         d_sym.deinit();
     }
 @@ -350,10 +342,10 @@ pub fn flush(
     tid: Zcu.PerThread.Id,
     prog_node: std.Progress.Node,
 ) link.File.FlushError!void {
-    try self.flushModule(arena, tid, prog_node);
+    try self.flushZcu(arena, tid, prog_node);
 }
-pub fn flushModule(
+pub fn flushZcu(
     self: *MachO,
     arena: Allocator,
     tid: Zcu.PerThread.Id,
 @@ -366,10 +358,6 @@ pub fn flushModule(
     const gpa = comp.gpa;
     const diags = &self.base.comp.link_diags;
-    if (self.llvm_object) |llvm_object| {
-        try self.base.emitLlvmObject(arena, llvm_object, prog_node);
-    }
     const sub_prog_node = prog_node.start("MachO Flush", 0);
     defer sub_prog_node.end();
 @@ -385,7 +373,7 @@ pub fn flushModule(
     // --verbose-link
     if (comp.verbose_link) try self.dumpArgv(comp);
-    if (self.getZigObject()) |zo| try zo.flushModule(self, tid);
+    if (self.getZigObject()) |zo| try zo.flushZcu(self, tid);
     if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);
     if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);
 @@ -629,7 +617,7 @@ pub fn flushModule(
         error.LinkFailure => return error.LinkFailure,
         else => |e| return diags.fail("failed to calculate and write uuid: {s}", .{@errorName(e)}),
     };
-    if (self.getDebugSymbols()) |dsym| dsym.flushModule(self) catch |err| switch (err) {
+    if (self.getDebugSymbols()) |dsym| dsym.flushZcu(self) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         else => |e| return diags.fail("failed to get debug symbols: {s}", .{@errorName(e)}),
     };
 @@ -3079,7 +3067,6 @@ pub fn updateFunc(
     if (build_options.skip_non_native and builtin.object_format != .macho) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateFunc(pt, func_index, air, liveness);
     return self.getZigObject().?.updateFunc(self, pt, func_index, air, liveness);
 }
 @@ -3087,12 +3074,10 @@ pub fn updateNav(self: *MachO, pt: Zcu.PerThread, nav: InternPool.Nav.Index) lin
     if (build_options.skip_non_native and builtin.object_format != .macho) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav);
     return self.getZigObject().?.updateNav(self, pt, nav);
 }
 pub fn updateLineNumber(self: *MachO, pt: Zcu.PerThread, ti_id: InternPool.TrackedInst.Index) !void {
-    if (self.llvm_object) |_| return;
     return self.getZigObject().?.updateLineNumber(pt, ti_id);
 }
 @@ -3105,7 +3090,6 @@ pub fn updateExports(
     if (build_options.skip_non_native and builtin.object_format != .macho) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
     return self.getZigObject().?.updateExports(self, pt, exported, export_indices);
 }
 @@ -3114,17 +3098,14 @@ pub fn deleteExport(
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    if (self.llvm_object) |_| return;
     return self.getZigObject().?.deleteExport(self, exported, name);
 }
 pub fn freeNav(self: *MachO, nav: InternPool.Nav.Index) void {
-    if (self.llvm_object) |llvm_object| return llvm_object.freeNav(nav);
     return self.getZigObject().?.freeNav(nav);
 }
 pub fn getNavVAddr(self: *MachO, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index, reloc_info: link.File.RelocInfo) !u64 {
-    assert(self.llvm_object == null);
     return self.getZigObject().?.getNavVAddr(self, pt, nav_index, reloc_info);
 }
 @@ -3139,7 +3120,6 @@ pub fn lowerUav(
 }
 pub fn getUavVAddr(self: *MachO, uav: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 {
-    assert(self.llvm_object == null);
     return self.getZigObject().?.getUavVAddr(self, uav, reloc_info);
 }
 @@ -5496,7 +5476,6 @@ const ObjcStubsSection = synthetic.ObjcStubsSection;
 const Object = @import("MachO/Object.zig");
 const LazyBind = bind.LazyBind;
 const LaSymbolPtrSection = synthetic.LaSymbolPtrSection;
-const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Md5 = std.crypto.hash.Md5;
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");

src/link/MachO/DebugSymbols.zig+1-1

...	@@ -178,7 +178,7 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) !u64	...	@@ -178,7 +178,7 @@ fn findFreeSpace(self: *DebugSymbols, object_size: u64, min_alignment: u64) !u64
178	return offset;	178	return offset;
179	}	179	}
180		180
181	pub fn flushModule(self: DebugSymbols, macho_file: MachO) !void {	181	pub fn flushZcu(self: DebugSymbols, macho_file: MachO) !void {
182	const zo = macho_file.getZigObject().?;	182	const zo = macho_file.getZigObject().?;
183	for (self.relocs.items) \|*reloc\| {	183	for (self.relocs.items) \|*reloc\| {
184	const sym = zo.symbols.items[reloc.target];	184	const sym = zo.symbols.items[reloc.target];

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

src/link/Plan9.zig+5-5

src/link/SpirV.zig+4-4

...	@@ -17,7 +17,7 @@	...	@@ -17,7 +17,7 @@
17	//! All regular functions.	17	//! All regular functions.
18		18
19	// Because SPIR-V requires re-compilation anyway, and so hot swapping will not work	19	// Because SPIR-V requires re-compilation anyway, and so hot swapping will not work
20	// anyway, we simply generate all the code in flushModule. This keeps	20	// anyway, we simply generate all the code in flushZcu. This keeps
21	// things considerably simpler.	21	// things considerably simpler.
22		22
23	const SpirV = @This();	23	const SpirV = @This();
...	@@ -194,17 +194,17 @@ pub fn updateExports(	...	@@ -194,17 +194,17 @@ pub fn updateExports(
194	}	194	}
195		195
196	pub fn flush(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	196	pub fn flush(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
197	return self.flushModule(arena, tid, prog_node);	197	return self.flushZcu(arena, tid, prog_node);
198	}	198	}
199		199
200	pub fn flushModule(	200	pub fn flushZcu(
201	self: *SpirV,	201	self: *SpirV,
202	arena: Allocator,	202	arena: Allocator,
203	tid: Zcu.PerThread.Id,	203	tid: Zcu.PerThread.Id,
204	prog_node: std.Progress.Node,	204	prog_node: std.Progress.Node,
205	) link.File.FlushError!void {	205	) link.File.FlushError!void {
206	// The goal is to never use this because it's only needed if we need to	206	// The goal is to never use this because it's only needed if we need to
207	// write to InternPool, but flushModule is too late to be writing to the	207	// write to InternPool, but flushZcu is too late to be writing to the
208	// InternPool.	208	// InternPool.
209	_ = tid;	209	_ = tid;
210		210

src/link/Wasm.zig+9-23

 @@ -36,7 +36,6 @@ const abi = @import("../arch/wasm/abi.zig");
 const Compilation = @import("../Compilation.zig");
 const Dwarf = @import("Dwarf.zig");
 const InternPool = @import("../InternPool.zig");
-const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Zcu = @import("../Zcu.zig");
 const codegen = @import("../codegen.zig");
 const dev = @import("../dev.zig");
 @@ -81,8 +80,6 @@ import_table: bool,
 export_table: bool,
 /// Output name of the file
 name: []const u8,
-/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
-llvm_object: ?LlvmObject.Ptr = null,
 /// List of relocatable files to be linked into the final binary.
 objects: std.ArrayListUnmanaged(Object) = .{},
 @@ -2992,9 +2989,6 @@ pub fn createEmpty(
         .object_host_name = .none,
         .preloaded_strings = undefined,
     };
-    if (use_llvm and comp.config.have_zcu) {
-        wasm.llvm_object = try LlvmObject.create(arena, comp);
-    }
     errdefer wasm.base.destroy();
     if (options.object_host_name) |name| wasm.object_host_name = (try wasm.internString(name)).toOptional();
 @@ -3116,7 +3110,6 @@ fn parseArchive(wasm: *Wasm, obj: link.Input.Object) !void {
 pub fn deinit(wasm: *Wasm) void {
     const gpa = wasm.base.comp.gpa;
-    if (wasm.llvm_object) |llvm_object| llvm_object.deinit();
     wasm.navs_exe.deinit(gpa);
     wasm.navs_obj.deinit(gpa);
 @@ -3196,7 +3189,6 @@ pub fn updateFunc(wasm: *Wasm, pt: Zcu.PerThread, func_index: InternPool.Index,
     if (build_options.skip_non_native and builtin.object_format != .wasm) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (wasm.llvm_object) |llvm_object| return llvm_object.updateFunc(pt, func_index, air, liveness);
     dev.check(.wasm_backend);
 @@ -3228,7 +3220,6 @@ pub fn updateNav(wasm: *Wasm, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index
     if (build_options.skip_non_native and builtin.object_format != .wasm) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (wasm.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav_index);
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
 @@ -3308,8 +3299,6 @@ pub fn deleteExport(
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    if (wasm.llvm_object != null) return;
     const zcu = wasm.base.comp.zcu.?;
     const ip = &zcu.intern_pool;
     const name_slice = name.toSlice(ip);
 @@ -3332,7 +3321,6 @@ pub fn updateExports(
     if (build_options.skip_non_native and builtin.object_format != .wasm) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (wasm.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
 @@ -3391,7 +3379,7 @@ pub fn flush(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: st
             else => |e| return diags.fail("failed to link with LLD: {s}", .{@errorName(e)}),
         };
     }
-    return wasm.flushModule(arena, tid, prog_node);
+    return wasm.flushZcu(arena, tid, prog_node);
 }
 pub fn prelink(wasm: *Wasm, prog_node: std.Progress.Node) link.File.FlushError!void {
 @@ -3785,26 +3773,20 @@ fn markTable(wasm: *Wasm, i: ObjectTableIndex) link.File.FlushError!void {
     try wasm.tables.put(wasm.base.comp.gpa, .fromObjectTable(i), {});
 }
-pub fn flushModule(
+pub fn flushZcu(
     wasm: *Wasm,
     arena: Allocator,
     tid: Zcu.PerThread.Id,
     prog_node: std.Progress.Node,
 ) link.File.FlushError!void {
     // The goal is to never use this because it's only needed if we need to
-    // write to InternPool, but flushModule is too late to be writing to the
+    // write to InternPool, but flushZcu is too late to be writing to the
     // InternPool.
     _ = tid;
     const comp = wasm.base.comp;
-    const use_lld = build_options.have_llvm and comp.config.use_lld;
     const diags = &comp.link_diags;
     const gpa = comp.gpa;
-    if (wasm.llvm_object) |llvm_object| {
-        try wasm.base.emitLlvmObject(arena, llvm_object, prog_node);
-        if (use_lld) return;
-    }
     if (comp.verbose_link) Compilation.dump_argv(wasm.dump_argv_list.items);
     if (wasm.base.zcu_object_sub_path) |path| {
 @@ -3870,8 +3852,12 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
     // If there is no Zig code to compile, then we should skip flushing the output file because it
     // will not be part of the linker line anyway.
-    const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
+    const module_obj_path: ?[]const u8 = if (comp.zcu) |zcu| blk: {
-        try wasm.flushModule(arena, tid, prog_node);
+        if (zcu.llvm_object == null) {
+            try wasm.flushZcu(arena, tid, prog_node);
+        } else {
+            // `Compilation.flush` has already made LLVM emit this object file for us.
+        }
         if (fs.path.dirname(full_out_path)) |dirname| {
             break :blk try fs.path.join(arena, &.{ dirname, wasm.base.zcu_object_sub_path.? });

src/link/Xcoff.zig+22-24

...	@@ -17,10 +17,8 @@ const link = @import("../link.zig");	...	@@ -17,10 +17,8 @@ const link = @import("../link.zig");
17	const trace = @import("../tracy.zig").trace;	17	const trace = @import("../tracy.zig").trace;
18	const build_options = @import("build_options");	18	const build_options = @import("build_options");
19	const Air = @import("../Air.zig");	19	const Air = @import("../Air.zig");
20	const LlvmObject = @import("../codegen/llvm.zig").Object;
21		20
22	base: link.File,	21	base: link.File,
23	llvm_object: LlvmObject.Ptr,
24		22
25	pub fn createEmpty(	23	pub fn createEmpty(
26	arena: Allocator,	24	arena: Allocator,
...	@@ -36,7 +34,6 @@ pub fn createEmpty(	...	@@ -36,7 +34,6 @@ pub fn createEmpty(
36	assert(!use_lld); // Caught by Compilation.Config.resolve.	34	assert(!use_lld); // Caught by Compilation.Config.resolve.
37	assert(target.os.tag == .aix); // Caught by Compilation.Config.resolve.	35	assert(target.os.tag == .aix); // Caught by Compilation.Config.resolve.
38		36
39	const llvm_object = try LlvmObject.create(arena, comp);
40	const xcoff = try arena.create(Xcoff);	37	const xcoff = try arena.create(Xcoff);
41	xcoff.* = .{	38	xcoff.* = .{
42	.base = .{	39	.base = .{
...	@@ -52,7 +49,6 @@ pub fn createEmpty(	...	@@ -52,7 +49,6 @@ pub fn createEmpty(
52	.disable_lld_caching = options.disable_lld_caching,	49	.disable_lld_caching = options.disable_lld_caching,
53	.build_id = options.build_id,	50	.build_id = options.build_id,
54	},	51	},
55	.llvm_object = llvm_object,
56	};	52	};
57		53
58	return xcoff;	54	return xcoff;
...	@@ -70,7 +66,7 @@ pub fn open(	...	@@ -70,7 +66,7 @@ pub fn open(
70	}	66	}
71		67
72	pub fn deinit(self: *Xcoff) void {	68	pub fn deinit(self: *Xcoff) void {
73	self.llvm_object.deinit();	69	_ = self;
74	}	70	}
75		71
76	pub fn updateFunc(	72	pub fn updateFunc(
...	@@ -80,17 +76,19 @@ pub fn updateFunc(	...	@@ -80,17 +76,19 @@ pub fn updateFunc(
80	air: Air,	76	air: Air,
81	liveness: Air.Liveness,	77	liveness: Air.Liveness,
82	) link.File.UpdateNavError!void {	78	) link.File.UpdateNavError!void {
83	if (build_options.skip_non_native and builtin.object_format != .xcoff)	79	_ = self;
84	@panic("Attempted to compile for object format that was disabled by build configuration");	80	_ = pt;
85		81	_ = func_index;
86	try self.llvm_object.updateFunc(pt, func_index, air, liveness);	82	_ = air;
		83	_ = liveness;
		84	unreachable; // we always use llvm
87	}	85	}
88		86
89	pub fn updateNav(self: *Xcoff, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {	87	pub fn updateNav(self: *Xcoff, pt: Zcu.PerThread, nav: InternPool.Nav.Index) link.File.UpdateNavError!void {
90	if (build_options.skip_non_native and builtin.object_format != .xcoff)	88	_ = self;
91	@panic("Attempted to compile for object format that was disabled by build configuration");	89	_ = pt;
92		90	_ = nav;
93	return self.llvm_object.updateNav(pt, nav);	91	unreachable; // we always use llvm
94	}	92	}
95		93
96	pub fn updateExports(	94	pub fn updateExports(
...	@@ -99,21 +97,21 @@ pub fn updateExports(	...	@@ -99,21 +97,21 @@ pub fn updateExports(
99	exported: Zcu.Exported,	97	exported: Zcu.Exported,
100	export_indices: []const Zcu.Export.Index,	98	export_indices: []const Zcu.Export.Index,
101	) !void {	99	) !void {
102	if (build_options.skip_non_native and builtin.object_format != .xcoff)	100	_ = self;
103	@panic("Attempted to compile for object format that was disabled by build configuration");	101	_ = pt;
104		102	_ = exported;
105	return self.llvm_object.updateExports(pt, exported, export_indices);	103	_ = export_indices;
		104	unreachable; // we always use llvm
106	}	105	}
107		106
108	pub fn flush(self: *Xcoff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	107	pub fn flush(self: *Xcoff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
109	return self.flushModule(arena, tid, prog_node);	108	return self.flushZcu(arena, tid, prog_node);
110	}	109	}
111		110
112	pub fn flushModule(self: *Xcoff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {	111	pub fn flushZcu(self: *Xcoff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
113	if (build_options.skip_non_native and builtin.object_format != .xcoff)	112	_ = self;
114	@panic("Attempted to compile for object format that was disabled by build configuration");	113	_ = arena;
115
116	_ = tid;	114	_ = tid;
117		115	_ = prog_node;
118	try self.base.emitLlvmObject(arena, self.llvm_object, prog_node);	116	unreachable; // we always use llvm
119	}	117	}

src/target.zig+1-1

...	@@ -739,7 +739,7 @@ pub fn functionPointerMask(target: std.Target) ?u64 {	...	@@ -739,7 +739,7 @@ pub fn functionPointerMask(target: std.Target) ?u64 {
739		739
740	pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend) bool {	740	pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend) bool {
741	switch (backend) {	741	switch (backend) {
742	.stage1, .stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target),	742	.stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target),
743	.stage2_c => return true,	743	.stage2_c => return true,
744	else => return false,	744	else => return false,
745	}	745	}

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-05-28 06:36:47+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-06-12 13:55:39+01:00
log	3743c3e39c6bb645db7403fd446953d43ac7c7dc
tree	e9223b737051f606b7eec326e71e5977f4164dfc
parent	424e6ac54b0f8bbfb43f24e28c71ac72169f3719
signature	Commit is signed but in an unrecognized format.

...	@@ -310,7 +310,7 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {	...	@@ -310,7 +310,7 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {
310	if (self.dwarf) \|*dwarf\| {	310	if (self.dwarf) \|*dwarf\| {
311	const pt: Zcu.PerThread = .activate(elf_file.base.comp.zcu.?, tid);	311	const pt: Zcu.PerThread = .activate(elf_file.base.comp.zcu.?, tid);
312	defer pt.deactivate();	312	defer pt.deactivate();
313	try dwarf.flushModule(pt);	313	try dwarf.flushZcu(pt);
314		314
315	const gpa = elf_file.base.comp.gpa;	315	const gpa = elf_file.base.comp.gpa;
316	const cpu_arch = elf_file.getTarget().cpu.arch;	316	const cpu_arch = elf_file.getTarget().cpu.arch;
...	@@ -481,7 +481,7 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {	...	@@ -481,7 +481,7 @@ pub fn flush(self: ZigObject, elf_file: Elf, tid: Zcu.PerThread.Id) !void {
481	self.debug_str_section_dirty = false;	481	self.debug_str_section_dirty = false;
482	}	482	}
483		483
484	// The point of flushModule() is to commit changes, so in theory, nothing should	484	// The point of flushZcu() is to commit changes, so in theory, nothing should
485	// be dirty after this. However, it is possible for some things to remain	485	// be dirty after this. However, it is possible for some things to remain
486	// dirty because they fail to be written in the event of compile errors,	486	// dirty because they fail to be written in the event of compile errors,
487	// such as debug_line_header_dirty and debug_info_header_dirty.	487	// such as debug_line_header_dirty and debug_info_header_dirty.
...	@@ -661,7 +661,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {	...	@@ -661,7 +661,7 @@ pub fn scanRelocs(self: ZigObject, elf_file: Elf, undefs: anytype) !void {
661	if (shdr.sh_type == elf.SHT_NOBITS) continue;	661	if (shdr.sh_type == elf.SHT_NOBITS) continue;
662	if (atom_ptr.scanRelocsRequiresCode(elf_file)) {	662	if (atom_ptr.scanRelocsRequiresCode(elf_file)) {
663	// TODO ideally we don't have to fetch the code here.	663	// TODO ideally we don't have to fetch the code here.
664	// Perhaps it would make sense to save the code until flushModule where we	664	// Perhaps it would make sense to save the code until flushZcu where we
665	// would free all of generated code?	665	// would free all of generated code?
666	const code = try self.codeAlloc(elf_file, atom_index);	666	const code = try self.codeAlloc(elf_file, atom_index);
667	defer gpa.free(code);	667	defer gpa.free(code);
...	@@ -1075,7 +1075,7 @@ pub fn getOrCreateMetadataForLazySymbol(	...	@@ -1075,7 +1075,7 @@ pub fn getOrCreateMetadataForLazySymbol(
1075	}	1075	}
1076	state_ptr.* = .pending_flush;	1076	state_ptr.* = .pending_flush;
1077	const symbol_index = symbol_index_ptr.*;	1077	const symbol_index = symbol_index_ptr.*;
1078	// anyerror needs to be deferred until flushModule	1078	// anyerror needs to be deferred until flushZcu
1079	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbol(elf_file, pt, lazy_sym, symbol_index);	1079	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbol(elf_file, pt, lazy_sym, symbol_index);
1080	return symbol_index;	1080	return symbol_index;
1081	}	1081	}

...	@@ -550,7 +550,7 @@ pub fn getInputSection(self: ZigObject, atom: Atom, macho_file: *MachO) macho.se	...	@@ -550,7 +550,7 @@ pub fn getInputSection(self: ZigObject, atom: Atom, macho_file: *MachO) macho.se
550	return sect;	550	return sect;
551	}	551	}
552		552
553	pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id) link.File.FlushError!void {	553	pub fn flushZcu(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id) link.File.FlushError!void {
554	const diags = &macho_file.base.comp.link_diags;	554	const diags = &macho_file.base.comp.link_diags;
555		555
556	// Handle any lazy symbols that were emitted by incremental compilation.	556	// Handle any lazy symbols that were emitted by incremental compilation.
...	@@ -589,7 +589,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)	...	@@ -589,7 +589,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)
589	if (self.dwarf) \|*dwarf\| {	589	if (self.dwarf) \|*dwarf\| {
590	const pt: Zcu.PerThread = .activate(macho_file.base.comp.zcu.?, tid);	590	const pt: Zcu.PerThread = .activate(macho_file.base.comp.zcu.?, tid);
591	defer pt.deactivate();	591	defer pt.deactivate();
592	dwarf.flushModule(pt) catch \|err\| switch (err) {	592	dwarf.flushZcu(pt) catch \|err\| switch (err) {
593	error.OutOfMemory => return error.OutOfMemory,	593	error.OutOfMemory => return error.OutOfMemory,
594	else => \|e\| return diags.fail("failed to flush dwarf module: {s}", .{@errorName(e)}),	594	else => \|e\| return diags.fail("failed to flush dwarf module: {s}", .{@errorName(e)}),
595	};	595	};
...	@@ -599,7 +599,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)	...	@@ -599,7 +599,7 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)
599	self.debug_strtab_dirty = false;	599	self.debug_strtab_dirty = false;
600	}	600	}
601		601
602	// The point of flushModule() is to commit changes, so in theory, nothing should	602	// The point of flushZcu() is to commit changes, so in theory, nothing should
603	// be dirty after this. However, it is possible for some things to remain	603	// be dirty after this. However, it is possible for some things to remain
604	// dirty because they fail to be written in the event of compile errors,	604	// dirty because they fail to be written in the event of compile errors,
605	// such as debug_line_header_dirty and debug_info_header_dirty.	605	// such as debug_line_header_dirty and debug_info_header_dirty.
...	@@ -1537,7 +1537,7 @@ pub fn getOrCreateMetadataForLazySymbol(	...	@@ -1537,7 +1537,7 @@ pub fn getOrCreateMetadataForLazySymbol(
1537	}	1537	}
1538	state_ptr.* = .pending_flush;	1538	state_ptr.* = .pending_flush;
1539	const symbol_index = symbol_index_ptr.*;	1539	const symbol_index = symbol_index_ptr.*;
1540	// anyerror needs to be deferred until flushModule	1540	// anyerror needs to be deferred until flushZcu
1541	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbol(macho_file, pt, lazy_sym, symbol_index);	1541	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbol(macho_file, pt, lazy_sym, symbol_index);
1542	return symbol_index;	1542	return symbol_index;
1543	}	1543	}

...	@@ -494,7 +494,7 @@ fn updateFinish(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index	...	@@ -494,7 +494,7 @@ fn updateFinish(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index
494	// write the symbol	494	// write the symbol
495	// we already have the got index	495	// we already have the got index
496	const sym: aout.Sym = .{	496	const sym: aout.Sym = .{
497	.value = undefined, // the value of stuff gets filled in in flushModule	497	.value = undefined, // the value of stuff gets filled in in flushZcu
498	.type = atom.type,	498	.type = atom.type,
499	.name = try gpa.dupe(u8, nav.name.toSlice(ip)),	499	.name = try gpa.dupe(u8, nav.name.toSlice(ip)),
500	};	500	};
...	@@ -543,7 +543,7 @@ pub fn flush(	...	@@ -543,7 +543,7 @@ pub fn flush(
543	.Obj => return diags.fail("writing plan9 object files unimplemented", .{}),	543	.Obj => return diags.fail("writing plan9 object files unimplemented", .{}),
544	.Lib => return diags.fail("writing plan9 lib files unimplemented", .{}),	544	.Lib => return diags.fail("writing plan9 lib files unimplemented", .{}),
545	}	545	}
546	return self.flushModule(arena, tid, prog_node);	546	return self.flushZcu(arena, tid, prog_node);
547	}	547	}
548		548
549	pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void {	549	pub fn changeLine(l: *std.ArrayList(u8), delta_line: i32) !void {
...	@@ -586,7 +586,7 @@ fn atomCount(self: *Plan9) usize {	...	@@ -586,7 +586,7 @@ fn atomCount(self: *Plan9) usize {
586	return data_nav_count + fn_nav_count + lazy_atom_count + extern_atom_count + uav_atom_count;	586	return data_nav_count + fn_nav_count + lazy_atom_count + extern_atom_count + uav_atom_count;
587	}	587	}
588		588
589	pub fn flushModule(	589	pub fn flushZcu(
590	self: *Plan9,	590	self: *Plan9,
591	arena: Allocator,	591	arena: Allocator,
592	/// TODO: stop using this	592	/// TODO: stop using this
...	@@ -610,7 +610,7 @@ pub fn flushModule(	...	@@ -610,7 +610,7 @@ pub fn flushModule(
610	const sub_prog_node = prog_node.start("Flush Module", 0);	610	const sub_prog_node = prog_node.start("Flush Module", 0);
611	defer sub_prog_node.end();	611	defer sub_prog_node.end();
612		612
613	log.debug("flushModule", .{});	613	log.debug("flushZcu", .{});
614		614
615	defer assert(self.hdr.entry != 0x0);	615	defer assert(self.hdr.entry != 0x0);
616		616
...	@@ -1039,7 +1039,7 @@ pub fn getOrCreateAtomForLazySymbol(self: *Plan9, pt: Zcu.PerThread, lazy_sym: F	...	@@ -1039,7 +1039,7 @@ pub fn getOrCreateAtomForLazySymbol(self: *Plan9, pt: Zcu.PerThread, lazy_sym: F
1039	const atom = atom_ptr.*;	1039	const atom = atom_ptr.*;
1040	_ = try self.getAtomPtr(atom).getOrCreateSymbolTableEntry(self);	1040	_ = try self.getAtomPtr(atom).getOrCreateSymbolTableEntry(self);
1041	_ = self.getAtomPtr(atom).getOrCreateOffsetTableEntry(self);	1041	_ = self.getAtomPtr(atom).getOrCreateOffsetTableEntry(self);
1042	// anyerror needs to be deferred until flushModule	1042	// anyerror needs to be deferred until flushZcu
1043	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbolAtom(pt, lazy_sym, atom);	1043	if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbolAtom(pt, lazy_sym, atom);
1044	return atom;	1044	return atom;
1045	}	1045	}

compiler: slightly untangle LLVM from the linkers