Commit 73b010e2216331b0b87240b05ea061294749383b | zig

lib/compiler/Maker.zig+4-1

lib/compiler/Maker/Step.zig+7

...	@@ -656,6 +656,13 @@ fn zigProcessUpdate(step_index: Configuration.Step.Index, maker: Maker, zp: Zi	...	@@ -656,6 +656,13 @@ fn zigProcessUpdate(step_index: Configuration.Step.Index, maker: Maker, zp: Zi
656	};	656	};
657	try addWatchInputFromPath(s, maker, path, Dir.path.basename(sub_path));	657	try addWatchInputFromPath(s, maker, path, Dir.path.basename(sub_path));
658	},	658	},
		659	.build_root => {
		660	const path: Path = .{
		661	.root_dir = graph.build_root_directory,
		662	.sub_path = sub_path_dirname,
		663	};
		664	try addWatchInputFromPath(s, maker, path, Dir.path.basename(sub_path));
		665	},
659	}	666	}
660	}	667	}
661	},	668	},

lib/compiler/Maker/Step/Compile.zig+2-1

 @@ -658,9 +658,10 @@ fn lowerZigArgs(
         zig_args.appendAssumeCapacity(libc_file);
     }
-    (try zig_args.addManyAsArray(gpa, 4)).* = .{
+    (try zig_args.addManyAsArray(gpa, 6)).* = .{
         "--cache-dir",        graph.local_cache_root.path orelse ".",
         "--global-cache-dir", graph.global_cache_root.path orelse ".",
+        "--build-root",       graph.build_root_directory.path orelse ".",
     };
     try zig_args.ensureUnusedCapacity(gpa, 1);

lib/std/Build/Cache.zig+34-51

...	@@ -417,18 +417,6 @@ pub const Manifest = struct {	...	@@ -417,18 +417,6 @@ pub const Manifest = struct {
417	return addFileInner(m, prefixed_path, handle, max_file_size);	417	return addFileInner(m, prefixed_path, handle, max_file_size);
418	}	418	}
419		419
420	/// Deprecated; use `addFilePath`.
421	pub fn addFile(self: *Manifest, file_path: []const u8, max_file_size: ?usize) !usize {
422	assert(self.manifest_file == null);
423
424	const gpa = self.cache.gpa;
425	try self.files.ensureUnusedCapacity(gpa, 1);
426	const prefixed_path = try self.cache.findPrefix(file_path);
427	errdefer gpa.free(prefixed_path.sub_path);
428
429	return addFileInner(self, prefixed_path, null, max_file_size);
430	}
431
432	fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, handle: ?Io.File, max_file_size: ?usize) usize {	420	fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, handle: ?Io.File, max_file_size: ?usize) usize {
433	const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});	421	const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});
434	if (gop.found_existing) {	422	if (gop.found_existing) {
...	@@ -452,26 +440,12 @@ pub const Manifest = struct {	...	@@ -452,26 +440,12 @@ pub const Manifest = struct {
452	return gop.index;	440	return gop.index;
453	}	441	}
454		442
455	/// Deprecated, use `addOptionalFilePath`.
456	pub fn addOptionalFile(self: *Manifest, optional_file_path: ?[]const u8) !void {
457	self.hash.add(optional_file_path != null);
458	const file_path = optional_file_path orelse return;
459	_ = try self.addFile(file_path, null);
460	}
461
462	pub fn addOptionalFilePath(self: *Manifest, optional_file_path: ?Path) !void {	443	pub fn addOptionalFilePath(self: *Manifest, optional_file_path: ?Path) !void {
463	self.hash.add(optional_file_path != null);	444	self.hash.add(optional_file_path != null);
464	const file_path = optional_file_path orelse return;	445	const file_path = optional_file_path orelse return;
465	_ = try self.addFilePath(file_path, null);	446	_ = try self.addFilePath(file_path, null);
466	}	447	}
467		448
468	pub fn addListOfFiles(self: *Manifest, list_of_files: []const []const u8) !void {
469	self.hash.add(list_of_files.len);
470	for (list_of_files) \|file_path\| {
471	_ = try self.addFile(file_path, null);
472	}
473	}
474
475	pub fn addDepFile(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {	449	pub fn addDepFile(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {
476	assert(self.manifest_file == null);	450	assert(self.manifest_file == null);
477	return self.addDepFileMaybePost(dir, dep_file_sub_path);	451	return self.addDepFileMaybePost(dir, dep_file_sub_path);
...	@@ -1058,24 +1032,32 @@ pub const Manifest = struct {	...	@@ -1058,24 +1032,32 @@ pub const Manifest = struct {
1058		1032
1059	/// Like `addFilePost` but when the file contents have already been loaded from disk.	1033	/// Like `addFilePost` but when the file contents have already been loaded from disk.
1060	pub fn addFilePostContents(	1034	pub fn addFilePostContents(
1061	self: *Manifest,	1035	man: *Manifest,
1062	file_path: []const u8,	1036	file_path: []const u8,
1063	bytes: []const u8,	1037	bytes: []const u8,
1064	stat: File.Stat,	1038	stat: File.Stat,
1065	) !void {	1039	) !void {
1066	assert(self.manifest_file != null);	1040	assert(man.manifest_file != null);
1067	const gpa = self.cache.gpa;	1041	const gpa = man.cache.gpa;
1068		1042	const prefixed_path = try man.cache.findPrefix(file_path);
1069	const prefixed_path = try self.cache.findPrefix(file_path);	1043	var keep = false;
1070	errdefer gpa.free(prefixed_path.sub_path);	1044	defer if (!keep) gpa.free(prefixed_path.sub_path);
		1045	keep = try addPrefixedPathPostContents(man, prefixed_path, bytes, stat);
		1046	}
1071		1047
1072	const gop = try self.files.getOrPutAdapted(gpa, prefixed_path, FilesAdapter{});	1048	/// Low level function. `prefixed_path` references cloned memory. Returns
1073	errdefer _ = self.files.pop();	1049	/// whether or not `prefixed_path.sub_path` should be kept.
		1050	pub fn addPrefixedPathPostContents(
		1051	man: *Manifest,
		1052	prefixed_path: PrefixedPath,
		1053	bytes: []const u8,
		1054	stat: File.Stat,
		1055	) !bool {
		1056	const gpa = man.cache.gpa;
		1057	const gop = try man.files.getOrPutAdapted(gpa, prefixed_path, FilesAdapter{});
		1058	errdefer _ = man.files.pop();
1074		1059
1075	if (gop.found_existing) {	1060	if (gop.found_existing) return false;
1076	gpa.free(prefixed_path.sub_path);
1077	return;
1078	}
1079		1061
1080	const new_file = gop.key_ptr;	1062	const new_file = gop.key_ptr;
1081		1063
...	@@ -1088,7 +1070,7 @@ pub const Manifest = struct {	...	@@ -1088,7 +1070,7 @@ pub const Manifest = struct {
1088	.contents = null,	1070	.contents = null,
1089	};	1071	};
1090		1072
1091	if (try self.isProblematicTimestamp(new_file.stat.mtime)) {	1073	if (try man.isProblematicTimestamp(new_file.stat.mtime)) {
1092	// The actual file has an unreliable timestamp, force it to be hashed	1074	// The actual file has an unreliable timestamp, force it to be hashed
1093	new_file.stat.mtime = .zero;	1075	new_file.stat.mtime = .zero;
1094	new_file.stat.inode = 0;	1076	new_file.stat.inode = 0;
...	@@ -1100,7 +1082,8 @@ pub const Manifest = struct {	...	@@ -1100,7 +1082,8 @@ pub const Manifest = struct {
1100	hasher.final(&new_file.bin_digest);	1082	hasher.final(&new_file.bin_digest);
1101	}	1083	}
1102		1084
1103	self.hash.hasher.update(&new_file.bin_digest);	1085	man.hash.hasher.update(&new_file.bin_digest);
		1086	return true;
1104	}	1087	}
1105		1088
1106	pub fn addDepFilePost(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {	1089	pub fn addDepFilePost(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {
...	@@ -1127,13 +1110,13 @@ pub const Manifest = struct {	...	@@ -1127,13 +1110,13 @@ pub const Manifest = struct {
1127	// Clang is invoked in single-source mode but other programs may not	1110	// Clang is invoked in single-source mode but other programs may not
1128	.target, .target_must_resolve => {},	1111	.target, .target_must_resolve => {},
1129	.prereq => \|file_path\| if (self.manifest_file == null) {	1112	.prereq => \|file_path\| if (self.manifest_file == null) {
1130	_ = try self.addFile(file_path, null);	1113	_ = try self.addFilePath(.initCwd(file_path), null);
1131	} else try self.addFilePost(file_path),	1114	} else try self.addFilePost(file_path),
1132	.prereq_must_resolve => {	1115	.prereq_must_resolve => {
1133	resolve_buf.clearRetainingCapacity();	1116	resolve_buf.clearRetainingCapacity();
1134	try token.resolve(gpa, &resolve_buf);	1117	try token.resolve(gpa, &resolve_buf);
1135	if (self.manifest_file == null) {	1118	if (self.manifest_file == null) {
1136	_ = try self.addFile(resolve_buf.items, null);	1119	_ = try self.addFilePath(.initCwd(resolve_buf.items), null);
1137	} else try self.addFilePost(resolve_buf.items);	1120	} else try self.addFilePost(resolve_buf.items);
1138	},	1121	},
1139	else => \|err\| {	1122	else => \|err\| {
...	@@ -1290,10 +1273,10 @@ pub const Manifest = struct {	...	@@ -1290,10 +1273,10 @@ pub const Manifest = struct {
1290	}	1273	}
1291	}	1274	}
1292		1275
1293	pub fn populateOtherManifest(man: Manifest, other: Manifest, prefix_map: [4]u8) Allocator.Error!void {	1276	pub fn populateOtherManifest(man: Manifest, other: Manifest, prefix_map: [5]u8) Allocator.Error!void {
1294	const gpa = other.cache.gpa;	1277	const gpa = other.cache.gpa;
1295	assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == man.cache.prefixes_len);	1278	assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == man.cache.prefixes_len);
1296	assert(man.cache.prefixes_len == 4);	1279	assert(man.cache.prefixes_len == 5);
1297	for (man.files.keys()) \|file\| {	1280	for (man.files.keys()) \|file\| {
1298	const prefixed_path: PrefixedPath = .{	1281	const prefixed_path: PrefixedPath = .{
1299	.prefix = prefix_map[file.prefixed_path.prefix],	1282	.prefix = prefix_map[file.prefixed_path.prefix],
...	@@ -1392,7 +1375,7 @@ test "cache file and then recall it" {	...	@@ -1392,7 +1375,7 @@ test "cache file and then recall it" {
1392	ch.hash.add(true);	1375	ch.hash.add(true);
1393	ch.hash.add(@as(u16, 1234));	1376	ch.hash.add(@as(u16, 1234));
1394	ch.hash.addBytes("1234");	1377	ch.hash.addBytes("1234");
1395	_ = try ch.addFile(temp_file, null);	1378	_ = try ch.addFilePath(.initCwd(temp_file), null);
1396		1379
1397	// There should be nothing in the cache	1380	// There should be nothing in the cache
1398	try testing.expectEqual(false, try ch.hit(.none));	1381	try testing.expectEqual(false, try ch.hit(.none));
...	@@ -1407,7 +1390,7 @@ test "cache file and then recall it" {	...	@@ -1407,7 +1390,7 @@ test "cache file and then recall it" {
1407	ch.hash.add(true);	1390	ch.hash.add(true);
1408	ch.hash.add(@as(u16, 1234));	1391	ch.hash.add(@as(u16, 1234));
1409	ch.hash.addBytes("1234");	1392	ch.hash.addBytes("1234");
1410	_ = try ch.addFile(temp_file, null);	1393	_ = try ch.addFilePath(.initCwd(temp_file), null);
1411		1394
1412	// Cache hit! We just "built" the same file	1395	// Cache hit! We just "built" the same file
1413	try testing.expect(try ch.hit(.none));	1396	try testing.expect(try ch.hit(.none));
...	@@ -1460,7 +1443,7 @@ test "check that changing a file makes cache fail" {	...	@@ -1460,7 +1443,7 @@ test "check that changing a file makes cache fail" {
1460	defer ch.deinit();	1443	defer ch.deinit();
1461		1444
1462	ch.hash.addBytes("1234");	1445	ch.hash.addBytes("1234");
1463	const temp_file_idx = try ch.addFile(temp_file, 100);	1446	const temp_file_idx = try ch.addFilePath(.initCwd(temp_file), 100);
1464		1447
1465	// There should be nothing in the cache	1448	// There should be nothing in the cache
1466	try testing.expectEqual(false, try ch.hit(.none));	1449	try testing.expectEqual(false, try ch.hit(.none));
...	@@ -1479,7 +1462,7 @@ test "check that changing a file makes cache fail" {	...	@@ -1479,7 +1462,7 @@ test "check that changing a file makes cache fail" {
1479	defer ch.deinit();	1462	defer ch.deinit();
1480		1463
1481	ch.hash.addBytes("1234");	1464	ch.hash.addBytes("1234");
1482	const temp_file_idx = try ch.addFile(temp_file, 100);	1465	const temp_file_idx = try ch.addFilePath(.initCwd(temp_file), 100);
1483		1466
1484	// A file that we depend on has been updated, so the cache should not contain an entry for it	1467	// A file that we depend on has been updated, so the cache should not contain an entry for it
1485	try testing.expectEqual(false, try ch.hit(.none));	1468	try testing.expectEqual(false, try ch.hit(.none));
...	@@ -1587,7 +1570,7 @@ test "Manifest with files added after initial hash work" {	...	@@ -1587,7 +1570,7 @@ test "Manifest with files added after initial hash work" {
1587	defer ch.deinit();	1570	defer ch.deinit();
1588		1571
1589	ch.hash.addBytes("1234");	1572	ch.hash.addBytes("1234");
1590	_ = try ch.addFile(temp_file1, null);	1573	_ = try ch.addFilePath(.initCwd(temp_file1), null);
1591		1574
1592	// There should be nothing in the cache	1575	// There should be nothing in the cache
1593	try testing.expectEqual(false, try ch.hit(.none));	1576	try testing.expectEqual(false, try ch.hit(.none));
...	@@ -1602,7 +1585,7 @@ test "Manifest with files added after initial hash work" {	...	@@ -1602,7 +1585,7 @@ test "Manifest with files added after initial hash work" {
1602	defer ch.deinit();	1585	defer ch.deinit();
1603		1586
1604	ch.hash.addBytes("1234");	1587	ch.hash.addBytes("1234");
1605	_ = try ch.addFile(temp_file1, null);	1588	_ = try ch.addFilePath(.initCwd(temp_file1), null);
1606		1589
1607	try testing.expect(try ch.hit(.none));	1590	try testing.expect(try ch.hit(.none));
1608	digest2 = ch.final();	1591	digest2 = ch.final();
...	@@ -1625,7 +1608,7 @@ test "Manifest with files added after initial hash work" {	...	@@ -1625,7 +1608,7 @@ test "Manifest with files added after initial hash work" {
1625	defer ch.deinit();	1608	defer ch.deinit();
1626		1609
1627	ch.hash.addBytes("1234");	1610	ch.hash.addBytes("1234");
1628	_ = try ch.addFile(temp_file1, null);	1611	_ = try ch.addFilePath(.initCwd(temp_file1), null);
1629		1612
1630	// A file that we depend on has been updated, so the cache should not contain an entry for it	1613	// A file that we depend on has been updated, so the cache should not contain an entry for it
1631	try testing.expectEqual(false, try ch.hit(.none));	1614	try testing.expectEqual(false, try ch.hit(.none));

lib/std/fs/path.zig+16-16

 @@ -1093,23 +1093,23 @@ pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) Allocator
     return result.toOwnedSlice(allocator);
 }
-/// This function is like a series of `cd` statements executed one after another.
+/// Simulates a series of relative directory changes on a virtual filesystem
-///
+/// that has no symlinks.
-/// It resolves "." and ".." to the best of its ability, but will not convert relative paths to
-/// an absolute path, use Io.Dir.realpath instead.
 ///
-/// ".." components may persist in the resolved path if the resolved path is relative.
+/// "." and ".." are resolved but will not make relative paths absolute. ".."
+/// components remain in the resolved path when the resolved path is relative
+/// and there are not previous components to cancel out.
 ///
 /// The result does not have a trailing path separator.
 ///
 /// This function does not perform any syscalls. Executing this series of path
-/// lookups on the actual filesystem may produce different results due to
+/// lookups on an actual filesystem may produce different results due to
 /// symlinks.
-pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) Allocator.Error![]u8 {
+pub fn resolvePosix(gpa: Allocator, paths: []const []const u8) Allocator.Error![]u8 {
     assert(paths.len > 0);
-    var result = std.array_list.Managed(u8).init(allocator);
+    var result: std.ArrayList(u8) = .empty;
-    defer result.deinit();
+    defer result.deinit(gpa);
     var negative_count: usize = 0;
     var is_abs = false;
 @@ -1135,23 +1135,23 @@ pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) Allocator.E
                     if (ends_with_slash or result.items.len == 0) break;
                 }
             } else if (result.items.len > 0 or is_abs) {
-                try result.ensureUnusedCapacity(1 + component.len);
+                try result.ensureUnusedCapacity(gpa, 1 + component.len);
                 result.appendAssumeCapacity('/');
                 result.appendSliceAssumeCapacity(component);
             } else {
-                try result.appendSlice(component);
+                try result.appendSlice(gpa, component);
             }
         }
     }
     if (result.items.len == 0) {
         if (is_abs) {
-            return allocator.dupe(u8, "/");
+            return gpa.dupe(u8, "/");
         }
         if (negative_count == 0) {
-            return allocator.dupe(u8, ".");
+            return gpa.dupe(u8, ".");
         } else {
-            const real_result = try allocator.alloc(u8, 3 * negative_count - 1);
+            const real_result = try gpa.alloc(u8, 3 * negative_count - 1);
             var count = negative_count - 1;
             var i: usize = 0;
             while (count > 0) : (count -= 1) {
 @@ -1164,9 +1164,9 @@ pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) Allocator.E
     }
     if (negative_count == 0) {
-        return result.toOwnedSlice();
+        return result.toOwnedSlice(gpa);
     } else {
-        const real_result = try allocator.alloc(u8, 3 * negative_count + result.items.len);
+        const real_result = try gpa.alloc(u8, 3 * negative_count + result.items.len);
         var count = negative_count;
         var i: usize = 0;
         while (count > 0) : (count -= 1) {

lib/std/zig.zig+31-15

 @@ -1283,14 +1283,20 @@ pub const Directories = struct {
     /// `local_cache.path` is resolved (`resolvePath`) or `null` for cwd.
     /// This may be the same as `global_cache`.
     local_cache: Cache.Directory,
+    /// The directory that contains build.zig. This path is provided by the
+    /// build system, when the build system is used, otherwise, it is `null`
+    /// for cwd.
+    build_root: Cache.Directory,
     pub fn deinit(dirs: *Directories, io: Io) void {
         // The local and global caches could be the same.
         const close_local = dirs.local_cache.handle.handle != dirs.global_cache.handle.handle;
+        const close_build_root = dirs.build_root.handle.handle != Io.Dir.cwd().handle;
         dirs.global_cache.handle.close(io);
         if (close_local) dirs.local_cache.handle.close(io);
         dirs.zig_lib.handle.close(io);
+        if (close_build_root) dirs.build_root.handle.close(io);
     }
     /// Returns a `Directories` where `local_cache` is replaced with `global_cache`, intended for
 @@ -1302,6 +1308,7 @@ pub const Directories = struct {
             .zig_lib = dirs.zig_lib,
             .global_cache = dirs.global_cache,
             .local_cache = dirs.global_cache,
+            .build_root = dirs.build_root,
         };
     }
 @@ -1311,12 +1318,10 @@ pub const Directories = struct {
         global,
     };
-    /// Uses `std.process.fatal` on error conditions.
+    pub const InitOptions = struct {
-    pub fn init(
-        arena: Allocator,
-        io: Io,
         override_zig_lib: ?[]const u8,
         override_global_cache: ?[]const u8,
+        build_root: ?[]const u8,
         local_cache_strat: LocalCacheStrategy,
         preopens: std.process.Preopens,
         self_exe_path: switch (builtin.target.os.tag) {
 @@ -1325,27 +1330,37 @@ pub const Directories = struct {
         },
         environ_map: *const std.process.Environ.Map,
         cwd: []const u8,
-    ) Directories {
+    };
+    /// Uses `std.process.fatal` on error conditions.
+    pub fn init(arena: Allocator, io: Io, options: InitOptions) Directories {
         const wasi = builtin.target.os.tag == .wasi;
+        const cwd = options.cwd;
         const zig_lib: Cache.Directory = d: {
-            if (override_zig_lib) |path| break :d openUnresolved(arena, io, cwd, path, .@"zig lib");
+            if (options.override_zig_lib) |path| break :d openUnresolved(arena, io, cwd, path, .@"zig lib");
-            if (wasi) break :d getPreopen(preopens, "/lib");
+            if (wasi) break :d getPreopen(options.preopens, "/lib");
-            break :d findZigLibDirFromSelfExe(arena, io, cwd, self_exe_path) catch |err| {
+            break :d findZigLibDirFromSelfExe(arena, io, cwd, options.self_exe_path) catch |err| {
-                fatal("unable to find zig installation directory from executable path {q}: {t}", .{ self_exe_path, err });
+                fatal("unable to find zig installation directory from executable path {q}: {t}", .{
+                    options.self_exe_path, err,
+                });
             };
         };
+        const build_root: Cache.Directory = if (options.build_root) |s|
+            openUnresolved(arena, io, cwd, s, .@"build root")
+        else
+            .cwd();
         const global_cache: Cache.Directory = d: {
-            if (override_global_cache) |path| break :d openUnresolved(arena, io, cwd, path, .@"global cache");
+            if (options.override_global_cache) |path| break :d openUnresolved(arena, io, cwd, path, .@"global cache");
-            if (wasi) break :d getPreopen(preopens, "/cache");
+            if (wasi) break :d getPreopen(options.preopens, "/cache");
-            const path = resolveGlobalCacheDir(arena, environ_map) catch |err| {
+            const path = resolveGlobalCacheDir(arena, options.environ_map) catch |err| {
                 fatal("unable to resolve zig cache directory: {t}", .{err});
             };
             break :d openUnresolved(arena, io, cwd, path, .@"global cache");
         };
-        const local_cache = getLocalCacheDirectory(arena, io, cwd, global_cache, local_cache_strat);
+        const local_cache = getLocalCacheDirectory(arena, io, cwd, global_cache, options.local_cache_strat);
         if (mem.eql(u8, zig_lib.path orelse "", global_cache.path orelse "")) {
             fatal("zig lib directory '{f}' cannot be equal to global cache directory '{f}'", .{ zig_lib, global_cache });
 @@ -1359,6 +1374,7 @@ pub const Directories = struct {
             .zig_lib = zig_lib,
             .global_cache = global_cache,
             .local_cache = local_cache,
+            .build_root = build_root,
         };
     }
 @@ -1395,14 +1411,14 @@ pub const Directories = struct {
         io: Io,
         cwd: []const u8,
         unresolved_path: []const u8,
-        thing: enum { @"zig lib", @"global cache", @"local cache" },
+        thing: enum { @"zig lib", @"global cache", @"local cache", @"build root" },
     ) Cache.Directory {
         const path = resolvePath(arena, cwd, &.{unresolved_path}) catch |err| {
             fatal("unable to resolve {t} directory: {t}", .{ thing, err });
         };
         const nonempty_path = if (path.len == 0) "." else path;
         const handle_or_err = switch (thing) {
-            .@"zig lib" => Dir.cwd().openDir(io, nonempty_path, .{}),
+            .@"zig lib", .@"build root" => Dir.cwd().openDir(io, nonempty_path, .{}),
             .@"global cache", .@"local cache" => Dir.cwd().createDirPathOpen(io, nonempty_path, .{}),
         };
         return .{

lib/std/zig/Server.zig+1

...	@@ -135,6 +135,7 @@ pub const Message = struct {	...	@@ -135,6 +135,7 @@ pub const Message = struct {
135	zig_lib,	135	zig_lib,
136	local_cache,	136	local_cache,
137	global_cache,	137	global_cache,
		138	build_root,
138	};	139	};
139		140
140	/// Trailing:	141	/// Trailing:

src/Compilation.zig+126-68

 @@ -397,6 +397,7 @@ pub const Path = struct {
         global_cache,
         /// `sub_path` is relative to the local cache directory on `Compilation`.
         local_cache,
+        build_root,
         /// `sub_path` is not relative to any of the roots listed above.
         /// It is resolved starting with `Directories.cwd`; so it is an absolute path on most
         /// targets, but cwd-relative on WASI. We do not make it cwd-relative on other targets
 @@ -434,11 +435,12 @@ pub const Path = struct {
         const dir = switch (p.root) {
             .none => {
                 const cwd_sub_path = absToCwdRelative(p.sub_path, dirs.cwd);
-                return .{ Io.Dir.cwd(), cwd_sub_path };
+                return .{ Io.Dir.cwd(), if (cwd_sub_path.len == 0) "." else cwd_sub_path };
             },
             .zig_lib => dirs.zig_lib.handle,
             .global_cache => dirs.global_cache.handle,
             .local_cache => dirs.local_cache.handle,
+            .build_root => dirs.build_root.handle,
         };
         if (p.sub_path.len == 0) return .{ dir, "." };
         assert(!fs.path.isAbsolute(p.sub_path));
 @@ -454,19 +456,18 @@ pub const Path = struct {
         comp: *Compilation,
         pub fn format(f: Formatter, w: *Writer) Writer.Error!void {
             const root_path: []const u8 = switch (f.p.root) {
-                .zig_lib => f.comp.dirs.zig_lib.path orelse ".",
+                .zig_lib => f.comp.dirs.zig_lib.path orelse "",
-                .global_cache => f.comp.dirs.global_cache.path orelse ".",
+                .global_cache => f.comp.dirs.global_cache.path orelse "",
-                .local_cache => f.comp.dirs.local_cache.path orelse ".",
+                .local_cache => f.comp.dirs.local_cache.path orelse "",
+                .build_root => f.comp.dirs.build_root.path orelse "",
                 .none => {
-                    const cwd_sub_path = absToCwdRelative(f.p.sub_path, f.comp.dirs.cwd);
+                    try w.writeAll(absToCwdRelative(f.p.sub_path, f.comp.dirs.cwd));
-                    try w.writeAll(cwd_sub_path);
                     return;
                 },
             };
-            assert(root_path.len != 0);
             try w.writeAll(root_path);
             if (f.p.sub_path.len > 0) {
-                try w.writeByte(fs.path.sep);
+                if (root_path.len != 0) try w.writeByte(fs.path.sep);
                 try w.writeAll(f.p.sub_path);
             }
         }
 @@ -474,16 +475,16 @@ pub const Path = struct {
     /// Given the `sub_path` of a `Path` with `Path.root == .none`, attempts to convert
     /// the (absolute) path to a cwd-relative path. Otherwise, returns the absolute path
-    /// unmodified. The returned string is never empty: "" is converted to ".".
+    /// unmodified. The returned string is never "."; empty string will be returned instead.
     fn absToCwdRelative(sub_path: []const u8, cwd_path: []const u8) []const u8 {
         if (builtin.target.os.tag == .wasi) {
-            if (sub_path.len == 0) return ".";
+            if (sub_path.len == 0) return "";
             assert(!fs.path.isAbsolute(sub_path));
             return sub_path;
         }
         assert(fs.path.isAbsolute(sub_path));
         if (!std.mem.startsWith(u8, sub_path, cwd_path)) return sub_path;
-        if (sub_path.len == cwd_path.len) return "."; // the strings are equal
+        if (sub_path.len == cwd_path.len) return ""; // the strings are equal
         const path_sep_index = path_sep_index: {
             // cwd is just a root, e.g. / or C:\
             if (cwd_path[cwd_path.len - 1] == fs.path.sep) break :path_sep_index cwd_path.len - 1;
 @@ -503,10 +504,11 @@ pub const Path = struct {
         // so that we prefer `.root = .local_cache` over `.root = .zig_lib`. The easiest way to do
         // this is simply to prioritize the longest root path.
         const PathAndRoot = struct { ?[]const u8, Root };
-        var roots: [3]PathAndRoot = .{
+        var roots: [4]PathAndRoot = .{
             .{ dirs.zig_lib.path, .zig_lib },
             .{ dirs.global_cache.path, .global_cache },
             .{ dirs.local_cache.path, .local_cache },
+            .{ dirs.build_root.path, .build_root },
         };
         // This must be a stable sort, because the global and local cache directories may be the same, in
         // which case we need to make a consistent choice.
 @@ -581,6 +583,7 @@ pub const Path = struct {
                 .zig_lib => dirs.zig_lib.path orelse "",
                 .global_cache => dirs.global_cache.path orelse "",
                 .local_cache => dirs.local_cache.path orelse "",
+                .build_root => dirs.build_root.path orelse "",
                 .none => "",
             },
             sub_path,
 @@ -603,6 +606,7 @@ pub const Path = struct {
                 .zig_lib => dirs.zig_lib.path orelse "",
                 .global_cache => dirs.global_cache.path orelse "",
                 .local_cache => dirs.local_cache.path orelse "",
+                .build_root => dirs.build_root.path orelse "",
                 .none => "",
             },
             p.sub_path,
 @@ -622,6 +626,7 @@ pub const Path = struct {
                 .zig_lib => dirs.zig_lib.path orelse "",
                 .global_cache => dirs.global_cache.path orelse "",
                 .local_cache => dirs.local_cache.path orelse "",
+                .build_root => dirs.build_root.path orelse "",
                 .none => "",
             },
             p.sub_path,
 @@ -635,11 +640,12 @@ pub const Path = struct {
             .zig_lib => dirs.zig_lib,
             .global_cache => dirs.global_cache,
             .local_cache => dirs.local_cache,
+            .build_root => dirs.build_root,
             else => {
                 const cwd_sub_path = absToCwdRelative(p.sub_path, dirs.cwd);
                 return .{
                     .root_dir = .cwd(),
-                    .sub_path = cwd_sub_path,
+                    .sub_path = if (cwd_sub_path.len == 0) null else cwd_sub_path,
                 };
             },
         };
 @@ -653,18 +659,15 @@ pub const Path = struct {
     /// This should not be used for most of the compiler pipeline, but is useful when emitting
     /// paths from the compilation (e.g. in debug info), because they will not depend on the cwd.
     /// The returned path is owned by the caller and allocated into `gpa`.
-    pub fn toAbsolute(p: Path, dirs: std.zig.Directories, gpa: Allocator) Allocator.Error![]u8 {
+    pub fn toAbsolute(p: Path, dirs: *const std.zig.Directories, gpa: Allocator) Allocator.Error![]u8 {
         const root_path: []const u8 = switch (p.root) {
             .zig_lib => dirs.zig_lib.path orelse "",
             .global_cache => dirs.global_cache.path orelse "",
             .local_cache => dirs.local_cache.path orelse "",
+            .build_root => dirs.build_root.path orelse "",
             .none => "",
         };
-        return fs.path.resolve(gpa, &.{
+        return fs.path.resolve(gpa, &.{ dirs.cwd, root_path, p.sub_path });
-            dirs.cwd,
-            root_path,
-            p.sub_path,
-        });
     }
     pub fn isNested(inner: Path, outer: Path) union(enum) {
 @@ -697,6 +700,66 @@ pub const Path = struct {
             .no, .different_roots => false,
         };
     }
+    pub fn addToCacheManifestPostHit(p: Path, man: *Cache.Manifest, dirs: *const std.zig.Directories) !void {
+        comptime assert(0 == @backingInt(std.zig.Server.Message.PathPrefix.cwd));
+        comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib));
+        comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache));
+        comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache));
+        comptime assert(4 == @backingInt(std.zig.Server.Message.PathPrefix.build_root));
+        comptime assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == 5);
+        const gpa = man.cache.gpa;
+        const prefixed_path: Cache.PrefixedPath = .{
+            .prefix = switch (p.root) {
+                .none => {
+                    const path = try p.toAbsolute(dirs, gpa);
+                    defer gpa.free(path);
+                    return man.addFilePost(path);
+                },
+                .zig_lib => 1,
+                .local_cache => 2,
+                .global_cache => 3,
+                .build_root => 4,
+            },
+            .sub_path = try gpa.dupe(u8, p.sub_path),
+        };
+        var keep = false;
+        defer if (!keep) gpa.free(prefixed_path.sub_path);
+        keep = try man.addPrefixedPathPost(prefixed_path);
+    }
+    pub fn addToCacheManifestPostHitContents(
+        p: Path,
+        man: *Cache.Manifest,
+        dirs: *const std.zig.Directories,
+        bytes: []const u8,
+        stat: Cache.File.Stat,
+    ) !void {
+        comptime assert(0 == @backingInt(std.zig.Server.Message.PathPrefix.cwd));
+        comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib));
+        comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache));
+        comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache));
+        comptime assert(4 == @backingInt(std.zig.Server.Message.PathPrefix.build_root));
+        comptime assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == 5);
+        const gpa = man.cache.gpa;
+        const prefixed_path: Cache.PrefixedPath = .{
+            .prefix = switch (p.root) {
+                .none => {
+                    const path = try p.toAbsolute(dirs, gpa);
+                    defer gpa.free(path);
+                    return man.addFilePostContents(path, bytes, stat);
+                },
+                .zig_lib => 1,
+                .local_cache => 2,
+                .global_cache => 3,
+                .build_root => 4,
+            },
+            .sub_path = try gpa.dupe(u8, p.sub_path),
+        };
+        var keep = false;
+        defer if (!keep) gpa.free(prefixed_path.sub_path);
+        keep = try man.addPrefixedPathPostContents(prefixed_path, bytes, stat);
+    }
 };
 /// This small wrapper function just checks whether debug extensions are enabled before checking
 @@ -1278,7 +1341,7 @@ pub const cache_helpers = struct {
     }
     pub fn hashCSource(self: *Cache.Manifest, c_source: CSourceFile) !void {
-        _ = try self.addFile(c_source.src_path, null);
+        _ = try self.addFilePath(.initCwd(c_source.src_path), null);
         // Hash the extra flags, with special care to call addFile for file parameters.
         // TODO this logic can likely be improved by utilizing clang_options_data.zig.
         const file_args = [_][]const u8{"-include"};
 @@ -1289,7 +1352,7 @@ pub const cache_helpers = struct {
             for (file_args) |file_arg| {
                 if (mem.eql(u8, file_arg, arg) and arg_i + 1 < c_source.extra_flags.len) {
                     arg_i += 1;
-                    _ = try self.addFile(c_source.extra_flags[arg_i], null);
+                    _ = try self.addFilePath(.initCwd(c_source.extra_flags[arg_i]), null);
                 }
             }
         }
 @@ -1348,7 +1411,7 @@ pub const CacheMode = enum {
 pub const ParentWholeCache = struct {
     manifest: *Cache.Manifest,
     mutex: *std.Io.Mutex,
-    prefix_map: [4]u8,
+    prefix_map: [5]u8,
 };
 const CacheUse = union(CacheMode) {
 @@ -1466,8 +1529,8 @@ pub const CreateOptions = struct {
     stack_report: bool = false,
     link_eh_frame_hdr: bool = false,
     link_emit_relocs: bool = false,
-    linker_script: ?[]const u8 = null,
+    linker_script: ?Cache.Path = null,
-    version_script: ?[]const u8 = null,
+    version_script: ?Cache.Path = null,
     linker_allow_undefined_version: bool = false,
     linker_enable_new_dtags: ?bool = null,
     soname: ?[]const u8 = null,
 @@ -1546,7 +1609,7 @@ pub const CreateOptions = struct {
     /// (Darwin) Install name of the dylib
     install_name: ?[]const u8 = null,
     /// (Darwin) Path to entitlements file
-    entitlements: ?[]const u8 = null,
+    entitlements: ?Cache.Path = null,
     /// (Darwin) size of the __PAGEZERO segment
     pagezero_size: ?u64 = null,
     /// (Darwin) set minimum space for future expansion of the load commands
 @@ -1613,15 +1676,7 @@ pub const CreateOptions = struct {
     };
 };
-fn addModuleTableToCacheHash(
+fn addModuleTableToCacheHash(zcu: *Zcu, hash: *Cache.HashHelper) error{ OutOfMemory, Unexpected }!void {
-    zcu: *Zcu,
-    arena: Allocator,
-    hash: *Cache.HashHelper,
-    hash_type: union(enum) { path_bytes, files: *Cache.Manifest },
-) error{
-    OutOfMemory,
-    Unexpected,
-}!void {
     assert(zcu.module_roots.count() != 0); // module_roots is populated
     for (zcu.module_roots.keys(), zcu.module_roots.values()) |mod, opt_mod_root_file| {
 @@ -1630,17 +1685,9 @@ fn addModuleTableToCacheHash(
             if (zcu.fileByIndex(mod_root_file).is_builtin) continue; // redundant
         }
         cache_helpers.addModule(hash, mod);
-        switch (hash_type) {
+        hash.add(mod.root.root);
-            .path_bytes => {
+        hash.addBytes(mod.root.sub_path);
-                hash.add(mod.root.root);
+        hash.addBytes(mod.root_src_path);
-                hash.addBytes(mod.root.sub_path);
-                hash.addBytes(mod.root_src_path);
-            },
-            .files => |man| if (mod.root_src_path.len != 0) {
-                const root_src_path = try mod.root.toCachePath(zcu.comp.dirs).join(arena, mod.root_src_path);
-                _ = try man.addFilePath(root_src_path, null);
-            },
-        }
         hash.addListOfBytes(mod.deps.keys());
     }
 }
 @@ -1926,6 +1973,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
         }
         const error_limit = options.error_limit orelse (std.math.maxInt(u16) - 1);
+        const main_mod = options.main_mod orelse options.root_mod;
         // We put everything into the cache hash that *cannot be modified
         // during an incremental update*. For example, one cannot change the
 @@ -1944,11 +1992,17 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             },
             .cwd = options.dirs.cwd,
         };
-        // These correspond to std.zig.Server.Message.PathPrefix.
+        comptime assert(0 == @backingInt(std.zig.Server.Message.PathPrefix.cwd));
+        comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib));
+        comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache));
+        comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache));
+        comptime assert(4 == @backingInt(std.zig.Server.Message.PathPrefix.build_root));
+        comptime assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == 5);
         cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
         cache.addPrefix(options.dirs.zig_lib);
         cache.addPrefix(options.dirs.local_cache);
         cache.addPrefix(options.dirs.global_cache);
+        cache.addPrefix(options.dirs.build_root);
         errdefer cache.manifest_dir.close(io);
         // This is shared hasher state common to zig source and all C source files.
 @@ -1984,7 +2038,6 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
         cache.hash.add(options.emit_docs != .no);
         // TODO audit this and make sure everything is in it
-        const main_mod = options.main_mod orelse options.root_mod;
         const comp = try arena.create(Compilation);
         const opt_zcu: ?*Zcu = if (have_zcu) blk: {
             // Pre-open the directory handles for cached ZIR code so that it does not need
 @@ -2265,7 +2318,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
                 // likely different compilations and therefore this would be likely to
                 // cause cache hits.
                 if (comp.zcu) |zcu| {
-                    try addModuleTableToCacheHash(zcu, arena, &hash, .path_bytes);
+                    try addModuleTableToCacheHash(zcu, &hash);
                 } else {
                     cache_helpers.addModule(&hash, options.root_mod);
                 }
 @@ -2741,7 +2794,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
     // If using the whole caching strategy, we check for *everything* up front, including
     // C source files.
-    log.debug("Compilation.update for {s}, CacheMode.{s}", .{ comp.root_name, @tagName(comp.cache_use) });
+    log.debug("Compilation.update for {s}, CacheMode.{t}", .{ comp.root_name, comp.cache_use });
     switch (comp.cache_use) {
         .none => |none| {
             assert(none.tmp_artifact_directory == null);
 @@ -2750,7 +2803,9 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
                 const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(tmp_dir_rand_int);
                 const path = try comp.dirs.local_cache.join(arena, &.{tmp_dir_sub_path});
                 const handle = comp.dirs.local_cache.handle.createDirPathOpen(io, tmp_dir_sub_path, .{}) catch |err| {
-                    return comp.setMiscFailure(.open_output, "failed to create output directory '{s}': {t}", .{ path, err });
+                    return comp.setMiscFailure(.open_output, "failed to create output directory {q}: {t}", .{
+                        path, err,
+                    });
                 };
                 break :d .{ .path = path, .handle = handle };
             };
 @@ -2763,7 +2818,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
             man = comp.cache_parent.obtain();
             whole.cache_manifest = &man;
-            try addNonIncrementalStuffToCacheManifest(comp, arena, &man);
+            try addNonIncrementalStuffToCacheManifest(comp, &man);
             // Under `--time-report`, ignore cache hits; do the work anyway for those juicy numbers.
             const ignore_hit = comp.time_report != null;
 @@ -3114,6 +3169,7 @@ pub fn appendFileSystemInput(comp: *Compilation, path: Compilation.Path) Allocat
         .zig_lib => comp.dirs.zig_lib,
         .global_cache => comp.dirs.global_cache,
         .local_cache => comp.dirs.local_cache,
+        .build_root => comp.dirs.build_root,
         .none => .cwd(),
     };
     const prefix: u8 = for (prefixes, 1..) |prefix_dir, i| {
 @@ -3121,8 +3177,8 @@ pub fn appendFileSystemInput(comp: *Compilation, path: Compilation.Path) Allocat
             break @intCast(i);
         }
     } else std.debug.panic(
-        "missing prefix directory '{s}' ('{f}') for '{s}'",
+        "missing prefix directory {t} ('{f}') for {q}",
-        .{ @tagName(path.root), want_prefix_dir, path.sub_path },
+        .{ path.root, want_prefix_dir, path.sub_path },
     );
     // There may be concurrent calls to this function from C object workers and/or the main thread.
 @@ -3314,15 +3370,15 @@ fn renameTmpIntoCache(
 /// anything from the link cache manifest.
 pub const link_hash_implementation_version = 14;
-fn addNonIncrementalStuffToCacheManifest(
+fn addNonIncrementalStuffToCacheManifest(comp: *Compilation, man: *Cache.Manifest) !void {
-    comp: *Compilation,
-    arena: Allocator,
-    man: *Cache.Manifest,
-) !void {
     comptime assert(link_hash_implementation_version == 14);
     if (comp.zcu) |zcu| {
-        try addModuleTableToCacheHash(zcu, arena, &man.hash, .{ .files = man });
+        // No need to hash the actual file contents here because it is
+        // redundant with the logic in `PerThread.update` which iterates over
+        // `zcu.alive_files` and adds those files discovered via `@import` to
+        // the whole cache manifest.
+        try addModuleTableToCacheHash(zcu, &man.hash);
         // Synchronize with other matching comments: ZigOnlyHashStuff
         man.hash.addListOfBytes(comp.test_filters);
 @@ -3336,7 +3392,7 @@ fn addNonIncrementalStuffToCacheManifest(
     try link.hashInputs(man, comp.link_inputs);
     for (comp.c_objects.items) |c_object| {
-        _ = try man.addFile(c_object.src.src_path, null);
+        _ = try man.addFilePath(.initCwd(c_object.src.src_path), null);
         man.hash.addOptional(c_object.src.ext);
         man.hash.addListOfBytes(c_object.src.extra_flags);
     }
 @@ -3344,11 +3400,11 @@ fn addNonIncrementalStuffToCacheManifest(
     for (comp.win32_resources.items) |win32_resource| {
         switch (win32_resource.src) {
             .rc => |rc_src| {
-                _ = try man.addFile(rc_src.src_path, null);
+                _ = try man.addFilePath(.initCwd(rc_src.src_path), null);
                 man.hash.addListOfBytes(rc_src.extra_flags);
             },
             .manifest => |manifest_path| {
-                _ = try man.addFile(manifest_path, null);
+                _ = try man.addFilePath(.initCwd(manifest_path), null);
             },
         }
     }
 @@ -3380,8 +3436,8 @@ fn addNonIncrementalStuffToCacheManifest(
     const opts = comp.cache_use.whole.lf_open_opts;
-    try man.addOptionalFile(opts.linker_script);
+    try man.addOptionalFilePath(opts.linker_script);
-    try man.addOptionalFile(opts.version_script);
+    try man.addOptionalFilePath(opts.version_script);
     man.hash.add(opts.allow_undefined_version);
     man.hash.addOptional(opts.enable_new_dtags);
 @@ -3440,7 +3496,7 @@ fn addNonIncrementalStuffToCacheManifest(
     // Mach-O specific stuff
     try link.File.MachO.hashAddFrameworks(man, opts.frameworks);
-    try man.addOptionalFile(opts.entitlements);
+    try man.addOptionalFilePath(opts.entitlements);
     man.hash.addOptional(opts.pagezero_size);
     man.hash.addOptional(opts.headerpad_size);
     man.hash.add(opts.headerpad_max_install_names);
 @@ -5278,6 +5334,7 @@ fn buildMingwCrtFile(comp: *Compilation, crt_file: mingw.CrtFile, prog_node: std
 fn buildMingwImportLib(comp: *Compilation, lib_name: []const u8, is_prelink: bool, prog_node: std.Progress.Node) void {
     const crt_file_path = mingw.buildImportLib(comp, lib_name, prog_node) catch |err| switch (err) {
+        error.AlreadyReported => return,
         // TODO: This isn't actually true for self-hosted
         // In the non-prelink case we will end up putting foo.lib onto the linker line and letting the linker
         // use its library paths to look for libraries and report any problems.
 @@ -5291,7 +5348,7 @@ fn buildMingwImportLib(comp: *Compilation, lib_name: []const u8, is_prelink: boo
         // TODO Surface more error details.
         else => |e| return comp.lockAndSetMiscFailure(
             .windows_import_lib,
-            "unable to generate mingw DLL import .lib file for {s}: {t}",
+            "generating mingw DLL import .lib file for {s} failed: {t}",
             .{ lib_name, e },
         ),
     };
 @@ -5818,7 +5875,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
     // the XML data as a RT_MANIFEST resource. This means we can skip preprocessing,
     // include paths, CLI options, etc.
     if (win32_resource.src == .manifest) {
-        _ = try man.addFile(src_path, null);
+        _ = try man.addFilePath(.initCwd(src_path), null);
         const rc_basename = try std.fmt.allocPrint(arena, "{s}.rc", .{src_basename});
         const res_basename = try std.fmt.allocPrint(arena, "{s}.res", .{src_basename});
 @@ -5911,7 +5968,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
     // We now know that we're compiling an .rc file
     const rc_src = win32_resource.src.rc;
-    _ = try man.addFile(rc_src.src_path, null);
+    _ = try man.addFilePath(.initCwd(rc_src.src_path), null);
     man.hash.addListOfBytes(rc_src.extra_flags);
     const rc_basename_noext = src_basename[0 .. src_basename.len - fs.path.extension(src_basename).len];
 @@ -7321,6 +7378,7 @@ fn buildOutputFromZig(
                 1, // zig lib dir is the same
                 3, // local cache is mapped to global cache
                 3, // global cache is the same
+                0, // build root is not provided
             },
         },
         .incremental, .none => null,

src/Zcu/PerThread.zig+5-11

 @@ -221,22 +221,19 @@ pub fn update(
                     .astgen_failure, .success => {}, // the file was read successfully
                 }
-                const path = try file.path.toAbsolute(comp.dirs, gpa);
-                defer gpa.free(path);
                 const result = res: {
                     try whole.cache_manifest_mutex.lock(io);
                     defer whole.cache_manifest_mutex.unlock(io);
                     if (file.source) |source| {
-                        break :res man.addFilePostContents(path, source, file.stat);
+                        break :res file.path.addToCacheManifestPostHitContents(man, &comp.dirs, source, file.stat);
                     } else {
-                        break :res man.addFilePost(path);
+                        break :res file.path.addToCacheManifestPostHit(man, &comp.dirs);
                     }
                 };
                 result catch |err| switch (err) {
                     error.OutOfMemory => |e| return e,
                     else => {
-                        try pt.reportRetryableFileError(file_index, "unable to update cache: {s}", .{@errorName(err)});
+                        try pt.reportRetryableFileError(file_index, "unable to update cache: {t}", .{err});
                         continue;
                     },
                 };
 @@ -481,7 +478,7 @@ pub fn updateFile(
     const stat = try source_file.stat(io);
     const want_local_cache = switch (file.path.root) {
-        .none, .local_cache => true,
+        .none, .local_cache, .build_root => true,
         .global_cache, .zig_lib => false,
     };
 @@ -2965,13 +2962,10 @@ fn newEmbedFile(
         const array_len = Value.fromInterned(new_file.val).typeOf(zcu).childType(zcu).arrayLen(zcu);
         const contents = ip_str.toSlice(array_len, ip);
-        const path_str = try path.toAbsolute(comp.dirs, gpa);
-        defer gpa.free(path_str);
         try whole.cache_manifest_mutex.lock(io);
         defer whole.cache_manifest_mutex.unlock(io);
-        try man.addFilePostContents(path_str, contents, new_file.stat);
+        try path.addToCacheManifestPostHitContents(man, &comp.dirs, contents, new_file.stat);
     }
     return new_file;

src/codegen/llvm.zig+2-1

...	@@ -481,7 +481,7 @@ pub const Object = struct {	...	@@ -481,7 +481,7 @@ pub const Object = struct {
481	// way already, but here we throw all that sweet information	481	// way already, but here we throw all that sweet information
482	// into the garbage can by converting into absolute paths. What	482	// into the garbage can by converting into absolute paths. What
483	// a terrible tragedy.	483	// a terrible tragedy.
484	const compile_unit_dir = try zcu.main_mod.root.toAbsolute(comp.dirs, arena);	484	const compile_unit_dir = try zcu.main_mod.root.toAbsolute(&comp.dirs, arena);
485		485
486	const debug_file = try builder.debugFile(	486	const debug_file = try builder.debugFile(
487	try builder.metadataString(comp.root_name),	487	try builder.metadataString(comp.root_name),
...	@@ -1701,6 +1701,7 @@ pub const Object = struct {	...	@@ -1701,6 +1701,7 @@ pub const Object = struct {
1701	.zig_lib => dirs.zig_lib.path,	1701	.zig_lib => dirs.zig_lib.path,
1702	.global_cache => dirs.global_cache.path,	1702	.global_cache => dirs.global_cache.path,
1703	.local_cache => dirs.local_cache.path,	1703	.local_cache => dirs.local_cache.path,
		1704	.build_root => dirs.build_root.path,
1704	.none => null,	1705	.none => null,
1705	};	1706	};
1706		1707

src/libs/freebsd.zig+8-4

 @@ -458,8 +458,10 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     man.hash.add(target.abi);
     man.hash.add(target_os_version);
-    const full_abilists_path = try comp.dirs.zig_lib.join(arena, &.{abilists_path});
+    const abilists_index = try man.addFilePath(.{
-    const abilists_index = try man.addFile(full_abilists_path, abilists_max_size);
+        .root_dir = comp.dirs.zig_lib,
+        .sub_path = abilists_path,
+    }, abilists_max_size);
     if (try man.hit(prog_node)) {
         const digest = man.final();
 @@ -1044,7 +1046,6 @@ fn buildSharedLib(
     const version: Version = .{ .major = sover, .minor = 0, .patch = 0 };
     const ld_basename = path.basename(target.standardDynamicLinkerPath().get().?);
     const soname = if (mem.eql(u8, lib.name, "ld")) ld_basename else basename;
-    const map_file_path = try path.join(arena, &.{ bin_directory.path.?, all_map_basename });
     const optimize_mode = comp.compilerRtOptMode();
     const strip = comp.compilerRtStrip();
 @@ -1113,7 +1114,10 @@ fn buildSharedLib(
         .verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,
         .clang_passthrough_mode = comp.clang_passthrough_mode,
         .version = version,
-        .version_script = map_file_path,
+        .version_script = .{
+            .root_dir = bin_directory,
+            .sub_path = all_map_basename,
+        },
         .soname = soname,
         .c_source_files = &c_source_files,
         .skip_linker_dependencies = true,

src/libs/glibc.zig+8-4

 @@ -698,8 +698,10 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     man.hash.add(target.abi);
     man.hash.add(target_version);
-    const full_abilists_path = try comp.dirs.zig_lib.join(arena, &.{abilists_path});
+    const abilists_index = try man.addFilePath(.{
-    const abilists_index = try man.addFile(full_abilists_path, abilists_max_size);
+        .root_dir = comp.dirs.zig_lib,
+        .sub_path = abilists_path,
+    }, abilists_max_size);
     if (try man.hit(prog_node)) {
         const digest = man.final();
 @@ -1188,7 +1190,6 @@ fn buildSharedLib(
     const version: Version = .{ .major = lib.sover, .minor = 0, .patch = 0 };
     const ld_basename = path.basename(comp.getTarget().standardDynamicLinkerPath().get().?);
     const soname = if (mem.eql(u8, lib.name, "ld")) ld_basename else basename;
-    const map_file_path = try path.join(arena, &.{ bin_directory.path.?, all_map_basename });
     const optimize_mode = comp.compilerRtOptMode();
     const strip = comp.compilerRtStrip();
 @@ -1257,7 +1258,10 @@ fn buildSharedLib(
         .verbose_llvm_cpu_features = comp.verbose_llvm_cpu_features,
         .clang_passthrough_mode = comp.clang_passthrough_mode,
         .version = version,
-        .version_script = map_file_path,
+        .version_script = .{
+            .root_dir = bin_directory,
+            .sub_path = all_map_basename,
+        },
         .soname = soname,
         .c_source_files = &c_source_files,
         .skip_linker_dependencies = true,

src/libs/mingw.zig+50-48

...	@@ -215,12 +215,15 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P	...	@@ -215,12 +215,15 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P
215	defer arena_allocator.deinit();	215	defer arena_allocator.deinit();
216	const arena = arena_allocator.allocator();	216	const arena = arena_allocator.allocator();
217		217
218	const def_file_path = findDef(arena, io, comp.getTarget(), comp.dirs.zig_lib, lib_name) catch \|err\| switch (err) {	218	const def_file_path: Cache.Path = .{
219	error.FileNotFound => return error.DefNotFound,	219	.root_dir = comp.dirs.zig_lib,
220	else => \|e\| return e,	220	.sub_path = findDef(arena, io, comp.getTarget(), comp.dirs.zig_lib, lib_name) catch \|err\| switch (err) {
		221	error.FileNotFound => return error.DefNotFound,
		222	else => \|e\| return e,
		223	},
221	};	224	};
222	// Only .def.in files need preprocessing	225	// Only .def.in files need preprocessing
223	const def_needs_preprocessing = mem.endsWith(u8, def_file_path, ".def.in");	226	const def_needs_preprocessing = mem.endsWith(u8, def_file_path.sub_path, ".def.in");
224		227
225	const target = comp.getTarget();	228	const target = comp.getTarget();
226		229
...	@@ -243,12 +246,34 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P	...	@@ -243,12 +246,34 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P
243	var man = cache.obtain();	246	var man = cache.obtain();
244	defer man.deinit();	247	defer man.deinit();
245		248
246	_ = try man.addFile(def_file_path, null);	249	_ = try man.addFilePath(def_file_path, null);
247		250
248	const final_lib_basename = try std.fmt.allocPrint(gpa, "{s}.lib", .{lib_name});	251	const final_lib_basename = try std.fmt.allocPrint(gpa, "{s}.lib", .{lib_name});
249	errdefer gpa.free(final_lib_basename);	252	errdefer gpa.free(final_lib_basename);
250		253
251	if (try man.hit(prog_node)) {	254	const is_hit = man.hit(prog_node) catch \|err\| switch (err) {
		255	error.CacheCheckFailed => switch (man.diagnostic) {
		256	.none => unreachable,
		257	.manifest_create, .manifest_read, .manifest_lock => \|e\| {
		258	comp.setMiscFailure(.windows_import_lib, "checking cache failed: {t} {t}", .{ man.diagnostic, e });
		259	return error.AlreadyReported;
		260	},
		261	.file_open, .file_stat, .file_read, .file_hash => \|op\| {
		262	const pp = man.files.keys()[op.file_index].prefixed_path;
		263	const prefix = man.cache.prefixes()[pp.prefix];
		264	comp.setMiscFailure(.windows_import_lib, "checking cache failed: {f}{s} {t} {t}", .{
		265	prefix, pp.sub_path, man.diagnostic, op.err,
		266	});
		267	return error.AlreadyReported;
		268	},
		269	},
		270	error.OutOfMemory, error.Canceled => \|e\| return e,
		271	error.InvalidFormat => {
		272	comp.setMiscFailure(.windows_import_lib, "checking cache failed: invalid manifest file format", .{});
		273	return error.AlreadyReported;
		274	},
		275	};
		276	if (is_hit) {
252	const digest = man.final();	277	const digest = man.final();
253	const sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });	278	const sub_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });
254	errdefer gpa.free(sub_path);	279	errdefer gpa.free(sub_path);
...	@@ -273,20 +298,11 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P	...	@@ -273,20 +298,11 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P
273	var o_dir = try comp.dirs.global_cache.handle.createDirPathOpen(io, o_sub_path, .{});	298	var o_dir = try comp.dirs.global_cache.handle.createDirPathOpen(io, o_sub_path, .{});
274	defer o_dir.close(io);	299	defer o_dir.close(io);
275		300
276	const include_dir = try comp.dirs.zig_lib.join(arena, &.{ "libc", "mingw", "def-include" });	301	const sep = path.sep_str;
277		302	const include_dir: Cache.Path = .{
278	if (comp.verbose_cc) {	303	.root_dir = comp.dirs.zig_lib,
279	var buffer: [256]u8 = undefined;	304	.sub_path = "libc" ++ sep ++ "mingw" ++ sep ++ "def-include",
280	const stderr = try io.lockStderr(&buffer, null);	305	};
281	defer io.unlockStderr();
282	const w = &stderr.file_writer.interface;
283	w.print("def file: {s}\n", .{def_file_path}) catch \|err\| switch (err) {
284	error.WriteFailed => return stderr.file_writer.err.?,
285	};
286	w.print("include dir: {s}\n", .{include_dir}) catch \|err\| switch (err) {
287	error.WriteFailed => return stderr.file_writer.err.?,
288	};
289	}
290		306
291	const members = members: {	307	const members = members: {
292	const members_node = sub_node.start("Members", 0);	308	const members_node = sub_node.start("Members", 0);
...	@@ -310,7 +326,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P	...	@@ -310,7 +326,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8, prog_node: std.P
310		326
311	break :pp try aw.toOwnedSliceSentinel(0);	327	break :pp try aw.toOwnedSliceSentinel(0);
312	},	328	},
313	false => try Io.Dir.cwd().readFileAllocOptions(io, def_file_path, gpa, .unlimited, .of(u8), 0),	329	false => try def_file_path.root_dir.handle.readFileAllocOptions(io, def_file_path.sub_path, gpa, .unlimited, .of(u8), 0),
314	};	330	};
315	defer gpa.free(input);	331	defer gpa.free(input);
316		332
...	@@ -384,7 +400,7 @@ pub fn libExists(	...	@@ -384,7 +400,7 @@ pub fn libExists(
384	/// This function body is verbose but all it does is test 3 different paths and	400	/// This function body is verbose but all it does is test 3 different paths and
385	/// see if a .def file exists.	401	/// see if a .def file exists.
386	fn findDef(	402	fn findDef(
387	allocator: Allocator,	403	gpa: Allocator,
388	io: Io,	404	io: Io,
389	target: *const std.Target,	405	target: *const std.Target,
390	zig_lib_directory: Cache.Directory,	406	zig_lib_directory: Cache.Directory,
...	@@ -398,21 +414,17 @@ fn findDef(	...	@@ -398,21 +414,17 @@ fn findDef(
398	else => unreachable,	414	else => unreachable,
399	};	415	};
400		416
401	var override_path = std.array_list.Managed(u8).init(allocator);	417	var override_path: std.ArrayList(u8) = .empty;
402	defer override_path.deinit();	418	defer override_path.deinit(gpa);
403		419
404	const s = path.sep_str;	420	const s = path.sep_str;
405		421
406	{	422	{
407	// Try the archtecture-specific path first.	423	// Try the archtecture-specific path first.
408	const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "{s}" ++ s ++ "{s}.def";	424	override_path.shrinkRetainingCapacity(0);
409	if (zig_lib_directory.path) \|p\| {	425	try override_path.print(gpa, "libc" ++ s ++ "mingw" ++ s ++ "{s}" ++ s ++ "{s}.def", .{ lib_path, lib_name });
410	try override_path.print("{s}" ++ s ++ fmt_path, .{ p, lib_path, lib_name });	426	if (zig_lib_directory.handle.access(io, override_path.items, .{})) \|_\| {
411	} else {	427	return override_path.toOwnedSlice(gpa);
412	try override_path.print(fmt_path, .{ lib_path, lib_name });
413	}
414	if (Io.Dir.cwd().access(io, override_path.items, .{})) \|_\| {
415	return override_path.toOwnedSlice();
416	} else \|err\| switch (err) {	428	} else \|err\| switch (err) {
417	error.FileNotFound => {},	429	error.FileNotFound => {},
418	else => \|e\| return e,	430	else => \|e\| return e,
...	@@ -422,14 +434,9 @@ fn findDef(	...	@@ -422,14 +434,9 @@ fn findDef(
422	{	434	{
423	// Try the generic version.	435	// Try the generic version.
424	override_path.shrinkRetainingCapacity(0);	436	override_path.shrinkRetainingCapacity(0);
425	const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def";	437	try override_path.print(gpa, "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def", .{lib_name});
426	if (zig_lib_directory.path) \|p\| {	438	if (zig_lib_directory.handle.access(io, override_path.items, .{})) \|_\| {
427	try override_path.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });	439	return override_path.toOwnedSlice(gpa);
428	} else {
429	try override_path.print(fmt_path, .{lib_name});
430	}
431	if (Io.Dir.cwd().access(io, override_path.items, .{})) \|_\| {
432	return override_path.toOwnedSlice();
433	} else \|err\| switch (err) {	440	} else \|err\| switch (err) {
434	error.FileNotFound => {},	441	error.FileNotFound => {},
435	else => \|e\| return e,	442	else => \|e\| return e,
...	@@ -439,14 +446,9 @@ fn findDef(	...	@@ -439,14 +446,9 @@ fn findDef(
439	{	446	{
440	// Try the generic version and preprocess it.	447	// Try the generic version and preprocess it.
441	override_path.shrinkRetainingCapacity(0);	448	override_path.shrinkRetainingCapacity(0);
442	const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def.in";	449	try override_path.print(gpa, "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def.in", .{lib_name});
443	if (zig_lib_directory.path) \|p\| {	450	if (zig_lib_directory.handle.access(io, override_path.items, .{})) \|_\| {
444	try override_path.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });	451	return override_path.toOwnedSlice(gpa);
445	} else {
446	try override_path.print(fmt_path, .{lib_name});
447	}
448	if (Io.Dir.cwd().access(io, override_path.items, .{})) \|_\| {
449	return override_path.toOwnedSlice();
450	} else \|err\| switch (err) {	452	} else \|err\| switch (err) {
451	error.FileNotFound => {},	453	error.FileNotFound => {},
452	else => \|e\| return e,	454	else => \|e\| return e,

src/libs/mingw/Preprocessor.zig+12-22

 @@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator;
 const Token = Tokenizer.Token;
 const mem = std.mem;
 const assert = std.debug.assert;
+const Path = std.Build.Cache.Path;
 test {
     _ = Tokenizer;
 @@ -25,15 +26,15 @@ pub const Source = struct {
     pub const generated: Source.Id = std.math.maxInt(usize);
     pub const Id = usize;
     id: Id = generated,
-    path: []const u8,
+    path: Path,
     buf: []const u8,
 };
-sources: std.array_hash_map.String(Source) = .empty,
+sources: std.array_hash_map.Custom(Path, Source, Path.TableAdapter, false) = .empty,
 arena: Allocator,
 io: std.Io,
-include_dir: []const u8,
+include_dir: Path,
 top_expansion_buf: ExpandBuf = .empty,
 add_expansion_nl: usize = 0,
 @@ -132,7 +133,7 @@ fn defineBuiltin(pp: *Preprocessor, name: []const u8) !void {
     });
 }
-pub fn preprocess(pp: *Preprocessor, file_path: []const u8) !void {
+pub fn preprocess(pp: *Preprocessor, file_path: Path) !void {
     const source = try pp.addSourceFromPath(file_path);
     try pp.preprocessFile(source);
 }
 @@ -789,13 +790,9 @@ fn makeGeneratedToken(
     return pasted_token;
 }
-fn findInclude(
+fn findInclude(pp: *Preprocessor, filename: []const u8, includer_token: Token) !?Source {
-    pp: *Preprocessor,
-    filename: []const u8,
-    includer_token: Token,
-) !?Source {
     const other_file = pp.sources.values()[includer_token.source].path;
-    const dir = std.fs.path.dirname(other_file) orelse ".";
+    const dir: Path = other_file.dirname() orelse .cwd();
     if (try pp.checkIncludeDir(filename, dir)) |res| return res;
     return pp.checkIncludeDir(filename, pp.include_dir);
 @@ -804,31 +801,24 @@ fn findInclude(
 fn checkIncludeDir(
     pp: *Preprocessor,
     include_path: []const u8,
-    include_dir: []const u8,
+    include_dir: Path,
 ) !?Source {
-    const format = "{s}{c}{s}";
     var bfa_buf: [1024]u8 = undefined;
     var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.arena);
     const bfa = bfa_state.allocator();
-    const header_path = try std.fmt.allocPrint(bfa, format, .{
+    const header_path = try include_dir.join(bfa, include_path);
-        include_dir,
-        std.fs.path.sep,
-        include_path,
-    });
-    defer bfa.free(header_path);
     return pp.addSourceFromPath(header_path) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         else => return null,
     };
 }
-pub fn addSourceFromPath(pp: *Preprocessor, path: []const u8) !Source {
+pub fn addSourceFromPath(pp: *Preprocessor, path: Path) !Source {
     if (pp.sources.get(path)) |src| return src;
     try pp.sources.ensureUnusedCapacity(pp.arena, 1);
-    const contents = try std.Io.Dir.cwd().readFileAlloc(pp.io, path, pp.arena, .limited(std.math.maxInt(u32)));
+    const contents = try path.root_dir.handle.readFileAlloc(pp.io, path.sub_path, pp.arena, .limited(std.math.maxInt(u32)));
-    const duped_path = try pp.arena.dupe(u8, path);
+    const duped_path = try path.clone(pp.arena);
     const src: Source = .{
         .buf = contents,

src/libs/netbsd.zig+4-2

 @@ -406,8 +406,10 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     man.hash.add(target.abi);
     man.hash.add(target_version);
-    const full_abilists_path = try comp.dirs.zig_lib.join(arena, &.{abilists_path});
+    const abilists_index = try man.addFilePath(.{
-    const abilists_index = try man.addFile(full_abilists_path, abilists_max_size);
+        .root_dir = comp.dirs.zig_lib,
+        .sub_path = abilists_path,
+    }, abilists_max_size);
     if (try man.hit(prog_node)) {
         const digest = man.final();

src/libs/openbsd.zig+4-2

 @@ -327,8 +327,10 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     man.hash.add(target.abi);
     man.hash.add(target_version);
-    const full_abilists_path = try comp.dirs.zig_lib.join(arena, &.{abilists_path});
+    const abilists_index = try man.addFilePath(.{
-    const abilists_index = try man.addFile(full_abilists_path, abilists_max_size);
+        .root_dir = comp.dirs.zig_lib,
+        .sub_path = abilists_path,
+    }, abilists_max_size);
     if (try man.hit(prog_node)) {
         const digest = man.final();

src/link.zig+3-3

...	@@ -461,8 +461,8 @@ pub const File = struct {	...	@@ -461,8 +461,8 @@ pub const File = struct {
461	allow_undefined_version: bool,	461	allow_undefined_version: bool,
462	enable_new_dtags: ?bool,	462	enable_new_dtags: ?bool,
463	subsystem: ?std.zig.Subsystem,	463	subsystem: ?std.zig.Subsystem,
464	linker_script: ?[]const u8,	464	linker_script: ?Path,
465	version_script: ?[]const u8,	465	version_script: ?Path,
466	soname: ?[]const u8,	466	soname: ?[]const u8,
467	print_gc_sections: bool,	467	print_gc_sections: bool,
468	print_icf_sections: bool,	468	print_icf_sections: bool,
...	@@ -493,7 +493,7 @@ pub const File = struct {	...	@@ -493,7 +493,7 @@ pub const File = struct {
493	/// Install name for the dylib	493	/// Install name for the dylib
494	install_name: ?[]const u8,	494	install_name: ?[]const u8,
495	/// Path to entitlements file	495	/// Path to entitlements file
496	entitlements: ?[]const u8,	496	entitlements: ?Path,
497	/// size of the __PAGEZERO segment	497	/// size of the __PAGEZERO segment
498	pagezero_size: ?u64,	498	pagezero_size: ?u64,
499	/// Set minimum space for future expansion of the load commands	499	/// Set minimum space for future expansion of the load commands

src/link/Dwarf.zig+1-1

...	@@ -4735,7 +4735,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError \|\| Writer.Err	...	@@ -4735,7 +4735,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError \|\| Writer.Err
4735	}	4735	}
4736		4736
4737	for (dwarf.mods.keys(), dwarf.mods.values()) \|mod, *mod_info\| {	4737	for (dwarf.mods.keys(), dwarf.mods.values()) \|mod, *mod_info\| {
4738	const root_dir_path = try mod.root.toAbsolute(zcu.comp.dirs, dwarf.gpa);	4738	const root_dir_path = try mod.root.toAbsolute(&zcu.comp.dirs, dwarf.gpa);
4739	defer dwarf.gpa.free(root_dir_path);	4739	defer dwarf.gpa.free(root_dir_path);
4740	mod_info.root_dir_path = try dwarf.debug_line_str.addString(dwarf, root_dir_path);	4740	mod_info.root_dir_path = try dwarf.debug_line_str.addString(dwarf, root_dir_path);
4741	}	4741	}

src/link/Lld.zig+4-4

...	@@ -75,8 +75,8 @@ pub const Elf = struct {	...	@@ -75,8 +75,8 @@ pub const Elf = struct {
75	entry_name: ?[]const u8,	75	entry_name: ?[]const u8,
76	hash_style: HashStyle,	76	hash_style: HashStyle,
77	image_base: u64,	77	image_base: u64,
78	linker_script: ?[]const u8,	78	linker_script: ?Cache.Path,
79	version_script: ?[]const u8,	79	version_script: ?Cache.Path,
80	sort_section: ?SortSection,	80	sort_section: ?SortSection,
81	print_icf_sections: bool,	81	print_icf_sections: bool,
82	print_map: bool,	82	print_map: bool,
...	@@ -930,7 +930,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {	...	@@ -930,7 +930,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
930		930
931	if (elf.linker_script) \|linker_script\| {	931	if (elf.linker_script) \|linker_script\| {
932	try argv.append("-T");	932	try argv.append("-T");
933	try argv.append(linker_script);	933	try argv.append(try linker_script.toString(arena));
934	}	934	}
935		935
936	if (elf.sort_section) \|how\| {	936	if (elf.sort_section) \|how\| {
...	@@ -1086,7 +1086,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {	...	@@ -1086,7 +1086,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void {
1086	}	1086	}
1087	if (elf.version_script) \|version_script\| {	1087	if (elf.version_script) \|version_script\| {
1088	try argv.append("-version-script");	1088	try argv.append("-version-script");
1089	try argv.append(version_script);	1089	try argv.append(try version_script.toString(arena));
1090	}	1090	}
1091	if (elf.allow_undefined_version) {	1091	if (elf.allow_undefined_version) {
1092	try argv.append("--undefined-version");	1092	try argv.append("--undefined-version");

src/link/MachO.zig+2-2

...	@@ -127,7 +127,7 @@ frameworks: []const Framework,	...	@@ -127,7 +127,7 @@ frameworks: []const Framework,
127	/// TODO: unify with soname	127	/// TODO: unify with soname
128	install_name: ?[]const u8,	128	install_name: ?[]const u8,
129	/// Path to entitlements file.	129	/// Path to entitlements file.
130	entitlements: ?[]const u8,	130	entitlements: ?Path,
131	compatibility_version: ?std.SemanticVersion,	131	compatibility_version: ?std.SemanticVersion,
132	/// Entry name	132	/// Entry name
133	entry_name: ?[]const u8,	133	entry_name: ?[]const u8,
...	@@ -580,7 +580,7 @@ pub fn flush(	...	@@ -580,7 +580,7 @@ pub fn flush(
580	var codesig = CodeSignature.init(self.getPageSize());	580	var codesig = CodeSignature.init(self.getPageSize());
581	codesig.code_directory.ident = fs.path.basename(self.base.emit.sub_path);	581	codesig.code_directory.ident = fs.path.basename(self.base.emit.sub_path);
582	if (self.entitlements) \|path\| codesig.addEntitlements(gpa, io, path) catch \|err\|	582	if (self.entitlements) \|path\| codesig.addEntitlements(gpa, io, path) catch \|err\|
583	return diags.fail("failed to add entitlements from {s}: {t}", .{ path, err });	583	return diags.fail("failed to add entitlements from {f}: {t}", .{ path, err });
584	try self.writeCodeSignaturePadding(&codesig);	584	try self.writeCodeSignaturePadding(&codesig);
585	break :blk codesig;	585	break :blk codesig;
586	} else null;	586	} else null;

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

...	@@ -246,8 +246,8 @@ pub fn deinit(self: *CodeSignature, allocator: Allocator) void {	...	@@ -246,8 +246,8 @@ pub fn deinit(self: *CodeSignature, allocator: Allocator) void {
246	}	246	}
247	}	247	}
248		248
249	pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, io: Io, path: []const u8) !void {	249	pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, io: Io, path: std.Build.Cache.Path) !void {
250	const inner = try Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(std.math.maxInt(u32)));	250	const inner = try path.root_dir.handle.readFileAlloc(io, path.sub_path, allocator, .limited(std.math.maxInt(u32)));
251	self.entitlements = .{ .inner = inner };	251	self.entitlements = .{ .inner = inner };
252	}	252	}
253		253

src/main.zig+52-52

 @@ -423,17 +423,16 @@ fn mainArgs(
                 .wasi => {},
                 else => process.executablePathAlloc(io, arena) catch |err| fatal("unable to find zig self exe path: {t}", .{err}),
             };
-            var dirs: std.zig.Directories = .init(
+            var dirs: std.zig.Directories = .init(arena, io, .{
-                arena,
+                .override_zig_lib = EnvVar.ZIG_LIB_DIR.get(environ_map),
-                io,
+                .override_global_cache = EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
-                EnvVar.ZIG_LIB_DIR.get(environ_map),
+                .build_root = null,
-                EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
+                .local_cache_strat = .global,
-                .global,
+                .preopens = preopens,
-                preopens,
+                .self_exe_path = self_exe_path,
-                self_exe_path,
+                .environ_map = environ_map,
-                environ_map,
+                .cwd = try std.zig.getResolvedCwd(io, arena),
-                try std.zig.getResolvedCwd(io, arena),
+            });
-            );
             defer dirs.deinit(io);
             const host = std.zig.resolveTargetQueryOrFatal(io, .{});
             var stdout_writer = Io.File.stdout().writer(io, &stdout_buffer);
 @@ -458,17 +457,16 @@ fn mainArgs(
                 .wasi => args[0],
                 else => process.executablePathAlloc(io, arena) catch |err| fatal("unable to find zig self exe path: {t}", .{err}),
             };
-            var dirs: std.zig.Directories = .init(
+            var dirs: std.zig.Directories = .init(arena, io, .{
-                arena,
+                .override_zig_lib = EnvVar.ZIG_LIB_DIR.get(environ_map),
-                io,
+                .override_global_cache = EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
-                EnvVar.ZIG_LIB_DIR.get(environ_map),
+                .build_root = null,
-                EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
+                .local_cache_strat = .global,
-                .global,
+                .preopens = preopens,
-                preopens,
+                .self_exe_path = if (native_os != .wasi) self_exe_path,
-                if (native_os != .wasi) self_exe_path,
+                .environ_map = environ_map,
-                environ_map,
+                .cwd = try std.zig.getResolvedCwd(io, arena),
-                try std.zig.getResolvedCwd(io, arena),
+            });
-            );
             defer dirs.deinit(io);
             const host = std.zig.resolveTargetQueryOrFatal(io, .{});
             var stdout_writer = Io.File.stdout().writer(io, &stdout_buffer);
 @@ -511,7 +509,7 @@ fn mainArgs(
     }
 }
-const usage_build_generic =
+const compile_usage =
     \\Usage: zig build-exe   [options] [files]
     \\       zig build-lib   [options] [files]
     \\       zig build-obj   [options] [files]
 @@ -565,16 +563,16 @@ const usage_build_generic =
     \\  --cache-dir [path]        Override the local cache directory
     \\  --global-cache-dir [path] Override the global cache directory
     \\  --zig-lib-dir [path]      Override path to Zig installation lib directory
+    \\  --build-root [path]       Override path to project source files
     \\
     \\Global Compile Options:
     \\  --name [name]             Compilation unit name (not a file path)
-    \\  --libc [file]             Provide a file which specifies libc paths
-    \\  -x language               Treat subsequent input files as having type <language>
-    \\  --dep [[import=]name]     Add an entry to the next module's import table
     \\  -M[name][=src]            Create a module based on the current per-module settings.
     \\                            The first module is the main module.
     \\                            "std" can be configured by omitting src
     \\                            After a -M argument, per-module settings are reset.
+    \\  --libc [file]             Provide a file which specifies libc paths
+    \\  -x [language]             Treat subsequent input files as having type <language>
     \\  --error-limit [num]       Set the maximum amount of distinct error values
     \\  -fllvm                    Force using LLVM as the codegen backend
     \\  -fno-llvm                 Prevent using LLVM as the codegen backend
 @@ -599,6 +597,7 @@ const usage_build_generic =
     \\  --time-report             Send timing diagnostics to '--listen' clients
     \\
     \\Per-Module Compile Options:
+    \\  --dep [[import=]name]     Add an entry to the next module's import table
     \\  -target [name]            <arch><sub>-<os>-<abi> see the targets command
     \\  -O [mode]                 Choose what to optimize for
     \\    debug (default)         Prioritize bug detection, accurate debug info, compilation speed
 @@ -1054,6 +1053,7 @@ fn buildOutputType(
     var rc_includes: std.zig.RcIncludes = .any;
     var manifest_file: ?[]const u8 = null;
     var linker_export_symbol_names: std.ArrayList([]const u8) = .empty;
+    var build_root_path: ?[]const u8 = null;
     // Tracks the position in c_source_files which have already their owner populated.
     var c_source_files_owner_index: usize = 0;
 @@ -1167,7 +1167,7 @@ fn buildOutputType(
                         fatal("unable to read response file {q}: {t}", .{ resp_file_path, err });
                 } else if (mem.startsWith(u8, arg, "-")) {
                     if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                        try Io.File.stdout().writeStreamingAll(io, usage_build_generic);
+                        try Io.File.stdout().writeStreamingAll(io, compile_usage);
                         return cleanExit(io);
                     } else if (mem.eql(u8, arg, "--")) {
                         if (arg_mode == .run) {
 @@ -1440,6 +1440,8 @@ fn buildOutputType(
                         override_global_cache_dir = args_iter.nextOrFatal();
                     } else if (mem.eql(u8, arg, "--zig-lib-dir")) {
                         override_lib_dir = args_iter.nextOrFatal();
+                    } else if (mem.eql(u8, arg, "--build-root")) {
+                        build_root_path = args_iter.nextOrFatal();
                     } else if (mem.eql(u8, arg, "--debug-log")) {
                         try addDebugLog(arena, args_iter.nextOrFatal());
                     } else if (mem.eql(u8, arg, "--listen")) {
 @@ -3254,23 +3256,22 @@ fn buildOutputType(
     const cwd_path = try std.zig.getResolvedCwd(io, arena);
     // This `init` calls `fatal` on error.
-    var dirs: std.zig.Directories = .init(
+    var dirs: std.zig.Directories = .init(arena, io, .{
-        arena,
+        .override_zig_lib = override_lib_dir,
-        io,
+        .override_global_cache = override_global_cache_dir,
-        override_lib_dir,
+        .build_root = build_root_path,
-        override_global_cache_dir,
+        .local_cache_strat = s: {
-        s: {
             if (override_local_cache_dir) |p| break :s .{ .override = p };
             break :s switch (arg_mode) {
                 .run => .global,
                 else => .search,
             };
         },
-        preopens,
+        .preopens = preopens,
-        self_exe_path,
+        .self_exe_path = self_exe_path,
-        environ_map,
+        .environ_map = environ_map,
-        cwd_path,
+        .cwd = cwd_path,
-    );
+    });
     defer dirs.deinit(io);
     if (linker_optimization) |o| warn("ignoring deprecated linker optimization setting {q}", .{o});
 @@ -3666,8 +3667,8 @@ fn buildOutputType(
         .want_compiler_rt = if (zig_cc_explicitly_link_compiler_rt) true else want_compiler_rt,
         .want_ubsan_rt = want_ubsan_rt,
         .hash_style = hash_style,
-        .linker_script = linker_script,
+        .linker_script = if (linker_script) |p| .initCwd(p) else null,
-        .version_script = version_script,
+        .version_script = if (version_script) |p| .initCwd(p) else null,
         .linker_allow_undefined_version = linker_allow_undefined_version,
         .linker_enable_new_dtags = linker_enable_new_dtags,
         .disable_c_depfile = disable_c_depfile,
 @@ -3740,7 +3741,7 @@ fn buildOutputType(
         .debug_incremental = debug_incremental,
         .enable_link_snapshots = enable_link_snapshots,
         .install_name = install_name,
-        .entitlements = entitlements,
+        .entitlements = if (entitlements) |p| .initCwd(p) else null,
         .pagezero_size = pagezero_size,
         .headerpad_size = headerpad_size,
         .headerpad_max_install_names = headerpad_max_install_names,
 @@ -5020,17 +5021,16 @@ fn jitCmdInner(
     const cwd_path = try std.zig.getResolvedCwd(io, arena);
     // This `init` calls `fatal` on error.
-    var dirs: std.zig.Directories = .init(
+    var dirs: std.zig.Directories = .init(arena, io, .{
-        arena,
+        .override_zig_lib = override_lib_dir,
-        io,
+        .override_global_cache = override_global_cache_dir,
-        override_lib_dir,
+        .build_root = null,
-        override_global_cache_dir,
+        .local_cache_strat = .global,
-        .global,
+        .preopens = preopens,
-        preopens,
+        .self_exe_path = self_exe_path,
-        self_exe_path,
+        .environ_map = environ_map,
-        environ_map,
+        .cwd = cwd_path,
-        cwd_path,
+    });
-    );
     defer dirs.deinit(io);
     var child_argv: std.ArrayList([]const u8) = .empty;

tools/check_mingw.zig+2-2

...	@@ -71,11 +71,11 @@ pub fn main(init: std.process.Init) !void {	...	@@ -71,11 +71,11 @@ pub fn main(init: std.process.Init) !void {
71	var pp: Preprocessor = .{	71	var pp: Preprocessor = .{
72	.io = io,	72	.io = io,
73	.arena = pp_arena,	73	.arena = pp_arena,
74	.include_dir = mingw_include_path,	74	.include_dir = .initCwd(mingw_include_path),
75	.target = target,	75	.target = target,
76	};	76	};
77		77
78	pp.preprocess(file_path) catch \|err\| {	78	pp.preprocess(.initCwd(file_path)) catch \|err\| {
79	std.log.err("error preprocessing file {s} for target {t}: {t}", .{ entry.path, target.cpu.arch, err });	79	std.log.err("error preprocessing file {s} for target {t}: {t}", .{ entry.path, target.cpu.arch, err });
80	fail = true;	80	fail = true;
81	continue;	81	continue;

author	Andrew Kelley <andrew@ziglang.org> 2026-08-20 11:25:43+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-08-20 11:25:43+02:00
log	73b010e2216331b0b87240b05ea061294749383b
tree	c7d08b440f359918ca3842eecb5e026a952d8c0e
parent	efd227eca2e2013b4e540ab2ba44664668a5253b
parent	5ee54cd52ad5f03ce24ec8c0ffee35972df3a5f3

...	@@ -614,6 +614,8 @@ pub fn main(init: process.Init.Minimal) !void {	...	@@ -614,6 +614,8 @@ pub fn main(init: process.Init.Minimal) !void {
614	comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib));	614	comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib));
615	comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache));	615	comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache));
616	comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache));	616	comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache));
		617	comptime assert(4 == @backingInt(std.zig.Server.Message.PathPrefix.build_root));
		618	comptime assert(@typeInfo(std.zig.Server.Message.PathPrefix).@"enum".field_names.len == 5);
617		619
618	graph.cache.hash.addBytes(builtin.zig_version_string);	620	graph.cache.hash.addBytes(builtin.zig_version_string);
619		621
...	@@ -1118,6 +1120,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {	...	@@ -1118,6 +1120,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
1118	graph.zig_exe, "build-exe", //	1120	graph.zig_exe, "build-exe", //
1119	"--cache-dir", graph.local_cache_root.path orelse ".", //	1121	"--cache-dir", graph.local_cache_root.path orelse ".", //
1120	"--global-cache-dir", graph.global_cache_root.path orelse ".", //	1122	"--global-cache-dir", graph.global_cache_root.path orelse ".", //
		1123	"--build-root", graph.build_root_directory.path orelse ".", //
1121	"--zig-lib-dir", graph.zig_lib_directory.path orelse ".", //	1124	"--zig-lib-dir", graph.zig_lib_directory.path orelse ".", //
1122	"--name", configurer_exe_name, //	1125	"--name", configurer_exe_name, //
1123	"-fsingle-threaded", //	1126	"-fsingle-threaded", //
...	@@ -1412,7 +1415,6 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {	...	@@ -1412,7 +1415,6 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
1412		1415
1413	if (config_man) \|man\| {	1416	if (config_man) \|man\| {
1414	if (try man.hit(compile_prog_node)) {	1417	if (try man.hit(compile_prog_node)) {
1415	log.debug("configuration cache hit", .{});
1416	const digest = man.final();	1418	const digest = man.final();
1417	const path: Path = .{	1419	const path: Path = .{
1418	.root_dir = graph.local_cache_root,	1420	.root_dir = graph.local_cache_root,
...	@@ -1422,6 +1424,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {	...	@@ -1422,6 +1424,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig {
1422	break :cp .{ path, man.toOwnedLock() };	1424	break :cp .{ path, man.toOwnedLock() };
1423	}	1425	}
1424	}	1426	}
		1427	try graph.handleVerbose(null, null, build_configurer_argv.items);
1425	const configure_exe_path: Path = if (std.zig.buildExeSubprocess(gpa, io, .{	1428	const configure_exe_path: Path = if (std.zig.buildExeSubprocess(gpa, io, .{
1426	.argv = build_configurer_argv.items,	1429	.argv = build_configurer_argv.items,
1427	.cache_root = graph.local_cache_root,	1430	.cache_root = graph.local_cache_root,

Merge pull request 'make frontend and build system more resistant to absolute paths' (#36548) from absolutely-not into master