@zigc/lib 0.16.0-dev.3091 → 0.16.0-dev.3128

package/c/math.zig

@@ -35,33 +35,47 @@ comptime {
     }
 
     if (builtin.target.isMinGW() or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
-        symbol(&coshf, "coshf");
+        symbol(&frexpf, "frexpf");
+        symbol(&frexpl, "frexpl");
         symbol(&hypotf, "hypotf");
         symbol(&hypotl, "hypotl");
-        symbol(&modff, "modff");
         symbol(&modfl, "modfl");
-        symbol(&nan, "nan");
-        symbol(&nanf, "nanf");
+    }
+
+    if ((builtin.target.isMinGW() and @sizeOf(f64) != @sizeOf(c_longdouble)) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&atanl, "atanl");
+        symbol(&copysignl, "copysignl");
         symbol(&nanl, "nanl");
+    }
+
+    if ((builtin.target.isMinGW() and builtin.cpu.arch == .x86) or builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
+        symbol(&acosf, "acosf");
+        symbol(&atanf, "atanf");
+        symbol(&coshf, "coshf");
+        symbol(&modff, "modff");
         symbol(&tanhf, "tanhf");
     }
 
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
         symbol(&acos, "acos");
-        symbol(&acosf, "acosf");
         symbol(&acoshf, "acoshf");
         symbol(&asin, "asin");
         symbol(&atan, "atan");
-        symbol(&atanf, "atanf");
-        symbol(&atanl, "atanl");
         symbol(&cbrt, "cbrt");
         symbol(&cbrtf, "cbrtf");
         symbol(&cosh, "cosh");
         symbol(&exp10, "exp10");
         symbol(&exp10f, "exp10f");
         symbol(&fdim, "fdim");
+        symbol(&finite, "finite");
+        symbol(&finitef, "finitef");
+        symbol(&frexp, "frexp");
         symbol(&hypot, "hypot");
+        symbol(&lrint, "lrint");
+        symbol(&lrintf, "lrintf");
         symbol(&modf, "modf");
+        symbol(&nan, "nan");
+        symbol(&nanf, "nanf");
         symbol(&pow, "pow");
         symbol(&pow10, "pow10");
         symbol(&pow10f, "pow10f");
@@ -72,9 +86,8 @@ comptime {
         symbol(&copysign, "copysign");
         symbol(&copysignf, "copysignf");
         symbol(&rint, "rint");
+        symbol(&rintf, "rintf");
     }
-
-    symbol(&copysignl, "copysignl");
 }
 
 fn acos(x: f64) callconv(.c) f64 {
@@ -161,6 +174,45 @@ fn fdim(x: f64, y: f64) callconv(.c) f64 {
     return 0;
 }
 
+fn finite(x: f64) callconv(.c) c_int {
+    return if (math.isFinite(x)) 1 else 0;
+}
+
+fn finitef(x: f32) callconv(.c) c_int {
+    return if (math.isFinite(x)) 1 else 0;
+}
+
+fn frexpGeneric(comptime T: type, x: T, e: *c_int) T {
+    // libc expects `*e` to be unspecified in this case; an unspecified C value
+    // should be a valid value of the relevant type, yet Zig's std
+    // implementation sets it to `undefined` -- which can even be nonsense
+    // according to the type (int). Therefore, we're setting it to a valid
+    // int value in Zig -- a zero.
+    //
+    // This mirrors the handling of infinities, where libc also expects
+    // unspecified for the value of `*e` and Zig std sets it to a zero.
+    if (math.isNan(x)) {
+        e.* = 0;
+        return x;
+    }
+
+    const r = math.frexp(x);
+    e.* = r.exponent;
+    return r.significand;
+}
+
+fn frexp(x: f64, e: *c_int) callconv(.c) f64 {
+    return frexpGeneric(f64, x, e);
+}
+
+fn frexpf(x: f32, e: *c_int) callconv(.c) f32 {
+    return frexpGeneric(f32, x, e);
+}
+
+fn frexpl(x: c_longdouble, e: *c_int) callconv(.c) c_longdouble {
+    return frexpGeneric(c_longdouble, x, e);
+}
+
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
     return math.hypot(x, y);
 }
@@ -185,6 +237,14 @@ fn isnanl(x: c_longdouble) callconv(.c) c_int {
     return if (math.isNan(x)) 1 else 0;
 }
 
+fn lrint(x: f64) callconv(.c) c_long {
+    return @intFromFloat(rint(x));
+}
+
+fn lrintf(x: f32) callconv(.c) c_long {
+    return @intFromFloat(rintf(x));
+}
+
 fn modfGeneric(comptime T: type, x: T, iptr: *T) T {
     if (math.isNegativeInf(x)) {
         iptr.* = -math.inf(T);
@@ -299,7 +359,7 @@ fn pow10f(x: f32) callconv(.c) f32 {
 }
 
 fn rint(x: f64) callconv(.c) f64 {
-    const toint: f64 = 1.0 / @as(f64, math.floatEps(f64));
+    const toint: f64 = 1.0 / math.floatEps(f64);
     const a: u64 = @bitCast(x);
     const e = a >> 52 & 0x7ff;
     const s = a >> 63;
@@ -319,39 +379,70 @@ fn rint(x: f64) callconv(.c) f64 {
     return y;
 }
 
-test "rint" {
+fn rintf(x: f32) callconv(.c) f32 {
+    const toint: f32 = 1.0 / math.floatEps(f32);
+    const a: u32 = @bitCast(x);
+    const e = a >> 23 & 0xff;
+    const s = a >> 31;
+    var y: f32 = undefined;
+
+    if (e >= 0x7f + 23) {
+        return x;
+    }
+
+    if (s == 1) {
+        y = x - toint + toint;
+    } else {
+        y = x + toint - toint;
+    }
+
+    if (y == 0) {
+        return if (s == 1) -0.0 else 0;
+    }
+    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(f64, 42.0), rint(42.2));
-    try expectEqual(@as(f64, 42.0), rint(41.8));
+    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(f64, -6.0), rint(-5.9));
-    try expectEqual(@as(f64, -6.0), rint(-6.1));
+    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(f64, 5.0), rint(5.0));
-    try expectEqual(@as(f64, -10.0), rint(-10.0));
-    try expectEqual(@as(f64, 0.0), rint(0.0));
+    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: f64 = 9007199254740992.0; // 2^53
-    try expectEqual(large, rint(large));
-    try expectEqual(-large, rint(-large));
+    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 = rint(0.3);
-    try expectEqual(@as(f64, 0.0), pos_result);
-    try expect(@as(u64, @bitCast(pos_result)) == 0);
+    const pos_result = f(0.3);
+    try expect(math.isPositiveZero(pos_result));
 
     // Small negative numbers round to negative zero
-    const neg_result = rint(-0.3);
-    try expectEqual(@as(f64, 0.0), neg_result);
-    const bits: u64 = @bitCast(neg_result);
-    try expect((bits >> 63) == 1);
+    const neg_result = f(-0.3);
+    try expect(math.isNegativeZero(neg_result));
 
     // Exact half rounds to nearest even (banker's rounding)
-    try expectEqual(@as(f64, 2.0), rint(2.5));
-    try expectEqual(@as(f64, 4.0), rint(3.5));
+    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 {

package/compiler/build_runner.zig

@@ -424,6 +424,7 @@ pub fn main(init: process.Init.Minimal) !void {
                     fatal("unable to parse jobs count '{s}': {t}", .{ text, err });
                 if (n < 1) fatal("number of jobs must be at least 1", .{});
                 threaded.setAsyncLimit(.limited(n));
+                graph.max_jobs = n;
             } else if (mem.eql(u8, arg, "--")) {
                 builder.args = argsRest(args, arg_idx);
                 break;

package/compiler/test_runner.zig

@@ -6,6 +6,7 @@ const Io = std.Io;
 const fatal = std.process.fatal;
 const testing = std.testing;
 const assert = std.debug.assert;
+const panic = std.debug.panic;
 const fuzz_abi = std.Build.abi.fuzz;
 
 pub const std_options: std.Options = .{
@@ -17,6 +18,8 @@ var fba: std.heap.FixedBufferAllocator = .init(&fba_buffer);
 var fba_buffer: [8192]u8 = undefined;
 var stdin_buffer: [4096]u8 = undefined;
 var stdout_buffer: [4096]u8 = undefined;
+var stdin_reader: Io.File.Reader = undefined;
+var stdout_writer: Io.File.Writer = undefined;
 const runner_threaded_io: Io = Io.Threaded.global_single_threaded.io();
 
 /// Keep in sync with logic in `std.Build.addRunArtifact` which decides whether
@@ -38,10 +41,10 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (need_simple) {
-        return mainSimple() catch |err| std.debug.panic("test failure: {t}", .{err});
+        return mainSimple() catch |err| panic("test failure: {t}", .{err});
     }
 
-    const args = init.args.toSlice(fba.allocator()) catch |err| std.debug.panic("unable to parse command line args: {t}", .{err});
+    const args = init.args.toSlice(fba.allocator()) catch |err| panic("unable to parse command line args: {t}", .{err});
 
     var listen = false;
     var opt_cache_dir: ?[]const u8 = null;
@@ -55,7 +58,7 @@ pub fn main(init: std.process.Init.Minimal) void {
         } else if (std.mem.startsWith(u8, arg, "--cache-dir")) {
             opt_cache_dir = arg["--cache-dir=".len..];
         } else {
-            std.debug.panic("unrecognized command line argument: {s}", .{arg});
+            panic("unrecognized command line argument: {s}", .{arg});
         }
     }
 
@@ -65,7 +68,7 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (listen) {
-        return mainServer(init) catch |err| std.debug.panic("internal test runner failure: {t}", .{err});
+        return mainServer(init) catch |err| panic("internal test runner failure: {t}", .{err});
     } else {
         return mainTerminal(init);
     }
@@ -73,24 +76,14 @@ pub fn main(init: std.process.Init.Minimal) void {
 
 fn mainServer(init: std.process.Init.Minimal) !void {
     @disableInstrumentation();
-    var stdin_reader = Io.File.stdin().readerStreaming(runner_threaded_io, &stdin_buffer);
-    var stdout_writer = Io.File.stdout().writerStreaming(runner_threaded_io, &stdout_buffer);
+    stdin_reader = .initStreaming(.stdin(), runner_threaded_io, &stdin_buffer);
+    stdout_writer = .initStreaming(.stdout(), runner_threaded_io, &stdout_buffer);
     var server = try std.zig.Server.init(.{
         .in = &stdin_reader.interface,
         .out = &stdout_writer.interface,
         .zig_version = builtin.zig_version_string,
     });
 
-    if (builtin.fuzz) {
-        const coverage = fuzz_abi.fuzzer_coverage();
-        try server.serveCoverageIdMessage(
-            coverage.id,
-            coverage.runs,
-            coverage.unique,
-            coverage.seen,
-        );
-    }
-
     while (true) {
         const hdr = try server.receiveMessage();
         switch (hdr.tag) {
@@ -180,48 +173,75 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 // since they are not present.
                 if (!builtin.fuzz) unreachable;
 
-                const index: u32 = @intCast(index: {
-                    testing.allocator_instance = .{};
-                    defer if (testing.allocator_instance.deinit() == .leak) {
-                        @panic("internal test runner memory leak");
-                    };
-
-                    const name_len = try server.receiveBody_u32();
-                    const name = try server.in.readAlloc(testing.allocator, @intCast(name_len));
-                    defer testing.allocator.free(name);
-                    for (0.., builtin.test_functions) |i, test_fn| {
-                        if (std.mem.eql(u8, name, test_fn.name)) {
-                            break :index i;
-                        }
-                    } else {
-                        std.debug.panic("fuzz test {s} no longer exists", .{name});
-                    }
+                var gpa_instance: std.heap.DebugAllocator(.{}) = .init;
+                defer if (gpa_instance.deinit() == .leak) {
+                    @panic("internal test runner memory leak");
+                };
+                const gpa = gpa_instance.allocator();
+                var io_instance: Io.Threaded = .init(gpa, .{
+                    .argv0 = .init(init.args),
+                    .environ = init.environ,
                 });
+                defer io_instance.deinit();
+                const io = io_instance.io();
+
                 const mode: fuzz_abi.LimitKind = @enumFromInt(try server.receiveBody_u8());
                 const amount_or_instance = try server.receiveBody_u64();
+                const main_instance = mode == .iterations or amount_or_instance == 0;
+
+                if (main_instance) {
+                    const coverage = fuzz_abi.fuzzer_coverage();
+                    try server.serveCoverageIdMessage(
+                        coverage.id,
+                        coverage.runs,
+                        coverage.unique,
+                        coverage.seen,
+                    );
+                }
 
-                const test_fn = builtin.test_functions[index];
-                const entry_addr = @intFromPtr(test_fn.func);
+                const n_tests: u32 = try server.receiveBody_u32();
+                const test_indexes = try gpa.alloc(u32, n_tests);
+                defer gpa.free(test_indexes);
+                fuzz_runner = .{
+                    .indexes = test_indexes,
+                    .server = &server,
+                    .gpa = gpa,
+                    .io = io,
+                    .input_poller = undefined,
+                };
 
-                try server.serveU64Message(.fuzz_start_addr, fuzz_abi.fuzzer_unslide_address(entry_addr));
-                defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
-                is_fuzz_test = false;
-                fuzz_test_index = index;
-                fuzz_mode = mode;
-                fuzz_amount_or_instance = amount_or_instance;
+                {
+                    var large_name_buf: std.ArrayList(u8) = .empty;
+                    defer large_name_buf.deinit(gpa);
+                    for (test_indexes) |*i| {
+                        const name_len = try server.receiveBody_u32();
+                        const name = if (name_len <= server.in.buffer.len)
+                            try server.in.take(name_len)
+                        else large_name: {
+                            try large_name_buf.resize(gpa, name_len);
+                            try server.in.readSliceAll(large_name_buf.items);
+                            break :large_name large_name_buf.items;
+                        };
+
+                        for (0.., builtin.test_functions) |test_i, test_fn| {
+                            if (std.mem.eql(u8, name, test_fn.name)) {
+                                i.* = @intCast(test_i);
+                                break;
+                            }
+                        } else {
+                            panic("fuzz test {s} no longer exists", .{name});
+                        }
 
-                test_fn.func() catch |err| switch (err) {
-                    error.SkipZigTest => return,
-                    else => {
-                        if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace);
+                        if (main_instance) {
+                            const relocated_entry_addr = @intFromPtr(builtin.test_functions[i.*].func);
+                            const entry_addr = fuzz_abi.fuzzer_unslide_address(relocated_entry_addr);
+                            try server.serveU64Message(.fuzz_start_addr, entry_addr);
                         }
-                        std.debug.print("failed with error.{t}\n", .{err});
-                        std.process.exit(1);
-                    },
-                };
-                if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
-                if (log_err_count != 0) @panic("error logs detected");
+                    }
+                }
+
+                fuzz_abi.fuzzer_main(n_tests, testing.random_seed, mode, amount_or_instance);
+
                 assert(mode != .forever);
                 std.process.exit(0);
             },
@@ -382,16 +402,126 @@ pub fn mainSimple() anyerror!void {
         passed += 1;
     }
     if (enable_print) {
-        var stdout_writer = stdout.writer(runner_threaded_io, &.{});
-        stdout_writer.interface.print("{} passed, {} skipped, {} failed\n", .{ passed, skipped, failed }) catch {};
+        var unbuffered_stdout_writer = stdout.writer(runner_threaded_io, &.{});
+        unbuffered_stdout_writer.interface.print(
+            "{} passed, {} skipped, {} failed\n",
+            .{ passed, skipped, failed },
+        ) catch {};
     }
     if (failed != 0) std.process.exit(1);
 }
 
 var is_fuzz_test: bool = undefined;
-var fuzz_test_index: u32 = undefined;
-var fuzz_mode: fuzz_abi.LimitKind = undefined;
-var fuzz_amount_or_instance: u64 = undefined;
+var fuzz_runner: if (builtin.fuzz) struct {
+    indexes: []u32,
+    server: *std.zig.Server,
+    gpa: std.mem.Allocator,
+    io: Io,
+    input_poller: Io.Future(Io.Cancelable!void),
+
+    comptime {
+        assert(builtin.fuzz); // `fuzz_runner` was analyzed in non-fuzzing compilation
+    }
+
+    export fn runner_test_run(i: u32) void {
+        @disableInstrumentation();
+
+        fuzz_runner.server.serveU32Message(.fuzz_test_change, i) catch |e| switch (e) {
+            error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
+        };
+
+        testing.allocator_instance = .{};
+        defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+        is_fuzz_test = false;
+
+        builtin.test_functions[fuzz_runner.indexes[i]].func() catch |err| switch (err) {
+            error.SkipZigTest => return,
+            else => {
+                if (@errorReturnTrace()) |trace| {
+                    std.debug.dumpStackTrace(trace);
+                }
+                std.debug.print("failed with error.{t}\n", .{err});
+                std.process.exit(1);
+            },
+        };
+
+        if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
+        if (log_err_count != 0) @panic("error logs detected");
+    }
+
+    export fn runner_test_name(i: u32) fuzz_abi.Slice {
+        @disableInstrumentation();
+        return .fromSlice(builtin.test_functions[fuzz_runner.indexes[i]].name);
+    }
+
+    export fn runner_broadcast_input(test_i: u32, bytes_slice: fuzz_abi.Slice) void {
+        @disableInstrumentation();
+        const bytes = bytes_slice.toSlice();
+        fuzz_runner.server.serveBroadcastFuzzInputMessage(test_i, bytes) catch |e| switch (e) {
+            error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
+        };
+    }
+
+    export fn runner_start_input_poller() void {
+        @disableInstrumentation();
+        const future = fuzz_runner.io.concurrent(inputPoller, .{}) catch |e| switch (e) {
+            error.ConcurrencyUnavailable => @panic("failed to spawn concurrent fuzz input poller"),
+        };
+        fuzz_runner.input_poller = future;
+    }
+
+    export fn runner_stop_input_poller() void {
+        @disableInstrumentation();
+        assert(fuzz_runner.input_poller.cancel(fuzz_runner.io) == error.Canceled);
+    }
+
+    export fn runner_futex_wait(ptr: *const u32, expected: u32) bool {
+        @disableInstrumentation();
+        return fuzz_runner.io.futexWait(u32, ptr, expected) == error.Canceled;
+    }
+
+    export fn runner_futex_wake(ptr: *const u32, waiters: u32) void {
+        @disableInstrumentation();
+        fuzz_runner.io.futexWake(u32, ptr, waiters);
+    }
+
+    fn inputPoller() Io.Cancelable!void {
+        @disableInstrumentation();
+        switch (inputPollerInner()) {
+            error.Canceled => return error.Canceled,
+            error.ReadFailed => {
+                if (stdin_reader.err.? == error.Canceled) return error.Canceled;
+                panic("failed to read from stdin: {t}", .{stdin_reader.err.?});
+            },
+            error.EndOfStream => @panic("unexpected end of stdin"),
+        }
+    }
+
+    fn inputPollerInner() (Io.Cancelable || Io.Reader.Error) {
+        @disableInstrumentation();
+        const server = fuzz_runner.server;
+        var large_bytes_list: std.ArrayList(u8) = .empty;
+        defer large_bytes_list.deinit(fuzz_runner.gpa);
+        while (true) {
+            const hdr = try server.receiveMessage();
+            if (hdr.tag != .new_fuzz_input) {
+                panic("unexpected message: {x}\n", .{@intFromEnum(hdr.tag)});
+            }
+            const test_i = try server.receiveBody_u32();
+            const input_len = hdr.bytes_len - 4;
+            const bytes = if (input_len <= server.in.buffer.len)
+                try server.in.take(input_len)
+            else bytes: {
+                large_bytes_list.resize(fuzz_runner.gpa, @intCast(input_len)) catch @panic("OOM");
+                try server.in.readSliceAll(large_bytes_list.items);
+                break :bytes large_bytes_list.items;
+            };
+            if (fuzz_abi.fuzzer_receive_input(test_i, .fromSlice(bytes))) {
+                return error.Canceled;
+            }
+        }
+    }
+} else void = undefined;
 
 pub fn fuzz(
     context: anytype,
@@ -448,16 +578,18 @@ pub fn fuzz(
             return false;
         }
     };
+
     if (builtin.fuzz) {
+        // Preserve the calling test's allocator state
         const prev_allocator_state = testing.allocator_instance;
         testing.allocator_instance = .{};
         defer testing.allocator_instance = prev_allocator_state;
-        global.ctx = context;
 
-        fuzz_abi.fuzzer_set_test(&global.test_one, .fromSlice(builtin.test_functions[fuzz_test_index].name));
+        global.ctx = context;
+        fuzz_abi.fuzzer_set_test(&global.test_one);
         for (options.corpus) |elem|
             fuzz_abi.fuzzer_new_input(.fromSlice(elem));
-        fuzz_abi.fuzzer_main(fuzz_mode, fuzz_amount_or_instance);
+        fuzz_abi.fuzzer_start_test();
         return;
     }