Fix failing extensive tests

Author: ItsMeSamey

build.zig

@@ -46,6 +46,17 @@ fn serializeForeignRun(run: *std.Build.Step.Run) void {
     foreign_run_serial = &run.step;
 }
 
+fn configureExternalHelperRunner(run: *std.Build.Step.Run, exe: *std.Build.Step.Compile) void {
+    // The helper tools (`testenv`, `parityenv`) are always built for the host.
+    // Tell them when the child program itself must be launched under an emulator
+    // so emulator-specific path/argv handling stays in the harness only.
+    switch (externalRunnerFor(exe)) {
+        .darling => run.setEnvironmentVariable("ZIGLIBC_EXTERNAL_RUNNER", "darling"),
+        .wine => run.setEnvironmentVariable("ZIGLIBC_EXTERNAL_RUNNER", "wine"),
+        .none => {},
+    }
+}
+
 fn addRunArtifactCompat(b: *std.Build, exe: *std.Build.Step.Compile) *std.Build.Step.Run {
     return switch (externalRunnerFor(exe)) {
         .none => b.addRunArtifact(exe),
@@ -66,7 +77,11 @@ fn addRunArtifactCompat(b: *std.Build, exe: *std.Build.Step.Compile) *std.Build.
                 \\err="$(mktemp)"
                 \\darling "$abs" "${mapped[@]}" 2>"$err"
                 \\rc=$?
-                \\grep -v -E '^sig:[0-9]+$' "$err" >&2 || true
+                \\# Darling sometimes emits host-side diagnostics for ioctls it does not
+                \\# translate, even when the target program completed successfully. Filter
+                \\# only those emulator-only lines here; never change libc behavior or
+                \\# native-test expectations to compensate for emulator chatter.
+                \\grep -v -E '^(sig:[0-9]+|Passing thru unhandled ioctl 0x[0-9a-fA-F]+ on fd [0-9]+)$' "$err" >&2 || true
                 \\rm -f "$err"
                 \\[ "$rc" -eq 0 ] || [ "$rc" -eq 127 ]
                 ,
@@ -209,13 +224,13 @@ pub fn build(b: *std.Build) void {
     const test_env_exe = addExecutableCompat(b, .{
         .name = "testenv",
         .root_source_file = lazyPath(b, "tools" ++ std.fs.path.sep_str ++ "testenv.zig"),
-        .target = target,
+        .target = b.graph.host,
         .optimize = optimize,
     });
     const parity_env_exe = addExecutableCompat(b, .{
         .name = "parityenv",
         .root_source_file = lazyPath(b, "tools" ++ std.fs.path.sep_str ++ "parityenv.zig"),
-        .target = target,
+        .target = b.graph.host,
         .optimize = optimize,
     });
 
@@ -255,24 +270,21 @@ pub fn build(b: *std.Build) void {
         if (externalRunnerFor(exe) != .darling) {
             const run_step = addRunArtifactCompat(b, test_env_exe);
             addArtifactArgCompat(run_step, b, exe);
+            configureExternalHelperRunner(run_step, exe);
             run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
             test_step.dependOn(&run_step.step);
         }
-        // Darling corrupts argv before our macOS-target getopt_long parser can
-        // even read argv[optind]. Keep native targets covering this surface;
-        // the emulator is not a reliable signal here.
+        // Darling still corrupts argv during the GNU long-option/argp path for
+        // this binary specifically. Keep native macOS covering the surface; the
+        // emulator is useful for the broader POSIX/socket/pthread regressions,
+        // but not as a trustworthy signal for this argv-heavy GNU test.
     }
     {
         const exe = addTest("socket_extensive", b, target, optimize, libc_only_std_static, zig_start);
         addPosix(exe, libc_only_posix);
-        if (externalRunnerFor(exe) != .darling) {
-            const run_step = addRunArtifactCompat(b, exe);
-            run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
-            test_step.dependOn(&run_step.step);
-        }
-        // Darling's socket layer is not a reliable stand-in for native Darwin.
-        // Keep this coverage on native targets instead of treating emulator
-        // failures as libc regressions.
+        const run_step = addRunArtifactCompat(b, exe);
+        run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
+        test_step.dependOn(&run_step.step);
     }
     {
         const exe = addExecutableCompat(b, .{
@@ -291,26 +303,27 @@ pub fn build(b: *std.Build) void {
             exe.linkSystemLibrary("kernel32");
         }
         if (externalRunnerFor(exe) != .darling) {
-            // This test uses Zig's own thread runtime to exercise our pthread
-            // mutex/cond ABI surface. Native macOS runs it fine, but Darling
-            // frequently returns 127 before `main`, which is a runner/runtime
-            // limitation rather than a libc semantic failure.
             const run_step = addRunArtifactCompat(b, exe);
             run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
             test_step.dependOn(&run_step.step);
         }
+        // Darling still falls over in Zig's threaded runtime before this test can
+        // reliably exercise `main()`. Keep native macOS covering pthread ABI
+        // behavior; the emulator remains useful for the other Darwin-target paths.
     }
     {
         const exe = addTest("fs", b, target, optimize, libc_only_std_static, zig_start);
         const run_step = addRunArtifactCompat(b, test_env_exe);
         addArtifactArgCompat(run_step, b, exe);
+        configureExternalHelperRunner(run_step, exe);
         run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
         test_step.dependOn(&run_step.step);
     }
     {
         const exe = addTest("format", b, target, optimize, libc_only_std_static, zig_start);
         const run_step = addRunArtifactCompat(b, test_env_exe);
         addArtifactArgCompat(run_step, b, exe);
+        configureExternalHelperRunner(run_step, exe);
         run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
         test_step.dependOn(&run_step.step);
     }
@@ -343,13 +356,15 @@ pub fn build(b: *std.Build) void {
         const exe = addTest("stdio_extensive", b, target, optimize, libc_only_std_static, zig_start);
         const run_step = addRunArtifactCompat(b, test_env_exe);
         addArtifactArgCompat(run_step, b, exe);
+        configureExternalHelperRunner(run_step, exe);
         run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
         test_step.dependOn(&run_step.step);
     }
     {
         const exe = addTest("panic_replacements", b, target, optimize, libc_only_std_static, zig_start);
         const run_step = addRunArtifactCompat(b, test_env_exe);
         addArtifactArgCompat(run_step, b, exe);
+        configureExternalHelperRunner(run_step, exe);
         run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
         test_step.dependOn(&run_step.step);
     }
@@ -359,9 +374,14 @@ pub fn build(b: *std.Build) void {
         if (externalRunnerFor(exe) != .darling) {
             const run_step = addRunArtifactCompat(b, test_env_exe);
             addArtifactArgCompat(run_step, b, exe);
+            configureExternalHelperRunner(run_step, exe);
             run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
             test_step.dependOn(&run_step.step);
         }
+        // Darling still has a non-deterministic startup/runtime fault on this
+        // large POSIX coverage binary even after the target libc paths were fixed.
+        // Keep native macOS as the source of truth for this surface; the emulator
+        // remains enabled for the narrower Darwin-target tests that are stable.
     }
     {
         const exe = addTest("getopt", b, target, optimize, libc_only_std_static, zig_start);
@@ -399,16 +419,17 @@ pub fn build(b: *std.Build) void {
         }
     }
 
-    const parity_run: ?*std.Build.Step.Run = if (externalRunnerForTarget(target.result) != .darling) blk: {
+    const parity_run: ?*std.Build.Step.Run = blk: {
         const system_exe = addSystemParityProbe(b, target, optimize);
         const zig_exe = addZigParityProbe(b, target, optimize, libc_only_std_static, zig_start, libc_only_posix);
         const run_step = addRunArtifactCompat(b, parity_env_exe);
         addArtifactArgCompat(run_step, b, system_exe);
         addArtifactArgCompat(run_step, b, zig_exe);
+        configureExternalHelperRunner(run_step, zig_exe);
         run_step.addCheck(.{ .expect_stdout_exact = "Success!\n" });
         test_step.dependOn(&run_step.step);
         break :blk run_step;
-    } else null;
+    };
 
     if (supportsSetjmp(target.result)) {
         const exe = addTest("jmp", b, target, optimize, libc_only_std_static, zig_start);

inc/posix/netinet/in.h

@@ -22,6 +22,9 @@ struct in_addr {
 #define INADDR_LOOPBACK ((in_addr_t)0x7f000001)
 
 struct sockaddr_in {
+#ifdef __APPLE__
+  uint8_t sin_len;
+#endif
   sa_family_t sin_family;
   unsigned short sin_port;
   struct in_addr sin_addr;

inc/posix/private/sa_family_t.h

@@ -1,6 +1,11 @@
 #ifndef _PRIVATE_SA_FAMILY_T_H
 #define _PRIVATE_SA_FAMILY_T_H
 
+#ifdef __APPLE__
+#include "../../libc/private/uint8_t.h"
+typedef uint8_t sa_family_t;
+#else
 typedef unsigned short sa_family_t;
+#endif
 
 #endif /* _PRIVATE_SA_FAMILY_T_H */

inc/posix/private/sockaddr.h

@@ -1,9 +1,13 @@
 #ifndef _PRIVATE_SOCKADDR_H
 #define _PRIVATE_SOCKADDR_H
 
+#include "../../libc/private/uint8_t.h"
 #include "sa_family_t.h"
 
 struct sockaddr {
+#ifdef __APPLE__
+  uint8_t sa_len;
+#endif
   sa_family_t sa_family;
   char sa_data[14];
 };

inc/posix/pthread.h

@@ -29,24 +29,57 @@
 typedef int pthread_attr_t;
 typedef int pthread_barrier_t;
 typedef int pthread_barrierattr_t;
+#ifdef __APPLE__
+#if defined(__LP64__)
+#define __ZIGLIBC_PTHREAD_MUTEX_SIZE 56
+#define __ZIGLIBC_PTHREAD_COND_SIZE 40
+#else
+#define __ZIGLIBC_PTHREAD_MUTEX_SIZE 40
+#define __ZIGLIBC_PTHREAD_COND_SIZE 24
+#endif
+typedef struct {
+  long __sig;
+  char __opaque[__ZIGLIBC_PTHREAD_COND_SIZE];
+} pthread_cond_t;
+#else
 typedef int pthread_cond_t;
+#endif
 typedef int pthread_condattr_t;
 typedef int pthread_key_t;
+#ifdef __APPLE__
+typedef struct {
+  long __sig;
+  char __opaque[__ZIGLIBC_PTHREAD_MUTEX_SIZE];
+} pthread_mutex_t;
+#else
 typedef int pthread_mutex_t;
+#endif
 typedef int pthread_mutexattr_t;
 typedef int pthread_once_t;
 typedef int pthread_rwlock_t;
 typedef int pthread_rwlockattr_t;
 typedef int pthread_spinlock_t;
 typedef int pthread_t;
 
+#ifdef __APPLE__
+#define _PTHREAD_MUTEX_SIG_init 0x32AAABA7L
+#define _PTHREAD_COND_SIG_init 0x3CB0B1BBL
+#define PTHREAD_MUTEX_INITIALIZER {_PTHREAD_MUTEX_SIG_init, {0}}
+int pthread_mutex_init(pthread_mutex_t *restrict, const pthread_mutexattr_t *restrict);
+int pthread_mutex_destroy(pthread_mutex_t *);
+int pthread_mutex_lock(pthread_mutex_t *);
+int pthread_mutex_unlock(pthread_mutex_t *);
+
+#define PTHREAD_COND_INITIALIZER {_PTHREAD_COND_SIG_init, {0}}
+#else
 #define PTHREAD_MUTEX_INITIALIZER 0
 int pthread_mutex_init(pthread_mutex_t *restrict, const pthread_mutexattr_t *restrict);
 int pthread_mutex_destroy(pthread_mutex_t *);
 int pthread_mutex_lock(pthread_mutex_t *);
 int pthread_mutex_unlock(pthread_mutex_t *);
 
 #define PTHREAD_COND_INITIALIZER 0
+#endif
 int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
 int pthread_cond_destroy(pthread_cond_t *cond);
 int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

inc/posix/sys/socket.h

@@ -14,7 +14,7 @@
 #define AF_INET 2
 #define PF_INET AF_INET
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__APPLE__)
 #define SOL_SOCKET 0xffff
 #define SO_KEEPALIVE 0x0008
 #define SO_SNDBUF 0x1001

inc/posix/termios.h

@@ -42,15 +42,17 @@ struct termios {
 int tcgetattr(int, struct termios *);
 int tcsetattr(int fildes, int optional_actions, const struct termios *termios_p);
 
-/* I think these definitions are specific to linux but go in termios.h */
-#if 1
+#if defined(__APPLE__)
+    #define TIOCGWINSZ 0x40087468
+#else
     #define TIOCGWINSZ 0x5413
-    struct winsize {
-        unsigned short ws_row;
-        unsigned short ws_col;
-        unsigned short ws_xpixel;
-        unsigned short ws_ypixel;
-    };    
 #endif
 
+struct winsize {
+    unsigned short ws_row;
+    unsigned short ws_col;
+    unsigned short ws_xpixel;
+    unsigned short ws_ypixel;
+};
+
 #endif /* _TERMIOS_H */

src/cstd.zig

@@ -1156,48 +1156,41 @@ export fn strerror(errnum: c_int) callconv(.c) [*:0]const u8 {
 // --------------------------------------------------------------------------------
 // signal
 // --------------------------------------------------------------------------------
-const SignalFn = switch (builtin.zig_backend) {
-    .stage1 => fn (c_int) callconv(.c) void,
-    // `SIG_ERR` is represented as `(void (*)(int))-1`, which is intentionally
-    // not guaranteed to satisfy function-pointer alignment.
-    else => *align(1) const fn (c_int) callconv(.c) void,
-};
-
-export fn signal(sig: c_int, func: SignalFn) callconv(.c) ?SignalFn {
-    const sig_err = @as(?SignalFn, @ptrFromInt(@as(usize, @bitCast(@as(isize, -1)))));
+fn _zsignalRaw(sig: c_int, func_ptr: usize) callconv(.c) usize {
+    const sig_err = @as(usize, @bitCast(@as(isize, -1)));
     if (builtin.os.tag == .windows) {
         var action = std.mem.zeroes(c.struct_sigaction);
-        action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(@intFromPtr(func)));
+        action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(func_ptr));
 
         var old_action = std.mem.zeroes(c.struct_sigaction);
         if (__zwindows_sigaction(sig, &action, &old_action) != 0) {
             return sig_err;
         }
         return if (old_action.sa_handler) |h|
-            @as(?SignalFn, @ptrFromInt(@intFromPtr(h)))
+            @intFromPtr(h)
         else
-            null;
+            0;
     }
     if (sig < 0 or sig > std.math.maxInt(u6)) {
         errno = c.EINVAL;
         return sig_err;
     }
     if (builtin.os.tag.isDarwin()) {
         var action = std.mem.zeroes(c.struct_sigaction);
-        action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(@intFromPtr(func)));
+        action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(func_ptr));
         action.sa_flags = @as(c_int, @bitCast(@as(c_uint, @intCast(std.posix.SA.RESTART))));
 
         var old_action = std.mem.zeroes(c.struct_sigaction);
         if (c.sigaction(sig, &action, &old_action) != 0) {
             return sig_err;
         }
         return if (old_action.sa_handler) |h|
-            @as(?SignalFn, @ptrFromInt(@intFromPtr(h)))
+            @intFromPtr(h)
         else
-            null;
+            0;
     }
     var action = std.mem.zeroes(c.struct_sigaction);
-    action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(@intFromPtr(func)));
+    action.sa_handler = @as(@TypeOf(action.sa_handler), @ptrFromInt(func_ptr));
     action.sa_flags = @as(c_int, @bitCast(@as(c_uint, @intCast(std.posix.SA.RESTART))));
 
     var old_action: std.posix.Sigaction = undefined;
@@ -1206,14 +1199,22 @@ export fn signal(sig: c_int, func: SignalFn) callconv(.c) ?SignalFn {
         @ptrCast(&action),
         &old_action,
     ))) {
-        .SUCCESS => return @as(?SignalFn, @ptrCast(old_action.handler.handler)),
+        .SUCCESS => return @intFromPtr(old_action.handler.handler),
         else => |e| {
             errno = @intFromEnum(e);
             return sig_err;
         },
     }
 }
 
+comptime {
+    if (builtin.target.ofmt == .coff) {
+        @export(&_zsignalRaw, .{ .name = "_zsignalRaw" });
+    } else {
+        @export(&_zsignalRaw, .{ .name = "_zsignalRaw", .visibility = .hidden });
+    }
+}
+
 // --------------------------------------------------------------------------------
 // stdio
 // --------------------------------------------------------------------------------

src/posix.c

@@ -127,13 +127,11 @@ static int zgnu_getopt_long_common(
 
 int __ziglibc_getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex)
 {
-    // Keep the long-option parser in C. The Zig version matched Linux but crashed
-    // in macOS-target/Darling runs before entering user-visible logic, which is
-    // consistent with a target-specific ABI/codegen issue rather than parser
-    // semantics. Export the standard GNU names for ABI compatibility, but keep
-    // the implementation under a private alias so our own macOS-target callers
-    // do not rely on Darling resolving the public symbol back into the same
-    // image correctly.
+    // Keep the long-option parser in C. This path needs a conservative C ABI
+    // surface because the earlier Zig implementation hit target-specific ABI /
+    // codegen problems before any parser semantics were observable. Export the
+    // standard GNU names for compatibility, but keep the implementation under a
+    // private alias so the public symbol remains a thin, stable entry point.
     return zgnu_getopt_long_common(argc, argv, optstring, longopts, longindex, 0);
 }