@zigc/lib 0.17.0-dev.704 → 0.17.0-dev.813

package/std/crypto/tls/Client.zig

@@ -1202,6 +1202,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
             .tls_1_2 => {
                 const pv = &p.tls_1_2;
                 const P = @TypeOf(p.*);
+                if (record_len < P.record_iv_length + P.mac_length) return failRead(c, error.TlsRecordOverflow);
                 const message_len: u16 = record_len - P.record_iv_length - P.mac_length;
                 const ad_header = input.take(tls.record_header_len) catch unreachable; // already peeked
                 const ad = mem.toBytes(big(c.read_seq)) ++
@@ -1674,7 +1675,7 @@ else
         .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
     });
 
-fn testReadError(input_buf: []const u8, cipher: tls.ApplicationCipher) ReadError {
+fn testReadError(input_buf: []const u8, tls_version: tls.ProtocolVersion, cipher: tls.ApplicationCipher) ReadError {
     var input_reader: Reader = .fixed(input_buf);
     var read_buf: [tls.max_ciphertext_record_len]u8 = undefined;
     var c: Client = .{
@@ -1687,7 +1688,7 @@ fn testReadError(input_buf: []const u8, cipher: tls.ApplicationCipher) ReadError
         },
         .output = undefined,
         .writer = undefined,
-        .tls_version = .tls_1_3,
+        .tls_version = tls_version,
         .read_seq = 0,
         .write_seq = 0,
         .received_close_notify = false,
@@ -1715,6 +1716,7 @@ test "empty inner plaintext" {
 
     try std.testing.expectEqual(error.TlsDecodeError, testReadError(
         &record_header ++ ciphertext ++ tag,
+        .tls_1_3,
         .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
             .server_key = key,
             .server_iv = iv,
@@ -1734,6 +1736,7 @@ test "record shorter than tag" {
 
     try std.testing.expectEqual(error.TlsRecordOverflow, testReadError(
         &wire,
+        .tls_1_3,
         .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
             .server_key = undefined,
             .server_iv = undefined,
@@ -1744,3 +1747,15 @@ test "record shorter than tag" {
         } } },
     ));
 }
+
+test "TLS 1.2 record shorter than IV plus tag" {
+    const P = tls.ApplicationCipherT(crypto.aead.aes_gcm.Aes128Gcm, crypto.hash.sha2.Sha256, 8);
+    const record_len: u16 = P.record_iv_length + P.mac_length - 1;
+    const header = [_]u8{ 0x17, 0x03, 0x03 } ++ mem.toBytes(big(record_len));
+
+    try std.testing.expectEqual(error.TlsRecordOverflow, testReadError(
+        &(header ++ @as([record_len]u8, @splat(0))),
+        .tls_1_2,
+        .{ .AES_128_GCM_SHA256 = .{ .tls_1_2 = mem.zeroes(P.Tls_1_2) } },
+    ));
+}

package/std/debug/cpu_context.zig

@@ -50,7 +50,7 @@ pub fn fromPosixSignalContext(ctx_ptr: ?*const anyopaque) ?Native {
         };
 
         // I have no idea why the kernel is storing these registers in such a bizarre order...
-        std.mem.reverse(native.r[0..]);
+        std.mem.reverse(u32, native.r[0..]);
 
         return native;
     } else if (native_arch == .loongarch32 and native_os == .linux) {
@@ -350,7 +350,7 @@ const Alpha = extern struct {
             \\1:
             \\ stq $1, 0x100($0)
             :
-            : [ctx] "{r0}" (&ctx),
+            : [ctx] "{$0}" (&ctx),
             : .{ .r1 = true, .memory = true });
         return ctx;
     }
@@ -362,7 +362,7 @@ const Alpha = extern struct {
         return ctx.pc;
     }
 
-    pub fn dwarfRegisterBytes(ctx: *Aarch64, register_num: u16) DwarfRegisterError![]u8 {
+    pub fn dwarfRegisterBytes(ctx: *Alpha, register_num: u16) DwarfRegisterError![]u8 {
         switch (register_num) {
             0...31 => return @ptrCast(&ctx.r[register_num]),
             64 => return @ptrCast(&ctx.pc),

package/std/heap/BrkAllocator.zig

@@ -45,7 +45,7 @@ const size_class_count = math.log2(bigpage_size) - min_class;
 /// 1 - 2 bigpages
 /// 2 - 4 bigpages
 /// etc.
-const big_size_class_count = math.log2(bigpage_count);
+const big_size_class_count = math.log2(bigpage_count) + 1;
 
 fn alloc(ctx: *anyopaque, len: usize, alignment: Alignment, return_address: usize) ?[*]u8 {
     _ = ctx;

package/std/json/static.zig

@@ -32,6 +32,7 @@ pub const ParseOptions = struct {
     /// The default for `parseFromSlice` or `parseFromTokenSource` with a `*std.json.Scanner` input
     /// is the length of the input slice, which means `error.ValueTooLong` will never be returned.
     /// The default for `parseFromTokenSource` with a `*std.json.Reader` is `std.json.default_max_value_len`.
+    /// Ignored for values that don't need allocation or are not copied (see `allocate`).
     /// Ignored for `parseFromValue` and `parseFromValueLeaky`.
     max_value_len: ?usize = null,
 
@@ -495,7 +496,7 @@ pub fn innerParse(
                             if (ptrInfo.sentinel()) |s| {
                                 // Use our own array list so we can append the sentinel.
                                 var value_list = ArrayList(u8).init(allocator);
-                                _ = try source.allocNextIntoArrayList(&value_list, .alloc_always);
+                                _ = try source.allocNextIntoArrayListMax(&value_list, .alloc_always, options.max_value_len.?);
                                 return try value_list.toOwnedSliceSentinel(s);
                             }
                             if (ptrInfo.attrs.@"const") {

package/std/math/isnan.zig

@@ -29,6 +29,11 @@ test isNan {
 test isSignalNan {
     if (builtin.zig_backend == .stage2_x86_64 and builtin.object_format == .coff and builtin.abi != .gnu) return error.SkipZigTest;
 
+    if (builtin.os.tag == .windows) {
+        // https://codeberg.org/ziglang/zig/issues/35519
+        return error.SkipZigTest;
+    }
+
     inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| {
         // TODO: Signalling NaN values get converted to quiet NaN values in
         //       some cases where they shouldn't such that this can fail.

package/std/math/log1p.zig

@@ -43,17 +43,14 @@ fn log1p_32(x: f32) f32 {
 
     // 1 + x < sqrt(2)+
     if (ix < 0x3ED413D0 or ix >> 31 != 0) {
-        // x <= -1.0
-        if (ix >= 0xBF800000) {
+        // x = -1.0
+        if (ix == 0xBF800000)
             // log1p(-1) = -inf
-            if (x == -1.0) {
-                return -math.inf(f32);
-            }
+            return x / 0.0;
+        // x < -1.0
+        if (ix > 0xBF800000)
             // log1p(x < -1) = nan
-            else {
-                return math.nan(f32);
-            }
-        }
+            return (x - x) / 0.0;
         // |x| < 2^(-24)
         if ((ix << 1) < (0x33800000 << 1)) {
             // underflow if subnormal
@@ -122,21 +119,18 @@ fn log1p_64(x: f64) f64 {
 
     // 1 + x < sqrt(2)
     if (hx < 0x3FDA827A or hx >> 31 != 0) {
-        // x <= -1.0
-        if (hx >= 0xBFF00000) {
+        // x = -1.0
+        if (ix == 0xBFF0000000000000)
             // log1p(-1) = -inf
-            if (x == -1.0) {
-                return -math.inf(f64);
-            }
+            return x / 0.0;
+        // x < -1.0
+        if (hx >= 0xBFF00000)
             // log1p(x < -1) = nan
-            else {
-                return math.nan(f64);
-            }
-        }
+            return (x - x) / 0.0;
         // |x| < 2^(-53)
         if ((hx << 1) < (0x3CA00000 << 1)) {
             if ((hx & 0x7FF00000) == 0) {
-                math.raiseUnderflow();
+                mem.doNotOptimizeAway(@as(f32, @floatCast(x)));
             }
             return x;
         }

package/std/math.zig

@@ -461,6 +461,11 @@ pub fn wrap(x: anytype, r: anytype) @TypeOf(x) {
     }
 }
 test wrap {
+    if (builtin.os.tag == .windows and builtin.cpu.arch == .x86) {
+        // https://codeberg.org/ziglang/zig/issues/35520
+        return error.SkipZigTest;
+    }
+
     // Within range
     try testing.expect(wrap(@as(i32, -75), @as(i32, 180)) == -75);
     try testing.expect(wrap(@as(i32, -75), @as(i32, -180)) == -75);

package/std/meta.zig

@@ -15,7 +15,7 @@ test {
 }
 
 /// Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
-pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
+pub fn stringToEnum(comptime T: type, tag_name: []const u8) ?T {
     // Using StaticStringMap here is more performant, but it will start to take too
     // long to compile if the enum is large enough, due to the current limits of comptime
     // performance when doing things like constructing lookup maps at comptime.
@@ -23,19 +23,10 @@ pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
     // - https://github.com/ziglang/zig/issues/4055
     // - https://github.com/ziglang/zig/issues/3863
     if (@typeInfo(T).@"enum".field_names.len <= 100) {
-        const kvs = comptime build_kvs: {
-            const EnumKV = struct { []const u8, T };
-            var kvs_array: [@typeInfo(T).@"enum".field_names.len]EnumKV = undefined;
-            for (@typeInfo(T).@"enum".field_names, 0..) |name, i| {
-                kvs_array[i] = .{ name, @field(T, name) };
-            }
-            break :build_kvs kvs_array[0..];
-        };
-        const map = std.StaticStringMap(T).initComptime(kvs);
-        return map.get(str);
+        return std.StaticStringMap(T).initEnum().get(tag_name);
     } else {
         inline for (@typeInfo(T).@"enum".field_names) |name| {
-            if (mem.eql(u8, str, name)) {
+            if (mem.eql(u8, tag_name, name)) {
                 return @field(T, name);
             }
         }

package/std/os/linux/csky.zig

@@ -0,0 +1,165 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+        : .{ .memory = true });
+}
+
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+        : .{ .memory = true });
+}
+
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+        : .{ .memory = true });
+}
+
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+        : .{ .memory = true });
+}
+
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+        : .{ .memory = true });
+}
+
+pub fn syscall5(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+        : .{ .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
+) u32 {
+    return asm volatile ("trap 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r7}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+          [arg6] "{r5}" (arg6),
+        : .{ .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r0,   r1,    r2,    r3,  +0,   +4,  +8
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         r7         r0,    r1,    r2,   r3,  r4
+    asm volatile (
+        \\ // Preserve callee-saved registers.
+        \\ mov t0, r4
+        \\ mov t1, r7
+        \\
+        \\ andi r1, r1, -8
+        \\
+        \\ subi r1, 8
+        \\ stw r0, (r1, 0)
+        \\ stw r3, (r1, 4)
+        \\
+        \\ movi r7, 220 // SYS_clone
+        \\ mov r0, r2
+        \\ ldw r2, (sp, 0)
+        \\ ldw r3, (sp, 8)
+        \\ ldw r4, (sp, 4)
+        \\ trap 0
+        \\
+        \\ cmpnei r0, 0
+        \\ jbf 1f
+        \\
+        \\ // parent
+        \\ mov r7, t1
+        \\ mov r4, t0
+        \\ rts
+        \\
+        \\ // child
+        \\1:
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined lr
+    );
+    asm volatile (
+        \\ movi r8, 0
+        \\ movi lr, 0
+        \\
+        \\ ldw r0, (sp, 4)
+        \\ ldw r1, (sp, 0)
+        \\ jsr r1
+        \\
+        \\ movi r7, 93 // SYS_exit
+        \\ trap 0
+    );
+}
+
+pub const time_t = i32;
+
+pub const VDSO = void;

package/std/os/linux/microblaze.zig

@@ -0,0 +1,170 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+          [arg2] "{r6}" (arg2),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+          [arg2] "{r6}" (arg2),
+          [arg3] "{r7}" (arg3),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+          [arg2] "{r6}" (arg2),
+          [arg3] "{r7}" (arg3),
+          [arg4] "{r8}" (arg4),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall5(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+          [arg2] "{r6}" (arg2),
+          [arg3] "{r7}" (arg3),
+          [arg4] "{r8}" (arg4),
+          [arg5] "{r9}" (arg5),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
+) u32 {
+    return asm volatile ("brki r14, 0x8"
+        : [ret] "={r3}" (-> u32),
+        : [number] "{r12}" (@intFromEnum(number)),
+          [arg1] "{r5}" (arg1),
+          [arg2] "{r6}" (arg2),
+          [arg3] "{r7}" (arg3),
+          [arg4] "{r8}" (arg4),
+          [arg5] "{r9}" (arg5),
+          [arg6] "{r10}" (arg6),
+        : .{ .r4 = true, .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r5,   r6,    r7,    r8,  r9,   r10, +28
+    //
+    // syscall(SYS_clone, flags, stack, ptid, ctid, tls)
+    //         r12        r5,    r6,    r8,   r9,   r10
+    asm volatile (
+        \\ andi r6, r6, -4
+        \\
+        \\ addi r6, r6, -8
+        \\ swi r5, r6, 0
+        \\ swi r8, r6, 4
+        \\
+        \\ ori r12, r0, 120 # SYS_clone
+        \\ ori r5, r7, 0
+        \\ ori r7, r0, 0 # stack size
+        \\ ori r8, r9, 0
+        \\ lwi r9, r1, 28
+        \\ brki r14, 0x8
+        \\ beqi r3, 1f
+        \\
+        \\ // parent
+        \\ rtsd r15, 8
+        \\  nop
+        \\
+        \\ // child
+        \\1:
+        \\ ori r15, r0, 0
+        \\ ori r19, r0, 0
+        \\
+        \\ lwi r3, r1, 0
+        \\ lwi r5, r1, 4
+        \\ brald r15, r3
+        \\  nop
+        \\
+        \\ ori r12, r0, 1 # SYS_exit
+        \\ brki r14, 0x8
+    );
+}
+
+pub fn restore() callconv(.naked) noreturn {
+    asm volatile (
+        \\ brki r14, 0x8
+        :
+        : [number] "{r7}" (@intFromEnum(SYS.sigreturn)),
+    );
+}
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    asm volatile (
+        \\ brki r14, 0x8
+        :
+        : [number] "{r7}" (@intFromEnum(SYS.rt_sigreturn)),
+    );
+}
+
+pub const time_t = i32;
+
+pub const VDSO = void;