Investigate zig build test failures

Author: ItsMeSamey

build.zig

@@ -845,13 +845,9 @@ fn addLibcTest(
     // strtol, it seems there might be some disagreement between libc-test/glibc
     // about how strtoul interprets negative numbers, so leaving out strtol for now
     inline for (.{ "argv", "basename", "clock_gettime", "string" }) |name| {
-        const source_path = if (externalRunnerForTarget(target.result) == .darling and std.mem.eql(u8, name, "string"))
-            "test" ++ std.fs.path.sep_str ++ "libc_test_functional_string_compat.c"
-        else
-            b.pathJoin(&.{ libc_test_path, "src", "functional", name ++ ".c" });
         const exe = addExecutableCompat(b, .{
             .name = "libc-test-functional-" ++ name,
-            .root_source_file = lazyPath(b, source_path),
+            .root_source_file = lazyPath(b, b.pathJoin(&.{ libc_test_path, "src", "functional", name ++ ".c" })),
             .target = target,
             .optimize = optimize,
         });

src/cstd.zig

@@ -1963,6 +1963,8 @@ export fn _fwrite_buf(ptr: [*]const u8, size: usize, stream: *c.FILE) callconv(.
 
 const FormatLength = enum {
     none,
+    short,
+    char,
     long,
     long_long,
     size,
@@ -2092,7 +2094,16 @@ fn vformat(out_written: *usize, writer: *FormatWriter, fmt: [*:0]const u8, args:
         }
 
         var spec_length: FormatLength = .none;
-        if (fmt_slice[i] == 'l') {
+        if (fmt_slice[i] == 'h') {
+            if (i + 1 < fmt_slice.len and fmt_slice[i + 1] == 'h') {
+                spec_length = .char;
+                i += 2;
+            } else {
+                spec_length = .short;
+                i += 1;
+            }
+            if (i >= fmt_slice.len) return false;
+        } else if (fmt_slice[i] == 'l') {
             if (i + 1 < fmt_slice.len and fmt_slice[i + 1] == 'l') {
                 spec_length = .long_long;
                 i += 2;
@@ -2133,6 +2144,8 @@ fn vformat(out_written: *usize, writer: *FormatWriter, fmt: [*:0]const u8, args:
                 var buf: [100]u8 = undefined;
                 const len = switch (spec_length) {
                     .none => formatIntCompat(&buf, vaArgCompat(args, c_int), 10),
+                    .short => formatIntCompat(&buf, @as(i16, @intCast(vaArgCompat(args, c_int))), 10),
+                    .char => formatIntCompat(&buf, @as(i8, @intCast(vaArgCompat(args, c_int))), 10),
                     .long => formatIntCompat(&buf, vaArgCompat(args, c_long), 10),
                     .long_long => formatIntCompat(&buf, vaArgCompat(args, c_longlong), 10),
                     .size => formatIntCompat(&buf, vaArgCompat(args, isize), 10),
@@ -2147,6 +2160,8 @@ fn vformat(out_written: *usize, writer: *FormatWriter, fmt: [*:0]const u8, args:
                 var buf: [100]u8 = undefined;
                 const len = switch (spec_length) {
                     .none => formatIntCompat(&buf, vaArgCompat(args, c_uint), base),
+                    .short => formatIntCompat(&buf, @as(u16, @intCast(vaArgCompat(args, c_uint))), base),
+                    .char => formatIntCompat(&buf, @as(u8, @intCast(vaArgCompat(args, c_uint))), base),
                     .long => formatIntCompat(&buf, vaArgCompat(args, c_ulong), base),
                     .long_long => formatIntCompat(&buf, vaArgCompat(args, c_ulonglong), base),
                     .size => formatIntCompat(&buf, vaArgCompat(args, usize), base),
@@ -2155,6 +2170,18 @@ fn vformat(out_written: *usize, writer: *FormatWriter, fmt: [*:0]const u8, args:
                 out_written.* += written;
                 if (written != len) return false;
             },
+            'p' => {
+                if (spec_length != .none or precision != precision_none) return false;
+                const ptr_value = @intFromPtr(vaArgCompat(args, ?*const anyopaque) orelse @as(?*const anyopaque, null));
+                var buf: [2 + (@sizeOf(usize) * 2)]u8 = undefined;
+                buf[0] = '0';
+                buf[1] = 'x';
+                const hex_len = formatIntCompat(buf[2..], ptr_value, 16);
+                const total_len = 2 + hex_len;
+                const written = writer.write(buf[0..total_len]);
+                out_written.* += written;
+                if (written != total_len) return false;
+            },
             else => return false,
         }
 
@@ -2942,9 +2969,12 @@ fn ceilCompat(x: f64) f64 {
 // --------------------------------------------------------------------------------
 // locale
 // --------------------------------------------------------------------------------
-export fn setlocale(category: c_int, locale: [*:0]const u8) callconv(.c) ?[*:0]u8 {
+export fn setlocale(category: c_int, locale: ?[*:0]const u8) callconv(.c) ?[*:0]u8 {
     _ = category;
-    const requested = std.mem.span(locale);
+    if (locale == null) {
+        return @as([*:0]u8, @ptrCast(&global.current_locale));
+    }
+    const requested = std.mem.span(locale.?);
     if (requested.len == 0 or std.mem.eql(u8, requested, "C") or std.mem.eql(u8, requested, "POSIX")) {
         global.current_locale[0] = 'C';
         global.current_locale[1] = 0;

src/posix.c

@@ -208,6 +208,35 @@ int fcntl(int fildes, int cmd, ...)
 // --------------------------------------------------------------------------------
 LIBCGUANA_INTERNAL int _ioctlArgPtr(int fd, unsigned long request, void *arg);
 
+#if defined(__APPLE__) && defined(__aarch64__)
+LIBCGUANA_INTERNAL int _zdarwin_fstat64(int fd, void *buf)
+{
+    register long x0 __asm("x0") = (long)fd;
+    register void *x1 __asm("x1") = buf;
+    unsigned int carry;
+
+    /*
+     * Native Apple Silicon exposed a real ABI bug in the generic variadic
+     * `syscall()` path for `fstat`. Keep this on a fixed-arity trap so the
+     * kernel sees the exact register layout that libsyscall uses for
+     * `___fstat64`.
+     */
+    __asm__ volatile(
+        "mov x16, #339\n"
+        "svc #0x80\n"
+        "cset %w2, cs\n"
+        : "+r"(x0), "+r"(x1), "=r"(carry)
+        :
+        : "x16", "cc", "memory");
+
+    if (carry != 0) {
+        errno = (int)x0;
+        return -1;
+    }
+    return (int)x0;
+}
+#endif
+
 int ioctl(int fd, unsigned long request, ...)
 {
     va_list args;

src/posix.zig

@@ -38,6 +38,7 @@ const cstd = struct {
         oact: ?*c.struct_sigaction,
     ) callconv(.c) c_int;
     extern fn __zwindows_raise_signal(sig: c_int) callconv(.c) c_int;
+    extern fn _zdarwin_fstat64(fd: c_int, buf: *os.Stat) callconv(.c) c_int;
 };
 
 const AtomicFlag = std.atomic.Value(u32);
@@ -157,6 +158,7 @@ const darwin_syscall = if (builtin.os.tag.isDarwin()) struct {
     const setitimer: c_long = 83;
     const getitimer: c_long = 86;
     const fstat: c_long = 189;
+    const fstat64: c_long = 339;
     const fcntl: c_long = 92;
     const select: c_long = 93;
     const gettimeofday: c_long = 116;
@@ -3025,24 +3027,28 @@ export fn fstat(fd: c_int, buf: *c.struct_stat) c_int {
     }
     var stat_buf: os.Stat = undefined;
     if (builtin.os.tag.isDarwin()) {
-        // Darwin splits here by architecture. Apple Silicon uses the native
-        // `fstat` syscall ABI, but Intel macOS still routes modern callers
-        // through the `$INODE64` userland symbol. The raw syscall fixed the
-        // native arm64 recursion/crash, but it returned the wrong layout under
-        // the x86_64 Darwin-target run. Keep the path target-authentic.
-        const rc = if (builtin.cpu.arch == .x86_64)
-            darwin.@"fstat$INODE64"(fd, &stat_buf)
-        else
-            syscall(darwin_syscall.fstat, darwinSysSigned(fd), &stat_buf);
-        switch (os.errno(rc)) {
-            .SUCCESS => {
-                copyPosixStatToC(buf, stat_buf);
-                return 0;
-            },
-            else => |e| {
-                c.errno = @intFromEnum(e);
+        // Keep Darwin on the fixed-arity libsyscall stub instead of the generic
+        // variadic `syscall()` bridge. Native Apple Silicon surfaced a real
+        // `fstat` corruption bug there that Darling did not reproduce. Apple's
+        // syscall maps route both macOS architectures through `___fstat64`;
+        // `@"fstat$INODE64"` is just the public x86_64 alias for the same stub.
+        if (builtin.cpu.arch == .x86_64) {
+            switch (os.errno(darwin.@"fstat$INODE64"(fd, &stat_buf))) {
+                .SUCCESS => {
+                    copyPosixStatToC(buf, stat_buf);
+                    return 0;
+                },
+                else => |e| {
+                    c.errno = @intFromEnum(e);
+                    return -1;
+                },
+            }
+        } else {
+            if (cstd._zdarwin_fstat64(fd, &stat_buf) != 0) {
                 return -1;
-            },
+            }
+            copyPosixStatToC(buf, stat_buf);
+            return 0;
         }
     }
     switch (os.errno(os.system.fstat(fd, &stat_buf))) {

test/libc_parity.c

@@ -64,18 +64,19 @@ static void read_all(FILE *stream, char *buf, size_t len)
   buf[n] = 0;
 }
 
-int main(void)
+static void parity_system_blocks(void)
 {
-  setvbuf(stdout, NULL, _IONBF, 0);
-
   parity_mark("parity:block:system-null");
   printf("system-null:%d|", system(NULL));
 
   parity_mark("parity:block:system-exit7");
   printf("system-exit7:%d|", system(CMD_EXIT7));
   parity_mark("parity:block:getenv-path");
   printf("getenv-path:%s|", getenv("PATH") ? getenv("PATH") : "null");
+}
 
+static void parity_popen_blocks(void)
+{
   {
     parity_mark("parity:block:popen-read");
     FILE *p = parity_popen(CMD_PRINTF, "r");
@@ -135,14 +136,20 @@ int main(void)
       fclose(files[count]);
     }
   }
+}
 
+static void parity_signal_block(void)
+{
   {
     parity_mark("parity:block:signal");
     void (*old_handler)(int) = signal(SIGINT, parity_handler);
     void (*prev_handler)(int) = signal(SIGINT, old_handler);
     printf("signal-basic:%d:%d|", old_handler != SIG_ERR, prev_handler == parity_handler);
   }
+}
 
+static void parity_strto_blocks(void)
+{
   {
     parity_mark("parity:block:strtol");
     const char *s = "abc";
@@ -166,7 +173,10 @@ int main(void)
     dist = (long)(endptr - s);
     printf("strtod-nodigits:%d:%d:%ld|", value == 0.0, errno, dist);
   }
+}
 
+static void parity_signal_api_blocks(void)
+{
 #if LIBC_PARITY_HAVE_STRSIGNAL
   {
     const char *name = strsignal(SIGINT);
@@ -197,7 +207,10 @@ int main(void)
 #else
   printf("sigaction-basic:skip|");
 #endif
+}
 
+static void parity_time_blocks(void)
+{
 #if LIBC_PARITY_HAVE_SETITIMER
   {
     struct itimerval val;
@@ -234,7 +247,10 @@ int main(void)
 #else
   printf("pselect-timeout:skip|");
 #endif
+}
 
+static void parity_utimes_block(void)
+{
 #if LIBC_PARITY_HAVE_UTIMES
   {
     parity_mark("parity:block:utimes");
@@ -263,7 +279,10 @@ int main(void)
 #else
   printf("utimes-basic:skip|");
 #endif
+}
 
+static void parity_posix_io_blocks(void)
+{
 #if LIBC_PARITY_HAVE_POSIX_IO
   {
     parity_mark("parity:block:gethostname");
@@ -382,6 +401,20 @@ int main(void)
 #else
   printf("gethostname:skip|openat-size:skip|link-basic:skip|fcntl-basic:skip|writev-basic:skip|pathconf-basic:skip|");
 #endif
+}
+
+int main(void)
+{
+  setvbuf(stdout, NULL, _IONBF, 0);
+
+  parity_system_blocks();
+  parity_popen_blocks();
+  parity_signal_block();
+  parity_strto_blocks();
+  parity_signal_api_blocks();
+  parity_time_blocks();
+  parity_utimes_block();
+  parity_posix_io_blocks();
 
   return 0;
 }

test/panic_replacements.c

@@ -36,6 +36,7 @@ int main(int argc, char *argv[])
   }
 
   expect(NULL != setlocale(LC_ALL, "C"));
+  expect(0 == strcmp("C", setlocale(LC_ALL, NULL)));
   expect(0 == strcmp("C", setlocale(LC_ALL, "")));
   expect(NULL == setlocale(LC_ALL, "en_US.UTF-8"));