@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.76

package/c/inttypes.zig

@@ -24,13 +24,3 @@ fn imaxdiv(a: intmax_t, b: intmax_t) callconv(.c) imaxdiv_t {
         .rem = @rem(a, b),
     };
 }
-
-test imaxabs {
-    const val: intmax_t = -10;
-    try std.testing.expectEqual(10, imaxabs(val));
-}
-
-test imaxdiv {
-    const expected: imaxdiv_t = .{ .quot = 9, .rem = 0 };
-    try std.testing.expectEqual(expected, imaxdiv(9, 1));
-}

package/c/math.zig

@@ -2,10 +2,6 @@ const builtin = @import("builtin");
 
 const std = @import("std");
 const math = std.math;
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectApproxEqAbs = std.testing.expectApproxEqAbs;
-const expectApproxEqRel = std.testing.expectApproxEqRel;
 
 const symbol = @import("../c.zig").symbol;
 
@@ -304,59 +300,6 @@ fn modfl(x: c_longdouble, iptr: *c_longdouble) callconv(.c) c_longdouble {
     };
 }
 
-fn testModf(comptime T: type) !void {
-    // Choose the appropriate `modf` impl to test based on type
-    const f = switch (T) {
-        f32 => modff,
-        f64 => modf,
-        c_longdouble => modfl,
-        else => @compileError("modf not implemented for " ++ @typeName(T)),
-    };
-
-    var int: T = undefined;
-    const iptr = ∫
-    const eps_val: comptime_float = @max(1e-6, math.floatEps(T));
-
-    const normal_frac = f(@as(T, 1234.567), iptr);
-    // Account for precision error
-    const expected = 1234.567 - @as(T, 1234);
-    try expectApproxEqAbs(expected, normal_frac, eps_val);
-    try expectApproxEqRel(@as(T, 1234.0), iptr.*, eps_val);
-
-    // When `x` is a NaN, NaN is returned and `*iptr` is set to NaN
-    const nan_frac = f(math.nan(T), iptr);
-    try expect(math.isNan(nan_frac));
-    try expect(math.isNan(iptr.*));
-
-    // When `x` is positive infinity, +0 is returned and `*iptr` is set to
-    // positive infinity
-    const pos_zero_frac = f(math.inf(T), iptr);
-    try expect(math.isPositiveZero(pos_zero_frac));
-    try expect(math.isPositiveInf(iptr.*));
-
-    // When `x` is negative infinity, -0 is returned and `*iptr` is set to
-    // negative infinity
-    const neg_zero_frac = f(-math.inf(T), iptr);
-    try expect(math.isNegativeZero(neg_zero_frac));
-    try expect(math.isNegativeInf(iptr.*));
-
-    // Return -0 when `x` is a negative integer
-    const nz_frac = f(@as(T, -1000.0), iptr);
-    try expect(math.isNegativeZero(nz_frac));
-    try expectEqual(@as(T, -1000.0), iptr.*);
-
-    // Return +0 when `x` is a positive integer
-    const pz_frac = f(@as(T, 1000.0), iptr);
-    try expect(math.isPositiveZero(pz_frac));
-    try expectEqual(@as(T, 1000.0), iptr.*);
-}
-
-test "modf" {
-    try testModf(f32);
-    try testModf(f64);
-    try testModf(c_longdouble);
-}
-
 fn nan(_: [*:0]const c_char) callconv(.c) f64 {
     return math.nan(f64);
 }
@@ -421,49 +364,6 @@ fn rintf(x: f32) callconv(.c) f32 {
     return y;
 }
 
-fn testRint(comptime T: type) !void {
-    const f = switch (T) {
-        f32 => rintf,
-        f64 => rint,
-        else => @compileError("rint not implemented for" ++ @typeName(T)),
-    };
-
-    // Positive numbers round correctly
-    try expectEqual(@as(T, 42.0), f(42.2));
-    try expectEqual(@as(T, 42.0), f(41.8));
-
-    // Negative numbers round correctly
-    try expectEqual(@as(T, -6.0), f(-5.9));
-    try expectEqual(@as(T, -6.0), f(-6.1));
-
-    // No rounding needed test
-    try expectEqual(@as(T, 5.0), f(5.0));
-    try expectEqual(@as(T, -10.0), f(-10.0));
-    try expectEqual(@as(T, 0.0), f(0.0));
-
-    // Very large numbers return unchanged
-    const large: T = 9007199254740992.0; // 2^53
-    try expectEqual(large, f(large));
-    try expectEqual(-large, f(-large));
-
-    // Small positive numbers round to zero
-    const pos_result = f(0.3);
-    try expect(math.isPositiveZero(pos_result));
-
-    // Small negative numbers round to negative zero
-    const neg_result = f(-0.3);
-    try expect(math.isNegativeZero(neg_result));
-
-    // Exact half rounds to nearest even (banker's rounding)
-    try expectEqual(@as(T, 2.0), f(2.5));
-    try expectEqual(@as(T, 4.0), f(3.5));
-}
-
-test "rint" {
-    try testRint(f32);
-    try testRint(f64);
-}
-
 fn tanh(x: f64) callconv(.c) f64 {
     return math.tanh(x);
 }

package/c/search.zig

@@ -9,6 +9,7 @@ comptime {
     }
 }
 
+/// Not defined in `std.c` because C headers don't either.
 const Node = extern struct {
     next: ?*Node,
     prev: ?*Node,
@@ -38,30 +39,3 @@ fn remque(element: *anyopaque) callconv(.c) void {
     if (e.next) |next| next.prev = e.prev;
     if (e.prev) |prev| prev.next = e.next;
 }
-
-test "insque and remque" {
-    var first = Node{ .next = null, .prev = null };
-    var second = Node{ .next = null, .prev = null };
-    var third = Node{ .next = null, .prev = null };
-
-    insque(&first, null);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-    try std.testing.expectEqual(@as(?*Node, null), first.prev);
-
-    insque(&second, &first);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    insque(&third, &first);
-    try std.testing.expectEqual(@as(?*Node, &third), first.next);
-    try std.testing.expectEqual(@as(?*Node, &second), third.next);
-    try std.testing.expectEqual(@as(?*Node, &first), third.prev);
-    try std.testing.expectEqual(@as(?*Node, &third), second.prev);
-
-    remque(&third);
-    try std.testing.expectEqual(@as(?*Node, &second), first.next);
-    try std.testing.expectEqual(@as(?*Node, &first), second.prev);
-
-    remque(&second);
-    try std.testing.expectEqual(@as(?*Node, null), first.next);
-}

package/c/stdlib/drand48.zig

@@ -90,60 +90,3 @@ fn srand48(seedval: c_long) callconv(.c) void {
     const xi = (@as(u32, @truncate(@as(c_ulong, @bitCast(seedval)))) << 16) | 0x330E;
     lcg = .init(xi, default_multiplier, default_addend);
 }
-
-test erand48 {
-    var xsubi: [3]c_ushort = .{ 37174, 64810, 11603 };
-
-    try std.testing.expectApproxEqAbs(0.8965, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 22537, 47966, 58735 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.3375, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37344, 32911, 22119 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.6475, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 23659, 29872, 42445 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5005, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31642, 7875, 32802 }, &xsubi);
-
-    try std.testing.expectApproxEqAbs(0.5065, erand48(&xsubi), 0.0005);
-    try std.testing.expectEqualSlices(c_ushort, &.{ 64669, 14399, 33170 }, &xsubi);
-}
-
-test jrand48 {
-    var xsubi: [3]c_ushort = .{ 25175, 11052, 45015 };
-
-    try std.testing.expectEqual(1699503220, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 2326, 23668, 25932 }, &xsubi);
-
-    try std.testing.expectEqual(-992276007, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 41577, 4569, 50395 }, &xsubi);
-
-    try std.testing.expectEqual(-19535776, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 31936, 59488, 65237 }, &xsubi);
-
-    try std.testing.expectEqual(79438377, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 40395, 8745, 1212 }, &xsubi);
-
-    try std.testing.expectEqual(-1258917728, jrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 37242, 28832, 46326 }, &xsubi);
-}
-
-test nrand48 {
-    var xsubi: [3]c_ushort = .{ 546, 33817, 23389 };
-
-    try std.testing.expectEqual(914920692, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 29829, 10728, 27921 }, &xsubi);
-
-    try std.testing.expectEqual(754104482, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 6828, 28997, 23013 }, &xsubi);
-
-    try std.testing.expectEqual(609453945, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58183, 3826, 18599 }, &xsubi);
-
-    try std.testing.expectEqual(1878644360, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 36678, 44304, 57331 }, &xsubi);
-
-    try std.testing.expectEqual(2114923686, nrand48(&xsubi));
-    try std.testing.expectEqualSlices(c_ushort, &.{ 58585, 22861, 64542 }, &xsubi);
-}

package/c/stdlib.zig

@@ -294,103 +294,3 @@ fn bsearch(key: *const anyopaque, base: *const anyopaque, n: usize, size: usize,
     }
     return null;
 }
-
-test abs {
-    const val: c_int = -10;
-    try std.testing.expectEqual(10, abs(val));
-}
-
-test labs {
-    const val: c_long = -10;
-    try std.testing.expectEqual(10, labs(val));
-}
-
-test llabs {
-    const val: c_longlong = -10;
-    try std.testing.expectEqual(10, llabs(val));
-}
-
-test div {
-    const expected: div_t = .{ .quot = 5, .rem = 5 };
-    try std.testing.expectEqual(expected, div(55, 10));
-}
-
-test ldiv {
-    const expected: ldiv_t = .{ .quot = -6, .rem = 2 };
-    try std.testing.expectEqual(expected, ldiv(38, -6));
-}
-
-test lldiv {
-    const expected: lldiv_t = .{ .quot = 1, .rem = 2 };
-    try std.testing.expectEqual(expected, lldiv(5, 3));
-}
-
-test atoi {
-    try std.testing.expectEqual(0, atoi(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoi(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoi(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoi(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoi(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoi(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoi(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoi(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoi(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoi(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_int)}))));
-    try std.testing.expectEqual(std.math.minInt(c_int), atoi(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_int)}))));
-}
-
-test atol {
-    try std.testing.expectEqual(0, atol(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atol(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atol(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atol(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atol(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atol(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atol(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atol(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atol(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atol(@ptrCast("+32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_long)}))));
-    try std.testing.expectEqual(std.math.minInt(c_long), atol(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_long)}))));
-}
-
-test atoll {
-    try std.testing.expectEqual(0, atoll(@ptrCast("stop42true")));
-    try std.testing.expectEqual(42, atoll(@ptrCast("42true")));
-    try std.testing.expectEqual(-1, atoll(@ptrCast("-01")));
-    try std.testing.expectEqual(1, atoll(@ptrCast("+001")));
-    try std.testing.expectEqual(100, atoll(@ptrCast("            100")));
-    try std.testing.expectEqual(500, atoll(@ptrCast("000000000000500")));
-    try std.testing.expectEqual(1111, atoll(@ptrCast("0000000000001111_0000")));
-    try std.testing.expectEqual(0, atoll(@ptrCast("0xAA")));
-    try std.testing.expectEqual(700, atoll(@ptrCast("700B")));
-    try std.testing.expectEqual(32453, atoll(@ptrCast("   +32453more")));
-    try std.testing.expectEqual(std.math.maxInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.maxInt(c_longlong)}))));
-    try std.testing.expectEqual(std.math.minInt(c_longlong), atoll(@ptrCast(std.fmt.comptimePrint("{d}", .{std.math.minInt(c_longlong)}))));
-}
-
-// FIXME: We cannot test strtol, strtoll, strtoul, etc.. here as it must modify errno and libc is not linked in tests
-
-test bsearch {
-    const Comparison = struct {
-        pub fn compare(a: *const anyopaque, b: *const anyopaque) callconv(.c) c_int {
-            const a_u16: *const u16 = @ptrCast(@alignCast(a));
-            const b_u16: *const u16 = @ptrCast(@alignCast(b));
-
-            return switch (std.math.order(a_u16.*, b_u16.*)) {
-                .gt => 1,
-                .eq => 0,
-                .lt => -1,
-            };
-        }
-    };
-
-    const items: []const u16 = &.{ 0, 5, 7, 9, 10, 200, 512, 768 };
-
-    try std.testing.expectEqual(@as(?*anyopaque, null), bsearch(&@as(u16, 2000), items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-
-    for (items) |*value| {
-        try std.testing.expectEqual(@as(*const anyopaque, value), bsearch(value, items.ptr, items.len, @sizeOf(u16), Comparison.compare));
-    }
-}

package/c/string.zig

@@ -290,10 +290,3 @@ fn mempcpy(noalias dst: *anyopaque, noalias src: *const anyopaque, len: usize) c
     @memcpy(dst_bytes[0..len], src_bytes[0..len]);
     return dst_bytes + len;
 }
-
-test strncmp {
-    try std.testing.expect(strncmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncmp(@ptrCast("a"), @ptrCast("c"), 1) < 0);
-    try std.testing.expect(strncmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncmp(@ptrCast("\xff"), @ptrCast("\x02"), 1) > 0);
-}

package/c/strings.zig

@@ -81,41 +81,3 @@ fn __strncasecmp_l(a: [*:0]const c_char, b: [*:0]const c_char, n: usize, locale:
     _ = locale;
     return strncasecmp(a, b, n);
 }
-
-test bzero {
-    var array: [10]u8 = [_]u8{ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
-    var a = std.mem.zeroes([array.len]u8);
-    a[9] = '0';
-    bzero(&array[0], 9);
-    try std.testing.expect(std.mem.eql(u8, &array, &a));
-}
-
-test firstBitSet {
-    try std.testing.expectEqual(0, firstBitSet(usize, 0));
-
-    for (0..@bitSizeOf(usize)) |i| {
-        const bit = @as(usize, 1) << @intCast(i);
-
-        try std.testing.expectEqual(i + 1, firstBitSet(usize, bit));
-    }
-}
-
-test strcasecmp {
-    try std.testing.expect(strcasecmp(@ptrCast("a"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("a")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("A")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("A")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("B"), @ptrCast("b")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("bb"), @ptrCast("AA")) > 0);
-}
-
-test strncasecmp {
-    try std.testing.expect(strncasecmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("A"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("A"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("B"), @ptrCast("b"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("bb"), @ptrCast("AA"), 2) > 0);
-}

package/c/unistd.zig

@@ -21,6 +21,8 @@ comptime {
         symbol(&chrootLinux, "chroot");
         symbol(&ctermidLinux, "ctermid");
         symbol(&dupLinux, "dup");
+        symbol(&dup2Linux, "dup2");
+        symbol(&dup3Linux, "dup3");
 
         symbol(&getegidLinux, "getegid");
         symbol(&geteuidLinux, "geteuid");
@@ -101,6 +103,31 @@ fn dupLinux(fd: c_int) callconv(.c) c_int {
     return errno(linux.dup(fd));
 }
 
+fn dup2Linux(old: c_int, new: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+    while (res == busy) res = linux.dup2(old, new);
+    return errno(res);
+}
+
+fn dup3Linux(old: c_int, new: c_int, flags: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+
+    if (@hasField(linux.SYS, "dup3")) {
+        while (res == busy) res = linux.dup3(old, new, @intCast(flags));
+    } else if (@hasField(linux.SYS, "dup2")) {
+        const cloexec: c_int = @bitCast(linux.O{ .CLOEXEC = true });
+        const inval: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.INVAL)));
+        if (old == new or (flags & ~cloexec != 0)) return errno(inval);
+        while (res == busy) res = linux.dup2(old, new);
+        _ = if (res >= 0 and (flags & cloexec == cloexec)) linux.fcntl(new, linux.F.SETFD, linux.FD_CLOEXEC);
+    } else {
+        return errno(@bitCast(-@as(isize, @intFromEnum(linux.E.NOSYS))));
+    }
+    return errno(res);
+}
+
 fn getegidLinux() callconv(.c) linux.gid_t {
     return linux.getegid();
 }
@@ -206,32 +233,6 @@ fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isiz
     }
 }
 
-test swab {
-    var a: [4]u8 = undefined;
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 4);
-    try std.testing.expectEqualSlices(u8, "badc", &a);
-
-    // Partial copy
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 2);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-
-    // n < 1
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 0);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, -1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-
-    // Odd n
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, 3);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-}
-
 fn close(fd: std.c.fd_t) callconv(.c) c_int {
     const signed: isize = @bitCast(linux.close(fd));
     if (signed < 0) {

package/c.zig

@@ -2,8 +2,7 @@
 //! bundled libcs.
 //!
 //! mingw-w64 libc is not fully statically linked, so some symbols don't need
-//! to be exported. However, a future enhancement could be eliminating Zig's
-//! dependency on msvcrt dll even when linking libc and targeting Windows.
+//! to be exported.
 
 const builtin = @import("builtin");
 const std = @import("std");

package/compiler_rt/limb64.zig

@@ -152,6 +152,10 @@ fn test__addo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool })
 }
 
 test __addo_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__addo_limb64(u64, 1, 2, .{ 3, false });
     try test__addo_limb64(u64, maxInt(u64), 2, .{ 1, true });
     try test__addo_limb64(u65, maxInt(u65), 2, .{ 1, true });
@@ -228,6 +232,10 @@ fn test__subo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool })
 }
 
 test __subo_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__subo_limb64(u64, 3, 2, .{ 1, false });
     try test__subo_limb64(u64, 0, 1, .{ maxInt(u64), true });
     try test__subo_limb64(u65, 0, 1, .{ maxInt(u65), true });
@@ -477,6 +485,10 @@ fn test__not_limb64(comptime T: type, a: T, expected: T) !void {
 }
 
 test __not_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__not_limb64(u64, 1, maxInt(u64) - 1);
     try test__not_limb64(u64, 3, maxInt(u64) - 3);
     try test__not_limb64(u65, maxInt(u65), 0);
@@ -555,6 +567,10 @@ fn test__shlo_limb64(comptime T: type, a: T, shift: u16, expected: struct { T, b
 }
 
 test __shlo_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__shlo_limb64(u64, 0x1234_5678_9ABC_DEF0, 4, .{ 0x2345_6789_ABCD_EF00, true });
     try test__shlo_limb64(u64, 0x8000_0000_0000_0001, 63, .{ 0x8000_0000_0000_0000, true });
     try test__shlo_limb64(u65, 1, 64, .{ 0x1_0000_0000_0000_0000, false });
@@ -631,6 +647,10 @@ fn test__shr_limb64(comptime T: type, a: T, shift: u16, expected: T) !void {
 }
 
 test __shr_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__shr_limb64(u64, 0x1234_5678_9ABC_DEF0, 4, 0x0123_4567_89AB_CDEF);
     try test__shr_limb64(u64, 0x8000_0000_0000_0001, 63, 1);
     try test__shr_limb64(u65, 0x1_0000_0000_0000_0000, 64, 1);
@@ -858,6 +878,10 @@ fn test__bitreverse_limb64(comptime T: type, a: T, expected: T) !void {
 }
 
 test __bitreverse_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__bitreverse_limb64(u64, 1 << 7, 1 << 56);
     try test__bitreverse_limb64(u65, 1 << 64, 1);
     try test__bitreverse_limb64(u65, 1 << 9, 1 << 55);
@@ -910,6 +934,10 @@ fn test__byteswap_limb64(comptime T: type, a: T, expected: T) !void {
 }
 
 test __byteswap_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__byteswap_limb64(u64, 0x0123_4567_89AB_CDEF, 0xEFCD_AB89_6745_2301);
     try test__byteswap_limb64(u72, 0x01_23_45_67_89_AB_CD_EF_11, 0x11_EF_CD_AB_89_67_45_23_01);
     try test__byteswap_limb64(u128, 1 << 72, 1 << 48);
@@ -1036,6 +1064,10 @@ fn test__mulo_limb64(comptime T: type, a: T, b: T, expected: struct { T, bool })
 }
 
 test __mulo_limb64 {
+    if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .mips64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+    if (builtin.cpu.arch == .powerpc64) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/31905
+
     try test__mulo_limb64(u64, 3, 5, .{ 15, false });
     try test__mulo_limb64(u64, maxInt(u64), 2, .{ maxInt(u64) - 1, true });
     try test__mulo_limb64(u65, 1 << 32, 1 << 32, .{ 1 << 64, false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.56",
+  "version": "0.17.0-dev.76",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Io/Semaphore.zig

@@ -15,14 +15,42 @@ cond: Io.Condition = .init,
 /// It is OK to initialize this field to any value.
 permits: usize = 0,
 
+/// Blocks until a `permit` is available and consumes a single one.
+/// Unblocks without consuming a `permit` when canceled.
+///
+/// See also:
+/// * `waitTimeout`
+/// * `waitUncancelable`
 pub fn wait(s: *Semaphore, io: Io) Io.Cancelable!void {
+    s.waitTimeout(io, .none) catch |err| switch (err) {
+        error.Timeout => unreachable,
+        error.Canceled => |e| return e,
+    };
+}
+
+pub const WaitTimeoutError = Io.Cancelable || Io.Timeout.Error;
+
+/// Blocks until a `permit` is available and consumes a single one.
+/// Unblocks without consuming a `permit` when canceled or when the provided
+/// timeout expires before a `permit` is available.
+///
+/// See also:
+/// * `wait`
+/// * `waitUncancelable`
+pub fn waitTimeout(s: *Semaphore, io: Io, timeout: Io.Timeout) WaitTimeoutError!void {
+    const deadline = timeout.toDeadline(io);
     try s.mutex.lock(io);
     defer s.mutex.unlock(io);
-    while (s.permits == 0) try s.cond.wait(io, &s.mutex);
+    while (s.permits == 0) try s.cond.waitTimeout(io, &s.mutex, deadline);
     s.permits -= 1;
     if (s.permits > 0) s.cond.signal(io);
 }
 
+/// Blocks until a `permit` is available and consumes a single one.
+///
+/// See also:
+/// * `wait`
+/// * `waitTimeout`
 pub fn waitUncancelable(s: *Semaphore, io: Io) void {
     s.mutex.lockUncancelable(io);
     defer s.mutex.unlock(io);
@@ -31,6 +59,7 @@ pub fn waitUncancelable(s: *Semaphore, io: Io) void {
     if (s.permits > 0) s.cond.signal(io);
 }
 
+/// Makes an additional `permit` available.
 pub fn post(s: *Semaphore, io: Io) void {
     s.mutex.lockUncancelable(io);
     defer s.mutex.unlock(io);
@@ -39,27 +68,93 @@ pub fn post(s: *Semaphore, io: Io) void {
     s.cond.signal(io);
 }
 
-test Semaphore {
-    if (builtin.single_threaded) return error.SkipZigTest;
+test wait {
     const io = testing.io;
 
-    const TestContext = struct {
-        sem: *Semaphore,
-        n: *i32,
+    const Context = struct {
+        sem: Semaphore = .{ .permits = 1 },
+        n: u32 = 0,
+
         fn worker(ctx: *@This()) !void {
             try ctx.sem.wait(io);
-            ctx.n.* += 1;
+            ctx.n += 1;
             ctx.sem.post(io);
         }
     };
-    const num_threads = 3;
-    var sem: Semaphore = .{ .permits = 1 };
-    var threads: [num_threads]std.Thread = undefined;
-    var n: i32 = 0;
-    var ctx = TestContext{ .sem = &sem, .n = &n };
-
-    for (&threads) |*t| t.* = try std.Thread.spawn(.{}, TestContext.worker, .{&ctx});
-    for (threads) |t| t.join();
-    try sem.wait(io);
-    try testing.expect(n == num_threads);
+
+    var ctx: Context = .{};
+
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+
+    const num_workers = 3;
+    for (0..num_workers) |_| group.async(io, Context.worker, .{&ctx});
+
+    try group.await(io);
+    try testing.expectEqual(num_workers, ctx.n);
+}
+
+test waitTimeout {
+    const io = testing.io;
+
+    const Context = struct {
+        ready: Io.Event = .unset,
+        sem: Semaphore = .{ .permits = 0 },
+        value: u32 = 0,
+
+        fn worker(ctx: *@This()) !void {
+            defer ctx.ready.set(io);
+
+            try testing.expectError(error.Timeout, ctx.sem.waitTimeout(io, .{ .duration = .{
+                .raw = .fromMilliseconds(1),
+                .clock = .awake,
+            } }));
+            try testing.expectEqual(0, ctx.value);
+
+            ctx.ready.set(io);
+
+            while (ctx.value == 0) try ctx.sem.wait(io);
+            try testing.expectEqual(1, ctx.value);
+        }
+    };
+
+    var ctx: Context = .{};
+
+    var future = io.concurrent(Context.worker, .{&ctx}) catch |err| switch (err) {
+        error.ConcurrencyUnavailable => return error.SkipZigTest,
+    };
+    defer future.cancel(io) catch {};
+
+    try ctx.ready.wait(io);
+
+    ctx.value = 1;
+    ctx.sem.post(io);
+
+    try future.await(io);
+}
+
+test waitUncancelable {
+    const io = testing.io;
+
+    const Context = struct {
+        sem: Semaphore = .{ .permits = 1 },
+        n: u32 = 0,
+
+        fn worker(ctx: *@This()) !void {
+            ctx.sem.waitUncancelable(io);
+            ctx.n += 1;
+            ctx.sem.post(io);
+        }
+    };
+
+    var ctx: Context = .{};
+
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+
+    const num_workers = 3;
+    for (0..num_workers) |_| group.async(io, Context.worker, .{&ctx});
+
+    try group.await(io);
+    try testing.expectEqual(num_workers, ctx.n);
 }

package/std/Io/Threaded.zig

@@ -2005,7 +2005,7 @@ const have_waitid = switch (native_os) {
 
 const have_wait4 = switch (native_os) {
     .linux => @hasField(std.os.linux.SYS, "wait4"),
-    .dragonfly, .freebsd, .netbsd, .openbsd, .illumos, .serenity, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => true,
+    .dragonfly, .freebsd, .netbsd, .openbsd, .illumos, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => true,
     else => false,
 };
 

package/std/Io.zig

@@ -1681,20 +1681,29 @@ pub const Condition = struct {
         .epoch = .init(0),
     };
 
+    /// Blocks until the condition is signaled or canceled.
+    ///
+    /// See also:
+    /// * `waitUncancelable`
+    /// * `waitTimeout`
     pub fn wait(cond: *Condition, io: Io, mutex: *Mutex) Cancelable!void {
-        try waitInner(cond, io, mutex, false);
+        waitTimeout(cond, io, mutex, .none) catch |err| switch (err) {
+            error.Timeout => unreachable,
+            error.Canceled => |e| return e,
+        };
     }
 
-    /// Same as `wait`, except does not introduce a cancelation point.
+    pub const WaitTimeoutError = Cancelable || Timeout.Error;
+
+    /// Blocks until the condition is signaled, canceled, or the provided
+    /// timeout expires.
     ///
-    /// For a description of cancelation and cancelation points, see `Future.cancel`.
-    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
-        waitInner(cond, io, mutex, true) catch |err| switch (err) {
-            error.Canceled => unreachable,
-        };
-    }
+    /// See also:
+    /// * `wait`
+    /// * `waitUncancelable`
+    pub fn waitTimeout(cond: *Condition, io: Io, mutex: *Mutex, timeout: Timeout) WaitTimeoutError!void {
+        const deadline = timeout.toDeadline(io);
 
-    fn waitInner(cond: *Condition, io: Io, mutex: *Mutex, uncancelable: bool) Cancelable!void {
         var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
 
         {
@@ -1706,10 +1715,7 @@ pub const Condition = struct {
         defer mutex.lockUncancelable(io);
 
         while (true) {
-            const result = if (uncancelable)
-                io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch)
-            else
-                io.futexWait(u32, &cond.epoch.raw, epoch);
+            const result = io.futexWaitTimeout(u32, &cond.epoch.raw, epoch, deadline);
 
             epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
 
@@ -1729,13 +1735,62 @@ pub const Condition = struct {
             }
 
             // There are no more signals available; this was a spurious wakeup or an error. If it
-            // was an error, we will remove ourselves as a waiter and return that error. Otherwise,
-            // we'll loop back to the futex wait.
+            // was an error, we will remove ourselves as a waiter and return that error. If a
+            // timeout was specified and the deadline has passed, we remove ourselves as a waiter
+            // and return `error.Timeout`. Otherwise, we'll loop back to the futex wait.
             result catch |err| {
                 const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
                 assert(prev_state.waiters > 0); // underflow caused by illegal state
                 return err;
             };
+            switch (deadline) {
+                .none => {},
+                .deadline => |d| if (d.untilNow(io).raw.nanoseconds >= 0) {
+                    const prev_state = cond.state.fetchSub(.{ .waiters = 1, .signals = 0 }, .monotonic);
+                    assert(prev_state.waiters > 0); // underflow caused by illegal state
+                    return error.Timeout;
+                },
+                .duration => unreachable,
+            }
+        }
+    }
+
+    /// Same as `wait`, except does not introduce a cancelation point.
+    ///
+    /// See `Future.cancel` for a description of cancelation points.
+    pub fn waitUncancelable(cond: *Condition, io: Io, mutex: *Mutex) void {
+        var epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before state load
+
+        {
+            const prev_state = cond.state.fetchAdd(.{ .waiters = 1, .signals = 0 }, .monotonic);
+            assert(prev_state.waiters < math.maxInt(u16)); // overflow caused by too many waiters
+        }
+
+        mutex.unlock(io);
+        defer mutex.lockUncancelable(io);
+
+        while (true) {
+            io.futexWaitUncancelable(u32, &cond.epoch.raw, epoch);
+
+            epoch = cond.epoch.load(.acquire); // `.acquire` to ensure ordered before `state` laod
+
+            // Even on error, try to consume a pending signal first. Otherwise a race might
+            // cause a signal to get stuck in the state with no corresponding waiter.
+            {
+                var prev_state = cond.state.load(.monotonic);
+                while (prev_state.signals > 0) {
+                    prev_state = cond.state.cmpxchgWeak(prev_state, .{
+                        .waiters = prev_state.waiters - 1,
+                        .signals = prev_state.signals - 1,
+                    }, .acquire, .monotonic) orelse {
+                        // We successfully consumed a signal.
+                        return;
+                    };
+                }
+            }
+
+            // There are no more signals available; this was a spurious wakeup,
+            // so we'll loop back to the futex wait.
         }
     }
 

package/std/c/serenity.zig

@@ -53,9 +53,7 @@ pub extern "c" fn profiling_enable(pid: pid_t, event_mask: PERF_EVENT) c_int;
 pub extern "c" fn profiling_disable(pid: pid_t) c_int;
 pub extern "c" fn profiling_free_buffer(pid: pid_t) c_int;
 
-pub extern "c" fn futex(userspace_address: *u32, futex_op: c_int, value: u32, timeout: *const timespec, userspace_address2: *u32, value3: u32) c_int;
-pub extern "c" fn futex_wait(userspace_address: *u32, value: u32, abstime: *const timespec, clockid: clockid_t, process_shared: c_int) c_int;
-pub extern "c" fn futex_wake(userspace_address: *u32, count: u32, process_shared: c_int) c_int;
+pub extern "c" fn futex(userspace_address: *u32, futex_op: c_int, value: u32, timeout: ?*const timespec, userspace_address2: ?*u32, value3: u32) c_int;
 
 pub extern "c" fn purge(mode: c_int) c_int;
 
@@ -66,9 +64,6 @@ pub extern "c" fn get_stack_bounds(user_stack_base: *usize, user_stack_size: *us
 
 pub extern "c" fn anon_create(size: usize, options: O) c_int;
 
-pub extern "c" fn serenity_readlink(path: [*]const u8, path_length: usize, buffer: [*]u8, buffer_size: usize) c_int;
-pub extern "c" fn serenity_open(path: [*]const u8, path_length: usize, options: c_int, ...) c_int;
-
 pub extern "c" fn getkeymap(name_buffer: [*]u8, name_buffer_size: usize, map: [*]u32, shift_map: [*]u32, alt_map: [*]u32, altgr_map: [*]u32, shift_altgr_map: [*]u32) c_int;
 pub extern "c" fn setkeymap(name: [*]const u8, map: [*]const u32, shift_map: [*]const u32, alt_map: [*]const u32, altgr_map: [*]const u32, shift_altgr_map: [*]const u32) c_int;
 

package/std/c.zig

@@ -11102,13 +11102,60 @@ pub const ioctl = switch (native_os) {
     else => private.ioctl,
 };
 
+pub extern "c" fn bzero(s: *anyopaque, n: usize) void;
+
+pub extern "c" fn swab(noalias from: *const anyopaque, noalias to: *anyopaque, n: isize) void;
+
+pub extern "c" fn strncmp(a: [*:0]const c_char, b: [*:0]const c_char, max: usize) c_int;
+pub extern "c" fn strcasecmp(a: [*:0]const c_char, b: [*:0]const c_char) c_int;
+pub extern "c" fn strncasecmp(a: [*:0]const c_char, b: [*:0]const c_char, max: usize) c_int;
+
+pub extern "c" fn ffs(i: c_int) c_int;
+pub extern "c" fn ffsl(i: c_long) c_long;
+pub extern "c" fn ffsll(i: c_longlong) c_longlong;
+
+pub extern "c" fn erand48(xsubi: *[3]c_ushort) f64;
+pub extern "c" fn jrand48(xsubi: *[3]c_ushort) c_long;
+pub extern "c" fn nrand48(xsubi: *[3]c_ushort) c_long;
+
+pub extern "c" fn insque(element: *anyopaque, pred: ?*anyopaque) void;
+pub extern "c" fn remque(element: *anyopaque) void;
+
+pub extern "c" fn imaxabs(a: intmax_t) intmax_t;
+pub extern "c" fn imaxdiv(a: intmax_t, b: intmax_t) imaxdiv_t;
+
+pub extern "c" fn abs(a: c_int) c_int;
+pub extern "c" fn labs(a: c_long) c_long;
+pub extern "c" fn llabs(a: c_longlong) c_longlong;
+
+pub extern "c" fn div(a: c_int, b: c_int) div_t;
+pub extern "c" fn ldiv(a: c_long, b: c_long) ldiv_t;
+pub extern "c" fn lldiv(a: c_longlong, b: c_longlong) lldiv_t;
+
+pub extern "c" fn atoi(str: [*:0]const c_char) c_int;
+pub extern "c" fn atol(str: [*:0]const c_char) c_long;
+pub extern "c" fn atoll(str: [*:0]const c_char) c_longlong;
+
+pub extern "c" fn bsearch(
+    key: *const anyopaque,
+    base: *const anyopaque,
+    n: usize,
+    size: usize,
+    compare: *const fn (a: *const anyopaque, b: *const anyopaque) callconv(.c) c_int,
+) ?*anyopaque;
+
 // Math
-pub extern "c" fn atan(x: f64) callconv(.c) f64;
-pub extern "c" fn copysign(x: f64, y: f64) callconv(.c) f64;
-pub extern "c" fn fdim(x: f64, y: f64) callconv(.c) f64;
-pub extern "c" fn frexp(x: f64, e: *c_int) callconv(.c) f64;
-pub extern "c" fn hypot(x: f64, y: f64) callconv(.c) f64;
-pub extern "c" fn modf(x: f64, iptr: *f64) callconv(.c) f64;
+pub extern "c" fn atan(x: f64) f64;
+pub extern "c" fn copysign(x: f64, y: f64) f64;
+pub extern "c" fn fdim(x: f64, y: f64) f64;
+pub extern "c" fn frexp(x: f64, e: *c_int) f64;
+pub extern "c" fn hypot(x: f64, y: f64) f64;
+pub extern "c" fn modff(x: f32, iptr: *f32) f32;
+pub extern "c" fn modf(x: f64, iptr: *f64) f64;
+pub extern "c" fn modfl(x: c_longdouble, iptr: *c_longdouble) c_longdouble;
+pub extern "c" fn rintf(x: f32) f32;
+pub extern "c" fn rint(x: f64) f64;
+pub extern "c" fn rintl(x: c_longdouble) c_longdouble;
 
 // OS-specific bits. These are protected from being used on the wrong OS by
 // comptime assertions inside each OS-specific file.
@@ -11459,15 +11506,11 @@ pub const disown = serenity.disown;
 pub const profiling_enable = serenity.profiling_enable;
 pub const profiling_disable = serenity.profiling_disable;
 pub const profiling_free_buffer = serenity.profiling_free_buffer;
-pub const futex_wait = serenity.futex_wait;
-pub const futex_wake = serenity.futex_wake;
 pub const purge = serenity.purge;
 pub const perf_event = serenity.perf_event;
 pub const perf_register_string = serenity.perf_register_string;
 pub const get_stack_bounds = serenity.get_stack_bounds;
 pub const anon_create = serenity.anon_create;
-pub const serenity_readlink = serenity.serenity_readlink;
-pub const serenity_open = serenity.serenity_open;
 pub const getkeymap = serenity.getkeymap;
 pub const setkeymap = serenity.setkeymap;
 

package/std/os.zig

@@ -1,4 +1,5 @@
 const builtin = @import("builtin");
+const std = @import("std.zig");
 const native_os = builtin.os.tag;
 
 pub const linux = @import("os/linux.zig");
@@ -8,6 +9,46 @@ pub const wasi = @import("os/wasi.zig");
 pub const emscripten = @import("os/emscripten.zig");
 pub const windows = @import("os/windows.zig");
 
+/// Returns whether the Zig standard library requires libc in order to interface
+/// with the operating system on the given target.
+pub fn targetRequiresLibC(target: *const std.Target) bool {
+    if (target.requiresLibC()) return true;
+    return switch (target.os.tag) {
+        .linux => switch (target.cpu.arch) {
+            // https://codeberg.org/ziglang/zig/issues/30940
+            .alpha,
+            // https://codeberg.org/ziglang/zig/issues/30942
+            .csky,
+            // https://codeberg.org/ziglang/zig/issues/30943
+            .hppa,
+            .hppa64,
+            // https://codeberg.org/ziglang/zig/issues/30944
+            .microblaze,
+            .microblazeel,
+            // https://codeberg.org/ziglang/zig/issues/30946
+            .sh,
+            .sheb,
+            // https://codeberg.org/ziglang/zig/issues/30945
+            .sparc,
+            // https://codeberg.org/ziglang/zig/issues/30947
+            .xtensa,
+            .xtensaeb,
+            => true,
+            else => false,
+        },
+        .freebsd => true, // https://codeberg.org/ziglang/zig/issues/30981
+        .netbsd => true, // https://codeberg.org/ziglang/zig/issues/30980
+        .openbsd => true, // https://codeberg.org/ziglang/zig/issues/30982
+        else => false,
+    };
+}
+
+/// Returns whether the Zig standard library requires libc in order to interface
+/// with the operating system on the current target.
+pub fn requiresLibC() bool {
+    return targetRequiresLibC(&builtin.target);
+}
+
 test {
     _ = linux;
     if (native_os == .uefi) _ = uefi;

package/libc/musl/src/unistd/dup2.c

@@ -1,20 +0,0 @@
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int dup2(int old, int new)
-{
-	int r;
-#ifdef SYS_dup2
-	while ((r=__syscall(SYS_dup2, old, new))==-EBUSY);
-#else
-	if (old==new) {
-		r = __syscall(SYS_fcntl, old, F_GETFD);
-		if (r >= 0) return old;
-	} else {
-		while ((r=__syscall(SYS_dup3, old, new, 0))==-EBUSY);
-	}
-#endif
-	return __syscall_ret(r);
-}

package/libc/musl/src/unistd/dup3.c

@@ -1,26 +0,0 @@
-#define _GNU_SOURCE
-#include <unistd.h>
-#include <errno.h>
-#include <fcntl.h>
-#include "syscall.h"
-
-int __dup3(int old, int new, int flags)
-{
-	int r;
-#ifdef SYS_dup2
-	if (old==new) return __syscall_ret(-EINVAL);
-	if (flags) {
-		while ((r=__syscall(SYS_dup3, old, new, flags))==-EBUSY);
-		if (r!=-ENOSYS) return __syscall_ret(r);
-		if (flags & ~O_CLOEXEC) return __syscall_ret(-EINVAL);
-	}
-	while ((r=__syscall(SYS_dup2, old, new))==-EBUSY);
-	if (r >= 0 && (flags & O_CLOEXEC))
-		__syscall(SYS_fcntl, new, F_SETFD, FD_CLOEXEC);
-#else
-	while ((r=__syscall(SYS_dup3, old, new, flags))==-EBUSY);
-#endif
-	return __syscall_ret(r);
-}
-
-weak_alias(__dup3, dup3);