Commit 4dd645fdddec2c56f8eaabce9f358f95b54f8eec | zig

author	Jacob Young <jacobly@ziglang.org> 2026-09-25 12:20:18-04:00
committer	Jacob Young <jacobly@ziglang.org> 2026-09-26 19:08:50-04:00
log	4dd645fdddec2c56f8eaabce9f358f95b54f8eec
tree	d1ec373560e390e2f1d9a505478114713c857d79
parent	ee0bd6c69ee01caf076e5c9f7461fe09fa8cf9ba

Runner: add --libc-runtimes support

9 files changed, 285 insertions(+), 112 deletions(-)

lib
- compiler
  - Maker.zig
  - Maker
    Step.zig
    Step
    Run.zig
- std
  - Build.zig
  - Build
    Configuration.zig
  - Io.zig
  - Io
    Threaded.zig
test
- src
  - Runner.zig
- tests.zig

lib/compiler/Maker.zig+25-9

 @@ -3631,7 +3631,7 @@ pub fn resolveLazyPath(
     const c = &maker.scanned_config.configuration;
     return switch (lazy_path) {
         .source_path => |sp| try packagePath(maker, arena, sp.owner, sp.sub_path.slice(c)),
-        .relative => |relative| relativePath(maker, arena, relative),
+        .relative => |relative| try relativePath(maker, arena, relative, stepByIndex(maker, asking_step_index)),
         .generated => |gen| {
             const base = generatedPath(maker, gen.index);
             var file_path = base;
 @@ -3768,7 +3768,12 @@ pub fn packagePath(
     };
 }
-pub fn relativePath(maker: *const Maker, arena: Allocator, relative: Configuration.LazyPath.Relative) Allocator.Error!Path {
+pub fn relativePath(
+    maker: *const Maker,
+    arena: Allocator,
+    relative: Configuration.LazyPath.Relative,
+    asking_step: *Step,
+) error{ OutOfMemory, MakeFailed }!Path {
     const graph = maker.graph;
     const c = &maker.scanned_config.configuration;
     const sub_path = relative.sub_path.slice(c);
 @@ -3789,12 +3794,12 @@ pub fn relativePath(maker: *const Maker, arena: Allocator, relative: Configurati
             .root_dir = graph.build_root_directory,
             .sub_path = sub_path,
         },
-        .zig_exe => .{
+        .zig_exe => {
-            .root_dir = .cwd(),
+            assert(sub_path.len == 0);
-            .sub_path = if (sub_path.len == 0)
+            return .{
-                graph.zig_exe
+                .root_dir = .cwd(),
-            else
+                .sub_path = graph.zig_exe,
-                try Io.Dir.path.join(arena, &.{ graph.zig_exe, sub_path }),
+            };
         },
         .zig_lib => .{
             .root_dir = graph.zig_lib_directory,
 @@ -3804,6 +3809,10 @@ pub fn relativePath(maker: *const Maker, arena: Allocator, relative: Configurati
         .install_lib => try maker.install_paths.lib.join(arena, sub_path),
         .install_bin => try maker.install_paths.bin.join(arena, sub_path),
         .install_include => try maker.install_paths.include.join(arena, sub_path),
+        .libc_runtimes => if (maker.graph.libc_runtimes_dir) |libc_runtimes_dir| .{
+            .root_dir = .cwd(),
+            .sub_path = try Dir.path.join(arena, &.{ libc_runtimes_dir, sub_path }),
+        } else asking_step.fail(maker, "unknown LazyPath: \"--libc-runtimes\" not specified", .{}),
     };
 }
 @@ -4391,15 +4400,22 @@ fn confPathDepToCachePath(
                 else => |index| try Dir.path.join(arena, &.{ index.get(c).?.root_path.slice(c), sub_path }),
             },
         },
+        .zig_exe => {
+            assert(sub_path.len == 0);
+            return .{
+                .root_dir = .cwd(),
+                .sub_path = graph.zig_exe,
+            };
+        },
         .zig_lib => .{
             .root_dir = graph.zig_lib_directory,
             .sub_path = sub_path,
         },
-        .zig_exe => @panic("TODO"),
         .install_prefix => @panic("TODO"),
         .install_lib => @panic("TODO"),
         .install_bin => @panic("TODO"),
         .install_include => @panic("TODO"),
+        .libc_runtimes => @panic("TODO"),
     };
 }

lib/compiler/Maker/Step.zig+5-5

lib/compiler/Maker/Step/Run.zig+23-9

 @@ -250,9 +250,18 @@ pub fn make(
                         protocol_args.appendAssumeCapacity(0);
                     },
                     .path_file => {
+                        const lazy_path = arg.path.value.?.get(conf);
+                        switch (lazy_path) {
+                            else => {},
+                            .relative => |relative| switch (relative.flags.base) {
+                                else => {},
+                                .libc_runtimes => if (graph.libc_runtimes_dir == null) continue,
+                            },
+                        }
                         const prefix = if (arg.prefix.value) |p| p.slice(conf) else "";
                         const suffix = if (arg.suffix.value) |p| p.slice(conf) else "";
-                        const file_path = try maker.resolveLazyPathIndex(arena, arg.path.value.?, run_index);
+                        const file_path = try maker.resolveLazyPath(arena, lazy_path, run_index);
                         try owned_files.resize(gpa, owned_files.bit_length + 1, true);
                         try inherit_files.ensureUnusedCapacity(gpa, 1);
 @@ -283,9 +292,18 @@ pub fn make(
                         }
                     },
                     .path_directory => {
+                        const lazy_path = arg.path.value.?.get(conf);
+                        switch (lazy_path) {
+                            else => {},
+                            .relative => |relative| switch (relative.flags.base) {
+                                else => {},
+                                .libc_runtimes => if (graph.libc_runtimes_dir == null) continue,
+                            },
+                        }
                         const prefix = if (arg.prefix.value) |p| p.slice(conf) else "";
                         const suffix = if (arg.suffix.value) |p| p.slice(conf) else "";
-                        const dir_path = try maker.resolveLazyPathIndex(arena, arg.path.value.?, run_index);
+                        const dir_path = try maker.resolveLazyPath(arena, lazy_path, run_index);
                         try input_dirs.append(gpa, dir_path);
                         const has_sub_path = dir_path.sub_path.len > 0;
 @@ -2242,12 +2260,8 @@ fn runCommand(
                     else => builtin.target,
                 };
-                const need_cross_libc = config.flags.link_libc and root_target.os.tag == .linux and
+                const need_cross_libc = root_target.os.tag == .linux and
-                    switch (producer.flags2.linkage) {
+                    config.flags.link_libc and config.flags.link_mode == .dynamic;
-                        .static => false,
-                        .dynamic => true,
-                        .default => root_target.isGnuLibC(),
-                    };
                 switch (std.zig.system.getExternalExecutor(io, &root_target, .{
                     .host_cpu_arch = host.cpu.arch,
                     .host_os_tag = host.os.tag,
 @@ -2316,7 +2330,7 @@ fn runCommand(
                             interp_argv.appendAssumeCapacity(bin_name);
                             interp_argv.appendAssumeCapacity("--dir=.");
                             for (conf_run.preopens.slice) |preopen| {
-                                const path = try maker.resolveLazyPath(arena, preopen.path.get(conf), run_index);
+                                const path = try maker.resolveLazyPathIndex(arena, preopen.path, run_index);
                                 path.root_dir.handle.createDirPath(io, path.subPathOrDot()) catch |e|
                                     return step.fail(maker, "failed creating directory {f}: {t}", .{ path, e });
                                 interp_argv.appendAssumeCapacity(try arena.print("--dir={f}::{s}", .{ path, preopen.name.slice(conf) }));

lib/std/Build.zig+4-1

 @@ -2693,12 +2693,15 @@ fn validateConfigureDependency(lazy_path: LazyPath) void {
         .src_path, .cwd_relative, .dependency => {}, // OK
         .generated => @panic("configure phase cannot depend on files generated during make phase"),
         .relative => |relative| switch (relative.base) {
-            .cwd, .build_root, .local_cache, .global_cache, .zig_exe, .zig_lib => {}, // OK
+            .cwd, .build_root, .local_cache, .global_cache, .zig_lib => {}, // OK
+            .zig_exe => if (relative.sub_path.len > 0) @panic("file base cannot have a sub path"),
             .install_prefix,
             .install_lib,
             .install_bin,
             .install_include,
             => @panic("configure phase cannot depend on files installed during make phase"),
+            .libc_runtimes,
+            => @panic("configure phase cannot depend on directory known only during make phase"),
         },
     }
 }

lib/std/Build/Configuration.zig+1

...	@@ -1575,6 +1575,7 @@ pub const LazyPath = union(@This().Tag) {	...	@@ -1575,6 +1575,7 @@ pub const LazyPath = union(@This().Tag) {
1575	install_lib,	1575	install_lib,
1576	install_bin,	1576	install_bin,
1577	install_include,	1577	install_include,
		1578	libc_runtimes,
1578	};	1579	};
1579	};	1580	};
1580	};	1581	};

lib/std/Io.zig+12-8

 @@ -218,8 +218,8 @@ pub const VTable = struct {
     childKill: *const fn (?*anyopaque, *std.process.Child) void,
     progressParentFile: *const fn (?*anyopaque) std.Progress.ParentFileError!File,
-    inheritParentDir: *const fn (?*anyopaque, handle: Dir.Handle) (Cancelable || UnexpectedError)!Dir,
+    inheritParentDir: *const fn (?*anyopaque, handle: Dir.Handle) InheritParentHandleError!Dir,
-    inheritParentFile: *const fn (?*anyopaque, handle: File.Handle, flags: File.Flags) (Cancelable || UnexpectedError)!File,
+    inheritParentFile: *const fn (?*anyopaque, handle: File.Handle, flags: File.Flags) InheritParentHandleError!File,
     now: *const fn (?*anyopaque, Clock) Timestamp,
     clockResolution: *const fn (?*anyopaque, Clock) Clock.ResolutionError!Duration,
 @@ -827,6 +827,10 @@ pub const UnexpectedError = error{
     Unexpected,
 };
+pub const InheritParentHandleError = error{
+    UnsupportedOperation,
+} || Cancelable || UnexpectedError;
 pub const Clock = enum {
     /// A settable system-wide clock that measures real (i.e. wall-clock)
     /// time. This clock is affected by discontinuous jumps in the system
 @@ -2802,8 +2806,8 @@ pub const failing: std.Io = .{
         .childKill = unreachableChildKill,
         .progressParentFile = failingProgressParentFile,
-        .inheritParentDir = unreachableInheritParentDir,
+        .inheritParentDir = failingInheritParentDir,
-        .inheritParentFile = unreachableInheritParentFile,
+        .inheritParentFile = failingInheritParentFile,
         .random = noRandom,
         .randomSecure = failingRandomSecure,
 @@ -3474,17 +3478,17 @@ pub fn failingProgressParentFile(userdata: ?*anyopaque) std.Progress.ParentFileE
     return error.UnsupportedOperation;
 }
-pub fn unreachableInheritParentDir(userdata: ?*anyopaque, handle: Dir.Handle) (Cancelable || UnexpectedError)!Dir {
+pub fn failingInheritParentDir(userdata: ?*anyopaque, handle: Dir.Handle) InheritParentHandleError!Dir {
     _ = userdata;
     _ = handle;
-    unreachable;
+    return error.UnsupportedOperation;
 }
-pub fn unreachableInheritParentFile(userdata: ?*anyopaque, handle: File.Handle, flags: File.Flags) (Cancelable || UnexpectedError)!File {
+pub fn failingInheritParentFile(userdata: ?*anyopaque, handle: File.Handle, flags: File.Flags) InheritParentHandleError!File {
     _ = userdata;
     _ = handle;
     _ = flags;
-    unreachable;
+    return error.UnsupportedOperation;
 }
 pub fn noRandom(userdata: ?*anyopaque, buffer: []u8) void {

lib/std/Io/Threaded.zig+5-1

...	@@ -1975,6 +1975,10 @@ const have_copy_file_range = switch (native_os) {	...	@@ -1975,6 +1975,10 @@ const have_copy_file_range = switch (native_os) {
1975	.linux, .freebsd => true,	1975	.linux, .freebsd => true,
1976	else => false,	1976	else => false,
1977	};	1977	};
		1978	const have_fcntl = switch (native_os) {
		1979	.linux, .dragonfly, .freebsd, .netbsd, .openbsd, .illumos, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => true,
		1980	else => false,
		1981	};
1978	const have_fcopyfile = is_darwin;	1982	const have_fcopyfile = is_darwin;
1979	const have_fchmodat2 = native_os == .linux and	1983	const have_fchmodat2 = native_os == .linux and
1980	(builtin.os.isAtLeast(.linux, .{ .major = 6, .minor = 6, .patch = 0 }) orelse true) and	1984	(builtin.os.isAtLeast(.linux, .{ .major = 6, .minor = 6, .patch = 0 }) orelse true) and
...	@@ -17195,7 +17199,7 @@ pub fn posixExecveat(	...	@@ -17195,7 +17199,7 @@ pub fn posixExecveat(
17195	break :err posix.errno(posix.system.execve(p, argv, env_block.slice.ptr));	17199	break :err posix.errno(posix.system.execve(p, argv, env_block.slice.ptr));
17196	};	17200	};
17197	if (comptime native_os == .linux and (!builtin.link_libc or	17201	if (comptime native_os == .linux and (!builtin.link_libc or
17198	(builtin.target.abi.isGnu() and builtin.target.os.version_range.linux.glibc.order(	17202	(builtin.target.isGnuLibC() and builtin.target.os.version_range.linux.glibc.order(
17199	.{ .major = 2, .minor = 34, .patch = 0 },	17203	.{ .major = 2, .minor = 34, .patch = 0 },
17200	).compare(.gte))))	17204	).compare(.gte))))
17201	{	17205	{

test/src/Runner.zig+209-79

 @@ -22,10 +22,12 @@ const Args = struct {
     src_dir: ?std.Io.Dir,
     targets: std.ArrayList(u32),
     target_bytes: std.ArrayList(u8),
+    libc_runtimes_dir: ?std.Io.Dir,
+    enable_darling: bool,
     enable_qemu: bool,
-    enable_wine: bool,
+    enable_rosetta: bool,
     enable_wasmtime: bool,
-    enable_darling: bool,
+    enable_wine: bool,
     quiet: bool,
     fn deinit(args: *Args, gpa: std.mem.Allocator) void {
 @@ -73,7 +75,28 @@ pub fn runServer(runner: *Runner) ProtocolError {
             .args => {
                 const args_body = try arena.alloc(u8, hdr.bytes_len);
                 runner.server.in.readSliceAll(args_body) catch unreachable;
-                var state: enum { positional, zig, lib, src, target } = .positional;
+                const State = enum {
+                    positional,
+                    @"--zig",
+                    @"--lib",
+                    @"--src",
+                    @"--target",
+                    @"--libc-runtimes",
+                };
+                var state: State = .positional;
+                const state_expected: std.enums.EnumArray(State, enum {
+                    path,
+                    dir,
+                    file,
+                    string,
+                }) = .init(.{
+                    .positional = .path,
+                    .@"--zig" = .file,
+                    .@"--lib" = .dir,
+                    .@"--src" = .dir,
+                    .@"--target" = .string,
+                    .@"--libc-runtimes" = .dir,
+                });
                 var input_dir: std.zig.Server.Message.InputDir = .cwd;
                 var args_body_offset: usize = 0;
                 while (args_body.len - args_body_offset > 0) {
 @@ -87,42 +110,56 @@ pub fn runServer(runner: *Runner) ProtocolError {
                             args_body_offset = end + 1;
                             switch (state) {
                                 .positional => if (std.mem.eql(u8, string, "--target")) {
-                                    state = .target;
+                                    state = .@"--target";
                                     continue;
                                 } else if (std.mem.cutPrefix(u8, string, "--target=")) |target| {
                                     try runner.args.addTarget(runner.gpa, target);
+                                } else if (std.mem.eql(u8, string, "--libc-runtimes")) {
+                                    state = .@"--libc-runtimes";
+                                    continue;
+                                } else if (std.mem.eql(u8, string, "-fdarling")) {
+                                    runner.args.enable_darling = true;
                                 } else if (std.mem.eql(u8, string, "-fqemu")) {
                                     runner.args.enable_qemu = true;
-                                } else if (std.mem.eql(u8, string, "-fwine")) {
+                                } else if (std.mem.eql(u8, string, "-frosetta")) {
-                                    runner.args.enable_wine = true;
+                                    runner.args.enable_rosetta = true;
                                 } else if (std.mem.eql(u8, string, "-fwasmtime")) {
                                     runner.args.enable_wasmtime = true;
-                                } else if (std.mem.eql(u8, string, "-fdarling")) {
+                                } else if (std.mem.eql(u8, string, "-fwine")) {
-                                    runner.args.enable_darling = true;
+                                    runner.args.enable_wine = true;
                                 } else if (std.mem.eql(u8, string, "--quiet")) {
                                     runner.args.quiet = true;
                                 },
-                                .zig => unreachable,
+                                .@"--target" => try runner.args.addTarget(runner.gpa, string),
-                                .lib => unreachable,
+                                else => return runner.fail(
-                                .src => unreachable,
+                                    "\"{t}\" expected {t}, got {t}",
-                                .target => try runner.args.addTarget(runner.gpa, string),
+                                    .{ state, state_expected.get(state), arg },
+                                ),
                             }
                         },
                         .prefix => {
                             const end = std.mem.findScalarPos(u8, args_body, args_body_offset, 0).?;
                             const string = args_body[args_body_offset..end];
                             args_body_offset = end + 1;
+                            assert(state == .positional);
                             state = if (std.mem.eql(u8, string, "--zig="))
-                                .zig
+                                .@"--zig"
                             else if (std.mem.eql(u8, string, "--lib="))
-                                .lib
+                                .@"--lib"
                             else if (std.mem.eql(u8, string, "--src="))
-                                .src
+                                .@"--src"
+                            else if (std.mem.eql(u8, string, "--libc-runtimes="))
+                                .@"--libc-runtimes"
                             else
-                                unreachable;
+                                return runner.fail("unsupported arg prefix: {q}", .{string});
                             continue;
                         },
-                        .suffix => unreachable,
+                        .suffix => {
+                            const end = std.mem.findScalarPos(u8, args_body, args_body_offset, 0).?;
+                            const string = args_body[args_body_offset..end];
+                            args_body_offset = end + 1;
+                            return runner.fail("unsupported arg suffix: {q}", .{string});
+                        },
                         .input_dir => {
                             input_dir = @fromBackingInt(@backingInt(input_dir) + 1);
                             continue :arg .output_dir;
 @@ -137,16 +174,19 @@ pub fn runServer(runner: *Runner) ProtocolError {
                                 dir_handle.*,
                             ) catch |err| switch (err) {
                                 error.Canceled => |e| return e,
-                                error.Unexpected => |e| return runner.fail(
+                                else => |e| return runner.fail(
                                     "unable to inherit parent dir: {t}",
                                     .{e},
                                 ),
                             };
                             switch (state) {
                                 .positional => {
-                                    assert(runner.args.@"test" == null);
+                                    if (runner.args.@"test" != null or
+                                        runner.args.manifest_file != null) return runner.fail(
+                                        "{t} specified multiple times",
+                                        .{state},
+                                    );
                                     runner.args.@"test" = .{ .input_dir = input_dir, .dir = dir };
-                                    assert(runner.args.manifest_file == null);
                                     const manifest_path = "manifest";
                                     runner.args.manifest_file = dir.openFile(
                                         runner.io,
 @@ -161,16 +201,31 @@ pub fn runServer(runner: *Runner) ProtocolError {
                                     };
                                     try runner.discoverInput(input_dir, manifest_path);
                                 },
-                                .zig => unreachable,
+                                .@"--lib" => {
-                                .lib => {
+                                    if (runner.args.lib_dir != null) return runner.fail(
-                                    assert(runner.args.lib_dir == null);
+                                        "\"{t}\" specified multiple times",
+                                        .{state},
+                                    );
                                     runner.args.lib_dir = dir;
                                 },
-                                .src => {
+                                .@"--src" => {
-                                    assert(runner.args.src_dir == null);
+                                    if (runner.args.src_dir != null) return runner.fail(
+                                        "\"{t}\" specified multiple times",
+                                        .{state},
+                                    );
                                     runner.args.src_dir = dir;
                                 },
-                                .target => unreachable,
+                                .@"--libc-runtimes" => {
+                                    if (runner.args.libc_runtimes_dir != null) return runner.fail(
+                                        "\"{t}\" specified multiple times",
+                                        .{state},
+                                    );
+                                    runner.args.libc_runtimes_dir = dir;
+                                },
+                                else => return runner.fail(
+                                    "\"{t}\" expected {t}, got {t}",
+                                    .{ state, state_expected.get(state), arg },
+                                ),
                             }
                         },
                         .input_file, .input_file_content, .output_file => {
 @@ -184,23 +239,31 @@ pub fn runServer(runner: *Runner) ProtocolError {
                                 .{ .nonblocking = false },
                             ) catch |err| switch (err) {
                                 error.Canceled => |e| return e,
-                                error.Unexpected => |e| return runner.fail(
+                                else => |e| return runner.fail(
                                     "unable to inherit parent file: {t}",
                                     .{e},
                                 ),
                             };
                             switch (state) {
                                 .positional => {
-                                    assert(runner.args.manifest_file == null);
+                                    if (runner.args.@"test" != null or
+                                        runner.args.manifest_file != null) return runner.fail(
+                                        "{t} specified multiple times",
+                                        .{state},
+                                    );
                                     runner.args.manifest_file = file;
                                 },
-                                .zig => {
+                                .@"--zig" => {
-                                    assert(runner.args.zig_exe == null);
+                                    if (runner.args.zig_exe != null) return runner.fail(
+                                        "\"{t}\" specified multiple times",
+                                        .{state},
+                                    );
                                     runner.args.zig_exe = file;
                                 },
-                                .lib => unreachable,
+                                else => return runner.fail(
-                                .src => unreachable,
+                                    "\"{t}\" expected {t}, got {t}",
-                                .target => unreachable,
+                                    .{ state, state_expected.get(state), arg },
+                                ),
                             }
                         },
                     }
 @@ -480,7 +543,6 @@ fn testOne(runner: *Runner, test_index: u32) TestError!void {
         .target_query = target_query,
         .manifest_sr = .init(&manifest_fr.interface, runner.gpa, &runner.eb_wip, src_path_string: {
             var path_buffer: [std.Io.Dir.max_path_bytes]u8 = undefined;
             const src_path = src_path: {
                 break :src_path path_buffer[0 .. manifest_file.realPath(
                     runner.io,
 @@ -1022,6 +1084,7 @@ const Compiler = struct {
         const gpa = runner.gpa;
         const arena = runner.arena.allocator();
         const io = runner.io;
+        const target = &comp.target.resolved;
         const config = &comp.config.?;
         const out_dir = ".zig-cache" ++ std.Io.Dir.path.sep_str ++
             "o" ++ std.Io.Dir.path.sep_str ++ std.Build.Cache.binToHex(digest.*);
 @@ -1036,16 +1099,18 @@ const Compiler = struct {
             .stdout, .exit, .lldb => {},
         }
-        const executor = executor: switch (std.zig.system.getExternalExecutor(
+        var argv: std.ArrayList([]const u8) = .initBuffer(try arena.alloc([]const u8, 4));
-            io,
+        var environ_map: std.process.Environ.Map = .init(gpa);
-            &comp.target.resolved,
+        defer environ_map.deinit();
-            .{
+        const need_cross_libc =
-                .host_cpu_arch = runner.host.cpu.arch,
+            target.os.tag == .linux and config.flags.link_libc and config.flags.link_mode == .dynamic;
-                .host_os_tag = runner.host.os.tag,
+        const use_executor = use_executor: switch (std.zig.system.getExternalExecutor(io, target, .{
-                .link_mode = config.flags.link_mode,
+            .host_cpu_arch = runner.host.cpu.arch,
-                .link_libc = config.flags.link_libc,
+            .host_os_tag = runner.host.os.tag,
-            },
+            .qemu_fixes_dl = need_cross_libc and runner.args.libc_runtimes_dir != null,
-        )) {
+            .link_mode = config.flags.link_mode,
+            .link_libc = config.flags.link_libc,
+        })) {
             .bad_dl, .bad_os_or_cpu => {
                 // This binary cannot be executed on this host.
                 if (!runner.args.quiet) std.log.warn("skipping execution because host {q} cannot " ++
 @@ -1054,24 +1119,57 @@ const Compiler = struct {
                 });
                 return;
             },
-            .native, .rosetta => null,
+            .native => false,
-            .qemu => |executor| if (runner.args.enable_qemu)
+            .darling => |executor| if (runner.args.enable_darling) {
-                executor
+                argv.appendAssumeCapacity(executor);
-            else
+                break :use_executor true;
-                continue :executor .bad_os_or_cpu,
+            } else continue :use_executor .bad_os_or_cpu,
-            .wine => |executor| if (runner.args.enable_wine)
+            .qemu => |executor| if (runner.args.enable_qemu) {
-                executor
+                argv.appendAssumeCapacity(executor);
-            else
+                if (need_cross_libc) {
-                continue :executor .bad_os_or_cpu,
+                    const libc_runtimes_dir = runner.args.libc_runtimes_dir orelse
-            .wasmtime => |executor| if (runner.args.enable_wasmtime)
+                        continue :use_executor .bad_os_or_cpu;
-                executor
+                    var path_buffer: [std.Io.Dir.max_path_bytes]u8 = undefined;
-            else
+                    const libc_runtimes_path = path_buffer[0 .. libc_runtimes_dir.realPath(
-                continue :executor .bad_os_or_cpu,
+                        runner.io,
-            .darling => |executor| if (runner.args.enable_darling)
+                        &path_buffer,
-                executor
+                    ) catch |err| switch (err) {
+                        error.Canceled => |e| return e,
+                        else => |e| return runner.fail("unable to get libc runtimes path: {t}", .{e}),
+                    }];
+                    argv.appendSliceAssumeCapacity(&.{ "-L", try std.Io.Dir.path.join(arena, &.{
+                        libc_runtimes_path,
+                        try if (target.isGnuLibC()) std.zig.target.glibcRuntimeTriple(
+                            arena,
+                            target.cpu.arch,
+                            target.os.tag,
+                            target.abi,
+                        ) else if (target.isMuslLibC()) std.zig.target.muslRuntimeTriple(
+                            arena,
+                            target.cpu.arch,
+                            target.abi,
+                        ) else unreachable,
+                    }) });
+                }
+                break :use_executor true;
+            } else continue :use_executor .bad_os_or_cpu,
+            .rosetta => if (runner.args.enable_rosetta)
+                true
             else
-                continue :executor .bad_os_or_cpu,
+                continue :use_executor .bad_os_or_cpu,
+            .wine => |executor| if (runner.args.enable_wine) {
+                if (!environ_map.contains("WINEDEBUG")) try environ_map.put("WINEDEBUG", "-all");
+                argv.appendAssumeCapacity(executor);
+                break :use_executor true;
+            } else continue :use_executor .bad_os_or_cpu,
+            .wasmtime => |executor| if (runner.args.enable_wasmtime) {
+                if (!environ_map.contains("WASMTIME_BACKTRACE_DETAILS"))
+                    try environ_map.put("WASMTIME_BACKTRACE_DETAILS", "1");
+                argv.appendSliceAssumeCapacity(&.{ executor, "--dir=.", "-Sinherit-env" });
+                break :use_executor true;
+            } else continue :use_executor .bad_os_or_cpu,
         };
+        argv.appendAssumeCapacity(bin_path);
         var name_buffer: [std.Progress.Node.max_name_len]u8 = undefined;
         const run_prog_node = runner.prog_node.start(std.mem.print(&name_buffer, "run {s}", .{
 @@ -1088,11 +1186,12 @@ const Compiler = struct {
             .errors => unreachable,
             .stdout, .exit => {
                 const result = std.process.run(gpa, io, .{
-                    .exe = if (executor) |_| .search else .{ .file = bin_file },
+                    .exe = if (use_executor) .search else .{ .file = bin_file },
-                    .argv = if (executor) |e| &.{ e, bin_path } else &.{bin_path},
+                    .argv = argv.items,
                     .cwd = .{ .dir = src_dir },
+                    .environ_map = &environ_map,
                     .progress_node = run_prog_node,
-                }) catch |err| if (executor) |_| {
+                }) catch |err| if (use_executor) {
                     // Chances are the foreign executor isn't available. Skip this evaluation.
                     if (!runner.args.quiet) std.log.warn(
                         "skipping execution of {q} via executor for foreign target {q}: {t}",
 @@ -1151,7 +1250,7 @@ const Compiler = struct {
                         .{bin_path},
                     ),
                 }
-                if (executor == null and result.stderr.len > 0) {
+                if (!use_executor and result.stderr.len > 0) {
                     std.log.err("generated executable {q} had unexpected stderr:\n{s}", .{
                         bin_path, result.stderr,
                     });
 @@ -1257,10 +1356,12 @@ const ClientArgs = struct {
     src_dir: std.Io.Dir,
     targets: std.ArrayList([]const u8),
     keep_src: bool,
+    libc_runtimes_dir: ?std.Io.Dir,
+    enable_darling: bool,
     enable_qemu: bool,
+    enable_rosetta: bool,
     enable_wine: bool,
     enable_wasmtime: bool,
-    enable_darling: bool,
     quiet: bool,
 };
 pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelable)!u8 {
 @@ -1275,6 +1376,7 @@ pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelabl
     var test_path_arg: ?[]const u8 = null;
     var zig_path_arg: ?[]const u8 = null;
     var lib_path_arg: ?[]const u8 = null;
+    var libc_runtimes_path_arg: ?[]const u8 = null;
     var args: ClientArgs = .{
         .test_file = undefined,
         .test_kind = undefined,
 @@ -1283,10 +1385,12 @@ pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelabl
         .src_dir = undefined,
         .targets = .empty,
         .keep_src = false,
+        .libc_runtimes_dir = null,
+        .enable_darling = false,
         .enable_qemu = false,
+        .enable_rosetta = false,
         .enable_wine = false,
         .enable_wasmtime = false,
-        .enable_darling = false,
         .quiet = false,
     };
     defer args.targets.deinit(init.gpa);
 @@ -1312,10 +1416,12 @@ pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelabl
                     .src_dir = null,
                     .targets = .empty,
                     .target_bytes = .empty,
+                    .libc_runtimes_dir = null,
+                    .enable_darling = false,
                     .enable_qemu = false,
-                    .enable_wine = false,
+                    .enable_rosetta = false,
                     .enable_wasmtime = false,
-                    .enable_darling = false,
+                    .enable_wine = false,
                     .quiet = false,
                 },
                 .host = std.zig.system.resolveTargetQuery(init.io, .{}) catch |err| switch (err) {
 @@ -1361,18 +1467,24 @@ pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelabl
             try args.targets.append(init.gpa, try arena.dupe(u8, target));
         } else if (std.mem.eql(u8, arg, "--keep-src")) {
             args.keep_src = true;
+        } else if (std.mem.eql(u8, arg, "--libc-runtimes")) {
+            libc_runtimes_path_arg = arg_it.next() orelse fatal("missing arg after {q}", .{arg});
+        } else if (std.mem.cutPrefix(u8, arg, "--libc-runtimes=")) |libc_runtimes_path| {
+            libc_runtimes_path_arg = libc_runtimes_path;
+        } else if (std.mem.eql(u8, arg, "-fdarling")) {
+            args.enable_darling = true;
         } else if (std.mem.eql(u8, arg, "-fqemu")) {
             args.enable_qemu = true;
+        } else if (std.mem.eql(u8, arg, "-frosetta")) {
+            args.enable_rosetta = true;
         } else if (std.mem.eql(u8, arg, "-fwine")) {
             args.enable_wine = true;
         } else if (std.mem.eql(u8, arg, "-fwasmtime")) {
             args.enable_wasmtime = true;
-        } else if (std.mem.eql(u8, arg, "-fdarling")) {
-            args.enable_darling = true;
         } else if (std.mem.eql(u8, arg, "--quiet")) {
             args.quiet = true;
         } else {
-            if (test_path_arg) |_| fatal("unknown arg {q}", .{arg});
+            if (test_path_arg) |_| fatal("unexpected arg {q}", .{arg});
             test_path_arg = arg;
         }
     }
 @@ -1403,6 +1515,15 @@ pub fn main(init: std.process.Init) (std.mem.Allocator.Error || std.Io.Cancelabl
         else => |e| fatal("unable to open {q}: {t}", .{ lib_path, e }),
     };
     defer args.lib_dir.close(init.io);
+    if (libc_runtimes_path_arg) |libc_runtimes_path| args.libc_runtimes_dir = cwd.openDir(
+        init.io,
+        libc_runtimes_path,
+        .{},
+    ) catch |err| switch (err) {
+        error.Canceled => |e| return e,
+        else => |e| fatal("unable to open {q}: {t}", .{ lib_path, e }),
+    };
+    defer if (args.libc_runtimes_dir) |libc_runtimes_dir| libc_runtimes_dir.close(init.io);
     const src_dir_path = "src_" ++ std.fmt.hex(rand_int: {
         var rand_int: u64 = undefined;
 @@ -1479,21 +1600,18 @@ fn runClient(
     try argv.append(gpa, @backingInt(Arg.prefix));
     try argv.appendSlice(gpa, "--zig=");
     try argv.append(gpa, 0);
     try argv.append(gpa, @backingInt(Arg.input_file));
     try argv.appendSlice(gpa, @ptrCast(&args.zig_exe.handle));
     try argv.append(gpa, @backingInt(Arg.prefix));
     try argv.appendSlice(gpa, "--lib=");
     try argv.append(gpa, 0);
     try argv.append(gpa, @backingInt(Arg.input_dir));
     try argv.appendSlice(gpa, @ptrCast(&args.lib_dir.handle));
     try argv.append(gpa, @backingInt(Arg.prefix));
     try argv.appendSlice(gpa, "--src=");
     try argv.append(gpa, 0);
     try argv.append(gpa, @backingInt(Arg.output_dir));
     try argv.appendSlice(gpa, @ptrCast(&args.src_dir.handle));
 @@ -1507,11 +1625,28 @@ fn runClient(
         try argv.append(gpa, 0);
     }
+    if (args.libc_runtimes_dir) |libc_runtimes_dir| {
+        try argv.append(gpa, @backingInt(Arg.prefix));
+        try argv.appendSlice(gpa, "--libc-runtimes=");
+        try argv.append(gpa, 0);
+        try argv.append(gpa, @backingInt(Arg.input_dir));
+        try argv.appendSlice(gpa, @ptrCast(&libc_runtimes_dir.handle));
+    }
+    if (args.enable_darling) {
+        try argv.append(gpa, @backingInt(Arg.string));
+        try argv.appendSlice(gpa, "-fdarling");
+        try argv.append(gpa, 0);
+    }
     if (args.enable_qemu) {
         try argv.append(gpa, @backingInt(Arg.string));
         try argv.appendSlice(gpa, "-fqemu");
         try argv.append(gpa, 0);
     }
+    if (args.enable_rosetta) {
+        try argv.append(gpa, @backingInt(Arg.string));
+        try argv.appendSlice(gpa, "-frosetta");
+        try argv.append(gpa, 0);
+    }
     if (args.enable_wine) {
         try argv.append(gpa, @backingInt(Arg.string));
         try argv.appendSlice(gpa, "-fwine");
 @@ -1522,11 +1657,6 @@ fn runClient(
         try argv.appendSlice(gpa, "-fwasmtime");
         try argv.append(gpa, 0);
     }
-    if (args.enable_darling) {
-        try argv.append(gpa, @backingInt(Arg.string));
-        try argv.appendSlice(gpa, "-fdarling");
-        try argv.append(gpa, 0);
-    }
     if (args.quiet) {
         try argv.append(gpa, @backingInt(Arg.string));

test/tests.zig+1

...	@@ -3411,6 +3411,7 @@ pub fn addIncrementalTests(	...	@@ -3411,6 +3411,7 @@ pub fn addIncrementalTests(
3411	run.addArgs(&.{ "--target", target_str });	3411	run.addArgs(&.{ "--target", target_str });
3412	}	3412	}
3413		3413
		3414	run.addPrefixedDirectoryArg("--libc-runtimes=", .{ .relative = .{ .base = .libc_runtimes } });
3414	run.addThirdPartyEnabledArgDarling(.{ .enabled = "-fdarling" });	3415	run.addThirdPartyEnabledArgDarling(.{ .enabled = "-fdarling" });
3415	run.addThirdPartyEnabledArgQemu(.{ .enabled = "-fqemu" });	3416	run.addThirdPartyEnabledArgQemu(.{ .enabled = "-fqemu" });
3416	run.addThirdPartyEnabledArgRosetta(.{ .enabled = "-frosetta" });	3417	run.addThirdPartyEnabledArgRosetta(.{ .enabled = "-frosetta" });

...	@@ -857,7 +857,7 @@ pub fn setWatchInputsFromManifestFiles(	...	@@ -857,7 +857,7 @@ pub fn setWatchInputsFromManifestFiles(
857	}	857	}
858		858
859	/// For steps that have a single input that never changes when re-running `make`.	859	/// For steps that have a single input that never changes when re-running `make`.
860	pub fn singleUnchangingWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_path: LazyPath) Allocator.Error!void {	860	pub fn singleUnchangingWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_path: LazyPath) FailError!void {
861	if (!step.inputs.populated()) try step.addWatchInput(maker, arena, lazy_path);	861	if (!step.inputs.populated()) try step.addWatchInput(maker, arena, lazy_path);
862	}	862	}
863		863
...	@@ -866,7 +866,7 @@ pub fn clearWatchInputs(step: Step, maker: Maker) void {	...	@@ -866,7 +866,7 @@ pub fn clearWatchInputs(step: Step, maker: Maker) void {
866	}	866	}
867		867
868	/// Places a file dependency on the path.	868	/// Places a file dependency on the path.
869	pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: LazyPath) Allocator.Error!void {	869	pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: LazyPath) FailError!void {
870	const conf = &maker.scanned_config.configuration;	870	const conf = &maker.scanned_config.configuration;
871	switch (lazy_file) {	871	switch (lazy_file) {
872	.source_path => \|source_path\| {	872	.source_path => \|source_path\| {
...	@@ -875,7 +875,7 @@ pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: La	...	@@ -875,7 +875,7 @@ pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: La
875	try addWatchInputPath(step, maker, pkg_path);	875	try addWatchInputPath(step, maker, pkg_path);
876	},	876	},
877	.relative => \|relative\| {	877	.relative => \|relative\| {
878	const resolved_path = try maker.relativePath(arena, relative);	878	const resolved_path = try maker.relativePath(arena, relative, step);
879	try addWatchInputPath(step, maker, resolved_path);	879	try addWatchInputPath(step, maker, resolved_path);
880	},	880	},
881	// Nothing to watch because this dependency edge is modeled instead via `dependants`.	881	// Nothing to watch because this dependency edge is modeled instead via `dependants`.
...	@@ -890,7 +890,7 @@ pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: La	...	@@ -890,7 +890,7 @@ pub fn addWatchInput(step: Step, maker: Maker, arena: Allocator, lazy_file: La
890	/// Paths derived from this directory should also be manually added via	890	/// Paths derived from this directory should also be manually added via
891	/// `addDirectoryWatchInputFromPath` if and only if this function returns	891	/// `addDirectoryWatchInputFromPath` if and only if this function returns
892	/// `true`.	892	/// `true`.
893	pub fn addDirectoryWatchInput(step: Step, maker: Maker, lazy_directory: LazyPath) Allocator.Error!bool {	893	pub fn addDirectoryWatchInput(step: Step, maker: Maker, lazy_directory: LazyPath) FailError!bool {
894	const graph = maker.graph;	894	const graph = maker.graph;
895	const arena = graph.arena; // TODO don't leak into the process arena	895	const arena = graph.arena; // TODO don't leak into the process arena
896	switch (lazy_directory) {	896	switch (lazy_directory) {
...	@@ -901,7 +901,7 @@ pub fn addDirectoryWatchInput(step: Step, maker: Maker, lazy_directory: LazyPa	...	@@ -901,7 +901,7 @@ pub fn addDirectoryWatchInput(step: Step, maker: Maker, lazy_directory: LazyPa
901	try addDirectoryWatchInputFromPath(step, maker, pkg_path);	901	try addDirectoryWatchInputFromPath(step, maker, pkg_path);
902	},	902	},
903	.relative => \|relative\| {	903	.relative => \|relative\| {
904	const resolved_path = try maker.relativePath(arena, relative);	904	const resolved_path = try maker.relativePath(arena, relative, step);
905	try addDirectoryWatchInputFromPath(step, maker, resolved_path);	905	try addDirectoryWatchInputFromPath(step, maker, resolved_path);
906	},	906	},
907	// Nothing to watch because this dependency edge is modeled instead via `dependants`.	907	// Nothing to watch because this dependency edge is modeled instead via `dependants`.