Commit 1340565e22e154db41e90a8d4f0b552176711ba0 | zig

lib/std/Build/Cache.zig+7

 @@ -398,12 +398,19 @@ pub const Manifest = struct {
         return gop.index;
     }
+    /// Deprecated, use `addOptionalFilePath`.
     pub fn addOptionalFile(self: *Manifest, optional_file_path: ?[]const u8) !void {
         self.hash.add(optional_file_path != null);
         const file_path = optional_file_path orelse return;
         _ = try self.addFile(file_path, null);
     }
+    pub fn addOptionalFilePath(self: *Manifest, optional_file_path: ?Path) !void {
+        self.hash.add(optional_file_path != null);
+        const file_path = optional_file_path orelse return;
+        _ = try self.addFilePath(file_path, null);
+    }
     pub fn addListOfFiles(self: *Manifest, list_of_files: []const []const u8) !void {
         self.hash.add(list_of_files.len);
         for (list_of_files) |file_path| {

lib/std/Build/Cache/Path.zig+22-2

 @@ -11,7 +11,11 @@ pub fn clone(p: Path, arena: Allocator) Allocator.Error!Path {
 }
 pub fn cwd() Path {
-    return .{ .root_dir = Cache.Directory.cwd() };
+    return initCwd("");
+}
+pub fn initCwd(sub_path: []const u8) Path {
+    return .{ .root_dir = Cache.Directory.cwd(), .sub_path = sub_path };
 }
 pub fn join(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {
 @@ -126,6 +130,14 @@ pub fn makePath(p: Path, sub_path: []const u8) !void {
     return p.root_dir.handle.makePath(joined_path);
 }
+pub fn toString(p: Path, allocator: Allocator) Allocator.Error![]u8 {
+    return std.fmt.allocPrint(allocator, "{}", .{p});
+}
+pub fn toStringZ(p: Path, allocator: Allocator) Allocator.Error![:0]u8 {
+    return std.fmt.allocPrintZ(allocator, "{}", .{p});
+}
 pub fn format(
     self: Path,
     comptime fmt_string: []const u8,
 @@ -137,7 +149,7 @@ pub fn format(
         const stringEscape = std.zig.stringEscape;
         const f = switch (fmt_string[0]) {
             'q' => "",
-            '\'' => '\'',
+            '\'' => "\'",
             else => @compileError("unsupported format string: " ++ fmt_string),
         };
         if (self.root_dir.path) |p| {
 @@ -182,6 +194,14 @@ pub fn subPathOrDot(self: Path) []const u8 {
     return if (self.sub_path.len == 0) "." else self.sub_path;
 }
+pub fn stem(p: Path) []const u8 {
+    return fs.path.stem(p.sub_path);
+}
+pub fn basename(p: Path) []const u8 {
+    return fs.path.basename(p.sub_path);
+}
 /// Useful to make `Path` a key in `std.ArrayHashMap`.
 pub const TableAdapter = struct {
     pub const Hash = std.hash.Wyhash;

lib/std/Build/Step/CheckObject.zig+32-12

 @@ -557,15 +557,15 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
     const check_object: *CheckObject = @fieldParentPtr("step", step);
     try step.singleUnchangingWatchInput(check_object.source);
-    const src_path = check_object.source.getPath2(b, step);
+    const src_path = check_object.source.getPath3(b, step);
-    const contents = fs.cwd().readFileAllocOptions(
+    const contents = src_path.root_dir.handle.readFileAllocOptions(
         gpa,
-        src_path,
+        src_path.sub_path,
         check_object.max_bytes,
         null,
         @alignOf(u64),
         null,
-    ) catch |err| return step.fail("unable to read '{s}': {s}", .{ src_path, @errorName(err) });
+    ) catch |err| return step.fail("unable to read '{'}': {s}", .{ src_path, @errorName(err) });
     var vars = std.StringHashMap(u64).init(gpa);
     for (check_object.checks.items) |chk| {
 @@ -640,8 +640,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
+                            \\========= file path: =================================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 @@ -655,8 +660,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\*{s}*
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
+                            \\========= file path: =================================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 @@ -669,8 +679,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does contain it: ========
                             \\{s}
-                            \\===================================================
+                            \\========= file path: ==============================
-                        , .{ fmtMessageString(chk.kind, act.phrase.resolve(b, step)), fmtMessageString(chk.kind, output) });
+                            \\{}
+                        , .{
+                            fmtMessageString(chk.kind, act.phrase.resolve(b, step)),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },
 @@ -684,8 +699,13 @@ fn make(step: *Step, make_options: Step.MakeOptions) !void {
                             \\{s}
                             \\========= but parsed file does not contain it: =======
                             \\{s}
-                            \\======================================================
+                            \\========= file path: ==============================
-                        , .{ act.phrase.resolve(b, step), fmtMessageString(chk.kind, output) });
+                            \\{}
+                        , .{
+                            act.phrase.resolve(b, step),
+                            fmtMessageString(chk.kind, output),
+                            src_path,
+                        });
                     }
                 },

lib/std/zig/LibCInstallation.zig+328

...	@@ -690,12 +690,340 @@ fn appendCcExe(args: *std.ArrayList([]const u8), skip_cc_env_var: bool) !void {	...	@@ -690,12 +690,340 @@ fn appendCcExe(args: *std.ArrayList([]const u8), skip_cc_env_var: bool) !void {
690	}	690	}
691	}	691	}
692		692
		693	/// These are basenames. This data is produced with a pure function. See also
		694	/// `CsuPaths`.
		695	pub const CrtBasenames = struct {
		696	crt0: ?[]const u8 = null,
		697	crti: ?[]const u8 = null,
		698	crtbegin: ?[]const u8 = null,
		699	crtend: ?[]const u8 = null,
		700	crtn: ?[]const u8 = null,
		701
		702	pub const GetArgs = struct {
		703	target: std.Target,
		704	link_libc: bool,
		705	output_mode: std.builtin.OutputMode,
		706	link_mode: std.builtin.LinkMode,
		707	pie: bool,
		708	};
		709
		710	/// Determine file system path names of C runtime startup objects for supported
		711	/// link modes.
		712	pub fn get(args: GetArgs) CrtBasenames {
		713	// crt objects are only required for libc.
		714	if (!args.link_libc) return .{};
		715
		716	// Flatten crt cases.
		717	const mode: enum {
		718	dynamic_lib,
		719	dynamic_exe,
		720	dynamic_pie,
		721	static_exe,
		722	static_pie,
		723	} = switch (args.output_mode) {
		724	.Obj => return .{},
		725	.Lib => switch (args.link_mode) {
		726	.dynamic => .dynamic_lib,
		727	.static => return .{},
		728	},
		729	.Exe => switch (args.link_mode) {
		730	.dynamic => if (args.pie) .dynamic_pie else .dynamic_exe,
		731	.static => if (args.pie) .static_pie else .static_exe,
		732	},
		733	};
		734
		735	const target = args.target;
		736
		737	if (target.isAndroid()) return switch (mode) {
		738	.dynamic_lib => .{
		739	.crtbegin = "crtbegin_so.o",
		740	.crtend = "crtend_so.o",
		741	},
		742	.dynamic_exe, .dynamic_pie => .{
		743	.crtbegin = "crtbegin_dynamic.o",
		744	.crtend = "crtend_android.o",
		745	},
		746	.static_exe, .static_pie => .{
		747	.crtbegin = "crtbegin_static.o",
		748	.crtend = "crtend_android.o",
		749	},
		750	};
		751
		752	return switch (target.os.tag) {
		753	.linux => switch (mode) {
		754	.dynamic_lib => .{
		755	.crti = "crti.o",
		756	.crtn = "crtn.o",
		757	},
		758	.dynamic_exe => .{
		759	.crt0 = "crt1.o",
		760	.crti = "crti.o",
		761	.crtn = "crtn.o",
		762	},
		763	.dynamic_pie => .{
		764	.crt0 = "Scrt1.o",
		765	.crti = "crti.o",
		766	.crtn = "crtn.o",
		767	},
		768	.static_exe => .{
		769	.crt0 = "crt1.o",
		770	.crti = "crti.o",
		771	.crtn = "crtn.o",
		772	},
		773	.static_pie => .{
		774	.crt0 = "rcrt1.o",
		775	.crti = "crti.o",
		776	.crtn = "crtn.o",
		777	},
		778	},
		779	.dragonfly => switch (mode) {
		780	.dynamic_lib => .{
		781	.crti = "crti.o",
		782	.crtbegin = "crtbeginS.o",
		783	.crtend = "crtendS.o",
		784	.crtn = "crtn.o",
		785	},
		786	.dynamic_exe => .{
		787	.crt0 = "crt1.o",
		788	.crti = "crti.o",
		789	.crtbegin = "crtbegin.o",
		790	.crtend = "crtend.o",
		791	.crtn = "crtn.o",
		792	},
		793	.dynamic_pie => .{
		794	.crt0 = "Scrt1.o",
		795	.crti = "crti.o",
		796	.crtbegin = "crtbeginS.o",
		797	.crtend = "crtendS.o",
		798	.crtn = "crtn.o",
		799	},
		800	.static_exe => .{
		801	.crt0 = "crt1.o",
		802	.crti = "crti.o",
		803	.crtbegin = "crtbegin.o",
		804	.crtend = "crtend.o",
		805	.crtn = "crtn.o",
		806	},
		807	.static_pie => .{
		808	.crt0 = "Scrt1.o",
		809	.crti = "crti.o",
		810	.crtbegin = "crtbeginS.o",
		811	.crtend = "crtendS.o",
		812	.crtn = "crtn.o",
		813	},
		814	},
		815	.freebsd => switch (mode) {
		816	.dynamic_lib => .{
		817	.crti = "crti.o",
		818	.crtbegin = "crtbeginS.o",
		819	.crtend = "crtendS.o",
		820	.crtn = "crtn.o",
		821	},
		822	.dynamic_exe => .{
		823	.crt0 = "crt1.o",
		824	.crti = "crti.o",
		825	.crtbegin = "crtbegin.o",
		826	.crtend = "crtend.o",
		827	.crtn = "crtn.o",
		828	},
		829	.dynamic_pie => .{
		830	.crt0 = "Scrt1.o",
		831	.crti = "crti.o",
		832	.crtbegin = "crtbeginS.o",
		833	.crtend = "crtendS.o",
		834	.crtn = "crtn.o",
		835	},
		836	.static_exe => .{
		837	.crt0 = "crt1.o",
		838	.crti = "crti.o",
		839	.crtbegin = "crtbeginT.o",
		840	.crtend = "crtend.o",
		841	.crtn = "crtn.o",
		842	},
		843	.static_pie => .{
		844	.crt0 = "Scrt1.o",
		845	.crti = "crti.o",
		846	.crtbegin = "crtbeginS.o",
		847	.crtend = "crtendS.o",
		848	.crtn = "crtn.o",
		849	},
		850	},
		851	.netbsd => switch (mode) {
		852	.dynamic_lib => .{
		853	.crti = "crti.o",
		854	.crtbegin = "crtbeginS.o",
		855	.crtend = "crtendS.o",
		856	.crtn = "crtn.o",
		857	},
		858	.dynamic_exe => .{
		859	.crt0 = "crt0.o",
		860	.crti = "crti.o",
		861	.crtbegin = "crtbegin.o",
		862	.crtend = "crtend.o",
		863	.crtn = "crtn.o",
		864	},
		865	.dynamic_pie => .{
		866	.crt0 = "crt0.o",
		867	.crti = "crti.o",
		868	.crtbegin = "crtbeginS.o",
		869	.crtend = "crtendS.o",
		870	.crtn = "crtn.o",
		871	},
		872	.static_exe => .{
		873	.crt0 = "crt0.o",
		874	.crti = "crti.o",
		875	.crtbegin = "crtbeginT.o",
		876	.crtend = "crtend.o",
		877	.crtn = "crtn.o",
		878	},
		879	.static_pie => .{
		880	.crt0 = "crt0.o",
		881	.crti = "crti.o",
		882	.crtbegin = "crtbeginT.o",
		883	.crtend = "crtendS.o",
		884	.crtn = "crtn.o",
		885	},
		886	},
		887	.openbsd => switch (mode) {
		888	.dynamic_lib => .{
		889	.crtbegin = "crtbeginS.o",
		890	.crtend = "crtendS.o",
		891	},
		892	.dynamic_exe, .dynamic_pie => .{
		893	.crt0 = "crt0.o",
		894	.crtbegin = "crtbegin.o",
		895	.crtend = "crtend.o",
		896	},
		897	.static_exe, .static_pie => .{
		898	.crt0 = "rcrt0.o",
		899	.crtbegin = "crtbegin.o",
		900	.crtend = "crtend.o",
		901	},
		902	},
		903	.haiku => switch (mode) {
		904	.dynamic_lib => .{
		905	.crti = "crti.o",
		906	.crtbegin = "crtbeginS.o",
		907	.crtend = "crtendS.o",
		908	.crtn = "crtn.o",
		909	},
		910	.dynamic_exe => .{
		911	.crt0 = "start_dyn.o",
		912	.crti = "crti.o",
		913	.crtbegin = "crtbegin.o",
		914	.crtend = "crtend.o",
		915	.crtn = "crtn.o",
		916	},
		917	.dynamic_pie => .{
		918	.crt0 = "start_dyn.o",
		919	.crti = "crti.o",
		920	.crtbegin = "crtbeginS.o",
		921	.crtend = "crtendS.o",
		922	.crtn = "crtn.o",
		923	},
		924	.static_exe => .{
		925	.crt0 = "start_dyn.o",
		926	.crti = "crti.o",
		927	.crtbegin = "crtbegin.o",
		928	.crtend = "crtend.o",
		929	.crtn = "crtn.o",
		930	},
		931	.static_pie => .{
		932	.crt0 = "start_dyn.o",
		933	.crti = "crti.o",
		934	.crtbegin = "crtbeginS.o",
		935	.crtend = "crtendS.o",
		936	.crtn = "crtn.o",
		937	},
		938	},
		939	.solaris, .illumos => switch (mode) {
		940	.dynamic_lib => .{
		941	.crti = "crti.o",
		942	.crtn = "crtn.o",
		943	},
		944	.dynamic_exe, .dynamic_pie => .{
		945	.crt0 = "crt1.o",
		946	.crti = "crti.o",
		947	.crtn = "crtn.o",
		948	},
		949	.static_exe, .static_pie => .{},
		950	},
		951	else => .{},
		952	};
		953	}
		954	};
		955
		956	pub const CrtPaths = struct {
		957	crt0: ?Path = null,
		958	crti: ?Path = null,
		959	crtbegin: ?Path = null,
		960	crtend: ?Path = null,
		961	crtn: ?Path = null,
		962	};
		963
		964	pub fn resolveCrtPaths(
		965	lci: LibCInstallation,
		966	arena: Allocator,
		967	crt_basenames: CrtBasenames,
		968	target: std.Target,
		969	) error{ OutOfMemory, LibCInstallationMissingCrtDir }!CrtPaths {
		970	const crt_dir_path: Path = .{
		971	.root_dir = std.Build.Cache.Directory.cwd(),
		972	.sub_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir,
		973	};
		974	switch (target.os.tag) {
		975	.dragonfly => {
		976	const gccv: []const u8 = if (target.os.version_range.semver.isAtLeast(.{
		977	.major = 5,
		978	.minor = 4,
		979	.patch = 0,
		980	}) orelse true) "gcc80" else "gcc54";
		981	return .{
		982	.crt0 = if (crt_basenames.crt0) \|basename\| try crt_dir_path.join(arena, basename) else null,
		983	.crti = if (crt_basenames.crti) \|basename\| try crt_dir_path.join(arena, basename) else null,
		984	.crtbegin = if (crt_basenames.crtbegin) \|basename\| .{
		985	.root_dir = crt_dir_path.root_dir,
		986	.sub_path = try fs.path.join(arena, &.{ crt_dir_path.sub_path, gccv, basename }),
		987	} else null,
		988	.crtend = if (crt_basenames.crtend) \|basename\| .{
		989	.root_dir = crt_dir_path.root_dir,
		990	.sub_path = try fs.path.join(arena, &.{ crt_dir_path.sub_path, gccv, basename }),
		991	} else null,
		992	.crtn = if (crt_basenames.crtn) \|basename\| try crt_dir_path.join(arena, basename) else null,
		993	};
		994	},
		995	.haiku => {
		996	const gcc_dir_path: Path = .{
		997	.root_dir = std.Build.Cache.Directory.cwd(),
		998	.sub_path = lci.gcc_dir orelse return error.LibCInstallationMissingCrtDir,
		999	};
		1000	return .{
		1001	.crt0 = if (crt_basenames.crt0) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1002	.crti = if (crt_basenames.crti) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1003	.crtbegin = if (crt_basenames.crtbegin) \|basename\| try gcc_dir_path.join(arena, basename) else null,
		1004	.crtend = if (crt_basenames.crtend) \|basename\| try gcc_dir_path.join(arena, basename) else null,
		1005	.crtn = if (crt_basenames.crtn) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1006	};
		1007	},
		1008	else => {
		1009	return .{
		1010	.crt0 = if (crt_basenames.crt0) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1011	.crti = if (crt_basenames.crti) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1012	.crtbegin = if (crt_basenames.crtbegin) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1013	.crtend = if (crt_basenames.crtend) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1014	.crtn = if (crt_basenames.crtn) \|basename\| try crt_dir_path.join(arena, basename) else null,
		1015	};
		1016	},
		1017	}
		1018	}
		1019
693	const LibCInstallation = @This();	1020	const LibCInstallation = @This();
694	const std = @import("std");	1021	const std = @import("std");
695	const builtin = @import("builtin");	1022	const builtin = @import("builtin");
696	const Target = std.Target;	1023	const Target = std.Target;
697	const fs = std.fs;	1024	const fs = std.fs;
698	const Allocator = std.mem.Allocator;	1025	const Allocator = std.mem.Allocator;
		1026	const Path = std.Build.Cache.Path;
699		1027
700	const is_darwin = builtin.target.isDarwin();	1028	const is_darwin = builtin.target.isDarwin();
701	const is_windows = builtin.target.os.tag == .windows;	1029	const is_windows = builtin.target.os.tag == .windows;

src/Compilation.zig+102-63

...	@@ -217,37 +217,37 @@ thread_pool: *ThreadPool,	...	@@ -217,37 +217,37 @@ thread_pool: *ThreadPool,
217		217
218	/// Populated when we build the libc++ static library. A Job to build this is placed in the queue	218	/// Populated when we build the libc++ static library. A Job to build this is placed in the queue
219	/// and resolved before calling linker.flush().	219	/// and resolved before calling linker.flush().
220	libcxx_static_lib: ?CRTFile = null,	220	libcxx_static_lib: ?CrtFile = null,
221	/// Populated when we build the libc++abi static library. A Job to build this is placed in the queue	221	/// Populated when we build the libc++abi static library. A Job to build this is placed in the queue
222	/// and resolved before calling linker.flush().	222	/// and resolved before calling linker.flush().
223	libcxxabi_static_lib: ?CRTFile = null,	223	libcxxabi_static_lib: ?CrtFile = null,
224	/// Populated when we build the libunwind static library. A Job to build this is placed in the queue	224	/// Populated when we build the libunwind static library. A Job to build this is placed in the queue
225	/// and resolved before calling linker.flush().	225	/// and resolved before calling linker.flush().
226	libunwind_static_lib: ?CRTFile = null,	226	libunwind_static_lib: ?CrtFile = null,
227	/// Populated when we build the TSAN library. A Job to build this is placed in the queue	227	/// Populated when we build the TSAN library. A Job to build this is placed in the queue
228	/// and resolved before calling linker.flush().	228	/// and resolved before calling linker.flush().
229	tsan_lib: ?CRTFile = null,	229	tsan_lib: ?CrtFile = null,
230	/// Populated when we build the libc static library. A Job to build this is placed in the queue	230	/// Populated when we build the libc static library. A Job to build this is placed in the queue
231	/// and resolved before calling linker.flush().	231	/// and resolved before calling linker.flush().
232	libc_static_lib: ?CRTFile = null,	232	libc_static_lib: ?CrtFile = null,
233	/// Populated when we build the libcompiler_rt static library. A Job to build this is indicated	233	/// Populated when we build the libcompiler_rt static library. A Job to build this is indicated
234	/// by setting `job_queued_compiler_rt_lib` and resolved before calling linker.flush().	234	/// by setting `job_queued_compiler_rt_lib` and resolved before calling linker.flush().
235	compiler_rt_lib: ?CRTFile = null,	235	compiler_rt_lib: ?CrtFile = null,
236	/// Populated when we build the compiler_rt_obj object. A Job to build this is indicated	236	/// Populated when we build the compiler_rt_obj object. A Job to build this is indicated
237	/// by setting `job_queued_compiler_rt_obj` and resolved before calling linker.flush().	237	/// by setting `job_queued_compiler_rt_obj` and resolved before calling linker.flush().
238	compiler_rt_obj: ?CRTFile = null,	238	compiler_rt_obj: ?CrtFile = null,
239	/// Populated when we build the libfuzzer static library. A Job to build this	239	/// Populated when we build the libfuzzer static library. A Job to build this
240	/// is indicated by setting `job_queued_fuzzer_lib` and resolved before	240	/// is indicated by setting `job_queued_fuzzer_lib` and resolved before
241	/// calling linker.flush().	241	/// calling linker.flush().
242	fuzzer_lib: ?CRTFile = null,	242	fuzzer_lib: ?CrtFile = null,
243		243
244	glibc_so_files: ?glibc.BuiltSharedObjects = null,	244	glibc_so_files: ?glibc.BuiltSharedObjects = null,
245	wasi_emulated_libs: []const wasi_libc.CRTFile,	245	wasi_emulated_libs: []const wasi_libc.CrtFile,
246		246
247	/// For example `Scrt1.o` and `libc_nonshared.a`. These are populated after building libc from source,	247	/// For example `Scrt1.o` and `libc_nonshared.a`. These are populated after building libc from source,
248	/// The set of needed CRT (C runtime) files differs depending on the target and compilation settings.	248	/// The set of needed CRT (C runtime) files differs depending on the target and compilation settings.
249	/// The key is the basename, and the value is the absolute path to the completed build artifact.	249	/// The key is the basename, and the value is the absolute path to the completed build artifact.
250	crt_files: std.StringHashMapUnmanaged(CRTFile) = .empty,	250	crt_files: std.StringHashMapUnmanaged(CrtFile) = .empty,
251		251
252	/// How many lines of reference trace should be included per compile error.	252	/// How many lines of reference trace should be included per compile error.
253	/// Null means only show snippet on first error.	253	/// Null means only show snippet on first error.
...	@@ -276,20 +276,20 @@ digest: ?[Cache.bin_digest_len]u8 = null,	...	@@ -276,20 +276,20 @@ digest: ?[Cache.bin_digest_len]u8 = null,
276	pub const default_stack_protector_buffer_size = target_util.default_stack_protector_buffer_size;	276	pub const default_stack_protector_buffer_size = target_util.default_stack_protector_buffer_size;
277	pub const SemaError = Zcu.SemaError;	277	pub const SemaError = Zcu.SemaError;
278		278
279	pub const CRTFile = struct {	279	pub const CrtFile = struct {
280	lock: Cache.Lock,	280	lock: Cache.Lock,
281	full_object_path: []const u8,	281	full_object_path: Path,
282		282
283	pub fn isObject(cf: CRTFile) bool {	283	pub fn isObject(cf: CrtFile) bool {
284	return switch (classifyFileExt(cf.full_object_path)) {	284	return switch (classifyFileExt(cf.full_object_path.sub_path)) {
285	.object => true,	285	.object => true,
286	else => false,	286	else => false,
287	};	287	};
288	}	288	}
289		289
290	pub fn deinit(self: *CRTFile, gpa: Allocator) void {	290	pub fn deinit(self: *CrtFile, gpa: Allocator) void {
291	self.lock.release();	291	self.lock.release();
292	gpa.free(self.full_object_path);	292	gpa.free(self.full_object_path.sub_path);
293	self.* = undefined;	293	self.* = undefined;
294	}	294	}
295	};	295	};
...	@@ -369,13 +369,13 @@ const Job = union(enum) {	...	@@ -369,13 +369,13 @@ const Job = union(enum) {
369	resolve_type_fully: InternPool.Index,	369	resolve_type_fully: InternPool.Index,
370		370
371	/// one of the glibc static objects	371	/// one of the glibc static objects
372	glibc_crt_file: glibc.CRTFile,	372	glibc_crt_file: glibc.CrtFile,
373	/// all of the glibc shared objects	373	/// all of the glibc shared objects
374	glibc_shared_objects,	374	glibc_shared_objects,
375	/// one of the musl static objects	375	/// one of the musl static objects
376	musl_crt_file: musl.CRTFile,	376	musl_crt_file: musl.CrtFile,
377	/// one of the mingw-w64 static objects	377	/// one of the mingw-w64 static objects
378	mingw_crt_file: mingw.CRTFile,	378	mingw_crt_file: mingw.CrtFile,
379	/// libunwind.a, usually needed when linking libc	379	/// libunwind.a, usually needed when linking libc
380	libunwind: void,	380	libunwind: void,
381	libcxx: void,	381	libcxx: void,
...	@@ -385,7 +385,7 @@ const Job = union(enum) {	...	@@ -385,7 +385,7 @@ const Job = union(enum) {
385	/// calls to, for example, memcpy and memset.	385	/// calls to, for example, memcpy and memset.
386	zig_libc: void,	386	zig_libc: void,
387	/// one of WASI libc static objects	387	/// one of WASI libc static objects
388	wasi_libc_crt_file: wasi_libc.CRTFile,	388	wasi_libc_crt_file: wasi_libc.CrtFile,
389		389
390	/// The value is the index into `system_libs`.	390	/// The value is the index into `system_libs`.
391	windows_import_lib: usize,	391	windows_import_lib: usize,
...	@@ -422,8 +422,8 @@ pub const CObject = struct {	...	@@ -422,8 +422,8 @@ pub const CObject = struct {
422	status: union(enum) {	422	status: union(enum) {
423	new,	423	new,
424	success: struct {	424	success: struct {
425	/// The outputted result. Owned by gpa.	425	/// The outputted result. `sub_path` owned by gpa.
426	object_path: []u8,	426	object_path: Path,
427	/// This is a file system lock on the cache hash manifest representing this	427	/// This is a file system lock on the cache hash manifest representing this
428	/// object. It prevents other invocations of the Zig compiler from interfering	428	/// object. It prevents other invocations of the Zig compiler from interfering
429	/// with this object until released.	429	/// with this object until released.
...	@@ -719,7 +719,7 @@ pub const CObject = struct {	...	@@ -719,7 +719,7 @@ pub const CObject = struct {
719	return true;	719	return true;
720	},	720	},
721	.success => \|*success\| {	721	.success => \|*success\| {
722	gpa.free(success.object_path);	722	gpa.free(success.object_path.sub_path);
723	success.lock.release();	723	success.lock.release();
724	self.status = .new;	724	self.status = .new;
725	return false;	725	return false;
...	@@ -1018,7 +1018,7 @@ const CacheUse = union(CacheMode) {	...	@@ -1018,7 +1018,7 @@ const CacheUse = union(CacheMode) {
1018	};	1018	};
1019		1019
1020	pub const LinkObject = struct {	1020	pub const LinkObject = struct {
1021	path: []const u8,	1021	path: Path,
1022	must_link: bool = false,	1022	must_link: bool = false,
1023	// When the library is passed via a positional argument, it will be	1023	// When the library is passed via a positional argument, it will be
1024	// added as a full path. If it's `-l<lib>`, then just the basename.	1024	// added as a full path. If it's `-l<lib>`, then just the basename.
...	@@ -1027,7 +1027,7 @@ pub const LinkObject = struct {	...	@@ -1027,7 +1027,7 @@ pub const LinkObject = struct {
1027	loption: bool = false,	1027	loption: bool = false,
1028		1028
1029	pub fn isObject(lo: LinkObject) bool {	1029	pub fn isObject(lo: LinkObject) bool {
1030	return switch (classifyFileExt(lo.path)) {	1030	return switch (classifyFileExt(lo.path.sub_path)) {
1031	.object => true,	1031	.object => true,
1032	else => false,	1032	else => false,
1033	};	1033	};
...	@@ -1095,7 +1095,7 @@ pub const CreateOptions = struct {	...	@@ -1095,7 +1095,7 @@ pub const CreateOptions = struct {
1095	/// * getpid	1095	/// * getpid
1096	/// * mman	1096	/// * mman
1097	/// * signal	1097	/// * signal
1098	wasi_emulated_libs: []const wasi_libc.CRTFile = &.{},	1098	wasi_emulated_libs: []const wasi_libc.CrtFile = &.{},
1099	/// This means that if the output mode is an executable it will be a	1099	/// This means that if the output mode is an executable it will be a
1100	/// Position Independent Executable. If the output mode is not an	1100	/// Position Independent Executable. If the output mode is not an
1101	/// executable this field is ignored.	1101	/// executable this field is ignored.
...	@@ -2302,7 +2302,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {	...	@@ -2302,7 +2302,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
2302	try pt.processExports();	2302	try pt.processExports();
2303	}	2303	}
2304		2304
2305	if (try comp.totalErrorCount() != 0) {	2305	if (anyErrors(comp)) {
2306	// Skip flushing and keep source files loaded for error reporting.	2306	// Skip flushing and keep source files loaded for error reporting.
2307	comp.link_error_flags = .{};	2307	comp.link_error_flags = .{};
2308	return;	2308	return;
...	@@ -2392,6 +2392,10 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {	...	@@ -2392,6 +2392,10 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
2392	.sub_path = o_sub_path,	2392	.sub_path = o_sub_path,
2393	}, .main, main_progress_node);	2393	}, .main, main_progress_node);
2394		2394
		2395	// Calling `flush` may have produced errors, in which case the
		2396	// cache manifest must not be written.
		2397	if (anyErrors(comp)) return;
		2398
2395	// Failure here only means an unnecessary cache miss.	2399	// Failure here only means an unnecessary cache miss.
2396	man.writeManifest() catch \|err\| {	2400	man.writeManifest() catch \|err\| {
2397	log.warn("failed to write cache manifest: {s}", .{@errorName(err)});	2401	log.warn("failed to write cache manifest: {s}", .{@errorName(err)});
...	@@ -2578,7 +2582,7 @@ fn addNonIncrementalStuffToCacheManifest(	...	@@ -2578,7 +2582,7 @@ fn addNonIncrementalStuffToCacheManifest(
2578	}	2582	}
2579		2583
2580	for (comp.objects) \|obj\| {	2584	for (comp.objects) \|obj\| {
2581	_ = try man.addFile(obj.path, null);	2585	_ = try man.addFilePath(obj.path, null);
2582	man.hash.add(obj.must_link);	2586	man.hash.add(obj.must_link);
2583	man.hash.add(obj.loption);	2587	man.hash.add(obj.loption);
2584	}	2588	}
...	@@ -2703,9 +2707,8 @@ fn emitOthers(comp: *Compilation) void {	...	@@ -2703,9 +2707,8 @@ fn emitOthers(comp: *Compilation) void {
2703	return;	2707	return;
2704	}	2708	}
2705	const obj_path = comp.c_object_table.keys()[0].status.success.object_path;	2709	const obj_path = comp.c_object_table.keys()[0].status.success.object_path;
2706	const cwd = std.fs.cwd();	2710	const ext = std.fs.path.extension(obj_path.sub_path);
2707	const ext = std.fs.path.extension(obj_path);	2711	const dirname = obj_path.sub_path[0 .. obj_path.sub_path.len - ext.len];
2708	const basename = obj_path[0 .. obj_path.len - ext.len];
2709	// This obj path always ends with the object file extension, but if we change the	2712	// This obj path always ends with the object file extension, but if we change the
2710	// extension to .ll, .bc, or .s, then it will be the path to those things.	2713	// extension to .ll, .bc, or .s, then it will be the path to those things.
2711	const outs = [_]struct {	2714	const outs = [_]struct {
...	@@ -2720,13 +2723,13 @@ fn emitOthers(comp: *Compilation) void {	...	@@ -2720,13 +2723,13 @@ fn emitOthers(comp: *Compilation) void {
2720	if (out.emit) \|loc\| {	2723	if (out.emit) \|loc\| {
2721	if (loc.directory) \|directory\| {	2724	if (loc.directory) \|directory\| {
2722	const src_path = std.fmt.allocPrint(comp.gpa, "{s}{s}", .{	2725	const src_path = std.fmt.allocPrint(comp.gpa, "{s}{s}", .{
2723	basename, out.ext,	2726	dirname, out.ext,
2724	}) catch \|err\| {	2727	}) catch \|err\| {
2725	log.err("unable to copy {s}{s}: {s}", .{ basename, out.ext, @errorName(err) });	2728	log.err("unable to copy {s}{s}: {s}", .{ dirname, out.ext, @errorName(err) });
2726	continue;	2729	continue;
2727	};	2730	};
2728	defer comp.gpa.free(src_path);	2731	defer comp.gpa.free(src_path);
2729	cwd.copyFile(src_path, directory.handle, loc.basename, .{}) catch \|err\| {	2732	obj_path.root_dir.handle.copyFile(src_path, directory.handle, loc.basename, .{}) catch \|err\| {
2730	log.err("unable to copy {s}: {s}", .{ src_path, @errorName(err) });	2733	log.err("unable to copy {s}: {s}", .{ src_path, @errorName(err) });
2731	};	2734	};
2732	}	2735	}
...	@@ -3292,6 +3295,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {	...	@@ -3292,6 +3295,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
3292	return bundle.toOwnedBundle(compile_log_text);	3295	return bundle.toOwnedBundle(compile_log_text);
3293	}	3296	}
3294		3297
		3298	fn anyErrors(comp: *Compilation) bool {
		3299	return (totalErrorCount(comp) catch return true) != 0;
		3300	}
		3301
3295	fn totalErrorCount(comp: *Compilation) !u32 {	3302	fn totalErrorCount(comp: *Compilation) !u32 {
3296	var errors = try comp.getAllErrorsAlloc();	3303	var errors = try comp.getAllErrorsAlloc();
3297	defer errors.deinit(comp.gpa);	3304	defer errors.deinit(comp.gpa);
...	@@ -3774,7 +3781,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3774,7 +3781,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3774	const named_frame = tracy.namedFrame("glibc_crt_file");	3781	const named_frame = tracy.namedFrame("glibc_crt_file");
3775	defer named_frame.end();	3782	defer named_frame.end();
3776		3783
3777	glibc.buildCRTFile(comp, crt_file, prog_node) catch \|err\| {	3784	glibc.buildCrtFile(comp, crt_file, prog_node) catch \|err\| {
3778	// TODO Surface more error details.	3785	// TODO Surface more error details.
3779	comp.lockAndSetMiscFailure(.glibc_crt_file, "unable to build glibc CRT file: {s}", .{	3786	comp.lockAndSetMiscFailure(.glibc_crt_file, "unable to build glibc CRT file: {s}", .{
3780	@errorName(err),	3787	@errorName(err),
...	@@ -3798,7 +3805,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3798,7 +3805,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3798	const named_frame = tracy.namedFrame("musl_crt_file");	3805	const named_frame = tracy.namedFrame("musl_crt_file");
3799	defer named_frame.end();	3806	defer named_frame.end();
3800		3807
3801	musl.buildCRTFile(comp, crt_file, prog_node) catch \|err\| {	3808	musl.buildCrtFile(comp, crt_file, prog_node) catch \|err\| {
3802	// TODO Surface more error details.	3809	// TODO Surface more error details.
3803	comp.lockAndSetMiscFailure(	3810	comp.lockAndSetMiscFailure(
3804	.musl_crt_file,	3811	.musl_crt_file,
...	@@ -3811,7 +3818,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3811,7 +3818,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3811	const named_frame = tracy.namedFrame("mingw_crt_file");	3818	const named_frame = tracy.namedFrame("mingw_crt_file");
3812	defer named_frame.end();	3819	defer named_frame.end();
3813		3820
3814	mingw.buildCRTFile(comp, crt_file, prog_node) catch \|err\| {	3821	mingw.buildCrtFile(comp, crt_file, prog_node) catch \|err\| {
3815	// TODO Surface more error details.	3822	// TODO Surface more error details.
3816	comp.lockAndSetMiscFailure(	3823	comp.lockAndSetMiscFailure(
3817	.mingw_crt_file,	3824	.mingw_crt_file,
...	@@ -3894,7 +3901,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3894,7 +3901,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3894	const named_frame = tracy.namedFrame("wasi_libc_crt_file");	3901	const named_frame = tracy.namedFrame("wasi_libc_crt_file");
3895	defer named_frame.end();	3902	defer named_frame.end();
3896		3903
3897	wasi_libc.buildCRTFile(comp, crt_file, prog_node) catch \|err\| {	3904	wasi_libc.buildCrtFile(comp, crt_file, prog_node) catch \|err\| {
3898	// TODO Surface more error details.	3905	// TODO Surface more error details.
3899	comp.lockAndSetMiscFailure(	3906	comp.lockAndSetMiscFailure(
3900	.wasi_libc_crt_file,	3907	.wasi_libc_crt_file,
...	@@ -4602,7 +4609,7 @@ fn buildRt(	...	@@ -4602,7 +4609,7 @@ fn buildRt(
4602	root_source_name: []const u8,	4609	root_source_name: []const u8,
4603	misc_task: MiscTask,	4610	misc_task: MiscTask,
4604	output_mode: std.builtin.OutputMode,	4611	output_mode: std.builtin.OutputMode,
4605	out: *?CRTFile,	4612	out: *?CrtFile,
4606	prog_node: std.Progress.Node,	4613	prog_node: std.Progress.Node,
4607	) void {	4614	) void {
4608	comp.buildOutputFromZig(	4615	comp.buildOutputFromZig(
...	@@ -4703,7 +4710,9 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr	...	@@ -4703,7 +4710,9 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr
4703		4710
4704	log.debug("updating C object: {s}", .{c_object.src.src_path});	4711	log.debug("updating C object: {s}", .{c_object.src.src_path});
4705		4712
4706	if (c_object.clearStatus(comp.gpa)) {	4713	const gpa = comp.gpa;
		4714
		4715	if (c_object.clearStatus(gpa)) {
4707	// There was previous failure.	4716	// There was previous failure.
4708	comp.mutex.lock();	4717	comp.mutex.lock();
4709	defer comp.mutex.unlock();	4718	defer comp.mutex.unlock();
...	@@ -4722,7 +4731,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr	...	@@ -4722,7 +4731,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr
4722		4731
4723	try cache_helpers.hashCSource(&man, c_object.src);	4732	try cache_helpers.hashCSource(&man, c_object.src);
4724		4733
4725	var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);	4734	var arena_allocator = std.heap.ArenaAllocator.init(gpa);
4726	defer arena_allocator.deinit();	4735	defer arena_allocator.deinit();
4727	const arena = arena_allocator.allocator();	4736	const arena = arena_allocator.allocator();
4728		4737
...	@@ -4744,7 +4753,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr	...	@@ -4744,7 +4753,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr
4744	const target = comp.getTarget();	4753	const target = comp.getTarget();
4745	const o_ext = target.ofmt.fileExt(target.cpu.arch);	4754	const o_ext = target.ofmt.fileExt(target.cpu.arch);
4746	const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: {	4755	const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: {
4747	var argv = std.ArrayList([]const u8).init(comp.gpa);	4756	var argv = std.ArrayList([]const u8).init(gpa);
4748	defer argv.deinit();	4757	defer argv.deinit();
4749		4758
4750	// In case we are doing passthrough mode, we need to detect -S and -emit-llvm.	4759	// In case we are doing passthrough mode, we need to detect -S and -emit-llvm.
...	@@ -4908,7 +4917,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr	...	@@ -4908,7 +4917,7 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr
4908		4917
4909	switch (term) {	4918	switch (term) {
4910	.Exited => \|code\| if (code != 0) if (out_diag_path) \|diag_file_path\| {	4919	.Exited => \|code\| if (code != 0) if (out_diag_path) \|diag_file_path\| {
4911	const bundle = CObject.Diag.Bundle.parse(comp.gpa, diag_file_path) catch \|err\| {	4920	const bundle = CObject.Diag.Bundle.parse(gpa, diag_file_path) catch \|err\| {
4912	log.err("{}: failed to parse clang diagnostics: {s}", .{ err, stderr });	4921	log.err("{}: failed to parse clang diagnostics: {s}", .{ err, stderr });
4913	return comp.failCObj(c_object, "clang exited with code {d}", .{code});	4922	return comp.failCObj(c_object, "clang exited with code {d}", .{code});
4914	};	4923	};
...	@@ -4982,9 +4991,10 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr	...	@@ -4982,9 +4991,10 @@ fn updateCObject(comp: Compilation, c_object: CObject, c_obj_prog_node: std.Pr
4982		4991
4983	c_object.status = .{	4992	c_object.status = .{
4984	.success = .{	4993	.success = .{
4985	.object_path = try comp.local_cache_directory.join(comp.gpa, &[_][]const u8{	4994	.object_path = .{
4986	"o", &digest, o_basename,	4995	.root_dir = comp.local_cache_directory,
4987	}),	4996	.sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, o_basename }),
		4997	},
4988	.lock = man.toOwnedLock(),	4998	.lock = man.toOwnedLock(),
4989	},	4999	},
4990	};	5000	};
...	@@ -6092,18 +6102,23 @@ test "classifyFileExt" {	...	@@ -6092,18 +6102,23 @@ test "classifyFileExt" {
6092	try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));	6102	try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));
6093	}	6103	}
6094		6104
6095	pub fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {	6105	pub fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) !Path {
6096	if (comp.wantBuildGLibCFromSource() or	6106	return (try crtFilePath(comp, basename)) orelse {
6097	comp.wantBuildMuslFromSource() or	6107	const lci = comp.libc_installation orelse return error.LibCInstallationNotAvailable;
6098	comp.wantBuildMinGWFromSource() or	6108	const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir;
6099	comp.wantBuildWasiLibcFromSource())	6109	const full_path = try std.fs.path.join(arena, &[_][]const u8{ crt_dir_path, basename });
6100	{	6110	return Path.initCwd(full_path);
6101	return comp.crt_files.get(basename).?.full_object_path;	6111	};
6102	}	6112	}
6103	const lci = comp.libc_installation orelse return error.LibCInstallationNotAvailable;	6113
6104	const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCRTDir;	6114	pub fn crtFileAsString(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {
6105	const full_path = try std.fs.path.join(arena, &[_][]const u8{ crt_dir_path, basename });	6115	const path = try get_libc_crt_file(comp, arena, basename);
6106	return full_path;	6116	return path.toString(arena);
		6117	}
		6118
		6119	pub fn crtFilePath(comp: *Compilation, basename: []const u8) Allocator.Error!?Path {
		6120	const crt_file = comp.crt_files.get(basename) orelse return null;
		6121	return crt_file.full_object_path;
6107	}	6122	}
6108		6123
6109	fn wantBuildLibCFromSource(comp: Compilation) bool {	6124	fn wantBuildLibCFromSource(comp: Compilation) bool {
...	@@ -6314,7 +6329,7 @@ fn buildOutputFromZig(	...	@@ -6314,7 +6329,7 @@ fn buildOutputFromZig(
6314	comp: *Compilation,	6329	comp: *Compilation,
6315	src_basename: []const u8,	6330	src_basename: []const u8,
6316	output_mode: std.builtin.OutputMode,	6331	output_mode: std.builtin.OutputMode,
6317	out: *?CRTFile,	6332	out: *?CrtFile,
6318	misc_task_tag: MiscTask,	6333	misc_task_tag: MiscTask,
6319	prog_node: std.Progress.Node,	6334	prog_node: std.Progress.Node,
6320	) !void {	6335	) !void {
...	@@ -6542,15 +6557,39 @@ pub fn build_crt_file(	...	@@ -6542,15 +6557,39 @@ pub fn build_crt_file(
6542	comp.crt_files.putAssumeCapacityNoClobber(basename, try sub_compilation.toCrtFile());	6557	comp.crt_files.putAssumeCapacityNoClobber(basename, try sub_compilation.toCrtFile());
6543	}	6558	}
6544		6559
6545	pub fn toCrtFile(comp: *Compilation) Allocator.Error!CRTFile {	6560	pub fn toCrtFile(comp: *Compilation) Allocator.Error!CrtFile {
6546	return .{	6561	return .{
6547	.full_object_path = try comp.local_cache_directory.join(comp.gpa, &.{	6562	.full_object_path = .{
6548	comp.cache_use.whole.bin_sub_path.?,	6563	.root_dir = comp.local_cache_directory,
6549	}),	6564	.sub_path = try comp.gpa.dupe(u8, comp.cache_use.whole.bin_sub_path.?),
		6565	},
6550	.lock = comp.cache_use.whole.moveLock(),	6566	.lock = comp.cache_use.whole.moveLock(),
6551	};	6567	};
6552	}	6568	}
6553		6569
		6570	pub fn getCrtPaths(
		6571	comp: *Compilation,
		6572	arena: Allocator,
		6573	) error{ OutOfMemory, LibCInstallationMissingCrtDir }!LibCInstallation.CrtPaths {
		6574	const target = comp.root_mod.resolved_target.result;
		6575	const basenames = LibCInstallation.CrtBasenames.get(.{
		6576	.target = target,
		6577	.link_libc = comp.config.link_libc,
		6578	.output_mode = comp.config.output_mode,
		6579	.link_mode = comp.config.link_mode,
		6580	.pie = comp.config.pie,
		6581	});
		6582	if (comp.libc_installation) \|lci\| return lci.resolveCrtPaths(arena, basenames, target);
		6583
		6584	return .{
		6585	.crt0 = if (basenames.crt0) \|basename\| try comp.crtFilePath(basename) else null,
		6586	.crti = if (basenames.crti) \|basename\| try comp.crtFilePath(basename) else null,
		6587	.crtbegin = if (basenames.crtbegin) \|basename\| try comp.crtFilePath(basename) else null,
		6588	.crtend = if (basenames.crtend) \|basename\| try comp.crtFilePath(basename) else null,
		6589	.crtn = if (basenames.crtn) \|basename\| try comp.crtFilePath(basename) else null,
		6590	};
		6591	}
		6592
6554	pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {	6593	pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
6555	// Avoid deadlocking on building import libs such as kernel32.lib	6594	// Avoid deadlocking on building import libs such as kernel32.lib
6556	// This can happen when the user uses `build-exe foo.obj -lkernel32` and	6595	// This can happen when the user uses `build-exe foo.obj -lkernel32` and

src/glibc.zig+4-3

 @@ -169,14 +169,14 @@ fn useElfInitFini(target: std.Target) bool {
     };
 }
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crti_o,
     crtn_o,
     scrt1_o,
     libc_nonshared_a,
 };
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
 @@ -292,7 +292,8 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progre
                 .owner = undefined,
             };
             var files = [_]Compilation.CSourceFile{ start_o, abi_note_o, init_o };
-            return comp.build_crt_file("Scrt1", .Obj, .@"glibc Scrt1.o", prog_node, &files);
+            const basename = if (comp.config.output_mode == .Exe and !comp.config.pie) "crt1" else "Scrt1";
+            return comp.build_crt_file(basename, .Obj, .@"glibc Scrt1.o", prog_node, &files);
         },
         .libc_nonshared_a => {
             const s = path.sep_str;

src/link.zig+12-15

 @@ -11,7 +11,7 @@ const wasi_libc = @import("wasi_libc.zig");
 const Air = @import("Air.zig");
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
-const Path = Cache.Path;
+const Path = std.Build.Cache.Path;
 const Compilation = @import("Compilation.zig");
 const LibCInstallation = std.zig.LibCInstallation;
 const Liveness = @import("Liveness.zig");
 @@ -34,7 +34,7 @@ pub const SystemLib = struct {
     /// 1. Windows DLLs that zig ships such as advapi32.
     /// 2. extern "foo" fn declarations where we find out about libraries too late
     /// TODO: make this non-optional and resolve those two cases somehow.
-    path: ?[]const u8,
+    path: ?Path,
 };
 pub fn hashAddSystemLibs(
 @@ -46,7 +46,7 @@ pub fn hashAddSystemLibs(
     for (hm.values()) |value| {
         man.hash.add(value.needed);
         man.hash.add(value.weak);
-        if (value.path) |p| _ = try man.addFile(p, null);
+        if (value.path) |p| _ = try man.addFilePath(p, null);
     }
 }
 @@ -551,7 +551,7 @@ pub const File = struct {
         LLDCrashed,
         LLDReportedFailure,
         LLD_LinkingIsTODO_ForSpirV,
-        LibCInstallationMissingCRTDir,
+        LibCInstallationMissingCrtDir,
         LibCInstallationNotAvailable,
         LinkingWithoutZigSourceUnimplemented,
         MalformedArchive,
 @@ -606,18 +606,15 @@ pub const File = struct {
         const comp = base.comp;
         if (comp.clang_preprocessor_mode == .yes or comp.clang_preprocessor_mode == .pch) {
             dev.check(.clang_command);
-            const gpa = comp.gpa;
             const emit = base.emit;
             // TODO: avoid extra link step when it's just 1 object file (the `zig cc -c` case)
             // Until then, we do `lld -r -o output.o input.o` even though the output is the same
             // as the input. For the preprocessing case (`zig cc -E -o foo`) we copy the file
             // to the final location. See also the corresponding TODO in Coff linking.
-            const full_out_path = try emit.root_dir.join(gpa, &[_][]const u8{emit.sub_path});
-            defer gpa.free(full_out_path);
             assert(comp.c_object_table.count() == 1);
             const the_key = comp.c_object_table.keys()[0];
             const cached_pp_file_path = the_key.status.success.object_path;
-            try fs.cwd().copyFile(cached_pp_file_path, fs.cwd(), full_out_path, .{});
+            try cached_pp_file_path.root_dir.handle.copyFile(cached_pp_file_path.sub_path, emit.root_dir.handle, emit.sub_path, .{});
             return;
         }
 @@ -781,7 +778,7 @@ pub const File = struct {
         log.debug("zcu_obj_path={s}", .{if (zcu_obj_path) |s| s else "(null)"});
-        const compiler_rt_path: ?[]const u8 = if (comp.include_compiler_rt)
+        const compiler_rt_path: ?Path = if (comp.include_compiler_rt)
             comp.compiler_rt_obj.?.full_object_path
         else
             null;
 @@ -806,18 +803,18 @@ pub const File = struct {
             base.releaseLock();
             for (objects) |obj| {
-                _ = try man.addFile(obj.path, null);
+                _ = try man.addFilePath(obj.path, null);
                 man.hash.add(obj.must_link);
                 man.hash.add(obj.loption);
             }
             for (comp.c_object_table.keys()) |key| {
-                _ = try man.addFile(key.status.success.object_path, null);
+                _ = try man.addFilePath(key.status.success.object_path, null);
             }
             for (comp.win32_resource_table.keys()) |key| {
                 _ = try man.addFile(key.status.success.res_path, null);
             }
             try man.addOptionalFile(zcu_obj_path);
-            try man.addOptionalFile(compiler_rt_path);
+            try man.addOptionalFilePath(compiler_rt_path);
             // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
             _ = try man.hit();
 @@ -851,10 +848,10 @@ pub const File = struct {
         defer object_files.deinit();
         for (objects) |obj| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, obj.path));
+            object_files.appendAssumeCapacity(try obj.path.toStringZ(arena));
         }
         for (comp.c_object_table.keys()) |key| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.object_path));
+            object_files.appendAssumeCapacity(try key.status.success.object_path.toStringZ(arena));
         }
         for (comp.win32_resource_table.keys()) |key| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.res_path));
 @@ -863,7 +860,7 @@ pub const File = struct {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
         }
         if (compiler_rt_path) |p| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
+            object_files.appendAssumeCapacity(try p.toStringZ(arena));
         }
         if (comp.verbose_link) {

src/link/Coff/lld.zig+25-22

 @@ -7,6 +7,7 @@ const fs = std.fs;
 const log = std.log.scoped(.link);
 const mem = std.mem;
 const Cache = std.Build.Cache;
+const Path = std.Build.Cache.Path;
 const mingw = @import("../../mingw.zig");
 const link = @import("../../link.zig");
 @@ -74,11 +75,11 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         comptime assert(Compilation.link_hash_implementation_version == 14);
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         for (comp.win32_resource_table.keys()) |key| {
             _ = try man.addFile(key.status.success.res_path, null);
 @@ -154,17 +155,19 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
+        try std.fs.Dir.copyFile(
-        // we can skip the file copy.
+            the_object_path.root_dir.handle,
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
+            the_object_path.sub_path,
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
+            directory.handle,
-        }
+            self.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
 @@ -270,14 +273,14 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         try argv.ensureUnusedCapacity(comp.objects.len);
         for (comp.objects) |obj| {
             if (obj.must_link) {
-                argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{s}", .{obj.path}));
+                argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{}", .{@as(Path, obj.path)}));
             } else {
-                argv.appendAssumeCapacity(obj.path);
+                argv.appendAssumeCapacity(try obj.path.toString(arena));
             }
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         for (comp.win32_resource_table.keys()) |key| {
 @@ -401,17 +404,17 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
                         }
                         if (is_dyn_lib) {
-                            try argv.append(try comp.get_libc_crt_file(arena, "dllcrt2.obj"));
+                            try argv.append(try comp.crtFileAsString(arena, "dllcrt2.obj"));
                             if (target.cpu.arch == .x86) {
                                 try argv.append("-ALTERNATENAME:__DllMainCRTStartup@12=_DllMainCRTStartup@12");
                             } else {
                                 try argv.append("-ALTERNATENAME:_DllMainCRTStartup=DllMainCRTStartup");
                             }
                         } else {
-                            try argv.append(try comp.get_libc_crt_file(arena, "crt2.obj"));
+                            try argv.append(try comp.crtFileAsString(arena, "crt2.obj"));
                         }
-                        try argv.append(try comp.get_libc_crt_file(arena, "mingw32.lib"));
+                        try argv.append(try comp.crtFileAsString(arena, "mingw32.lib"));
                     } else {
                         const lib_str = switch (comp.config.link_mode) {
                             .dynamic => "",
 @@ -456,36 +459,36 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         // libc++ dep
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
         }
         // libunwind dep
         if (comp.config.link_libunwind) {
-            try argv.append(comp.libunwind_static_lib.?.full_object_path);
+            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
         }
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
         if (is_exe_or_dyn_lib and !comp.skip_linker_dependencies) {
             if (!comp.config.link_libc) {
                 if (comp.libc_static_lib) |lib| {
-                    try argv.append(lib.full_object_path);
+                    try argv.append(try lib.full_object_path.toString(arena));
                 }
             }
             // MSVC compiler_rt is missing some stuff, so we build it unconditionally but
             // and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
-            if (comp.compiler_rt_obj) |obj| try argv.append(obj.full_object_path);
+            if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
-            if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
+            if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
         }
         try argv.ensureUnusedCapacity(comp.system_libs.count());
         for (comp.system_libs.keys()) |key| {
             const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
             if (comp.crt_files.get(lib_basename)) |crt_file| {
-                argv.appendAssumeCapacity(crt_file.full_object_path);
+                argv.appendAssumeCapacity(try crt_file.full_object_path.toString(arena));
                 continue;
             }
             if (try findLib(arena, lib_basename, self.lib_dirs)) |full_path| {

src/link/Elf.zig+118-325

 @@ -383,9 +383,9 @@ pub fn createEmpty(
             const index: File.Index = @intCast(try self.files.addOne(gpa));
             self.files.set(index, .{ .zig_object = .{
                 .index = index,
-                .path = try std.fmt.allocPrint(arena, "{s}.o", .{fs.path.stem(
+                .basename = try std.fmt.allocPrint(arena, "{s}.o", .{
-                    zcu.main_mod.root_src_path,
+                    fs.path.stem(zcu.main_mod.root_src_path),
-                )}),
+                }),
             } });
             self.zig_object_index = index;
             try self.zigObjectPtr().?.init(self, .{
 @@ -742,13 +742,12 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     const target = self.getTarget();
     const link_mode = comp.config.link_mode;
     const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
-    const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
+    const module_obj_path: ?Path = if (self.base.zcu_object_sub_path) |path| .{
-        const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
+        .root_dir = directory,
-        if (fs.path.dirname(full_out_path)) |dirname| {
+        .sub_path = if (fs.path.dirname(self.base.emit.sub_path)) |dirname|
-            break :blk try fs.path.join(arena, &.{ dirname, path });
+            try fs.path.join(arena, &.{ dirname, path })
-        } else {
+        else
-            break :blk path;
+            path,
-        }
     } else null;
     // --verbose-link
 @@ -758,7 +757,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);
     if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);
-    const csu = try CsuObjects.init(arena, comp);
+    const csu = try comp.getCrtPaths(arena);
     // csu prelude
     if (csu.crt0) |path| try parseObjectReportingFailure(self, path);
 @@ -790,23 +789,22 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
         if (comp.libc_static_lib) |lib| try parseCrtFileReportingFailure(self, lib);
     }
-    var system_libs = std.ArrayList(SystemLib).init(arena);
-    try system_libs.ensureUnusedCapacity(comp.system_libs.values().len);
     for (comp.system_libs.values()) |lib_info| {
-        system_libs.appendAssumeCapacity(.{ .needed = lib_info.needed, .path = lib_info.path.? });
+        try self.parseLibraryReportingFailure(.{
+            .needed = lib_info.needed,
+            .path = lib_info.path.?,
+        }, false);
     }
     // libc++ dep
     if (comp.config.link_libcpp) {
-        try system_libs.ensureUnusedCapacity(2);
+        try self.parseLibraryReportingFailure(.{ .path = comp.libcxxabi_static_lib.?.full_object_path }, false);
-        system_libs.appendAssumeCapacity(.{ .path = comp.libcxxabi_static_lib.?.full_object_path });
+        try self.parseLibraryReportingFailure(.{ .path = comp.libcxx_static_lib.?.full_object_path }, false);
-        system_libs.appendAssumeCapacity(.{ .path = comp.libcxx_static_lib.?.full_object_path });
     }
     // libunwind dep
     if (comp.config.link_libunwind) {
-        try system_libs.append(.{ .path = comp.libunwind_static_lib.?.full_object_path });
+        try self.parseLibraryReportingFailure(.{ .path = comp.libunwind_static_lib.?.full_object_path }, false);
     }
     // libc dep
 @@ -814,7 +812,6 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     if (comp.config.link_libc) {
         if (comp.libc_installation) |lc| {
             const flags = target_util.libcFullLinkFlags(target);
-            try system_libs.ensureUnusedCapacity(flags.len);
             var test_path = std.ArrayList(u8).init(arena);
             var checked_paths = std.ArrayList([]const u8).init(arena);
 @@ -840,39 +837,34 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
                     continue;
                 }
-                const resolved_path = try arena.dupe(u8, test_path.items);
+                const resolved_path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                system_libs.appendAssumeCapacity(.{ .path = resolved_path });
+                try self.parseLibraryReportingFailure(.{ .path = resolved_path }, false);
             }
         } else if (target.isGnuLibC()) {
-            try system_libs.ensureUnusedCapacity(glibc.libs.len + 1);
             for (glibc.libs) |lib| {
                 if (lib.removed_in) |rem_in| {
                     if (target.os.version_range.linux.glibc.order(rem_in) != .lt) continue;
                 }
-                const lib_path = try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
+                const lib_path = Path.initCwd(try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
                     comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
-                });
+                }));
-                system_libs.appendAssumeCapacity(.{ .path = lib_path });
+                try self.parseLibraryReportingFailure(.{ .path = lib_path }, false);
             }
-            system_libs.appendAssumeCapacity(.{
+            try self.parseLibraryReportingFailure(.{
                 .path = try comp.get_libc_crt_file(arena, "libc_nonshared.a"),
-            });
+            }, false);
         } else if (target.isMusl()) {
             const path = try comp.get_libc_crt_file(arena, switch (link_mode) {
                 .static => "libc.a",
                 .dynamic => "libc.so",
             });
-            try system_libs.append(.{ .path = path });
+            try self.parseLibraryReportingFailure(.{ .path = path }, false);
         } else {
             comp.link_error_flags.missing_libc = true;
         }
     }
-    for (system_libs.items) |lib| {
-        try self.parseLibraryReportingFailure(lib, false);
-    }
     // Finally, as the last input objects we add compiler_rt and CSU postlude (if any).
     // compiler-rt. Since compiler_rt exports symbols like `memset`, it needs
 @@ -1066,10 +1058,10 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
     } else null;
-    const csu = try CsuObjects.init(arena, comp);
+    const csu = try comp.getCrtPaths(arena);
     const compiler_rt_path: ?[]const u8 = blk: {
-        if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
+        if (comp.compiler_rt_lib) |x| break :blk try x.full_object_path.toString(arena);
-        if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
+        if (comp.compiler_rt_obj) |x| break :blk try x.full_object_path.toString(arena);
         break :blk null;
     };
 @@ -1092,11 +1084,11 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
     if (self.base.isRelocatable()) {
         for (comp.objects) |obj| {
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
 @@ -1178,9 +1170,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         // csu prelude
-        if (csu.crt0) |v| try argv.append(v);
+        if (csu.crt0) |path| try argv.append(try path.toString(arena));
-        if (csu.crti) |v| try argv.append(v);
+        if (csu.crti) |path| try argv.append(try path.toString(arena));
-        if (csu.crtbegin) |v| try argv.append(v);
+        if (csu.crtbegin) |path| try argv.append(try path.toString(arena));
         for (self.lib_dirs) |lib_dir| {
             try argv.append("-L");
 @@ -1205,10 +1197,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
             }
             if (obj.loption) {
-                assert(obj.path[0] == ':');
                 try argv.append("-l");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
 @@ -1216,7 +1207,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
 @@ -1224,17 +1215,17 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         if (comp.config.any_sanitize_thread) {
-            try argv.append(comp.tsan_lib.?.full_object_path);
+            try argv.append(try comp.tsan_lib.?.full_object_path.toString(arena));
         }
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
         // libc
         if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
             if (comp.libc_static_lib) |lib| {
-                try argv.append(lib.full_object_path);
+                try argv.append(try lib.full_object_path.toString(arena));
             }
         }
 @@ -1258,7 +1249,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
                     as_needed = true;
                 },
             }
-            argv.appendAssumeCapacity(lib_info.path.?);
+            argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
         }
         if (!as_needed) {
 @@ -1268,13 +1259,13 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         // libc++ dep
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
         }
         // libunwind dep
         if (comp.config.link_libunwind) {
-            try argv.append(comp.libunwind_static_lib.?.full_object_path);
+            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
         }
         // libc dep
 @@ -1295,9 +1286,9 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
                     });
                     try argv.append(lib_path);
                 }
-                try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
+                try argv.append(try comp.crtFileAsString(arena, "libc_nonshared.a"));
             } else if (target.isMusl()) {
-                try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
+                try argv.append(try comp.crtFileAsString(arena, switch (link_mode) {
                     .static => "libc.a",
                     .dynamic => "libc.so",
                 }));
 @@ -1310,8 +1301,8 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
         }
         // crt postlude
-        if (csu.crtend) |v| try argv.append(v);
+        if (csu.crtend) |path| try argv.append(try path.toString(arena));
-        if (csu.crtn) |v| try argv.append(v);
+        if (csu.crtn) |path| try argv.append(try path.toString(arena));
     }
     Compilation.dump_argv(argv.items);
 @@ -1331,7 +1322,7 @@ pub const ParseError = error{
     UnknownFileType,
 } || LdScript.Error || fs.Dir.AccessError || fs.File.SeekError || fs.File.OpenError || fs.File.ReadError;
-fn parseCrtFileReportingFailure(self: *Elf, crt_file: Compilation.CRTFile) error{OutOfMemory}!void {
+fn parseCrtFileReportingFailure(self: *Elf, crt_file: Compilation.CrtFile) error{OutOfMemory}!void {
     if (crt_file.isObject()) {
         try parseObjectReportingFailure(self, crt_file.full_object_path);
     } else {
 @@ -1339,7 +1330,7 @@ fn parseCrtFileReportingFailure(self: *Elf, crt_file: Compilation.CRTFile) error
     }
 }
-pub fn parseObjectReportingFailure(self: *Elf, path: []const u8) error{OutOfMemory}!void {
+pub fn parseObjectReportingFailure(self: *Elf, path: Path) error{OutOfMemory}!void {
     self.parseObject(path) catch |err| switch (err) {
         error.LinkFailure => return, // already reported
         error.OutOfMemory => return error.OutOfMemory,
 @@ -1367,17 +1358,20 @@ fn parseLibrary(self: *Elf, lib: SystemLib, must_link: bool) ParseError!void {
     }
 }
-fn parseObject(self: *Elf, path: []const u8) ParseError!void {
+fn parseObject(self: *Elf, path: Path) ParseError!void {
     const tracy = trace(@src());
     defer tracy.end();
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(handle);
-    const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
+    const index: File.Index = @intCast(try self.files.addOne(gpa));
     self.files.set(index, .{ .object = .{
-        .path = try gpa.dupe(u8, path),
+        .path = .{
+            .root_dir = path.root_dir,
+            .sub_path = try gpa.dupe(u8, path.sub_path),
+        },
         .file_handle = fh,
         .index = index,
     } });
 @@ -1387,15 +1381,15 @@ fn parseObject(self: *Elf, path: []const u8) ParseError!void {
     try object.parse(self);
 }
-fn parseArchive(self: *Elf, path: []const u8, must_link: bool) ParseError!void {
+fn parseArchive(self: *Elf, path: Path, must_link: bool) ParseError!void {
     const tracy = trace(@src());
     defer tracy.end();
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(path, .{});
+    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(handle);
-    var archive = Archive{};
+    var archive: Archive = .{};
     defer archive.deinit(gpa);
     try archive.parse(self, path, fh);
 @@ -1403,7 +1397,7 @@ fn parseArchive(self: *Elf, path: []const u8, must_link: bool) ParseError!void {
     defer gpa.free(objects);
     for (objects) |extracted| {
-        const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
+        const index: File.Index = @intCast(try self.files.addOne(gpa));
         self.files.set(index, .{ .object = extracted });
         const object = &self.files.items(.data)[index].object;
         object.index = index;
 @@ -1418,12 +1412,15 @@ fn parseSharedObject(self: *Elf, lib: SystemLib) ParseError!void {
     defer tracy.end();
     const gpa = self.base.comp.gpa;
-    const handle = try fs.cwd().openFile(lib.path, .{});
+    const handle = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
     defer handle.close();
     const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
     self.files.set(index, .{ .shared_object = .{
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .alive = lib.needed,
 @@ -1439,12 +1436,12 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
     defer tracy.end();
     const gpa = self.base.comp.gpa;
-    const in_file = try fs.cwd().openFile(lib.path, .{});
+    const in_file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
     defer in_file.close();
     const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
     defer gpa.free(data);
-    var script = LdScript{ .path = lib.path };
+    var script: LdScript = .{ .path = lib.path };
     defer script.deinit(gpa);
     try script.parse(data, self);
 @@ -1455,12 +1452,12 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
     var test_path = std.ArrayList(u8).init(arena);
     var checked_paths = std.ArrayList([]const u8).init(arena);
-    for (script.args.items) |scr_obj| {
+    for (script.args.items) |script_arg| {
         checked_paths.clearRetainingCapacity();
         success: {
-            if (mem.startsWith(u8, scr_obj.path, "-l")) {
+            if (mem.startsWith(u8, script_arg.path, "-l")) {
-                const lib_name = scr_obj.path["-l".len..];
+                const lib_name = script_arg.path["-l".len..];
                 // TODO I think technically we should re-use the mechanism used by the frontend here.
                 // Maybe we should hoist search-strategy all the way here?
 @@ -1474,33 +1471,30 @@ fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
                 }
             } else {
                 var buffer: [fs.max_path_bytes]u8 = undefined;
-                if (fs.realpath(scr_obj.path, &buffer)) |path| {
+                if (fs.realpath(script_arg.path, &buffer)) |path| {
                     test_path.clearRetainingCapacity();
                     try test_path.writer().writeAll(path);
                     break :success;
                 } else |_| {}
-                try checked_paths.append(try arena.dupe(u8, scr_obj.path));
+                try checked_paths.append(try arena.dupe(u8, script_arg.path));
                 for (self.lib_dirs) |lib_dir| {
-                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, scr_obj.path, null))
+                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, script_arg.path, null))
                         break :success;
                 }
             }
             try self.reportMissingLibraryError(
                 checked_paths.items,
-                "missing library dependency: GNU ld script '{s}' requires '{s}', but file not found",
+                "missing library dependency: GNU ld script '{}' requires '{s}', but file not found",
-                .{
+                .{ @as(Path, lib.path), script_arg.path },
-                    lib.path,
-                    scr_obj.path,
-                },
             );
             continue;
         }
-        const full_path = test_path.items;
+        const full_path = Path.initCwd(test_path.items);
         self.parseLibrary(.{
-            .needed = scr_obj.needed,
+            .needed = script_arg.needed,
             .path = full_path,
         }, false) catch |err| switch (err) {
             error.LinkFailure => continue, // already reported
 @@ -1841,7 +1835,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     const have_dynamic_linker = comp.config.link_libc and
         link_mode == .dynamic and is_exe_or_dyn_lib;
     const target = self.getTarget();
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
         break :blk null;
 @@ -1875,17 +1869,17 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         man.hash.add(self.allow_undefined_version);
         man.hash.addOptional(self.enable_new_dtags);
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
             man.hash.add(obj.loption);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         try man.addOptionalFile(module_obj_path);
-        try man.addOptionalFile(compiler_rt_path);
+        try man.addOptionalFilePath(compiler_rt_path);
-        try man.addOptionalFile(if (comp.tsan_lib) |l| l.full_object_path else null);
+        try man.addOptionalFilePath(if (comp.tsan_lib) |l| l.full_object_path else null);
-        try man.addOptionalFile(if (comp.fuzzer_lib) |l| l.full_object_path else null);
+        try man.addOptionalFilePath(if (comp.fuzzer_lib) |l| l.full_object_path else null);
         // We can skip hashing libc and libc++ components that we are in charge of building from Zig
         // installation sources because they are always a product of the compiler version + target information.
 @@ -1982,17 +1976,19 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
+        try std.fs.Dir.copyFile(
-        // we can skip the file copy.
+            the_object_path.root_dir.handle,
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
+            the_object_path.sub_path,
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
+            directory.handle,
-        }
+            self.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
 @@ -2177,10 +2173,10 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         try argv.append(full_out_path);
         // csu prelude
-        const csu = try CsuObjects.init(arena, comp);
+        const csu = try comp.getCrtPaths(arena);
-        if (csu.crt0) |v| try argv.append(v);
+        if (csu.crt0) |p| try argv.append(try p.toString(arena));
-        if (csu.crti) |v| try argv.append(v);
+        if (csu.crti) |p| try argv.append(try p.toString(arena));
-        if (csu.crtbegin) |v| try argv.append(v);
+        if (csu.crtbegin) |p| try argv.append(try p.toString(arena));
         for (self.rpath_table.keys()) |rpath| {
             try argv.appendSlice(&.{ "-rpath", rpath });
 @@ -2244,10 +2240,10 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             }
             if (obj.loption) {
-                assert(obj.path[0] == ':');
+                assert(obj.path.sub_path[0] == ':');
                 try argv.append("-l");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
 @@ -2255,7 +2251,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
 @@ -2264,12 +2260,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         if (comp.tsan_lib) |lib| {
             assert(comp.config.any_sanitize_thread);
-            try argv.append(lib.full_object_path);
+            try argv.append(try lib.full_object_path.toString(arena));
         }
         if (comp.fuzzer_lib) |lib| {
             assert(comp.config.any_fuzz);
-            try argv.append(lib.full_object_path);
+            try argv.append(try lib.full_object_path.toString(arena));
         }
         // libc
 @@ -2278,7 +2274,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             !comp.config.link_libc)
         {
             if (comp.libc_static_lib) |lib| {
-                try argv.append(lib.full_object_path);
+                try argv.append(try lib.full_object_path.toString(arena));
             }
         }
 @@ -2311,7 +2307,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                 // libraries and not static libraries (the check for that needs to be earlier),
                 // but they could be full paths to .so files, in which case we
                 // want to avoid prepending "-l".
-                argv.appendAssumeCapacity(lib_info.path.?);
+                argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
             }
             if (!as_needed) {
 @@ -2321,13 +2317,13 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             // libc++ dep
             if (comp.config.link_libcpp) {
-                try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+                try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-                try argv.append(comp.libcxx_static_lib.?.full_object_path);
+                try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
             }
             // libunwind dep
             if (comp.config.link_libunwind) {
-                try argv.append(comp.libunwind_static_lib.?.full_object_path);
+                try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
             }
             // libc dep
 @@ -2349,9 +2345,9 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                         });
                         try argv.append(lib_path);
                     }
-                    try argv.append(try comp.get_libc_crt_file(arena, "libc_nonshared.a"));
+                    try argv.append(try comp.crtFileAsString(arena, "libc_nonshared.a"));
                 } else if (target.isMusl()) {
-                    try argv.append(try comp.get_libc_crt_file(arena, switch (link_mode) {
+                    try argv.append(try comp.crtFileAsString(arena, switch (link_mode) {
                         .static => "libc.a",
                         .dynamic => "libc.so",
                     }));
 @@ -2365,12 +2361,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         // to be after the shared libraries, so they are picked up from the shared
         // libraries, not libcompiler_rt.
         if (compiler_rt_path) |p| {
-            try argv.append(p);
+            try argv.append(try p.toString(arena));
         }
         // crt postlude
-        if (csu.crtend) |v| try argv.append(v);
+        if (csu.crtend) |p| try argv.append(try p.toString(arena));
-        if (csu.crtn) |v| try argv.append(v);
+        if (csu.crtn) |p| try argv.append(try p.toString(arena));
         if (self.base.allow_shlib_undefined) {
             try argv.append("--allow-shlib-undefined");
 @@ -3183,8 +3179,9 @@ fn sortInitFini(self: *Elf) !void {
             const object = atom_ptr.file(self).?.object;
             const priority = blk: {
                 if (is_ctor_dtor) {
-                    if (mem.indexOf(u8, object.path, "crtbegin") != null) break :blk std.math.minInt(i32);
+                    const basename = object.path.basename();
-                    if (mem.indexOf(u8, object.path, "crtend") != null) break :blk std.math.maxInt(i32);
+                    if (mem.eql(u8, basename, "crtbegin.o")) break :blk std.math.minInt(i32);
+                    if (mem.eql(u8, basename, "crtend.o")) break :blk std.math.maxInt(i32);
                 }
                 const default: i32 = if (is_ctor_dtor) -1 else std.math.maxInt(i32);
                 const name = atom_ptr.name(self);
 @@ -4472,210 +4469,6 @@ pub fn padToIdeal(actual_size: anytype) @TypeOf(actual_size) {
     return actual_size +| (actual_size / ideal_factor);
 }
-// Provide a blueprint of csu (c-runtime startup) objects for supported
-// link modes.
-//
-// This is for cross-mode targets only. For host-mode targets the system
-// compiler can be probed to produce a robust blueprint.
-//
-// Targets requiring a libc for which zig does not bundle a libc are
-// host-mode targets. Unfortunately, host-mode probes are not yet
-// implemented. For now the data is hard-coded here. Such targets are
-// { freebsd, netbsd, openbsd, dragonfly }.
-const CsuObjects = struct {
-    crt0: ?[]const u8 = null,
-    crti: ?[]const u8 = null,
-    crtbegin: ?[]const u8 = null,
-    crtend: ?[]const u8 = null,
-    crtn: ?[]const u8 = null,
-    const InitArgs = struct {};
-    fn init(arena: Allocator, comp: *const Compilation) !CsuObjects {
-        // crt objects are only required for libc.
-        if (!comp.config.link_libc) return .{};
-        var result: CsuObjects = .{};
-        // Flatten crt cases.
-        const mode: enum {
-            dynamic_lib,
-            dynamic_exe,
-            dynamic_pie,
-            static_exe,
-            static_pie,
-        } = switch (comp.config.output_mode) {
-            .Obj => return CsuObjects{},
-            .Lib => switch (comp.config.link_mode) {
-                .dynamic => .dynamic_lib,
-                .static => return CsuObjects{},
-            },
-            .Exe => switch (comp.config.link_mode) {
-                .dynamic => if (comp.config.pie) .dynamic_pie else .dynamic_exe,
-                .static => if (comp.config.pie) .static_pie else .static_exe,
-            },
-        };
-        const target = comp.root_mod.resolved_target.result;
-        if (target.isAndroid()) {
-            switch (mode) {
-                // zig fmt: off
-                .dynamic_lib => result.set( null, null, "crtbegin_so.o",      "crtend_so.o",      null ),
-                .dynamic_exe,
-                .dynamic_pie => result.set( null, null, "crtbegin_dynamic.o", "crtend_android.o", null ),
-                .static_exe,
-                .static_pie  => result.set( null, null, "crtbegin_static.o",  "crtend_android.o", null ),
-                // zig fmt: on
-            }
-        } else {
-            switch (target.os.tag) {
-                .linux => {
-                    switch (mode) {
-                        // zig fmt: off
-                        .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                        .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        .static_exe  => result.set( "crt1.o",  "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                        .static_pie  => result.set( "rcrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                        // zig fmt: on
-                    }
-                    if (comp.libc_installation) |_| {
-                        // hosted-glibc provides crtbegin/end objects in platform/compiler-specific dirs
-                        // and they are not known at comptime. For now null-out crtbegin/end objects;
-                        // there is no feature loss, zig has never linked those objects in before.
-                        result.crtbegin = null;
-                        result.crtend = null;
-                    } else {
-                        // Bundled glibc only has Scrt1.o .
-                        if (result.crt0 != null and target.isGnuLibC()) result.crt0 = "Scrt1.o";
-                    }
-                },
-                .dragonfly => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",   "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt1.o",  "crti.o", "crtbegin.o",   "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "Scrt1.o", "crti.o", "crtbeginS.o",  "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .freebsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt1.o",  "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt1.o",  "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "Scrt1.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .netbsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,     "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "crt0.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "crt0.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "crt0.o", "crti.o", "crtbeginT.o", "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "crt0.o", "crti.o", "crtbeginT.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .openbsd => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,      null, "crtbeginS.o", "crtendS.o", null ),
-                    .dynamic_exe,
-                    .dynamic_pie => result.set( "crt0.o",  null, "crtbegin.o",  "crtend.o",  null ),
-                    .static_exe,
-                    .static_pie  => result.set( "rcrt0.o", null, "crtbegin.o",  "crtend.o",  null ),
-                    // zig fmt: on
-                },
-                .haiku => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,          "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .dynamic_exe => result.set( "start_dyn.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .dynamic_pie => result.set( "start_dyn.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    .static_exe  => result.set( "start_dyn.o", "crti.o", "crtbegin.o",  "crtend.o",  "crtn.o" ),
-                    .static_pie  => result.set( "start_dyn.o", "crti.o", "crtbeginS.o", "crtendS.o", "crtn.o" ),
-                    // zig fmt: on
-                },
-                .solaris, .illumos => switch (mode) {
-                    // zig fmt: off
-                    .dynamic_lib => result.set( null,     "crti.o", null, null, "crtn.o" ),
-                    .dynamic_exe,
-                    .dynamic_pie => result.set( "crt1.o", "crti.o", null, null, "crtn.o" ),
-                    .static_exe,
-                    .static_pie  => result.set( null,     null,     null, null, null     ),
-                    // zig fmt: on
-                },
-                else => {},
-            }
-        }
-        // Convert each object to a full pathname.
-        if (comp.libc_installation) |lci| {
-            const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCRTDir;
-            switch (target.os.tag) {
-                .dragonfly => {
-                    if (result.crt0) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crti) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crtn) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    var gccv: []const u8 = undefined;
-                    if (target.os.version_range.semver.isAtLeast(.{ .major = 5, .minor = 4, .patch = 0 }) orelse true) {
-                        gccv = "gcc80";
-                    } else {
-                        gccv = "gcc54";
-                    }
-                    if (result.crtbegin) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, gccv, obj.* });
-                    if (result.crtend) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, gccv, obj.* });
-                },
-                .haiku => {
-                    const gcc_dir_path = lci.gcc_dir orelse return error.LibCInstallationMissingCRTDir;
-                    if (result.crt0) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crti) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crtn) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                    if (result.crtbegin) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ gcc_dir_path, obj.* });
-                    if (result.crtend) |*obj| obj.* = try fs.path.join(arena, &[_][]const u8{ gcc_dir_path, obj.* });
-                },
-                else => {
-                    inline for (std.meta.fields(@TypeOf(result))) |f| {
-                        if (@field(result, f.name)) |*obj| {
-                            obj.* = try fs.path.join(arena, &[_][]const u8{ crt_dir_path, obj.* });
-                        }
-                    }
-                },
-            }
-        } else {
-            inline for (std.meta.fields(@TypeOf(result))) |f| {
-                if (@field(result, f.name)) |*obj| {
-                    if (comp.crt_files.get(obj.*)) |crtf| {
-                        obj.* = crtf.full_object_path;
-                    } else {
-                        @field(result, f.name) = null;
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    fn set(
-        self: *CsuObjects,
-        crt0: ?[]const u8,
-        crti: ?[]const u8,
-        crtbegin: ?[]const u8,
-        crtend: ?[]const u8,
-        crtn: ?[]const u8,
-    ) void {
-        self.crt0 = crt0;
-        self.crti = crti;
-        self.crtbegin = crtbegin;
-        self.crtend = crtend;
-        self.crtn = crtn;
-    }
-};
 /// If a target compiles other output modes as dynamic libraries,
 /// this function returns true for those too.
 pub fn isEffectivelyDynLib(self: Elf) bool {
 @@ -5089,13 +4882,13 @@ fn reportUnsupportedCpuArch(self: *Elf) error{OutOfMemory}!void {
 pub fn addParseError(
     self: *Elf,
-    path: []const u8,
+    path: Path,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
     var err = try self.base.addErrorWithNotes(1);
     try err.addMsg(format, args);
-    try err.addNote("while parsing {s}", .{path});
+    try err.addNote("while parsing {}", .{path});
 }
 pub fn addFileError(
 @@ -5121,7 +4914,7 @@ pub fn failFile(
 pub fn failParse(
     self: *Elf,
-    path: []const u8,
+    path: Path,
     comptime format: []const u8,
     args: anytype,
 ) error{ OutOfMemory, LinkFailure } {
 @@ -5274,7 +5067,7 @@ fn fmtDumpState(
     _ = options;
     if (self.zigObjectPtr()) |zig_object| {
-        try writer.print("zig_object({d}) : {s}\n", .{ zig_object.index, zig_object.path });
+        try writer.print("zig_object({d}) : {s}\n", .{ zig_object.index, zig_object.basename });
         try writer.print("{}{}", .{
             zig_object.fmtAtoms(self),
             zig_object.fmtSymtab(self),
 @@ -5299,7 +5092,7 @@ fn fmtDumpState(
     for (self.shared_objects.items) |index| {
         const shared_object = self.file(index).?.shared_object;
         try writer.print("shared_object({d}) : ", .{index});
-        try writer.print("{s}", .{shared_object.path});
+        try writer.print("{}", .{shared_object.path});
         try writer.print(" : needed({})", .{shared_object.needed});
         if (!shared_object.alive) try writer.writeAll(" : [*]");
         try writer.writeByte('\n');
 @@ -5482,7 +5275,7 @@ pub const null_shdr = elf.Elf64_Shdr{
 pub const SystemLib = struct {
     needed: bool = false,
-    path: []const u8,
+    path: Path,
 };
 pub const Ref = struct {

src/link/Elf/Archive.zig+13-7

 @@ -1,8 +1,8 @@
 objects: std.ArrayListUnmanaged(Object) = .empty,
 strtab: std.ArrayListUnmanaged(u8) = .empty,
-pub fn isArchive(path: []const u8) !bool {
+pub fn isArchive(path: Path) !bool {
-    const file = try std.fs.cwd().openFile(path, .{});
+    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     defer file.close();
     const reader = file.reader();
     const magic = reader.readBytesNoEof(elf.ARMAG.len) catch return false;
 @@ -15,7 +15,7 @@ pub fn deinit(self: *Archive, allocator: Allocator) void {
     self.strtab.deinit(allocator);
 }
-pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: File.HandleIndex) !void {
+pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.HandleIndex) !void {
     const comp = elf_file.base.comp;
     const gpa = comp.gpa;
     const handle = elf_file.fileHandle(handle_index);
 @@ -59,19 +59,24 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: Fil
         else
             unreachable;
-        const object = Object{
+        const object: Object = .{
             .archive = .{
-                .path = try gpa.dupe(u8, path),
+                .path = .{
+                    .root_dir = path.root_dir,
+                    .sub_path = try gpa.dupe(u8, path.sub_path),
+                },
                 .offset = pos,
                 .size = obj_size,
             },
-            .path = try gpa.dupe(u8, name),
+            .path = Path.initCwd(try gpa.dupe(u8, name)),
             .file_handle = handle_index,
             .index = undefined,
             .alive = false,
         };
-        log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });
+        log.debug("extracting object '{}' from archive '{}'", .{
+            @as(Path, object.path), @as(Path, path),
+        });
         try self.objects.append(gpa, object);
     }
 @@ -292,6 +297,7 @@ const elf = std.elf;
 const fs = std.fs;
 const log = std.log.scoped(.link);
 const mem = std.mem;
+const Path = std.Build.Cache.Path;
 const Allocator = mem.Allocator;
 const Archive = @This();

src/link/Elf/LdScript.zig+16-10

...	@@ -1,6 +1,11 @@	...	@@ -1,6 +1,11 @@
1	path: []const u8,	1	path: Path,
2	cpu_arch: ?std.Target.Cpu.Arch = null,	2	cpu_arch: ?std.Target.Cpu.Arch = null,
3	args: std.ArrayListUnmanaged(Elf.SystemLib) = .empty,	3	args: std.ArrayListUnmanaged(Arg) = .empty,
		4
		5	pub const Arg = struct {
		6	needed: bool = false,
		7	path: []const u8,
		8	};
4		9
5	pub fn deinit(scr: *LdScript, allocator: Allocator) void {	10	pub fn deinit(scr: *LdScript, allocator: Allocator) void {
6	scr.args.deinit(allocator);	11	scr.args.deinit(allocator);
...	@@ -47,7 +52,7 @@ pub fn parse(scr: LdScript, data: []const u8, elf_file: Elf) Error!void {	...	@@ -47,7 +52,7 @@ pub fn parse(scr: LdScript, data: []const u8, elf_file: Elf) Error!void {
47		52
48	var it = TokenIterator{ .tokens = tokens.items };	53	var it = TokenIterator{ .tokens = tokens.items };
49	var parser = Parser{ .source = data, .it = &it };	54	var parser = Parser{ .source = data, .it = &it };
50	var args = std.ArrayList(Elf.SystemLib).init(gpa);	55	var args = std.ArrayList(Arg).init(gpa);
51	scr.doParse(.{	56	scr.doParse(.{
52	.parser = &parser,	57	.parser = &parser,
53	.args = &args,	58	.args = &args,
...	@@ -70,7 +75,7 @@ pub fn parse(scr: LdScript, data: []const u8, elf_file: Elf) Error!void {	...	@@ -70,7 +75,7 @@ pub fn parse(scr: LdScript, data: []const u8, elf_file: Elf) Error!void {
70		75
71	fn doParse(scr: *LdScript, ctx: struct {	76	fn doParse(scr: *LdScript, ctx: struct {
72	parser: *Parser,	77	parser: *Parser,
73	args: *std.ArrayList(Elf.SystemLib),	78	args: *std.ArrayList(Arg),
74	}) !void {	79	}) !void {
75	while (true) {	80	while (true) {
76	ctx.parser.skipAny(&.{ .comment, .new_line });	81	ctx.parser.skipAny(&.{ .comment, .new_line });
...	@@ -142,7 +147,7 @@ const Parser = struct {	...	@@ -142,7 +147,7 @@ const Parser = struct {
142	return error.UnknownCpuArch;	147	return error.UnknownCpuArch;
143	}	148	}
144		149
145	fn group(p: Parser, args: std.ArrayList(Elf.SystemLib)) !void {	150	fn group(p: Parser, args: std.ArrayList(Arg)) !void {
146	if (!p.skip(&.{.lparen})) return error.UnexpectedToken;	151	if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
147		152
148	while (true) {	153	while (true) {
...	@@ -162,7 +167,7 @@ const Parser = struct {	...	@@ -162,7 +167,7 @@ const Parser = struct {
162	_ = try p.require(.rparen);	167	_ = try p.require(.rparen);
163	}	168	}
164		169
165	fn asNeeded(p: Parser, args: std.ArrayList(Elf.SystemLib)) !void {	170	fn asNeeded(p: Parser, args: std.ArrayList(Arg)) !void {
166	if (!p.skip(&.{.lparen})) return error.UnexpectedToken;	171	if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
167		172
168	while (p.maybe(.literal)) \|tok_id\| {	173	while (p.maybe(.literal)) \|tok_id\| {
...	@@ -239,7 +244,7 @@ const Token = struct {	...	@@ -239,7 +244,7 @@ const Token = struct {
239		244
240	const Index = usize;	245	const Index = usize;
241		246
242	inline fn get(tok: Token, source: []const u8) []const u8 {	247	fn get(tok: Token, source: []const u8) []const u8 {
243	return source[tok.start..tok.end];	248	return source[tok.start..tok.end];
244	}	249	}
245	};	250	};
...	@@ -399,11 +404,11 @@ const TokenIterator = struct {	...	@@ -399,11 +404,11 @@ const TokenIterator = struct {
399	return it.tokens[it.pos];	404	return it.tokens[it.pos];
400	}	405	}
401		406
402	inline fn reset(it: *TokenIterator) void {	407	fn reset(it: *TokenIterator) void {
403	it.pos = 0;	408	it.pos = 0;
404	}	409	}
405		410
406	inline fn seekTo(it: *TokenIterator, pos: Token.Index) void {	411	fn seekTo(it: *TokenIterator, pos: Token.Index) void {
407	it.pos = pos;	412	it.pos = pos;
408	}	413	}
409		414
...	@@ -416,7 +421,7 @@ const TokenIterator = struct {	...	@@ -416,7 +421,7 @@ const TokenIterator = struct {
416	}	421	}
417	}	422	}
418		423
419	inline fn get(it: *TokenIterator, pos: Token.Index) Token {	424	fn get(it: *TokenIterator, pos: Token.Index) Token {
420	assert(pos < it.tokens.len);	425	assert(pos < it.tokens.len);
421	return it.tokens[pos];	426	return it.tokens[pos];
422	}	427	}
...	@@ -426,6 +431,7 @@ const LdScript = @This();	...	@@ -426,6 +431,7 @@ const LdScript = @This();
426		431
427	const std = @import("std");	432	const std = @import("std");
428	const assert = std.debug.assert;	433	const assert = std.debug.assert;
		434	const Path = std.Build.Cache.Path;
429		435
430	const Allocator = std.mem.Allocator;	436	const Allocator = std.mem.Allocator;
431	const Elf = @import("../Elf.zig");	437	const Elf = @import("../Elf.zig");

src/link/Elf/Object.zig+14-13

...	@@ -1,5 +1,7 @@	...	@@ -1,5 +1,7 @@
1	archive: ?InArchive = null,	1	archive: ?InArchive = null,
2	path: []const u8,	2	/// Archive files cannot contain subdirectories, so only the basename is needed
		3	/// for output. However, the full path is kept for error reporting.
		4	path: Path,
3	file_handle: File.HandleIndex,	5	file_handle: File.HandleIndex,
4	index: File.Index,	6	index: File.Index,
5		7
...	@@ -36,8 +38,8 @@ output_symtab_ctx: Elf.SymtabCtx = .{},	...	@@ -36,8 +38,8 @@ output_symtab_ctx: Elf.SymtabCtx = .{},
36	output_ar_state: Archive.ArState = .{},	38	output_ar_state: Archive.ArState = .{},
37		39
38	pub fn deinit(self: *Object, allocator: Allocator) void {	40	pub fn deinit(self: *Object, allocator: Allocator) void {
39	if (self.archive) \|*ar\| allocator.free(ar.path);	41	if (self.archive) \|*ar\| allocator.free(ar.path.sub_path);
40	allocator.free(self.path);	42	allocator.free(self.path.sub_path);
41	self.shdrs.deinit(allocator);	43	self.shdrs.deinit(allocator);
42	self.symtab.deinit(allocator);	44	self.symtab.deinit(allocator);
43	self.strtab.deinit(allocator);	45	self.strtab.deinit(allocator);
...	@@ -474,8 +476,7 @@ pub fn scanRelocs(self: Object, elf_file: Elf, undefs: anytype) !void {	...	@@ -474,8 +476,7 @@ pub fn scanRelocs(self: Object, elf_file: Elf, undefs: anytype) !void {
474	if (sym.type(elf_file) != elf.STT_FUNC)	476	if (sym.type(elf_file) != elf.STT_FUNC)
475	// TODO convert into an error	477	// TODO convert into an error
476	log.debug("{s}: {s}: CIE referencing external data reference", .{	478	log.debug("{s}: {s}: CIE referencing external data reference", .{
477	self.fmtPath(),	479	self.fmtPath(), sym.name(elf_file),
478	sym.name(elf_file),
479	});	480	});
480	sym.flags.needs_plt = true;	481	sym.flags.needs_plt = true;
481	}	482	}
...	@@ -996,7 +997,7 @@ pub fn updateArSize(self: Object, elf_file: Elf) !void {	...	@@ -996,7 +997,7 @@ pub fn updateArSize(self: Object, elf_file: Elf) !void {
996	pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {	997	pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {
997	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;	998	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
998	const offset: u64 = if (self.archive) \|ar\| ar.offset else 0;	999	const offset: u64 = if (self.archive) \|ar\| ar.offset else 0;
999	const name = self.path;	1000	const name = std.fs.path.basename(self.path.sub_path);
1000	const hdr = Archive.setArHdr(.{	1001	const hdr = Archive.setArHdr(.{
1001	.name = if (name.len <= Archive.max_member_name_len)	1002	.name = if (name.len <= Archive.max_member_name_len)
1002	.{ .name = name }	1003	.{ .name = name }
...	@@ -1489,15 +1490,14 @@ fn formatPath(	...	@@ -1489,15 +1490,14 @@ fn formatPath(
1489	_ = unused_fmt_string;	1490	_ = unused_fmt_string;
1490	_ = options;	1491	_ = options;
1491	if (object.archive) \|ar\| {	1492	if (object.archive) \|ar\| {
1492	try writer.writeAll(ar.path);	1493	try writer.print("{}({})", .{ ar.path, object.path });
1493	try writer.writeByte('(');	1494	} else {
1494	try writer.writeAll(object.path);	1495	try writer.print("{}", .{object.path});
1495	try writer.writeByte(')');	1496	}
1496	} else try writer.writeAll(object.path);
1497	}	1497	}
1498		1498
1499	const InArchive = struct {	1499	const InArchive = struct {
1500	path: []const u8,	1500	path: Path,
1501	offset: u64,	1501	offset: u64,
1502	size: u32,	1502	size: u32,
1503	};	1503	};
...	@@ -1512,8 +1512,9 @@ const fs = std.fs;	...	@@ -1512,8 +1512,9 @@ const fs = std.fs;
1512	const log = std.log.scoped(.link);	1512	const log = std.log.scoped(.link);
1513	const math = std.math;	1513	const math = std.math;
1514	const mem = std.mem;	1514	const mem = std.mem;
1515		1515	const Path = std.Build.Cache.Path;
1516	const Allocator = mem.Allocator;	1516	const Allocator = mem.Allocator;
		1517
1517	const Archive = @import("Archive.zig");	1518	const Archive = @import("Archive.zig");
1518	const Atom = @import("Atom.zig");	1519	const Atom = @import("Atom.zig");
1519	const AtomList = @import("AtomList.zig");	1520	const AtomList = @import("AtomList.zig");

src/link/Elf/SharedObject.zig+8-7

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	path: []const u8,	1	path: Path,
2	index: File.Index,	2	index: File.Index,
3		3
4	header: ?elf.Elf64_Ehdr = null,	4	header: ?elf.Elf64_Ehdr = null,
...	@@ -22,8 +22,8 @@ alive: bool,	...	@@ -22,8 +22,8 @@ alive: bool,
22		22
23	output_symtab_ctx: Elf.SymtabCtx = .{},	23	output_symtab_ctx: Elf.SymtabCtx = .{},
24		24
25	pub fn isSharedObject(path: []const u8) !bool {	25	pub fn isSharedObject(path: Path) !bool {
26	const file = try std.fs.cwd().openFile(path, .{});	26	const file = try path.root_dir.handle.openFile(path.sub_path, .{});
27	defer file.close();	27	defer file.close();
28	const reader = file.reader();	28	const reader = file.reader();
29	const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;	29	const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
...	@@ -34,7 +34,7 @@ pub fn isSharedObject(path: []const u8) !bool {	...	@@ -34,7 +34,7 @@ pub fn isSharedObject(path: []const u8) !bool {
34	}	34	}
35		35
36	pub fn deinit(self: *SharedObject, allocator: Allocator) void {	36	pub fn deinit(self: *SharedObject, allocator: Allocator) void {
37	allocator.free(self.path);	37	allocator.free(self.path.sub_path);
38	self.shdrs.deinit(allocator);	38	self.shdrs.deinit(allocator);
39	self.symtab.deinit(allocator);	39	self.symtab.deinit(allocator);
40	self.strtab.deinit(allocator);	40	self.strtab.deinit(allocator);
...	@@ -319,7 +319,7 @@ pub fn asFile(self: *SharedObject) File {	...	@@ -319,7 +319,7 @@ pub fn asFile(self: *SharedObject) File {
319		319
320	fn verdefNum(self: *SharedObject) u32 {	320	fn verdefNum(self: *SharedObject) u32 {
321	for (self.dynamic_table.items) \|entry\| switch (entry.d_tag) {	321	for (self.dynamic_table.items) \|entry\| switch (entry.d_tag) {
322	elf.DT_VERDEFNUM => return @as(u32, @intCast(entry.d_val)),	322	elf.DT_VERDEFNUM => return @intCast(entry.d_val),
323	else => {},	323	else => {},
324	};	324	};
325	return 0;	325	return 0;
...	@@ -327,10 +327,10 @@ fn verdefNum(self: *SharedObject) u32 {	...	@@ -327,10 +327,10 @@ fn verdefNum(self: *SharedObject) u32 {
327		327
328	pub fn soname(self: *SharedObject) []const u8 {	328	pub fn soname(self: *SharedObject) []const u8 {
329	for (self.dynamic_table.items) \|entry\| switch (entry.d_tag) {	329	for (self.dynamic_table.items) \|entry\| switch (entry.d_tag) {
330	elf.DT_SONAME => return self.getString(@as(u32, @intCast(entry.d_val))),	330	elf.DT_SONAME => return self.getString(@intCast(entry.d_val)),
331	else => {},	331	else => {},
332	};	332	};
333	return std.fs.path.basename(self.path);	333	return std.fs.path.basename(self.path.sub_path);
334	}	334	}
335		335
336	pub fn initSymbolAliases(self: SharedObject, elf_file: Elf) !void {	336	pub fn initSymbolAliases(self: SharedObject, elf_file: Elf) !void {
...	@@ -508,6 +508,7 @@ const assert = std.debug.assert;	...	@@ -508,6 +508,7 @@ const assert = std.debug.assert;
508	const elf = std.elf;	508	const elf = std.elf;
509	const log = std.log.scoped(.elf);	509	const log = std.log.scoped(.elf);
510	const mem = std.mem;	510	const mem = std.mem;
		511	const Path = std.Build.Cache.Path;
511		512
512	const Allocator = mem.Allocator;	513	const Allocator = mem.Allocator;
513	const Elf = @import("../Elf.zig");	514	const Elf = @import("../Elf.zig");

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

src/link/Elf/file.zig+20-18

...	@@ -23,10 +23,10 @@ pub const File = union(enum) {	...	@@ -23,10 +23,10 @@ pub const File = union(enum) {
23	_ = unused_fmt_string;	23	_ = unused_fmt_string;
24	_ = options;	24	_ = options;
25	switch (file) {	25	switch (file) {
26	.zig_object => \|x\| try writer.print("{s}", .{x.path}),	26	.zig_object => \|zo\| try writer.writeAll(zo.basename),
27	.linker_defined => try writer.writeAll("(linker defined)"),	27	.linker_defined => try writer.writeAll("(linker defined)"),
28	.object => \|x\| try writer.print("{}", .{x.fmtPath()}),	28	.object => \|x\| try writer.print("{}", .{x.fmtPath()}),
29	.shared_object => \|x\| try writer.writeAll(x.path),	29	.shared_object => \|x\| try writer.print("{}", .{@as(Path, x.path)}),
30	}	30	}
31	}	31	}
32		32
...	@@ -240,30 +240,31 @@ pub const File = union(enum) {	...	@@ -240,30 +240,31 @@ pub const File = union(enum) {
240	return switch (file) {	240	return switch (file) {
241	.zig_object => \|x\| x.updateArSymtab(ar_symtab, elf_file),	241	.zig_object => \|x\| x.updateArSymtab(ar_symtab, elf_file),
242	.object => \|x\| x.updateArSymtab(ar_symtab, elf_file),	242	.object => \|x\| x.updateArSymtab(ar_symtab, elf_file),
243	inline else => unreachable,	243	else => unreachable,
244	};	244	};
245	}	245	}
246		246
247	pub fn updateArStrtab(file: File, allocator: Allocator, ar_strtab: *Archive.ArStrtab) !void {	247	pub fn updateArStrtab(file: File, allocator: Allocator, ar_strtab: *Archive.ArStrtab) !void {
248	const path = switch (file) {	248	switch (file) {
249	.zig_object => \|x\| x.path,	249	.zig_object => \|zo\| {
250	.object => \|x\| x.path,	250	const basename = zo.basename;
251	inline else => unreachable,	251	if (basename.len <= Archive.max_member_name_len) return;
252	};	252	zo.output_ar_state.name_off = try ar_strtab.insert(allocator, basename);
253	const state = switch (file) {	253	},
254	.zig_object => \|x\| &x.output_ar_state,	254	.object => \|o\| {
255	.object => \|x\| &x.output_ar_state,	255	const basename = std.fs.path.basename(o.path.sub_path);
256	inline else => unreachable,	256	if (basename.len <= Archive.max_member_name_len) return;
257	};	257	o.output_ar_state.name_off = try ar_strtab.insert(allocator, basename);
258	if (path.len <= Archive.max_member_name_len) return;	258	},
259	state.name_off = try ar_strtab.insert(allocator, path);	259	else => unreachable,
		260	}
260	}	261	}
261		262
262	pub fn updateArSize(file: File, elf_file: *Elf) !void {	263	pub fn updateArSize(file: File, elf_file: *Elf) !void {
263	return switch (file) {	264	return switch (file) {
264	.zig_object => \|x\| x.updateArSize(),	265	.zig_object => \|x\| x.updateArSize(),
265	.object => \|x\| x.updateArSize(elf_file),	266	.object => \|x\| x.updateArSize(elf_file),
266	inline else => unreachable,	267	else => unreachable,
267	};	268	};
268	}	269	}
269		270
...	@@ -271,7 +272,7 @@ pub const File = union(enum) {	...	@@ -271,7 +272,7 @@ pub const File = union(enum) {
271	return switch (file) {	272	return switch (file) {
272	.zig_object => \|x\| x.writeAr(writer),	273	.zig_object => \|x\| x.writeAr(writer),
273	.object => \|x\| x.writeAr(elf_file, writer),	274	.object => \|x\| x.writeAr(elf_file, writer),
274	inline else => unreachable,	275	else => unreachable,
275	};	276	};
276	}	277	}
277		278
...	@@ -292,8 +293,9 @@ pub const File = union(enum) {	...	@@ -292,8 +293,9 @@ pub const File = union(enum) {
292	const std = @import("std");	293	const std = @import("std");
293	const elf = std.elf;	294	const elf = std.elf;
294	const log = std.log.scoped(.link);	295	const log = std.log.scoped(.link);
295		296	const Path = std.Build.Cache.Path;
296	const Allocator = std.mem.Allocator;	297	const Allocator = std.mem.Allocator;
		298
297	const Archive = @import("Archive.zig");	299	const Archive = @import("Archive.zig");
298	const Atom = @import("Atom.zig");	300	const Atom = @import("Atom.zig");
299	const Cie = @import("eh_frame.zig").Cie;	301	const Cie = @import("eh_frame.zig").Cie;

src/link/Elf/relocatable.zig+15-11

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	pub fn flushStaticLib(elf_file: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {	1	pub fn flushStaticLib(elf_file: Elf, comp: Compilation, module_obj_path: ?Path) link.File.FlushError!void {
2	const gpa = comp.gpa;	2	const gpa = comp.gpa;
3		3
4	for (comp.objects) \|obj\| {	4	for (comp.objects) \|obj\| {
5	switch (Compilation.classifyFileExt(obj.path)) {	5	switch (Compilation.classifyFileExt(obj.path.sub_path)) {
6	.object => try parseObjectStaticLibReportingFailure(elf_file, obj.path),	6	.object => try parseObjectStaticLibReportingFailure(elf_file, obj.path),
7	.static_library => try parseArchiveStaticLibReportingFailure(elf_file, obj.path),	7	.static_library => try parseArchiveStaticLibReportingFailure(elf_file, obj.path),
8	else => try elf_file.addParseError(obj.path, "unrecognized file extension", .{}),	8	else => try elf_file.addParseError(obj.path, "unrecognized file extension", .{}),
...	@@ -140,7 +140,7 @@ pub fn flushStaticLib(elf_file: Elf, comp: Compilation, module_obj_path: ?[]co	...	@@ -140,7 +140,7 @@ pub fn flushStaticLib(elf_file: Elf, comp: Compilation, module_obj_path: ?[]co
140	if (elf_file.base.hasErrors()) return error.FlushFailure;	140	if (elf_file.base.hasErrors()) return error.FlushFailure;
141	}	141	}
142		142
143	pub fn flushObject(elf_file: Elf, comp: Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {	143	pub fn flushObject(elf_file: Elf, comp: Compilation, module_obj_path: ?Path) link.File.FlushError!void {
144	for (comp.objects) \|obj\| {	144	for (comp.objects) \|obj\| {
145	if (obj.isObject()) {	145	if (obj.isObject()) {
146	try elf_file.parseObjectReportingFailure(obj.path);	146	try elf_file.parseObjectReportingFailure(obj.path);
...	@@ -198,7 +198,7 @@ pub fn flushObject(elf_file: Elf, comp: Compilation, module_obj_path: ?[]const	...	@@ -198,7 +198,7 @@ pub fn flushObject(elf_file: Elf, comp: Compilation, module_obj_path: ?[]const
198	if (elf_file.base.hasErrors()) return error.FlushFailure;	198	if (elf_file.base.hasErrors()) return error.FlushFailure;
199	}	199	}
200		200
201	fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error{OutOfMemory}!void {	201	fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
202	parseObjectStaticLib(elf_file, path) catch \|err\| switch (err) {	202	parseObjectStaticLib(elf_file, path) catch \|err\| switch (err) {
203	error.LinkFailure => return,	203	error.LinkFailure => return,
204	error.OutOfMemory => return error.OutOfMemory,	204	error.OutOfMemory => return error.OutOfMemory,
...	@@ -206,7 +206,7 @@ fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error{	...	@@ -206,7 +206,7 @@ fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error{
206	};	206	};
207	}	207	}
208		208
209	fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error{OutOfMemory}!void {	209	fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
210	parseArchiveStaticLib(elf_file, path) catch \|err\| switch (err) {	210	parseArchiveStaticLib(elf_file, path) catch \|err\| switch (err) {
211	error.LinkFailure => return,	211	error.LinkFailure => return,
212	error.OutOfMemory => return error.OutOfMemory,	212	error.OutOfMemory => return error.OutOfMemory,
...	@@ -214,14 +214,17 @@ fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error	...	@@ -214,14 +214,17 @@ fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: []const u8) error
214	};	214	};
215	}	215	}
216		216
217	fn parseObjectStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {	217	fn parseObjectStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
218	const gpa = elf_file.base.comp.gpa;	218	const gpa = elf_file.base.comp.gpa;
219	const handle = try std.fs.cwd().openFile(path, .{});	219	const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
220	const fh = try elf_file.addFileHandle(handle);	220	const fh = try elf_file.addFileHandle(handle);
221		221
222	const index = @as(File.Index, @intCast(try elf_file.files.addOne(gpa)));	222	const index: File.Index = @intCast(try elf_file.files.addOne(gpa));
223	elf_file.files.set(index, .{ .object = .{	223	elf_file.files.set(index, .{ .object = .{
224	.path = try gpa.dupe(u8, path),	224	.path = .{
		225	.root_dir = path.root_dir,
		226	.sub_path = try gpa.dupe(u8, path.sub_path),
		227	},
225	.file_handle = fh,	228	.file_handle = fh,
226	.index = index,	229	.index = index,
227	} });	230	} });
...	@@ -231,9 +234,9 @@ fn parseObjectStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {	...	@@ -231,9 +234,9 @@ fn parseObjectStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {
231	try object.parseAr(elf_file);	234	try object.parseAr(elf_file);
232	}	235	}
233		236
234	fn parseArchiveStaticLib(elf_file: *Elf, path: []const u8) Elf.ParseError!void {	237	fn parseArchiveStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
235	const gpa = elf_file.base.comp.gpa;	238	const gpa = elf_file.base.comp.gpa;
236	const handle = try std.fs.cwd().openFile(path, .{});	239	const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
237	const fh = try elf_file.addFileHandle(handle);	240	const fh = try elf_file.addFileHandle(handle);
238		241
239	var archive = Archive{};	242	var archive = Archive{};
...	@@ -531,6 +534,7 @@ const log = std.log.scoped(.link);	...	@@ -531,6 +534,7 @@ const log = std.log.scoped(.link);
531	const math = std.math;	534	const math = std.math;
532	const mem = std.mem;	535	const mem = std.mem;
533	const state_log = std.log.scoped(.link_state);	536	const state_log = std.log.scoped(.link_state);
		537	const Path = std.Build.Cache.Path;
534	const std = @import("std");	538	const std = @import("std");
535		539
536	const Archive = @import("Archive.zig");	540	const Archive = @import("Archive.zig");

src/link/MachO.zig+57-47

 @@ -144,14 +144,14 @@ hot_state: if (is_hot_update_compatible) HotUpdateState else struct {} = .{},
 pub const Framework = struct {
     needed: bool = false,
     weak: bool = false,
-    path: []const u8,
+    path: Path,
 };
 pub fn hashAddFrameworks(man: *Cache.Manifest, hm: []const Framework) !void {
     for (hm) |value| {
         man.hash.add(value.needed);
         man.hash.add(value.weak);
-        _ = try man.addFile(value.path, null);
+        _ = try man.addFilePath(value.path, null);
     }
 }
 @@ -239,9 +239,9 @@ pub fn createEmpty(
             const index: File.Index = @intCast(try self.files.addOne(gpa));
             self.files.set(index, .{ .zig_object = .{
                 .index = index,
-                .path = try std.fmt.allocPrint(arena, "{s}.o", .{fs.path.stem(
+                .basename = try std.fmt.allocPrint(arena, "{s}.o", .{
-                    zcu.main_mod.root_src_path,
+                    fs.path.stem(zcu.main_mod.root_src_path),
-                )}),
+                }),
             } });
             self.zig_object = index;
             const zo = self.getZigObject().?;
 @@ -356,13 +356,12 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     defer sub_prog_node.end();
     const directory = self.base.emit.root_dir;
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
+    const module_obj_path: ?Path = if (self.base.zcu_object_sub_path) |path| .{
-    const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
+        .root_dir = directory,
-        if (fs.path.dirname(full_out_path)) |dirname| {
+        .sub_path = if (fs.path.dirname(self.base.emit.sub_path)) |dirname|
-            break :blk try fs.path.join(arena, &.{ dirname, path });
+            try fs.path.join(arena, &.{ dirname, path })
-        } else {
+        else
-            break :blk path;
+            path,
-        }
     } else null;
     // --verbose-link
 @@ -455,7 +454,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     }
     // Finally, link against compiler_rt.
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
         if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
         break :blk null;
 @@ -567,7 +566,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
         // The most important here is to have the correct vm and filesize of the __LINKEDIT segment
         // where the code signature goes into.
         var codesig = CodeSignature.init(self.getPageSize());
-        codesig.code_directory.ident = fs.path.basename(full_out_path);
+        codesig.code_directory.ident = fs.path.basename(self.base.emit.sub_path);
         if (self.entitlements) |path| try codesig.addEntitlements(gpa, path);
         try self.writeCodeSignaturePadding(&codesig);
         break :blk codesig;
 @@ -625,11 +624,11 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
     if (self.base.isRelocatable()) {
         for (comp.objects) |obj| {
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
 @@ -711,11 +710,11 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             if (obj.must_link) {
                 try argv.append("-force_load");
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
 @@ -723,13 +722,12 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
         if (comp.config.any_sanitize_thread) {
-            const path = comp.tsan_lib.?.full_object_path;
+            const path = try comp.tsan_lib.?.full_object_path.toString(arena);
-            try argv.append(path);
+            try argv.appendSlice(&.{ path, "-rpath", std.fs.path.dirname(path) orelse "." });
-            try argv.appendSlice(&.{ "-rpath", std.fs.path.dirname(path) orelse "." });
         }
         if (comp.config.any_fuzz) {
-            try argv.append(comp.fuzzer_lib.?.full_object_path);
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
         for (self.lib_dirs) |lib_dir| {
 @@ -754,7 +752,7 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
         for (self.frameworks) |framework| {
-            const name = fs.path.stem(framework.path);
+            const name = framework.path.stem();
             const arg = if (framework.needed)
                 try std.fmt.allocPrint(arena, "-needed_framework {s}", .{name})
             else if (framework.weak)
 @@ -765,14 +763,16 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
         }
         if (comp.config.link_libcpp) {
-            try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+            try argv.appendSlice(&.{
-            try argv.append(comp.libcxx_static_lib.?.full_object_path);
+                try comp.libcxxabi_static_lib.?.full_object_path.toString(arena),
+                try comp.libcxx_static_lib.?.full_object_path.toString(arena),
+            });
         }
         try argv.append("-lSystem");
-        if (comp.compiler_rt_lib) |lib| try argv.append(lib.full_object_path);
+        if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
-        if (comp.compiler_rt_obj) |obj| try argv.append(obj.full_object_path);
+        if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
     }
     Compilation.dump_argv(argv.items);
 @@ -807,20 +807,20 @@ pub fn resolveLibSystem(
         return error.MissingLibSystem;
     }
-    const libsystem_path = try arena.dupe(u8, test_path.items);
+    const libsystem_path = Path.initCwd(try arena.dupe(u8, test_path.items));
     try out_libs.append(.{
         .needed = true,
         .path = libsystem_path,
     });
 }
-pub fn classifyInputFile(self: *MachO, path: []const u8, lib: SystemLib, must_link: bool) !void {
+pub fn classifyInputFile(self: *MachO, path: Path, lib: SystemLib, must_link: bool) !void {
     const tracy = trace(@src());
     defer tracy.end();
-    log.debug("classifying input file {s}", .{path});
+    log.debug("classifying input file {}", .{path});
-    const file = try std.fs.cwd().openFile(path, .{});
+    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(file);
     var buffer: [Archive.SARMAG]u8 = undefined;
 @@ -844,7 +844,7 @@ pub fn classifyInputFile(self: *MachO, path: []const u8, lib: SystemLib, must_li
     _ = try self.addTbd(lib, true, fh);
 }
-fn parseFatFile(self: *MachO, file: std.fs.File, path: []const u8) !?fat.Arch {
+fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
     const fat_h = fat.readFatHeader(file) catch return null;
     if (fat_h.magic != macho.FAT_MAGIC and fat_h.magic != macho.FAT_MAGIC_64) return null;
     var fat_archs_buffer: [2]fat.Arch = undefined;
 @@ -873,7 +873,7 @@ pub fn readArMagic(file: std.fs.File, offset: usize, buffer: *[Archive.SARMAG]u8
     return buffer[0..Archive.SARMAG];
 }
-fn addObject(self: *MachO, path: []const u8, handle: File.HandleIndex, offset: u64) !void {
+fn addObject(self: *MachO, path: Path, handle: File.HandleIndex, offset: u64) !void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -886,7 +886,10 @@ fn addObject(self: *MachO, path: []const u8, handle: File.HandleIndex, offset: u
     const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
     self.files.set(index, .{ .object = .{
         .offset = offset,
-        .path = try gpa.dupe(u8, path),
+        .path = .{
+            .root_dir = path.root_dir,
+            .sub_path = try gpa.dupe(u8, path.sub_path),
+        },
         .file_handle = handle,
         .mtime = mtime,
         .index = index,
 @@ -937,7 +940,7 @@ fn addArchive(self: *MachO, lib: SystemLib, must_link: bool, handle: File.Handle
     const gpa = self.base.comp.gpa;
-    var archive = Archive{};
+    var archive: Archive = .{};
     defer archive.deinit(gpa);
     try archive.unpack(self, lib.path, handle, fat_arch);
 @@ -963,7 +966,10 @@ fn addDylib(self: *MachO, lib: SystemLib, explicit: bool, handle: File.HandleInd
         .offset = offset,
         .file_handle = handle,
         .tag = .dylib,
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .weak = lib.weak,
 @@ -986,7 +992,10 @@ fn addTbd(self: *MachO, lib: SystemLib, explicit: bool, handle: File.HandleIndex
         .offset = 0,
         .file_handle = handle,
         .tag = .tbd,
-        .path = try gpa.dupe(u8, lib.path),
+        .path = .{
+            .root_dir = lib.path.root_dir,
+            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
+        },
         .index = index,
         .needed = lib.needed,
         .weak = lib.weak,
 @@ -1175,11 +1184,11 @@ fn parseDependentDylibs(self: *MachO) !void {
                     continue;
                 }
             };
-            const lib = SystemLib{
+            const lib: SystemLib = .{
-                .path = full_path,
+                .path = Path.initCwd(full_path),
                 .weak = is_weak,
             };
-            const file = try std.fs.cwd().openFile(lib.path, .{});
+            const file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
             const fh = try self.addFileHandle(file);
             const fat_arch = try self.parseFatFile(file, lib.path);
             const offset = if (fat_arch) |fa| fa.offset else 0;
 @@ -2865,7 +2874,8 @@ fn writeLoadCommands(self: *MachO) !struct { usize, usize, u64 } {
         ncmds += 1;
     }
     if (comp.config.any_sanitize_thread) {
-        const path = comp.tsan_lib.?.full_object_path;
+        const path = try comp.tsan_lib.?.full_object_path.toString(gpa);
+        defer gpa.free(path);
         const rpath = std.fs.path.dirname(path) orelse ".";
         try load_commands.writeRpathLC(rpath, writer);
         ncmds += 1;
 @@ -3758,13 +3768,13 @@ pub fn eatPrefix(path: []const u8, prefix: []const u8) ?[]const u8 {
 pub fn reportParseError(
     self: *MachO,
-    path: []const u8,
+    path: Path,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
     var err = try self.base.addErrorWithNotes(1);
     try err.addMsg(format, args);
-    try err.addNote("while parsing {s}", .{path});
+    try err.addNote("while parsing {}", .{path});
 }
 pub fn reportParseError2(
 @@ -3913,7 +3923,7 @@ fn fmtDumpState(
     _ = options;
     _ = unused_fmt_string;
     if (self.getZigObject()) |zo| {
-        try writer.print("zig_object({d}) : {s}\n", .{ zo.index, zo.path });
+        try writer.print("zig_object({d}) : {s}\n", .{ zo.index, zo.basename });
         try writer.print("{}{}\n", .{
             zo.fmtAtoms(self),
             zo.fmtSymtab(self),
 @@ -3938,9 +3948,9 @@ fn fmtDumpState(
     }
     for (self.dylibs.items) |index| {
         const dylib = self.getFile(index).?.dylib;
-        try writer.print("dylib({d}) : {s} : needed({}) : weak({})", .{
+        try writer.print("dylib({d}) : {} : needed({}) : weak({})", .{
             index,
-            dylib.path,
+            @as(Path, dylib.path),
             dylib.needed,
             dylib.weak,
         });
 @@ -4442,7 +4452,7 @@ pub const default_pagezero_size: u64 = 0x100000000;
 pub const default_headerpad_size: u32 = 0x1000;
 const SystemLib = struct {
-    path: []const u8,
+    path: Path,
     needed: bool = false,
     weak: bool = false,
     hidden: bool = false,

src/link/MachO/Archive.zig+10-6

 @@ -4,7 +4,7 @@ pub fn deinit(self: *Archive, allocator: Allocator) void {
     self.objects.deinit(allocator);
 }
-pub fn unpack(self: *Archive, macho_file: *MachO, path: []const u8, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {
+pub fn unpack(self: *Archive, macho_file: *MachO, path: Path, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {
     const gpa = macho_file.base.comp.gpa;
     var arena = std.heap.ArenaAllocator.init(gpa);
 @@ -55,20 +55,23 @@ pub fn unpack(self: *Archive, macho_file: *MachO, path: []const u8, handle_index
             mem.eql(u8, name, SYMDEF_SORTED) or
             mem.eql(u8, name, SYMDEF64_SORTED)) continue;
-        const object = Object{
+        const object: Object = .{
             .offset = pos,
             .in_archive = .{
-                .path = try gpa.dupe(u8, path),
+                .path = .{
+                    .root_dir = path.root_dir,
+                    .sub_path = try gpa.dupe(u8, path.sub_path),
+                },
                 .size = hdr_size,
             },
-            .path = try gpa.dupe(u8, name),
+            .path = Path.initCwd(try gpa.dupe(u8, name)),
             .file_handle = handle_index,
             .index = undefined,
             .alive = false,
             .mtime = hdr.date() catch 0,
         };
-        log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });
+        log.debug("extracting object '{}' from archive '{}'", .{ object.path, path });
         try self.objects.append(gpa, object);
     }
 @@ -301,8 +304,9 @@ const log = std.log.scoped(.link);
 const macho = std.macho;
 const mem = std.mem;
 const std = @import("std");
 const Allocator = mem.Allocator;
+const Path = std.Build.Cache.Path;
 const Archive = @This();
 const File = @import("file.zig").File;
 const MachO = @import("../MachO.zig");

src/link/MachO/Dylib.zig+6-5

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	/// Non-zero for fat dylibs	1	/// Non-zero for fat dylibs
2	offset: u64,	2	offset: u64,
3	path: []const u8,	3	path: Path,
4	index: File.Index,	4	index: File.Index,
5	file_handle: File.HandleIndex,	5	file_handle: File.HandleIndex,
6	tag: enum { dylib, tbd },	6	tag: enum { dylib, tbd },
...	@@ -28,7 +28,7 @@ referenced: bool = false,	...	@@ -28,7 +28,7 @@ referenced: bool = false,
28	output_symtab_ctx: MachO.SymtabCtx = .{},	28	output_symtab_ctx: MachO.SymtabCtx = .{},
29		29
30	pub fn deinit(self: *Dylib, allocator: Allocator) void {	30	pub fn deinit(self: *Dylib, allocator: Allocator) void {
31	allocator.free(self.path);	31	allocator.free(self.path.sub_path);
32	self.exports.deinit(allocator);	32	self.exports.deinit(allocator);
33	self.strtab.deinit(allocator);	33	self.strtab.deinit(allocator);
34	if (self.id) \|*id\| id.deinit(allocator);	34	if (self.id) \|*id\| id.deinit(allocator);
...	@@ -61,7 +61,7 @@ fn parseBinary(self: Dylib, macho_file: MachO) !void {	...	@@ -61,7 +61,7 @@ fn parseBinary(self: Dylib, macho_file: MachO) !void {
61	const file = macho_file.getFileHandle(self.file_handle);	61	const file = macho_file.getFileHandle(self.file_handle);
62	const offset = self.offset;	62	const offset = self.offset;
63		63
64	log.debug("parsing dylib from binary: {s}", .{self.path});	64	log.debug("parsing dylib from binary: {}", .{@as(Path, self.path)});
65		65
66	var header_buffer: [@sizeOf(macho.mach_header_64)]u8 = undefined;	66	var header_buffer: [@sizeOf(macho.mach_header_64)]u8 = undefined;
67	{	67	{
...	@@ -267,7 +267,7 @@ fn parseTbd(self: Dylib, macho_file: MachO) !void {	...	@@ -267,7 +267,7 @@ fn parseTbd(self: Dylib, macho_file: MachO) !void {
267		267
268	const gpa = macho_file.base.comp.gpa;	268	const gpa = macho_file.base.comp.gpa;
269		269
270	log.debug("parsing dylib from stub: {s}", .{self.path});	270	log.debug("parsing dylib from stub: {}", .{self.path});
271		271
272	const file = macho_file.getFileHandle(self.file_handle);	272	const file = macho_file.getFileHandle(self.file_handle);
273	var lib_stub = LibStub.loadFromFile(gpa, file) catch \|err\| {	273	var lib_stub = LibStub.loadFromFile(gpa, file) catch \|err\| {
...	@@ -959,8 +959,9 @@ const mem = std.mem;	...	@@ -959,8 +959,9 @@ const mem = std.mem;
959	const tapi = @import("../tapi.zig");	959	const tapi = @import("../tapi.zig");
960	const trace = @import("../../tracy.zig").trace;	960	const trace = @import("../../tracy.zig").trace;
961	const std = @import("std");	961	const std = @import("std");
962
963	const Allocator = mem.Allocator;	962	const Allocator = mem.Allocator;
		963	const Path = std.Build.Cache.Path;
		964
964	const Dylib = @This();	965	const Dylib = @This();
965	const File = @import("file.zig").File;	966	const File = @import("file.zig").File;
966	const LibStub = tapi.LibStub;	967	const LibStub = tapi.LibStub;

src/link/MachO/Object.zig+45-18

 @@ -1,6 +1,8 @@
 /// Non-zero for fat object files or archives
 offset: u64,
-path: []const u8,
+/// Archive files cannot contain subdirectories, so only the basename is needed
+/// for output. However, the full path is kept for error reporting.
+path: Path,
 file_handle: File.HandleIndex,
 mtime: u64,
 index: File.Index,
 @@ -39,8 +41,8 @@ output_symtab_ctx: MachO.SymtabCtx = .{},
 output_ar_state: Archive.ArState = .{},
 pub fn deinit(self: *Object, allocator: Allocator) void {
-    if (self.in_archive) |*ar| allocator.free(ar.path);
+    if (self.in_archive) |*ar| allocator.free(ar.path.sub_path);
-    allocator.free(self.path);
+    allocator.free(self.path.sub_path);
     for (self.sections.items(.relocs), self.sections.items(.subsections)) |*relocs, *sub| {
         relocs.deinit(allocator);
         sub.deinit(allocator);
 @@ -1723,7 +1725,8 @@ pub fn updateArSize(self: *Object, macho_file: *MachO) !void {
 pub fn writeAr(self: Object, ar_format: Archive.Format, macho_file: *MachO, writer: anytype) !void {
     // Header
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
-    try Archive.writeHeader(self.path, size, ar_format, writer);
+    const basename = std.fs.path.basename(self.path.sub_path);
+    try Archive.writeHeader(basename, size, ar_format, writer);
     // Data
     const file = macho_file.getFileHandle(self.file_handle);
     // TODO try using copyRangeAll
 @@ -1774,6 +1777,11 @@ pub fn calcSymtabSize(self: *Object, macho_file: *MachO) void {
         self.calcStabsSize(macho_file);
 }
+fn pathLen(path: Path) usize {
+    // +1 for the path separator
+    return (if (path.root_dir.path) |p| p.len + @intFromBool(path.sub_path.len != 0) else 0) + path.sub_path.len;
+}
 pub fn calcStabsSize(self: *Object, macho_file: *MachO) void {
     if (self.compile_unit) |cu| {
         const comp_dir = cu.getCompDir(self.*);
 @@ -1784,9 +1792,9 @@ pub fn calcStabsSize(self: *Object, macho_file: *MachO) void {
         self.output_symtab_ctx.strsize += @as(u32, @intCast(tu_name.len + 1)); // tu_name
         if (self.in_archive) |ar| {
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(ar.path.len + 1 + self.path.len + 1 + 1));
+            self.output_symtab_ctx.strsize += @intCast(pathLen(ar.path) + 1 + self.path.basename().len + 1 + 1);
         } else {
-            self.output_symtab_ctx.strsize += @as(u32, @intCast(self.path.len + 1));
+            self.output_symtab_ctx.strsize += @intCast(pathLen(self.path) + 1);
         }
         for (self.symbols.items, 0..) |sym, i| {
 @@ -2118,19 +2126,36 @@ pub fn writeStabs(self: Object, stroff: u32, macho_file: *MachO, ctx: anytype) v
         };
         index += 1;
         if (self.in_archive) |ar| {
-            @memcpy(ctx.strtab.items[n_strx..][0..ar.path.len], ar.path);
+            if (ar.path.root_dir.path) |p| {
-            n_strx += @intCast(ar.path.len);
+                @memcpy(ctx.strtab.items[n_strx..][0..p.len], p);
+                n_strx += @intCast(p.len);
+                if (ar.path.sub_path.len != 0) {
+                    ctx.strtab.items[n_strx] = '/';
+                    n_strx += 1;
+                }
+            }
+            @memcpy(ctx.strtab.items[n_strx..][0..ar.path.sub_path.len], ar.path.sub_path);
+            n_strx += @intCast(ar.path.sub_path.len);
             ctx.strtab.items[n_strx] = '(';
             n_strx += 1;
-            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
+            const basename = self.path.basename();
-            n_strx += @intCast(self.path.len);
+            @memcpy(ctx.strtab.items[n_strx..][0..basename.len], basename);
+            n_strx += @intCast(basename.len);
             ctx.strtab.items[n_strx] = ')';
             n_strx += 1;
             ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         } else {
-            @memcpy(ctx.strtab.items[n_strx..][0..self.path.len], self.path);
+            if (self.path.root_dir.path) |p| {
-            n_strx += @intCast(self.path.len);
+                @memcpy(ctx.strtab.items[n_strx..][0..p.len], p);
+                n_strx += @intCast(p.len);
+                if (self.path.sub_path.len != 0) {
+                    ctx.strtab.items[n_strx] = '/';
+                    n_strx += 1;
+                }
+            }
+            @memcpy(ctx.strtab.items[n_strx..][0..self.path.sub_path.len], self.path.sub_path);
+            n_strx += @intCast(self.path.sub_path.len);
             ctx.strtab.items[n_strx] = 0;
             n_strx += 1;
         }
 @@ -2666,11 +2691,12 @@ fn formatPath(
     _ = unused_fmt_string;
     _ = options;
     if (object.in_archive) |ar| {
-        try writer.writeAll(ar.path);
+        try writer.print("{}({s})", .{
-        try writer.writeByte('(');
+            @as(Path, ar.path), object.path.basename(),
-        try writer.writeAll(object.path);
+        });
-        try writer.writeByte(')');
+    } else {
-    } else try writer.writeAll(object.path);
+        try writer.print("{}", .{@as(Path, object.path)});
+    }
 }
 const Section = struct {
 @@ -2777,7 +2803,7 @@ const CompileUnit = struct {
 };
 const InArchive = struct {
-    path: []const u8,
+    path: Path,
     size: u32,
 };
 @@ -3170,6 +3196,7 @@ const math = std.math;
 const mem = std.mem;
 const trace = @import("../../tracy.zig").trace;
 const std = @import("std");
+const Path = std.Build.Cache.Path;
 const Allocator = mem.Allocator;
 const Archive = @import("Archive.zig");

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

...	@@ -1,6 +1,6 @@	...	@@ -1,6 +1,6 @@
1	data: std.ArrayListUnmanaged(u8) = .empty,	1	data: std.ArrayListUnmanaged(u8) = .empty,
2	/// Externally owned memory.	2	/// Externally owned memory.
3	path: []const u8,	3	basename: []const u8,
4	index: File.Index,	4	index: File.Index,
5		5
6	symtab: std.MultiArrayList(Nlist) = .{},	6	symtab: std.MultiArrayList(Nlist) = .{},
...	@@ -317,7 +317,7 @@ pub fn updateArSize(self: *ZigObject) void {	...	@@ -317,7 +317,7 @@ pub fn updateArSize(self: *ZigObject) void {
317	pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !void {	317	pub fn writeAr(self: ZigObject, ar_format: Archive.Format, writer: anytype) !void {
318	// Header	318	// Header
319	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;	319	const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
320	try Archive.writeHeader(self.path, size, ar_format, writer);	320	try Archive.writeHeader(self.basename, size, ar_format, writer);
321	// Data	321	// Data
322	try writer.writeAll(self.data.items);	322	try writer.writeAll(self.data.items);
323	}	323	}

src/link/MachO/file.zig+6-5

 @@ -23,10 +23,10 @@ pub const File = union(enum) {
         _ = unused_fmt_string;
         _ = options;
         switch (file) {
-            .zig_object => |x| try writer.writeAll(x.path),
+            .zig_object => |zo| try writer.writeAll(zo.basename),
             .internal => try writer.writeAll("internal"),
             .object => |x| try writer.print("{}", .{x.fmtPath()}),
-            .dylib => |x| try writer.writeAll(x.path),
+            .dylib => |dl| try writer.print("{}", .{@as(Path, dl.path)}),
         }
     }
 @@ -373,13 +373,14 @@ pub const File = union(enum) {
     pub const HandleIndex = Index;
 };
+const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.link);
 const macho = std.macho;
-const std = @import("std");
-const trace = @import("../../tracy.zig").trace;
 const Allocator = std.mem.Allocator;
+const Path = std.Build.Cache.Path;
+const trace = @import("../../tracy.zig").trace;
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const InternalObject = @import("InternalObject.zig");

src/link/MachO/load_commands.zig+2-1

...	@@ -72,7 +72,8 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32	...	@@ -72,7 +72,8 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32
72	}	72	}
73		73
74	if (comp.config.any_sanitize_thread) {	74	if (comp.config.any_sanitize_thread) {
75	const path = comp.tsan_lib.?.full_object_path;	75	const path = try comp.tsan_lib.?.full_object_path.toString(gpa);
		76	defer gpa.free(path);
76	const rpath = std.fs.path.dirname(path) orelse ".";	77	const rpath = std.fs.path.dirname(path) orelse ".";
77	sizeofcmds += calcInstallNameLen(	78	sizeofcmds += calcInstallNameLen(
78	@sizeOf(macho.rpath_command),	79	@sizeOf(macho.rpath_command),

src/link/MachO/relocatable.zig+23-17

 @@ -1,6 +1,7 @@
-pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
+pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = macho_file.base.comp.gpa;
+    // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
     defer positionals.deinit();
     try positionals.ensureUnusedCapacity(comp.objects.len);
 @@ -19,7 +20,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]c
         // TODO: in the future, when we implement `dsymutil` alternative directly in the Zig
         // compiler, investigate if we can get rid of this `if` prong here.
         const path = positionals.items[0].path;
-        const in_file = try std.fs.cwd().openFile(path, .{});
+        const in_file = try path.root_dir.handle.openFile(path.sub_path, .{});
         const stat = try in_file.stat();
         const amt = try in_file.copyRangeAll(0, macho_file.base.file.?, 0, stat.size);
         if (amt != stat.size) return error.InputOutput; // TODO: report an actual user error
 @@ -72,7 +73,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]c
     try writeHeader(macho_file, ncmds, sizeofcmds);
 }
-pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?[]const u8) link.File.FlushError!void {
+pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = comp.gpa;
     var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
 @@ -173,21 +174,25 @@ pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?
         for (files.items) |index| {
             const file = macho_file.getFile(index).?;
-            const state = switch (file) {
+            switch (file) {
-                .zig_object => |x| &x.output_ar_state,
+                .zig_object => |zo| {
-                .object => |x| &x.output_ar_state,
+                    const state = &zo.output_ar_state;
+                    pos = mem.alignForward(usize, pos, 2);
+                    state.file_off = pos;
+                    pos += @sizeOf(Archive.ar_hdr);
+                    pos += mem.alignForward(usize, zo.basename.len + 1, ptr_width);
+                    pos += math.cast(usize, state.size) orelse return error.Overflow;
+                },
+                .object => |o| {
+                    const state = &o.output_ar_state;
+                    pos = mem.alignForward(usize, pos, 2);
+                    state.file_off = pos;
+                    pos += @sizeOf(Archive.ar_hdr);
+                    pos += mem.alignForward(usize, o.path.basename().len + 1, ptr_width);
+                    pos += math.cast(usize, state.size) orelse return error.Overflow;
+                },
                 else => unreachable,
-            };
+            }
-            const path = switch (file) {
-                .zig_object => |x| x.path,
-                .object => |x| x.path,
-                else => unreachable,
-            };
-            pos = mem.alignForward(usize, pos, 2);
-            state.file_off = pos;
-            pos += @sizeOf(Archive.ar_hdr);
-            pos += mem.alignForward(usize, path.len + 1, ptr_width);
-            pos += math.cast(usize, state.size) orelse return error.Overflow;
         }
         break :blk pos;
 @@ -777,6 +782,7 @@ const mem = std.mem;
 const state_log = std.log.scoped(.link_state);
 const std = @import("std");
 const trace = @import("../../tracy.zig").trace;
+const Path = std.Build.Cache.Path;
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");

src/link/StringTable.zig+1-1

...	@@ -15,7 +15,7 @@ pub fn insert(self: *Self, gpa: Allocator, string: []const u8) !u32 {	...	@@ -15,7 +15,7 @@ pub fn insert(self: *Self, gpa: Allocator, string: []const u8) !u32 {
15	if (gop.found_existing) return gop.key_ptr.*;	15	if (gop.found_existing) return gop.key_ptr.*;
16		16
17	try self.buffer.ensureUnusedCapacity(gpa, string.len + 1);	17	try self.buffer.ensureUnusedCapacity(gpa, string.len + 1);
18	const new_off = @as(u32, @intCast(self.buffer.items.len));	18	const new_off: u32 = @intCast(self.buffer.items.len);
19		19
20	self.buffer.appendSliceAssumeCapacity(string);	20	self.buffer.appendSliceAssumeCapacity(string);
21	self.buffer.appendAssumeCapacity(0);	21	self.buffer.appendAssumeCapacity(0);

src/link/Wasm.zig+31-28

 @@ -2507,6 +2507,7 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     } else null;
     // Positional arguments to the linker such as object files and static archives.
+    // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
     var positionals = std.ArrayList([]const u8).init(arena);
     try positionals.ensureUnusedCapacity(comp.objects.len);
 @@ -2527,23 +2528,23 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
             (output_mode == .Lib and link_mode == .dynamic);
         if (is_exe_or_dyn_lib) {
             for (comp.wasi_emulated_libs) |crt_file| {
-                try positionals.append(try comp.get_libc_crt_file(
+                try positionals.append(try comp.crtFileAsString(
                     arena,
                     wasi_libc.emulatedLibCRFileLibName(crt_file),
                 ));
             }
             if (link_libc) {
-                try positionals.append(try comp.get_libc_crt_file(
+                try positionals.append(try comp.crtFileAsString(
                     arena,
                     wasi_libc.execModelCrtFileFullName(wasi_exec_model),
                 ));
-                try positionals.append(try comp.get_libc_crt_file(arena, "libc.a"));
+                try positionals.append(try comp.crtFileAsString(arena, "libc.a"));
             }
             if (link_libcpp) {
-                try positionals.append(comp.libcxx_static_lib.?.full_object_path);
+                try positionals.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
-                try positionals.append(comp.libcxxabi_static_lib.?.full_object_path);
+                try positionals.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
             }
         }
     }
 @@ -2553,15 +2554,15 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     }
     for (comp.objects) |object| {
-        try positionals.append(object.path);
+        try positionals.append(try object.path.toString(arena));
     }
     for (comp.c_object_table.keys()) |c_object| {
-        try positionals.append(c_object.status.success.object_path);
+        try positionals.append(try c_object.status.success.object_path.toString(arena));
     }
-    if (comp.compiler_rt_lib) |lib| try positionals.append(lib.full_object_path);
+    if (comp.compiler_rt_lib) |lib| try positionals.append(try lib.full_object_path.toString(arena));
-    if (comp.compiler_rt_obj) |obj| try positionals.append(obj.full_object_path);
+    if (comp.compiler_rt_obj) |obj| try positionals.append(try obj.full_object_path.toString(arena));
     try wasm.parseInputFiles(positionals.items);
 @@ -3365,7 +3366,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
     defer sub_prog_node.end();
     const is_obj = comp.config.output_mode == .Obj;
-    const compiler_rt_path: ?[]const u8 = blk: {
+    const compiler_rt_path: ?Path = blk: {
         if (comp.compiler_rt_lib) |lib| break :blk lib.full_object_path;
         if (comp.compiler_rt_obj) |obj| break :blk obj.full_object_path;
         break :blk null;
 @@ -3387,14 +3388,14 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         comptime assert(Compilation.link_hash_implementation_version == 14);
         for (comp.objects) |obj| {
-            _ = try man.addFile(obj.path, null);
+            _ = try man.addFilePath(obj.path, null);
             man.hash.add(obj.must_link);
         }
         for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.object_path, null);
+            _ = try man.addFilePath(key.status.success.object_path, null);
         }
         try man.addOptionalFile(module_obj_path);
-        try man.addOptionalFile(compiler_rt_path);
+        try man.addOptionalFilePath(compiler_rt_path);
         man.hash.addOptionalBytes(wasm.entry_name);
         man.hash.add(wasm.base.stack_size);
         man.hash.add(wasm.base.build_id);
 @@ -3450,17 +3451,19 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
             if (module_obj_path) |p|
-                break :blk p;
+                break :blk Path.initCwd(p);
             // TODO I think this is unreachable. Audit this situation when solving the above TODO
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        // This can happen when using --enable-cache and using the stage1 backend. In this case
+        try std.fs.Dir.copyFile(
-        // we can skip the file copy.
+            the_object_path.root_dir.handle,
-        if (!mem.eql(u8, the_object_path, full_out_path)) {
+            the_object_path.sub_path,
-            try fs.cwd().copyFile(the_object_path, fs.cwd(), full_out_path, .{});
+            directory.handle,
-        }
+            wasm.base.emit.sub_path,
+            .{},
+        );
     } else {
         // Create an LLD command line and invoke it.
         var argv = std.ArrayList([]const u8).init(gpa);
 @@ -3581,23 +3584,23 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 (comp.config.output_mode == .Lib and comp.config.link_mode == .dynamic);
             if (is_exe_or_dyn_lib) {
                 for (comp.wasi_emulated_libs) |crt_file| {
-                    try argv.append(try comp.get_libc_crt_file(
+                    try argv.append(try comp.crtFileAsString(
                         arena,
                         wasi_libc.emulatedLibCRFileLibName(crt_file),
                     ));
                 }
                 if (comp.config.link_libc) {
-                    try argv.append(try comp.get_libc_crt_file(
+                    try argv.append(try comp.crtFileAsString(
                         arena,
                         wasi_libc.execModelCrtFileFullName(comp.config.wasi_exec_model),
                     ));
-                    try argv.append(try comp.get_libc_crt_file(arena, "libc.a"));
+                    try argv.append(try comp.crtFileAsString(arena, "libc.a"));
                 }
                 if (comp.config.link_libcpp) {
-                    try argv.append(comp.libcxx_static_lib.?.full_object_path);
+                    try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
-                    try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+                    try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
                 }
             }
         }
 @@ -3612,7 +3615,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 try argv.append("-no-whole-archive");
                 whole_archive = false;
             }
-            try argv.append(obj.path);
+            try argv.append(try obj.path.toString(arena));
         }
         if (whole_archive) {
             try argv.append("-no-whole-archive");
 @@ -3620,7 +3623,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         }
         for (comp.c_object_table.keys()) |key| {
-            try argv.append(key.status.success.object_path);
+            try argv.append(try key.status.success.object_path.toString(arena));
         }
         if (module_obj_path) |p| {
             try argv.append(p);
 @@ -3630,11 +3633,11 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             !comp.skip_linker_dependencies and
             !comp.config.link_libc)
         {
-            try argv.append(comp.libc_static_lib.?.full_object_path);
+            try argv.append(try comp.libc_static_lib.?.full_object_path.toString(arena));
         }
         if (compiler_rt_path) |p| {
-            try argv.append(p);
+            try argv.append(try p.toString(arena));
         }
         if (comp.verbose_link) {

src/main.zig+24-23

 @@ -13,6 +13,12 @@ const warn = std.log.warn;
 const ThreadPool = std.Thread.Pool;
 const cleanExit = std.process.cleanExit;
 const native_os = builtin.os.tag;
+const Cache = std.Build.Cache;
+const Path = std.Build.Cache.Path;
+const EnvVar = std.zig.EnvVar;
+const LibCInstallation = std.zig.LibCInstallation;
+const AstGen = std.zig.AstGen;
+const Server = std.zig.Server;
 const tracy = @import("tracy.zig");
 const Compilation = @import("Compilation.zig");
 @@ -20,16 +26,11 @@ const link = @import("link.zig");
 const Package = @import("Package.zig");
 const build_options = @import("build_options");
 const introspect = @import("introspect.zig");
-const EnvVar = std.zig.EnvVar;
-const LibCInstallation = std.zig.LibCInstallation;
 const wasi_libc = @import("wasi_libc.zig");
-const Cache = std.Build.Cache;
 const target_util = @import("target.zig");
 const crash_report = @import("crash_report.zig");
 const Zcu = @import("Zcu.zig");
-const AstGen = std.zig.AstGen;
 const mingw = @import("mingw.zig");
-const Server = std.zig.Server;
 const dev = @import("dev.zig");
 pub const std_options = .{
 @@ -1724,14 +1725,14 @@ fn buildOutputType(
                     }
                 } else switch (file_ext orelse Compilation.classifyFileExt(arg)) {
                     .shared_library => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                         create_module.opts.any_dyn_libs = true;
                     },
                     .object, .static_library => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                     },
                     .res => {
-                        try create_module.link_objects.append(arena, .{ .path = arg });
+                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
                         contains_res_file = true;
                     },
                     .manifest => {
 @@ -1845,20 +1846,20 @@ fn buildOutputType(
                         },
                         .shared_library => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                             create_module.opts.any_dyn_libs = true;
                         },
                         .unknown, .object, .static_library => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                         },
                         .res => {
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                             });
                             contains_res_file = true;
 @@ -1894,7 +1895,7 @@ fn buildOutputType(
                             // binary: no extra rpaths and DSO filename exactly
                             // as provided. Hello, Go.
                             try create_module.link_objects.append(arena, .{
-                                .path = it.only_arg,
+                                .path = Path.initCwd(it.only_arg),
                                 .must_link = must_link,
                                 .loption = true,
                             });
 @@ -2532,7 +2533,7 @@ fn buildOutputType(
                     install_name = linker_args_it.nextOrFatal();
                 } else if (mem.eql(u8, arg, "-force_load")) {
                     try create_module.link_objects.append(arena, .{
-                        .path = linker_args_it.nextOrFatal(),
+                        .path = Path.initCwd(linker_args_it.nextOrFatal()),
                         .must_link = true,
                     });
                 } else if (mem.eql(u8, arg, "-hash-style") or
 @@ -2707,7 +2708,7 @@ fn buildOutputType(
                 break :b create_module.c_source_files.items[0].src_path;
             if (create_module.link_objects.items.len >= 1)
-                break :b create_module.link_objects.items[0].path;
+                break :b create_module.link_objects.items[0].path.sub_path;
             if (emit_bin == .yes)
                 break :b emit_bin.yes;
 @@ -2963,7 +2964,7 @@ fn buildOutputType(
                     framework_dir_path,
                     framework_name,
                 )) {
-                    const path = try arena.dupe(u8, test_path.items);
+                    const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                     try resolved_frameworks.append(.{
                         .needed = info.needed,
                         .weak = info.weak,
 @@ -3635,7 +3636,7 @@ const CreateModule = struct {
         name: []const u8,
         lib: Compilation.SystemLib,
     }),
-    wasi_emulated_libs: std.ArrayListUnmanaged(wasi_libc.CRTFile),
+    wasi_emulated_libs: std.ArrayListUnmanaged(wasi_libc.CrtFile),
     c_source_files: std.ArrayListUnmanaged(Compilation.CSourceFile),
     rc_source_files: std.ArrayListUnmanaged(Compilation.RcSourceFile),
 @@ -3808,7 +3809,7 @@ fn createModule(
             }
             if (target.os.tag == .wasi) {
-                if (wasi_libc.getEmulatedLibCRTFile(lib_name)) |crt_file| {
+                if (wasi_libc.getEmulatedLibCrtFile(lib_name)) |crt_file| {
                     try create_module.wasi_emulated_libs.append(arena, crt_file);
                     continue;
                 }
 @@ -3929,7 +3930,7 @@ fn createModule(
                                 target,
                                 info.preferred_mode,
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.preferred_mode) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
 @@ -3963,7 +3964,7 @@ fn createModule(
                                 target,
                                 info.fallbackMode(),
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.fallbackMode()) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
 @@ -3997,7 +3998,7 @@ fn createModule(
                                 target,
                                 info.preferred_mode,
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.preferred_mode) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
 @@ -4021,7 +4022,7 @@ fn createModule(
                                 target,
                                 info.fallbackMode(),
                             )) {
-                                const path = try arena.dupe(u8, test_path.items);
+                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
                                 switch (info.fallbackMode()) {
                                     .static => try create_module.link_objects.append(arena, .{ .path = path }),
                                     .dynamic => try create_module.resolved_system_libs.append(arena, .{
 @@ -6163,7 +6164,7 @@ fn cmdAstCheck(
     }
     file.mod = try Package.Module.createLimited(arena, .{
-        .root = Cache.Path.cwd(),
+        .root = Path.cwd(),
         .root_src_path = file.sub_file_path,
         .fully_qualified_name = "root",
     });
 @@ -6523,7 +6524,7 @@ fn cmdChangelist(
     };
     file.mod = try Package.Module.createLimited(arena, .{
-        .root = Cache.Path.cwd(),
+        .root = Path.cwd(),
         .root_src_path = file.sub_file_path,
         .fully_qualified_name = "root",
     });

src/mingw.zig+23-19

 @@ -11,13 +11,13 @@ const build_options = @import("build_options");
 const Cache = std.Build.Cache;
 const dev = @import("dev.zig");
-pub const CRTFile = enum {
+pub const CrtFile = enum {
     crt2_o,
     dllcrt2_o,
     mingw32_lib,
 };
-pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
 @@ -160,7 +160,9 @@ fn add_cc_args(
 pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     dev.check(.build_import_lib);
-    var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
+    const gpa = comp.gpa;
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 @@ -178,7 +180,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     // Use the global cache directory.
     var cache: Cache = .{
-        .gpa = comp.gpa,
+        .gpa = gpa,
         .manifest_dir = try comp.global_cache_directory.handle.makeOpenPath("h", .{}),
     };
     cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
 @@ -195,17 +197,18 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     _ = try man.addFile(def_file_path, null);
-    const final_lib_basename = try std.fmt.allocPrint(comp.gpa, "{s}.lib", .{lib_name});
+    const final_lib_basename = try std.fmt.allocPrint(gpa, "{s}.lib", .{lib_name});
-    errdefer comp.gpa.free(final_lib_basename);
+    errdefer gpa.free(final_lib_basename);
     if (try man.hit()) {
         const digest = man.final();
-        try comp.crt_files.ensureUnusedCapacity(comp.gpa, 1);
+        try comp.crt_files.ensureUnusedCapacity(gpa, 1);
         comp.crt_files.putAssumeCapacityNoClobber(final_lib_basename, .{
-            .full_object_path = try comp.global_cache_directory.join(comp.gpa, &[_][]const u8{
+            .full_object_path = .{
-                "o", &digest, final_lib_basename,
+                .root_dir = comp.global_cache_directory,
-            }),
+                .sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename }),
+            },
             .lock = man.toOwnedLock(),
         });
         return;
 @@ -230,7 +233,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     };
     const aro = @import("aro");
-    var aro_comp = aro.Compilation.init(comp.gpa, std.fs.cwd());
+    var aro_comp = aro.Compilation.init(gpa, std.fs.cwd());
     defer aro_comp.deinit();
     const include_dir = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "mingw", "def-include" });
 @@ -244,7 +247,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         nosuspend stderr.print("output path: {s}\n", .{def_final_path}) catch break :print;
     }
-    try aro_comp.include_dirs.append(comp.gpa, include_dir);
+    try aro_comp.include_dirs.append(gpa, include_dir);
     const builtin_macros = try aro_comp.generateBuiltinMacros(.include_system_defines);
     const user_macros = try aro_comp.addSourceFromBuffer("<command line>", target_defines);
 @@ -271,17 +274,15 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         try pp.prettyPrintTokens(def_final_file.writer(), .result_only);
     }
-    const lib_final_path = try comp.global_cache_directory.join(comp.gpa, &[_][]const u8{
+    const lib_final_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });
-        "o", &digest, final_lib_basename,
+    errdefer gpa.free(lib_final_path);
-    });
-    errdefer comp.gpa.free(lib_final_path);
     if (!build_options.have_llvm) return error.ZigCompilerNotBuiltWithLLVMExtensions;
     const llvm_bindings = @import("codegen/llvm/bindings.zig");
     const llvm = @import("codegen/llvm.zig");
     const arch_tag = llvm.targetArch(target.cpu.arch);
     const def_final_path_z = try arena.dupeZ(u8, def_final_path);
-    const lib_final_path_z = try arena.dupeZ(u8, lib_final_path);
+    const lib_final_path_z = try comp.global_cache_directory.joinZ(arena, &.{lib_final_path});
     if (llvm_bindings.WriteImportLibrary(def_final_path_z.ptr, arch_tag, lib_final_path_z.ptr, true)) {
         // TODO surface a proper error here
         log.err("unable to turn {s}.def into {s}.lib", .{ lib_name, lib_name });
 @@ -292,8 +293,11 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         log.warn("failed to write cache manifest for DLL import {s}.lib: {s}", .{ lib_name, @errorName(err) });
     };
-    try comp.crt_files.putNoClobber(comp.gpa, final_lib_basename, .{
+    try comp.crt_files.putNoClobber(gpa, final_lib_basename, .{
-        .full_object_path = lib_final_path,
+        .full_object_path = .{
+            .root_dir = comp.global_cache_directory,
+            .sub_path = lib_final_path,
+        },
         .lock = man.toOwnedLock(),
     });
 }

src/musl.zig+2-2

...	@@ -9,7 +9,7 @@ const archName = std.zig.target.muslArchName;	...	@@ -9,7 +9,7 @@ const archName = std.zig.target.muslArchName;
9	const Compilation = @import("Compilation.zig");	9	const Compilation = @import("Compilation.zig");
10	const build_options = @import("build_options");	10	const build_options = @import("build_options");
11		11
12	pub const CRTFile = enum {	12	pub const CrtFile = enum {
13	crti_o,	13	crti_o,
14	crtn_o,	14	crtn_o,
15	crt1_o,	15	crt1_o,
...	@@ -19,7 +19,7 @@ pub const CRTFile = enum {	...	@@ -19,7 +19,7 @@ pub const CRTFile = enum {
19	libc_so,	19	libc_so,
20	};	20	};
21		21
22	pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {	22	pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
23	if (!build_options.have_llvm) {	23	if (!build_options.have_llvm) {
24	return error.ZigCompilerNotBuiltWithLLVMExtensions;	24	return error.ZigCompilerNotBuiltWithLLVMExtensions;
25	}	25	}

src/wasi_libc.zig+7-7

test/link/elf.zig+7-7

...	@@ -952,25 +952,25 @@ fn testEmitStaticLib(b: Build, opts: Options) Step {	...	@@ -952,25 +952,25 @@ fn testEmitStaticLib(b: Build, opts: Options) Step {
952		952
953	const check = lib.checkObject();	953	const check = lib.checkObject();
954	check.checkInArchiveSymtab();	954	check.checkInArchiveSymtab();
955	check.checkExactPath("in object", obj1.getEmittedBin());	955	check.checkExact("in object obj1.o");
956	check.checkExact("foo");	956	check.checkExact("foo");
957	check.checkInArchiveSymtab();	957	check.checkInArchiveSymtab();
958	check.checkExactPath("in object", obj1.getEmittedBin());	958	check.checkExact("in object obj1.o");
959	check.checkExact("bar");	959	check.checkExact("bar");
960	check.checkInArchiveSymtab();	960	check.checkInArchiveSymtab();
961	check.checkExactPath("in object", obj1.getEmittedBin());	961	check.checkExact("in object obj1.o");
962	check.checkExact("fooBar");	962	check.checkExact("fooBar");
963	check.checkInArchiveSymtab();	963	check.checkInArchiveSymtab();
964	check.checkExactPath("in object", obj2.getEmittedBin());	964	check.checkExact("in object obj2.o");
965	check.checkExact("tentative");	965	check.checkExact("tentative");
966	check.checkInArchiveSymtab();	966	check.checkInArchiveSymtab();
967	check.checkExactPath("in object", obj3.getEmittedBin());	967	check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
968	check.checkExact("weakFoo");	968	check.checkExact("weakFoo");
969	check.checkInArchiveSymtab();	969	check.checkInArchiveSymtab();
970	check.checkExactPath("in object", obj3.getEmittedBin());	970	check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
971	check.checkExact("strongBar");	971	check.checkExact("strongBar");
972	check.checkInArchiveSymtab();	972	check.checkInArchiveSymtab();
973	check.checkExactPath("in object", obj3.getEmittedBin());	973	check.checkExact("in object a_very_long_file_name_so_that_it_ends_up_in_strtab.o");
974	check.checkExact("strongBarAlias");	974	check.checkExact("strongBarAlias");
975	test_step.dependOn(&check.step);	975	test_step.dependOn(&check.step);
976		976

test/link/link.zig+1-1

 @@ -74,8 +74,8 @@ fn addCompileStep(
             .target = base.target,
             .optimize = base.optimize,
             .root_source_file = rsf: {
-                const name = b.fmt("{s}.zig", .{overlay.name});
                 const bytes = overlay.zig_source_bytes orelse break :rsf null;
+                const name = b.fmt("{s}.zig", .{overlay.name});
                 break :rsf b.addWriteFiles().add(name, bytes);
             },
             .pic = overlay.pic,

author	Andrew Kelley <andrew@ziglang.org> 2024-10-10 22:30:04-07:00
committer	GitHub <noreply@github.com> 2024-10-10 22:30:04-07:00
log	1340565e22e154db41e90a8d4f0b552176711ba0
tree	0fcb0dde8105082065f46d1f477c97903f69b7e5
parent	92ae5818d26925af7816fabcaec85236133b9e46
parent	2857a3bcb61ad8f119f46acf3a76fd70195f9bd5
signature	Signed by PGP key B5690EEEBB952194

...	@@ -5,7 +5,7 @@	...	@@ -5,7 +5,7 @@
5		5
6	data: std.ArrayListUnmanaged(u8) = .empty,	6	data: std.ArrayListUnmanaged(u8) = .empty,
7	/// Externally owned memory.	7	/// Externally owned memory.
8	path: []const u8,	8	basename: []const u8,
9	index: File.Index,	9	index: File.Index,
10		10
11	symtab: std.MultiArrayList(ElfSym) = .{},	11	symtab: std.MultiArrayList(ElfSym) = .{},
...	@@ -88,7 +88,7 @@ pub fn init(self: ZigObject, elf_file: Elf, options: InitOptions) !void {	...	@@ -88,7 +88,7 @@ pub fn init(self: ZigObject, elf_file: Elf, options: InitOptions) !void {
88	try self.strtab.buffer.append(gpa, 0);	88	try self.strtab.buffer.append(gpa, 0);
89		89
90	{	90	{
91	const name_off = try self.strtab.insert(gpa, self.path);	91	const name_off = try self.strtab.insert(gpa, self.basename);
92	const symbol_index = try self.newLocalSymbol(gpa, name_off);	92	const symbol_index = try self.newLocalSymbol(gpa, name_off);
93	const sym = self.symbol(symbol_index);	93	const sym = self.symbol(symbol_index);
94	const esym = &self.symtab.items(.elf_sym)[sym.esym_index];	94	const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
...	@@ -774,7 +774,7 @@ pub fn updateArSize(self: *ZigObject) void {	...	@@ -774,7 +774,7 @@ pub fn updateArSize(self: *ZigObject) void {
774	}	774	}
775		775
776	pub fn writeAr(self: ZigObject, writer: anytype) !void {	776	pub fn writeAr(self: ZigObject, writer: anytype) !void {
777	const name = self.path;	777	const name = self.basename;
778	const hdr = Archive.setArHdr(.{	778	const hdr = Archive.setArHdr(.{
779	.name = if (name.len <= Archive.max_member_name_len)	779	.name = if (name.len <= Archive.max_member_name_len)
780	.{ .name = name }	780	.{ .name = name }
...	@@ -2384,9 +2384,9 @@ const relocation = @import("relocation.zig");	...	@@ -2384,9 +2384,9 @@ const relocation = @import("relocation.zig");
2384	const target_util = @import("../../target.zig");	2384	const target_util = @import("../../target.zig");
2385	const trace = @import("../../tracy.zig").trace;	2385	const trace = @import("../../tracy.zig").trace;
2386	const std = @import("std");	2386	const std = @import("std");
		2387	const Allocator = std.mem.Allocator;
2387		2388
2388	const Air = @import("../../Air.zig");	2389	const Air = @import("../../Air.zig");
2389	const Allocator = std.mem.Allocator;
2390	const Archive = @import("Archive.zig");	2390	const Archive = @import("Archive.zig");
2391	const Atom = @import("Atom.zig");	2391	const Atom = @import("Atom.zig");
2392	const Dwarf = @import("../Dwarf.zig");	2392	const Dwarf = @import("../Dwarf.zig");

...	@@ -6,7 +6,7 @@ const Allocator = std.mem.Allocator;	...	@@ -6,7 +6,7 @@ const Allocator = std.mem.Allocator;
6	const Compilation = @import("Compilation.zig");	6	const Compilation = @import("Compilation.zig");
7	const build_options = @import("build_options");	7	const build_options = @import("build_options");
8		8
9	pub const CRTFile = enum {	9	pub const CrtFile = enum {
10	crt1_reactor_o,	10	crt1_reactor_o,
11	crt1_command_o,	11	crt1_command_o,
12	libc_a,	12	libc_a,
...	@@ -16,7 +16,7 @@ pub const CRTFile = enum {	...	@@ -16,7 +16,7 @@ pub const CRTFile = enum {
16	libwasi_emulated_signal_a,	16	libwasi_emulated_signal_a,
17	};	17	};
18		18
19	pub fn getEmulatedLibCRTFile(lib_name: []const u8) ?CRTFile {	19	pub fn getEmulatedLibCrtFile(lib_name: []const u8) ?CrtFile {
20	if (mem.eql(u8, lib_name, "wasi-emulated-process-clocks")) {	20	if (mem.eql(u8, lib_name, "wasi-emulated-process-clocks")) {
21	return .libwasi_emulated_process_clocks_a;	21	return .libwasi_emulated_process_clocks_a;
22	}	22	}
...	@@ -32,7 +32,7 @@ pub fn getEmulatedLibCRTFile(lib_name: []const u8) ?CRTFile {	...	@@ -32,7 +32,7 @@ pub fn getEmulatedLibCRTFile(lib_name: []const u8) ?CRTFile {
32	return null;	32	return null;
33	}	33	}
34		34
35	pub fn emulatedLibCRFileLibName(crt_file: CRTFile) []const u8 {	35	pub fn emulatedLibCRFileLibName(crt_file: CrtFile) []const u8 {
36	return switch (crt_file) {	36	return switch (crt_file) {
37	.libwasi_emulated_process_clocks_a => "libwasi-emulated-process-clocks.a",	37	.libwasi_emulated_process_clocks_a => "libwasi-emulated-process-clocks.a",
38	.libwasi_emulated_getpid_a => "libwasi-emulated-getpid.a",	38	.libwasi_emulated_getpid_a => "libwasi-emulated-getpid.a",
...	@@ -42,10 +42,10 @@ pub fn emulatedLibCRFileLibName(crt_file: CRTFile) []const u8 {	...	@@ -42,10 +42,10 @@ pub fn emulatedLibCRFileLibName(crt_file: CRTFile) []const u8 {
42	};	42	};
43	}	43	}
44		44
45	pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CRTFile {	45	pub fn execModelCrtFile(wasi_exec_model: std.builtin.WasiExecModel) CrtFile {
46	return switch (wasi_exec_model) {	46	return switch (wasi_exec_model) {
47	.reactor => CRTFile.crt1_reactor_o,	47	.reactor => CrtFile.crt1_reactor_o,
48	.command => CRTFile.crt1_command_o,	48	.command => CrtFile.crt1_command_o,
49	};	49	};
50	}	50	}
51		51
...	@@ -57,7 +57,7 @@ pub fn execModelCrtFileFullName(wasi_exec_model: std.builtin.WasiExecModel) []co	...	@@ -57,7 +57,7 @@ pub fn execModelCrtFileFullName(wasi_exec_model: std.builtin.WasiExecModel) []co
57	};	57	};
58	}	58	}
59		59
60	pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile, prog_node: std.Progress.Node) !void {	60	pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
61	if (!build_options.have_llvm) {	61	if (!build_options.have_llvm) {
62	return error.ZigCompilerNotBuiltWithLLVMExtensions;	62	return error.ZigCompilerNotBuiltWithLLVMExtensions;
63	}	63	}

Merge pull request #21654 from ziglang/embrace-path-abstraction