@zigc/lib 0.17.0-dev.9 → 0.17.0-dev.93

package/compiler_rt/log.zig

@@ -443,8 +443,6 @@ pub fn logq(a: f128) callconv(.c) f128 {
 
 pub fn logl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __logh(x),
-        32 => return logf(x),
         64 => return log(x),
         80 => return __logx(x),
         128 => return logq(x),

package/compiler_rt/log10.zig

@@ -177,8 +177,6 @@ pub fn log10q(a: f128) callconv(.c) f128 {
 
 pub fn log10l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log10h(x),
-        32 => return log10f(x),
         64 => return log10(x),
         80 => return __log10x(x),
         128 => return log10q(x),

package/compiler_rt/log2.zig

@@ -170,8 +170,6 @@ pub fn log2q(a: f128) callconv(.c) f128 {
 
 pub fn log2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log2h(x),
-        32 => return log2f(x),
         64 => return log2(x),
         80 => return __log2x(x),
         128 => return log2q(x),

package/compiler_rt/mulXi3.zig

@@ -63,7 +63,7 @@ fn DoubleInt(comptime T: type) type {
     };
 }
 
-fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
+pub fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
     const DT = DoubleInt(T);
     const word_t = compiler_rt.HalveInt(DT, false);
     const bits_in_word_2 = @sizeOf(T) * 8 / 2;

package/compiler_rt/round.zig

@@ -142,8 +142,6 @@ pub fn roundq(x_: f128) callconv(.c) f128 {
 
 pub fn roundl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __roundh(x),
-        32 => return roundf(x),
         64 => return round(x),
         80 => return __roundx(x),
         128 => return roundq(x),

package/compiler_rt/sin.zig

@@ -189,8 +189,6 @@ pub fn sinq(x: f128) callconv(.c) f128 {
 
 pub fn sinl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sinh(x),
-        32 => return sinf(x),
         64 => return sin(x),
         80 => return sinx(x),
         128 => return sinq(x),

package/compiler_rt/sincos.zig

@@ -292,8 +292,6 @@ pub fn sincosq(x: f128, r_sin: *f128, r_cos: *f128) callconv(.c) void {
 
 pub fn sincosl(x: c_longdouble, r_sin: *c_longdouble, r_cos: *c_longdouble) callconv(.c) void {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sincosh(x, r_sin, r_cos),
-        32 => return sincosf(x, r_sin, r_cos),
         64 => return sincos(x, r_sin, r_cos),
         80 => return sincosx(x, r_sin, r_cos),
         128 => return sincosq(x, r_sin, r_cos),

package/compiler_rt/sqrt.zig

@@ -481,8 +481,6 @@ fn _Qp_sqrt(c: *f128, a: *f128) callconv(.c) void {
 
 pub fn sqrtl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __sqrth(x),
-        32 => return sqrtf(x),
         64 => return sqrt(x),
         80 => return __sqrtx(x),
         128 => return sqrtq(x),

package/compiler_rt/ssp.zig

@@ -24,7 +24,7 @@ extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.c) ?[*]u8
 comptime {
     @export(&__stack_chk_fail, .{ .name = if (builtin.os.tag == .openbsd) "__stack_smash_handler" else "__stack_chk_fail", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
     symbol(&__chk_fail, "__chk_fail");
-    symbol(&__stack_chk_guard, "__stack_chk_guard");
+    symbol(&__stack_chk_guard, if (builtin.os.tag == .openbsd) "__guard_local" else "__stack_chk_guard");
     symbol(&__strcpy_chk, "__strcpy_chk");
     symbol(&__strncpy_chk, "__strncpy_chk");
     symbol(&__strcat_chk, "__strcat_chk");

package/compiler_rt/tan.zig

@@ -164,8 +164,6 @@ pub fn tanq(x: f128) callconv(.c) f128 {
 
 pub fn tanl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return tanh(x),
-        32 => return tanf(x),
         64 => return tan(x),
         80 => return tanx(x),
         128 => return tanq(x),

package/compiler_rt/trunc.zig

@@ -99,8 +99,6 @@ pub fn truncq(x: f128) callconv(.c) f128 {
 
 pub fn truncl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __trunch(x),
-        32 => return truncf(x),
         64 => return trunc(x),
         80 => return __truncx(x),
         128 => return truncq(x),

package/compiler_rt/udivmodei4.zig

@@ -13,6 +13,8 @@ const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max s
 comptime {
     symbol(&__udivei4, "__udivei4");
     symbol(&__umodei4, "__umodei4");
+    symbol(&__udivei5, "__udivei5");
+    symbol(&__umodei5, "__umodei5");
 }
 
 /// Get the value of a limb.
@@ -132,6 +134,32 @@ pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) ca
     @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
 }
 
+pub fn __udivei5(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
+}
+
+pub fn __umodei5(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
+}
+
 test "__udivei4/__umodei4" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

package/fuzzer.zig

@@ -171,6 +171,8 @@ const Executable = struct {
 
         const cache_dir = Io.Dir.cwd().createDirPathOpen(io, cache_dir_path, .{}) catch |e|
             panic("failed to open directory '{s}': {t}", .{ cache_dir_path, e });
+        cache_dir.createDirPath(io, "tmp") catch |e|
+            panic("failed to create directory 'tmp': {t}", .{e});
         log_f = cache_dir.createFile(io, "tmp/libfuzzer.log", .{ .truncate = false }) catch |e|
             panic("failed to create file 'tmp/libfuzzer.log': {t}", .{e});
         self.cache_f = cache_dir.createDirPathOpen(io, "f", .{}) catch |e|

package/libc/musl/arch/mipsn32/syscall_arch.h

@@ -1,6 +1,9 @@
 #define __SYSCALL_LL_E(x) (x)
 #define __SYSCALL_LL_O(x) (x)
 
+#define __scc(X) sizeof(1?(X):0ULL) < 8 ? (unsigned long) (X) : (long long) (X)
+typedef long long syscall_arg_t;
+
 #define SYSCALL_RLIM_INFINITY (-1UL/2)
 
 #if __mips_isa_rev >= 6
@@ -13,9 +16,9 @@
 	"$14", "$15", "$24", "$25", "hi", "lo", "memory"
 #endif
 
-static inline long __syscall0(long n)
+static inline long __syscall0(long long n)
 {
-	register long r7 __asm__("$7");
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 	__asm__ __volatile__ (
 		"daddu $2,$0,%2 ; syscall"
@@ -25,10 +28,10 @@ static inline long __syscall0(long n)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall1(long n, long a)
+static inline long __syscall1(long long n, long long a)
 {
-	register long r4 __asm__("$4") = a;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 	__asm__ __volatile__ (
 		"daddu $2,$0,%2 ; syscall"
@@ -38,11 +41,11 @@ static inline long __syscall1(long n, long a)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall2(long n, long a, long b)
+static inline long __syscall2(long long n, long long a, long long b)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -53,12 +56,12 @@ static inline long __syscall2(long n, long a, long b)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall3(long n, long a, long b, long c)
+static inline long __syscall3(long long n, long long a, long long b, long long c)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -69,12 +72,12 @@ static inline long __syscall3(long n, long a, long b, long c)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall4(long n, long a, long b, long c, long d)
+static inline long __syscall4(long long n, long long a, long long b, long long c, long long d)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -85,13 +88,13 @@ static inline long __syscall4(long n, long a, long b, long c, long d)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall5(long n, long a, long b, long c, long d, long e)
+static inline long __syscall5(long long n, long long a, long long b, long long c, long long d, long long e)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
-	register long r8 __asm__("$8") = e;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
+	register long long r8 __asm__("$8") = e;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -102,14 +105,14 @@ static inline long __syscall5(long n, long a, long b, long c, long d, long e)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
+static inline long __syscall6(long long n, long long a, long long b, long long c, long long d, long long e, long long f)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
-	register long r8 __asm__("$8") = e;
-	register long r9 __asm__("$9") = f;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
+	register long long r8 __asm__("$8") = e;
+	register long long r9 __asm__("$9") = f;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (

package/package.json

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

package/std/Build/Step/Compile.zig

@@ -1393,7 +1393,6 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         try zig_args.append("--debug-incremental");
     }
 
-    if (b.verbose_cimport) try zig_args.append("--verbose-cimport");
     if (b.verbose_air) try zig_args.append("--verbose-air");
     if (b.verbose_llvm_ir) |path| try zig_args.append(b.fmt("--verbose-llvm-ir={s}", .{path}));
     if (b.verbose_llvm_bc) |path| try zig_args.append(b.fmt("--verbose-llvm-bc={s}", .{path}));

package/std/Build.zig

@@ -38,7 +38,6 @@ verbose_cc: bool,
 verbose_air: bool,
 verbose_llvm_ir: ?[]const u8,
 verbose_llvm_bc: ?[]const u8,
-verbose_cimport: bool,
 verbose_llvm_cpu_features: bool,
 reference_trace: ?u32 = null,
 invalid_user_input: bool,
@@ -278,7 +277,6 @@ pub fn create(
         .verbose_air = false,
         .verbose_llvm_ir = null,
         .verbose_llvm_bc = null,
-        .verbose_cimport = false,
         .verbose_llvm_cpu_features = false,
         .invalid_user_input = false,
         .allocator = arena,
@@ -377,7 +375,6 @@ fn createChildOnly(
         .verbose_air = parent.verbose_air,
         .verbose_llvm_ir = parent.verbose_llvm_ir,
         .verbose_llvm_bc = parent.verbose_llvm_bc,
-        .verbose_cimport = parent.verbose_cimport,
         .verbose_llvm_cpu_features = parent.verbose_llvm_cpu_features,
         .reference_trace = parent.reference_trace,
         .invalid_user_input = false,

package/std/Io/Dispatch.zig

@@ -459,7 +459,6 @@ pub fn io(ev: *Evented) Io {
             .netConnectUnix = netConnectUnixUnavailable,
             .netSocketCreatePair = netSocketCreatePairUnavailable,
             .netSend = netSendUnavailable,
-            .netRead = netReadUnavailable,
             .netWrite = netWriteUnavailable,
             .netWriteFile = netWriteFileUnavailable,
             .netClose = netClose,
@@ -1713,6 +1712,7 @@ fn operate(userdata: ?*anyopaque, operation: Io.Operation) Io.Cancelable!Io.Oper
         },
         .device_io_control => |*o| return .{ .device_io_control = try deviceIoControl(o) },
         .net_receive => @panic("TODO implement net_receive operation"),
+        .net_read => @panic("TODO implement net_read operation"),
     }
 }
 
@@ -2134,6 +2134,7 @@ fn batchDrainSubmitted(
                 },
                 .device_io_control => {},
                 .net_receive => @panic("TODO implement batched net_receive"),
+                .net_read => @panic("TODO implement batched net_read"),
             };
             if (concurrency) return error.ConcurrencyUnavailable;
             break :result try operate(ev, storage.submission.operation);
@@ -2193,6 +2194,7 @@ fn batchSourceEvent(context: ?*anyopaque) callconv(.c) void {
         },
         .device_io_control => unreachable,
         .net_receive => @panic("TODO implement batched net_receive"),
+        .net_read => @panic("TODO implement batched net_read"),
     };
 
     switch (pending.node.prev) {
@@ -4877,18 +4879,6 @@ fn netSendUnavailable(
     return .{ error.NetworkDown, 0 };
 }
 
-fn netReadUnavailable(
-    userdata: ?*anyopaque,
-    fd: net.Socket.Handle,
-    data: [][]u8,
-) net.Stream.Reader.Error!usize {
-    const ev: *Evented = @ptrCast(@alignCast(userdata));
-    _ = ev;
-    _ = fd;
-    _ = data;
-    return error.NetworkDown;
-}
-
 fn netWriteUnavailable(
     userdata: ?*anyopaque,
     handle: net.Socket.Handle,

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);
 }