Commit d48611ba67c7871cb348f28a01b89d8771170dd8 | zig

author	Alex Rønne Petersen <alex@alexrp.com> 2024-12-12 18:55:15+01:00
committer	GitHub <noreply@github.com> 2024-12-12 18:55:15+01:00
log	d48611ba67c7871cb348f28a01b89d8771170dd8
tree	3358b3d4d11269aa645121b8b218f0e0f9398d90
parent	3f7b3daaa0a10cfe9eeeb42509abfbf851725741
parent	9293e040ecfc7f12ca3eac59da80324cf592b3fd
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #22090 from alexrp/glibc-runtime-triples

Add `std.zig.target.glibcRuntimeTriple()` and use it in `std.Build.Step.Run` and `process_headers.zig`

4 files changed, 124 insertions(+), 90 deletions(-)

lib
- std
  - Build
    Step
    Run.zig
  - Target.zig
  - zig
    target.zig
tools
- process_headers.zig

lib/std/Build/Step/Run.zig+13-19

...	...	@@ -1009,7 +1009,8 @@ fn runCommand(
1009	1009	else => break :interpret,
1010	1010	}
1011	1011
1012		const need_cross_glibc = exe.rootModuleTarget().isGnuLibC() and
	1012	const root_target = exe.rootModuleTarget();
	1013	const need_cross_glibc = root_target.isGnuLibC() and
1013	1014	exe.is_linking_libc;
1014	1015	const other_target = exe.root_module.resolved_target.?.result;
1015	1016	switch (std.zig.system.getExternalExecutor(b.graph.host.result, &other_target, .{
...	...	@@ -1039,23 +1040,16 @@ fn runCommand(
1039	1040	try interp_argv.append(bin_name);
1040	1041
1041	1042	if (glibc_dir_arg) \|dir\| {
1042		// TODO look into making this a call to `linuxTriple`. This
1043		// needs the directory to be called "i686" rather than
1044		// "x86" which is why we do it manually here.
1045		const fmt_str = "{s}" ++ fs.path.sep_str ++ "{s}-{s}-{s}";
1046		const cpu_arch = exe.rootModuleTarget().cpu.arch;
1047		const os_tag = exe.rootModuleTarget().os.tag;
1048		const abi = exe.rootModuleTarget().abi;
1049		const cpu_arch_name: []const u8 = if (cpu_arch == .x86)
1050		"i686"
1051		else
1052		@tagName(cpu_arch);
1053		const full_dir = try std.fmt.allocPrint(b.allocator, fmt_str, .{
1054		dir, cpu_arch_name, @tagName(os_tag), @tagName(abi),
1055		});
1056
1057	1043	try interp_argv.append("-L");
1058		try interp_argv.append(full_dir);
	1044	try interp_argv.append(b.pathJoin(&.{
	1045	dir,
	1046	try std.zig.target.glibcRuntimeTriple(
	1047	b.allocator,
	1048	root_target.cpu.arch,
	1049	root_target.os.tag,
	1050	root_target.abi,
	1051	),
	1052	}));
1059	1053	}
1060	1054
1061	1055	try interp_argv.appendSlice(argv);
...	...	@@ -1113,7 +1107,7 @@ fn runCommand(
1113	1107	if (allow_skip) return error.MakeSkipped;
1114	1108
1115	1109	const host_name = try b.graph.host.result.zigTriple(b.allocator);
1116		const foreign_name = try exe.rootModuleTarget().zigTriple(b.allocator);
	1110	const foreign_name = try root_target.zigTriple(b.allocator);
1117	1111
1118	1112	return step.fail("the host system ({s}) is unable to execute binaries from the target ({s})", .{
1119	1113	host_name, foreign_name,
...	...	@@ -1121,7 +1115,7 @@ fn runCommand(
1121	1115	},
1122	1116	}
1123	1117
1124		if (exe.rootModuleTarget().os.tag == .windows) {
	1118	if (root_target.os.tag == .windows) {
1125	1119	// On Windows we don't have rpaths so we have to add .dll search paths to PATH
1126	1120	run.addPathForDynLibs(exe);
1127	1121	}

lib/std/Target.zig+8

...	...	@@ -2013,6 +2013,14 @@ pub fn zigTriple(target: Target, allocator: Allocator) Allocator.Error![]u8 {
2013	2013	return Query.fromTarget(target).zigTriple(allocator);
2014	2014	}
2015	2015
	2016	pub fn hurdTupleSimple(allocator: Allocator, arch: Cpu.Arch, abi: Abi) ![]u8 {
	2017	return std.fmt.allocPrint(allocator, "{s}-{s}", .{ @tagName(arch), @tagName(abi) });
	2018	}
	2019
	2020	pub fn hurdTuple(target: Target, allocator: Allocator) ![]u8 {
	2021	return hurdTupleSimple(allocator, target.cpu.arch, target.abi);
	2022	}
	2023
2016	2024	pub fn linuxTripleSimple(allocator: Allocator, arch: Cpu.Arch, os_tag: Os.Tag, abi: Abi) ![]u8 {
2017	2025	return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ @tagName(arch), @tagName(os_tag), @tagName(abi) });
2018	2026	}

lib/std/zig/target.zig+48-19

...	...	@@ -4,8 +4,10 @@ pub const ArchOsAbi = struct {
4	4	abi: std.Target.Abi,
5	5	os_ver: ?std.SemanticVersion = null,
6	6
7		// Minimum glibc version that provides support for the arch/os when ABI is GNU.
	7	/// Minimum glibc version that provides support for the arch/os when ABI is GNU.
8	8	glibc_min: ?std.SemanticVersion = null,
	9	/// Override for `glibcRuntimeTriple` when glibc has an unusual directory name for the target.
	10	glibc_triple: ?[]const u8 = null,
9	11	};
10	12
11	13	pub const available_libcs = [_]ArchOsAbi{
...	...	@@ -29,44 +31,44 @@ pub const available_libcs = [_]ArchOsAbi{
29	31	.{ .arch = .aarch64, .os = .windows, .abi = .gnu },
30	32	.{ .arch = .aarch64_be, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 17, .patch = 0 } },
31	33	.{ .arch = .aarch64_be, .os = .linux, .abi = .musl },
32		.{ .arch = .csky, .os = .linux, .abi = .gnueabi, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 } },
33		.{ .arch = .csky, .os = .linux, .abi = .gnueabihf, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 } },
34		.{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
35		.{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
	34	.{ .arch = .csky, .os = .linux, .abi = .gnueabi, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 }, .glibc_triple = "csky-linux-gnuabiv2-soft" },
	35	.{ .arch = .csky, .os = .linux, .abi = .gnueabihf, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 }, .glibc_triple = "csky-linux-gnuabiv2" },
	36	.{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnu-lp64d" },
	37	.{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 }, .glibc_triple = "loongarch64-linux-gnu-lp64s" },
36	38	.{ .arch = .loongarch64, .os = .linux, .abi = .musl },
37	39	.{ .arch = .m68k, .os = .linux, .abi = .gnu },
38	40	.{ .arch = .m68k, .os = .linux, .abi = .musl },
39		.{ .arch = .mips, .os = .linux, .abi = .gnueabi },
40		.{ .arch = .mips, .os = .linux, .abi = .gnueabihf },
	41	.{ .arch = .mips, .os = .linux, .abi = .gnueabi, .glibc_triple = "mips-linux-gnu-soft" },
	42	.{ .arch = .mips, .os = .linux, .abi = .gnueabihf, .glibc_triple = "mips-linux-gnu" },
41	43	.{ .arch = .mips, .os = .linux, .abi = .musleabi },
42	44	.{ .arch = .mips, .os = .linux, .abi = .musleabihf },
43		.{ .arch = .mipsel, .os = .linux, .abi = .gnueabi },
44		.{ .arch = .mipsel, .os = .linux, .abi = .gnueabihf },
	45	.{ .arch = .mipsel, .os = .linux, .abi = .gnueabi, .glibc_triple = "mipsel-linux-gnu-soft" },
	46	.{ .arch = .mipsel, .os = .linux, .abi = .gnueabihf, .glibc_triple = "mipsel-linux-gnu" },
45	47	.{ .arch = .mipsel, .os = .linux, .abi = .musleabi },
46	48	.{ .arch = .mipsel, .os = .linux, .abi = .musleabihf },
47		.{ .arch = .mips64, .os = .linux, .abi = .gnuabi64 },
48		.{ .arch = .mips64, .os = .linux, .abi = .gnuabin32 },
	49	.{ .arch = .mips64, .os = .linux, .abi = .gnuabi64, .glibc_triple = "mips64-linux-gnu-n64" },
	50	.{ .arch = .mips64, .os = .linux, .abi = .gnuabin32, .glibc_triple = "mips64-linux-gnu-n32" },
49	51	.{ .arch = .mips64, .os = .linux, .abi = .muslabi64 },
50	52	.{ .arch = .mips64, .os = .linux, .abi = .muslabin32 },
51		.{ .arch = .mips64el, .os = .linux, .abi = .gnuabi64 },
52		.{ .arch = .mips64el, .os = .linux, .abi = .gnuabin32 },
	53	.{ .arch = .mips64el, .os = .linux, .abi = .gnuabi64, .glibc_triple = "mips64el-linux-gnu-n64" },
	54	.{ .arch = .mips64el, .os = .linux, .abi = .gnuabin32, .glibc_triple = "mips64el-linux-gnu-n32" },
53	55	.{ .arch = .mips64el, .os = .linux, .abi = .muslabi64 },
54	56	.{ .arch = .mips64el, .os = .linux, .abi = .muslabin32 },
55		.{ .arch = .powerpc, .os = .linux, .abi = .gnueabi },
56		.{ .arch = .powerpc, .os = .linux, .abi = .gnueabihf },
	57	.{ .arch = .powerpc, .os = .linux, .abi = .gnueabi, .glibc_triple = "powerpc-linux-gnu-soft" },
	58	.{ .arch = .powerpc, .os = .linux, .abi = .gnueabihf, .glibc_triple = "powerpc-linux-gnu" },
57	59	.{ .arch = .powerpc, .os = .linux, .abi = .musleabi },
58	60	.{ .arch = .powerpc, .os = .linux, .abi = .musleabihf },
59	61	.{ .arch = .powerpc64, .os = .linux, .abi = .gnu },
60	62	.{ .arch = .powerpc64, .os = .linux, .abi = .musl },
61	63	.{ .arch = .powerpc64le, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 19, .patch = 0 } },
62	64	.{ .arch = .powerpc64le, .os = .linux, .abi = .musl },
63		.{ .arch = .riscv32, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 33, .patch = 0 } },
	65	.{ .arch = .riscv32, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 33, .patch = 0 }, .glibc_triple = "riscv32-linux-gnu-rv32imafdc-ilp32d" },
64	66	.{ .arch = .riscv32, .os = .linux, .abi = .musl },
65		.{ .arch = .riscv64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 27, .patch = 0 } },
	67	.{ .arch = .riscv64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 27, .patch = 0 }, .glibc_triple = "riscv64-linux-gnu-rv64imafdc-lp64d" },
66	68	.{ .arch = .riscv64, .os = .linux, .abi = .musl },
67	69	.{ .arch = .s390x, .os = .linux, .abi = .gnu },
68	70	.{ .arch = .s390x, .os = .linux, .abi = .musl },
69		.{ .arch = .sparc, .os = .linux, .abi = .gnu },
	71	.{ .arch = .sparc, .os = .linux, .abi = .gnu, .glibc_triple = "sparcv9-linux-gnu" },
70	72	.{ .arch = .sparc64, .os = .linux, .abi = .gnu },
71	73	.{ .arch = .wasm32, .os = .freestanding, .abi = .musl },
72	74	.{ .arch = .wasm32, .os = .wasi, .abi = .musl },
...	...	@@ -74,7 +76,7 @@ pub const available_libcs = [_]ArchOsAbi{
74	76	.{ .arch = .x86, .os = .linux, .abi = .musl },
75	77	.{ .arch = .x86, .os = .windows, .abi = .gnu },
76	78	.{ .arch = .x86_64, .os = .linux, .abi = .gnu },
77		.{ .arch = .x86_64, .os = .linux, .abi = .gnux32 },
	79	.{ .arch = .x86_64, .os = .linux, .abi = .gnux32, .glibc_triple = "x86_64-linux-gnu-x32" },
78	80	.{ .arch = .x86_64, .os = .linux, .abi = .musl },
79	81	.{ .arch = .x86_64, .os = .linux, .abi = .muslx32 },
80	82	.{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 10, .minor = 7, .patch = 0 } },
...	...	@@ -100,6 +102,31 @@ pub fn canBuildLibC(target: std.Target) bool {
100	102	return false;
101	103	}
102	104
	105	/// Returns the subdirectory triple to be used to find the correct glibc for the given `arch`, `os`,
	106	/// and `abi` in an installation directory created by glibc's `build-many-glibcs.py` script.
	107	///
	108	/// `os` must be `.linux` or `.hurd`. `abi` must be a GNU ABI, i.e. `.isGnu()`.
	109	pub fn glibcRuntimeTriple(
	110	allocator: Allocator,
	111	arch: std.Target.Cpu.Arch,
	112	os: std.Target.Os.Tag,
	113	abi: std.Target.Abi,
	114	) Allocator.Error![]const u8 {
	115	assert(abi.isGnu());
	116
	117	for (available_libcs) \|libc\| {
	118	if (libc.arch == arch and libc.os == os and libc.abi == abi) {
	119	if (libc.glibc_triple) \|triple\| return allocator.dupe(u8, triple);
	120	}
	121	}
	122
	123	return switch (os) {
	124	.hurd => std.Target.hurdTupleSimple(allocator, arch, abi),
	125	.linux => std.Target.linuxTripleSimple(allocator, arch, os, abi),
	126	else => unreachable,
	127	};
	128	}
	129
103	130	pub fn muslArchName(arch: std.Target.Cpu.Arch, abi: std.Target.Abi) [:0]const u8 {
104	131	return switch (abi) {
105	132	.muslabin32 => "mipsn32",
...	...	@@ -285,3 +312,5 @@ fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool {
285	312	}
286	313
287	314	const std = @import("std");
	315	const assert = std.debug.assert;
	316	const Allocator = std.mem.Allocator;

tools/process_headers.zig+55-52

...	...	@@ -18,62 +18,61 @@ const assert = std.debug.assert;
18	18	const Blake3 = std.crypto.hash.Blake3;
19	19
20	20	const LibCTarget = struct {
21		name: []const u8,
22	21	arch: Arch,
23	22	abi: Abi,
24	23	};
25	24
26	25	const glibc_targets = [_]LibCTarget{
27		.{ .name = "arc-linux-gnu", .arch = .arc, .abi = .gnu },
28		.{ .name = "arm-linux-gnueabi", .arch = .arm, .abi = .gnueabi },
29		.{ .name = "arm-linux-gnueabihf", .arch = .arm, .abi = .gnueabihf },
30		.{ .name = "armeb-linux-gnueabi", .arch = .armeb, .abi = .gnueabi },
31		.{ .name = "armeb-linux-gnueabihf", .arch = .armeb, .abi = .gnueabihf },
32		.{ .name = "aarch64-linux-gnu", .arch = .aarch64, .abi = .gnu },
33		.{ .name = "aarch64_be-linux-gnu", .arch = .aarch64_be, .abi = .gnu },
34		.{ .name = "csky-linux-gnuabiv2-soft", .arch = .csky, .abi = .gnueabi },
35		.{ .name = "csky-linux-gnuabiv2", .arch = .csky, .abi = .gnueabihf },
36		.{ .name = "loongarch64-linux-gnu-lp64d", .arch = .loongarch64, .abi = .gnu },
37		.{ .name = "loongarch64-linux-gnu-lp64s", .arch = .loongarch64, .abi = .gnusf },
38		.{ .name = "m68k-linux-gnu", .arch = .m68k, .abi = .gnu },
39		.{ .name = "mips-linux-gnu", .arch = .mips, .abi = .gnueabihf },
40		.{ .name = "mips-linux-gnu-soft", .arch = .mips, .abi = .gnueabi },
41		.{ .name = "mipsel-linux-gnu-soft", .arch = .mipsel, .abi = .gnueabi },
42		.{ .name = "mipsel-linux-gnu", .arch = .mipsel, .abi = .gnueabihf },
43		.{ .name = "mips64-linux-gnu-n64", .arch = .mips64, .abi = .gnuabi64 },
44		.{ .name = "mips64-linux-gnu-n32", .arch = .mips64, .abi = .gnuabin32 },
45		.{ .name = "mips64el-linux-gnu-n64", .arch = .mips64el, .abi = .gnuabi64 },
46		.{ .name = "mips64el-linux-gnu-n32", .arch = .mips64el, .abi = .gnuabin32 },
47		.{ .name = "powerpc-linux-gnu-soft", .arch = .powerpc, .abi = .gnueabi },
48		.{ .name = "powerpc-linux-gnu", .arch = .powerpc, .abi = .gnueabihf },
49		.{ .name = "powerpc64-linux-gnu", .arch = .powerpc64, .abi = .gnu },
50		.{ .name = "powerpc64le-linux-gnu", .arch = .powerpc64le, .abi = .gnu },
51		.{ .name = "riscv32-linux-gnu-rv32imafdc-ilp32d", .arch = .riscv32, .abi = .gnu },
52		.{ .name = "riscv64-linux-gnu-rv64imafdc-lp64d", .arch = .riscv64, .abi = .gnu },
53		.{ .name = "s390x-linux-gnu", .arch = .s390x, .abi = .gnu },
54		.{ .name = "sparcv9-linux-gnu", .arch = .sparc, .abi = .gnu },
55		.{ .name = "sparc64-linux-gnu", .arch = .sparc64, .abi = .gnu },
56		.{ .name = "i686-linux-gnu", .arch = .x86, .abi = .gnu },
57		.{ .name = "x86_64-linux-gnu", .arch = .x86_64, .abi = .gnu },
58		.{ .name = "x86_64-linux-gnu-x32", .arch = .x86_64, .abi = .gnux32 },
	26	.{ .arch = .arc, .abi = .gnu },
	27	.{ .arch = .arm, .abi = .gnueabi },
	28	.{ .arch = .arm, .abi = .gnueabihf },
	29	.{ .arch = .armeb, .abi = .gnueabi },
	30	.{ .arch = .armeb, .abi = .gnueabihf },
	31	.{ .arch = .aarch64, .abi = .gnu },
	32	.{ .arch = .aarch64_be, .abi = .gnu },
	33	.{ .arch = .csky, .abi = .gnueabi },
	34	.{ .arch = .csky, .abi = .gnueabihf },
	35	.{ .arch = .loongarch64, .abi = .gnu },
	36	.{ .arch = .loongarch64, .abi = .gnusf },
	37	.{ .arch = .m68k, .abi = .gnu },
	38	.{ .arch = .mips, .abi = .gnueabi },
	39	.{ .arch = .mips, .abi = .gnueabihf },
	40	.{ .arch = .mipsel, .abi = .gnueabi },
	41	.{ .arch = .mipsel, .abi = .gnueabihf },
	42	.{ .arch = .mips64, .abi = .gnuabi64 },
	43	.{ .arch = .mips64, .abi = .gnuabin32 },
	44	.{ .arch = .mips64el, .abi = .gnuabi64 },
	45	.{ .arch = .mips64el, .abi = .gnuabin32 },
	46	.{ .arch = .powerpc, .abi = .gnueabi },
	47	.{ .arch = .powerpc, .abi = .gnueabihf },
	48	.{ .arch = .powerpc64, .abi = .gnu },
	49	.{ .arch = .powerpc64le, .abi = .gnu },
	50	.{ .arch = .riscv32, .abi = .gnu },
	51	.{ .arch = .riscv64, .abi = .gnu },
	52	.{ .arch = .s390x, .abi = .gnu },
	53	.{ .arch = .sparc, .abi = .gnu },
	54	.{ .arch = .sparc64, .abi = .gnu },
	55	.{ .arch = .x86, .abi = .gnu },
	56	.{ .arch = .x86_64, .abi = .gnu },
	57	.{ .arch = .x86_64, .abi = .gnux32 },
59	58	};
60	59
61	60	const musl_targets = [_]LibCTarget{
62		.{ .name = "arm", .arch = .arm, .abi = .musl },
63		.{ .name = "aarch64", .arch = .aarch64, .abi = .musl },
64		.{ .name = "loongarch64", .arch = .loongarch64, .abi = .musl },
65		.{ .name = "m68k", .arch = .m68k, .abi = .musl },
66		.{ .name = "mips", .arch = .mips, .abi = .musl },
67		.{ .name = "mips64", .arch = .mips64, .abi = .musl },
68		.{ .name = "mipsn32", .arch = .mips64, .abi = .muslabin32 },
69		.{ .name = "powerpc", .arch = .powerpc, .abi = .musl },
70		.{ .name = "powerpc64", .arch = .powerpc64, .abi = .musl },
71		.{ .name = "riscv32", .arch = .riscv32, .abi = .musl },
72		.{ .name = "riscv64", .arch = .riscv64, .abi = .musl },
73		.{ .name = "s390x", .arch = .s390x, .abi = .musl },
74		.{ .name = "i386", .arch = .x86, .abi = .musl },
75		.{ .name = "x86_64", .arch = .x86_64, .abi = .musl },
76		.{ .name = "x32", .arch = .x86_64, .abi = .muslx32 },
	61	.{ .arch = .arm, .abi = .musl },
	62	.{ .arch = .aarch64, .abi = .musl },
	63	.{ .arch = .loongarch64, .abi = .musl },
	64	.{ .arch = .m68k, .abi = .musl },
	65	.{ .arch = .mips, .abi = .musl },
	66	.{ .arch = .mips64, .abi = .musl },
	67	.{ .arch = .mips64, .abi = .muslabin32 },
	68	.{ .arch = .powerpc, .abi = .musl },
	69	.{ .arch = .powerpc64, .abi = .musl },
	70	.{ .arch = .riscv32, .abi = .musl },
	71	.{ .arch = .riscv64, .abi = .musl },
	72	.{ .arch = .s390x, .abi = .musl },
	73	.{ .arch = .x86, .abi = .musl },
	74	.{ .arch = .x86_64, .abi = .musl },
	75	.{ .arch = .x86_64, .abi = .muslx32 },
77	76	};
78	77
79	78	const DestTarget = struct {
...	...	@@ -174,6 +173,10 @@ pub fn main() !void {
174	173	var hasher = Blake3.init(.{});
175	174
176	175	for (libc_targets) \|libc_target\| {
	176	const libc_dir = switch (vendor) {
	177	.glibc => try std.zig.target.glibcRuntimeTriple(allocator, libc_target.arch, .linux, libc_target.abi),
	178	.musl => std.zig.target.muslArchName(libc_target.arch, libc_target.abi),
	179	};
177	180	const dest_target = DestTarget{
178	181	.arch = libc_target.arch,
179	182	.os = .linux,
...	...	@@ -182,8 +185,8 @@ pub fn main() !void {
182	185
183	186	search: for (search_paths.items) \|search_path\| {
184	187	const sub_path = switch (vendor) {
185		.glibc => &[_][]const u8{ search_path, libc_target.name, "usr", "include" },
186		.musl => &[_][]const u8{ search_path, libc_target.name, "usr", "local", "musl", "include" },
	188	.glibc => &[_][]const u8{ search_path, libc_dir, "usr", "include" },
	189	.musl => &[_][]const u8{ search_path, libc_dir, "usr", "local", "musl", "include" },
187	190	};
188	191	const target_include_dir = try std.fs.path.join(allocator, sub_path);
189	192	var dir_stack = std.ArrayList([]const u8).init(allocator);
...	...	@@ -219,7 +222,7 @@ pub fn main() !void {
219	222	max_bytes_saved += raw_bytes.len;
220	223	gop.value_ptr.hit_count += 1;
221	224	std.debug.print("duplicate: {s} {s} ({:2})\n", .{
222		libc_target.name,
	225	libc_dir,
223	226	rel_path,
224	227	std.fmt.fmtIntSizeDec(raw_bytes.len),
225	228	});
...	...	@@ -246,7 +249,7 @@ pub fn main() !void {
246	249	}
247	250	break;
248	251	} else {
249		std.debug.print("warning: libc target not found: {s}\n", .{libc_target.name});
	252	std.debug.print("warning: libc target not found: {s}\n", .{libc_dir});
250	253	}
251	254	}
252	255	std.debug.print("summary: {:2} could be reduced to {:2}\n", .{