@zigc/lib 0.15.0-dev.0 → 0.15.1

package/std/os/linux/powerpc64.zig

@@ -15,125 +15,84 @@ const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
 pub fn syscall0(number: SYS) usize {
-    // r0 is both an input register and a clobber. musl and glibc achieve this with
-    // a "+" constraint, which isn't supported in Zig, so instead we separately list
-    // r0 as both an input and an output. (Listing it as an input and a clobber would
-    // cause the C backend to emit invalid code; see #25209.)
-    var r0_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
-        : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
-    // r0 is both an input and a clobber.
-    var r0_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
-        : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
-    // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
-          [r4_out] "={r4}" (r4_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
-        : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
-    // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
-          [r4_out] "={r4}" (r4_out),
-          [r5_out] "={r5}" (r5_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
-        : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
-    // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
-          [r4_out] "={r4}" (r4_out),
-          [r5_out] "={r5}" (r5_out),
-          [r6_out] "={r6}" (r6_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
-        : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
-    // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
-          [r4_out] "={r4}" (r4_out),
-          [r5_out] "={r5}" (r5_out),
-          [r6_out] "={r6}" (r6_out),
-          [r7_out] "={r7}" (r7_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
-        : .{ .memory = true, .cr0 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall6(
@@ -145,25 +104,12 @@ pub fn syscall6(
     arg5: usize,
     arg6: usize,
 ) usize {
-    // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
-    var r8_out: usize = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
         : [ret] "={r3}" (-> usize),
-          [r0_out] "={r0}" (r0_out),
-          [r4_out] "={r4}" (r4_out),
-          [r5_out] "={r5}" (r5_out),
-          [r6_out] "={r6}" (r6_out),
-          [r7_out] "={r7}" (r7_out),
-          [r8_out] "={r8}" (r8_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
@@ -171,7 +117,7 @@ pub fn syscall6(
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
           [arg6] "{r8}" (arg6),
-        : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -232,19 +178,11 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
-        .stage2_c => asm volatile (
-            \\ li 0, %[number]
-            \\ sc
-            :
-            : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
-            : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }),
-        else => _ = asm volatile (
-            \\ sc
-            :
-            : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
-            : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true }),
-    }
+    asm volatile (
+        \\ sc
+        :
+        : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
+        : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub const F = struct {

package/std/os/linux.zig

@@ -1238,14 +1238,11 @@ pub fn access(path: [*:0]const u8, mode: u32) usize {
     if (@hasField(SYS, "access")) {
         return syscall2(.access, @intFromPtr(path), mode);
     } else {
-        return faccessat(AT.FDCWD, path, mode, 0);
+        return syscall4(.faccessat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), mode, 0);
     }
 }
 
 pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize {
-    if (flags == 0) {
-        return syscall3(.faccessat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode);
-    }
     return syscall4(.faccessat2, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, flags);
 }
 
@@ -9802,9 +9799,7 @@ pub const wrapped = struct {
     };
 
     pub fn copy_file_range(fd_in: fd_t, off_in: ?*i64, fd_out: fd_t, off_out: ?*i64, len: usize, flags: u32) CopyFileRangeError!usize {
-        const use_c = std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 });
-        const sys = if (use_c) std.c else std.os.linux;
-        const rc = sys.copy_file_range(fd_in, off_in, fd_out, off_out, len, flags);
+        const rc = system.copy_file_range(fd_in, off_in, fd_out, off_out, len, flags);
         switch (errno(rc)) {
             .SUCCESS => return @intCast(rc),
             .BADF => return error.BadFileFlags,

package/std/os/uefi/protocol/service_binding.zig

@@ -1,5 +1,5 @@
 const std = @import("std");
-const uefi = std.os.uefi;
+const uefi = std.uefi;
 const Guid = uefi.Guid;
 const Handle = uefi.Handle;
 const Status = uefi.Status;

package/std/os/uefi/tables.zig

@@ -90,7 +90,7 @@ pub const MemoryType = enum(u32) {
         return @truncate(as_int - vendor_start);
     }
 
-    pub fn format(self: MemoryType, w: *std.io.Writer) std.io.Writer.Error!void {
+    pub fn format(self: MemoryType, w: *std.io.Writer) std.io.WriteError!void {
         if (self.toOem()) |oemval|
             try w.print("OEM({X})", .{oemval})
         else if (self.toVendor()) |vendorval|

package/std/pie.zig

@@ -177,7 +177,7 @@ inline fn getDynamicSymbol() [*]const elf.Dyn {
                 \\ jg 2f
                 \\ 1: .quad _DYNAMIC - .
                 \\ 2:
-                : [ret] "=a" (-> [*]const elf.Dyn),
+                : [ret] "=r" (-> [*]const elf.Dyn),
             ),
             // The compiler does not necessarily have any obligation to load the `l7` register (pointing
             // to the GOT), so do it ourselves just in case.

package/std/posix.zig

@@ -6387,16 +6387,14 @@ pub const CopyFileRangeError = error{
 ///
 /// Maximum offsets on Linux and FreeBSD are `maxInt(i64)`.
 pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len: usize, flags: u32) CopyFileRangeError!usize {
-    if (builtin.os.tag == .freebsd or builtin.os.tag == .linux) {
-        const use_c = native_os != .linux or
-            std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 });
-        const sys = if (use_c) std.c else linux;
-
+    if (builtin.os.tag == .freebsd or
+        (comptime builtin.os.tag == .linux and std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 })))
+    {
         var off_in_copy: i64 = @bitCast(off_in);
         var off_out_copy: i64 = @bitCast(off_out);
 
         while (true) {
-            const rc = sys.copy_file_range(fd_in, &off_in_copy, fd_out, &off_out_copy, len, flags);
+            const rc = system.copy_file_range(fd_in, &off_in_copy, fd_out, &off_out_copy, len, flags);
             if (native_os == .freebsd) {
                 switch (errno(rc)) {
                     .SUCCESS => return @intCast(rc),

package/std/process/Child.zig

@@ -52,8 +52,6 @@ term: ?(SpawnError!Term),
 argv: []const []const u8,
 
 /// Leave as null to use the current env map using the supplied allocator.
-/// Required if unable to access the current env map (e.g. building a library on
-/// some platforms).
 env_map: ?*const EnvMap,
 
 stdin_behavior: StdIo,
@@ -416,8 +414,6 @@ pub fn run(args: struct {
     argv: []const []const u8,
     cwd: ?[]const u8 = null,
     cwd_dir: ?fs.Dir = null,
-    /// Required if unable to access the current env map (e.g. building a
-    /// library on some platforms).
     env_map: ?*const EnvMap = null,
     max_output_bytes: usize = 50 * 1024,
     expand_arg0: Arg0Expand = .no_expand,
@@ -618,7 +614,7 @@ fn spawnPosix(self: *ChildProcess) SpawnError!void {
             })).ptr;
         } else {
             // TODO come up with a solution for this.
-            @panic("missing std lib enhancement: ChildProcess implementation has no way to collect the environment variables to forward to the child process");
+            @compileError("missing std lib enhancement: ChildProcess implementation has no way to collect the environment variables to forward to the child process");
         }
     };
 

package/std/process.zig

@@ -1753,8 +1753,7 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
             if (std.os.linux.E.init(result) != .SUCCESS) {
                 return error.UnknownTotalSystemMemory;
             }
-            // Promote to u64 to avoid overflow on systems where info.totalram is a 32-bit usize
-            return @as(u64, info.totalram) * info.mem_unit;
+            return info.totalram * info.mem_unit;
         },
         .freebsd => {
             var physmem: c_ulong = undefined;
@@ -1763,20 +1762,7 @@ pub fn totalSystemMemory() TotalSystemMemoryError!u64 {
                 error.NameTooLong, error.UnknownName => unreachable,
                 else => return error.UnknownTotalSystemMemory,
             };
-            return @as(u64, @intCast(physmem));
-        },
-        // whole Darwin family
-        .driverkit, .ios, .macos, .tvos, .visionos, .watchos => {
-            // "hw.memsize" returns uint64_t
-            var physmem: u64 = undefined;
-            var len: usize = @sizeOf(u64);
-            posix.sysctlbynameZ("hw.memsize", &physmem, &len, null, 0) catch |err| switch (err) {
-                error.PermissionDenied => unreachable, // only when setting values,
-                error.SystemResources => unreachable, // memory already on the stack
-                error.UnknownName => unreachable, // constant, known good value
-                else => return error.UnknownTotalSystemMemory,
-            };
-            return physmem;
+            return @as(usize, @intCast(physmem));
         },
         .openbsd => {
             const mib: [2]c_int = [_]c_int{

package/std/sort/pdq.zig

@@ -227,7 +227,7 @@ fn partialInsertionSort(a: usize, b: usize, context: anytype) bool {
         // shift the smaller element to the left.
         if (i - a >= 2) {
             var j = i - 1;
-            while (j > a) : (j -= 1) {
+            while (j >= 1) : (j -= 1) {
                 if (!context.lessThan(j, j - 1)) break;
                 context.swap(j, j - 1);
             }
@@ -328,50 +328,3 @@ fn reverseRange(a: usize, b: usize, context: anytype) void {
         j -= 1;
     }
 }
-
-test "pdqContext respects arbitrary range boundaries" {
-    // Regression test for issue #25250
-    // pdqsort should never access indices outside the specified [a, b) range
-    var data: [2000]i32 = @splat(0);
-
-    // Fill with data that triggers the partialInsertionSort path
-    for (0..data.len) |i| {
-        data[i] = @intCast(@mod(@as(i32, @intCast(i)) * 7, 100));
-    }
-
-    const TestContext = struct {
-        items: []i32,
-        range_start: usize,
-        range_end: usize,
-
-        pub fn lessThan(ctx: @This(), a: usize, b: usize) bool {
-            // Assert indices are within the expected range
-            testing.expect(a >= ctx.range_start and a < ctx.range_end) catch @panic("index a out of range");
-            testing.expect(b >= ctx.range_start and b < ctx.range_end) catch @panic("index b out of range");
-            return ctx.items[a] < ctx.items[b];
-        }
-
-        pub fn swap(ctx: @This(), a: usize, b: usize) void {
-            // Assert indices are within the expected range
-            testing.expect(a >= ctx.range_start and a < ctx.range_end) catch @panic("index a out of range");
-            testing.expect(b >= ctx.range_start and b < ctx.range_end) catch @panic("index b out of range");
-            mem.swap(i32, &ctx.items[a], &ctx.items[b]);
-        }
-    };
-
-    // Test sorting a sub-range that doesn't start at 0
-    const start = 1118;
-    const end = 1764;
-    const ctx = TestContext{
-        .items = &data,
-        .range_start = start,
-        .range_end = end,
-    };
-
-    pdqContext(start, end, ctx);
-
-    // Verify the range is sorted
-    for ((start + 1)..end) |i| {
-        try testing.expect(data[i - 1] <= data[i]);
-    }
-}

package/std/testing.zig

@@ -1249,63 +1249,3 @@ pub const Reader = struct {
         return n;
     }
 };
-
-/// A `std.Io.Reader` that gets its data from another `std.Io.Reader`, and always
-/// writes to its own buffer (and returns 0) during `stream` and `readVec`.
-pub const ReaderIndirect = struct {
-    in: *std.Io.Reader,
-    interface: std.Io.Reader,
-
-    pub fn init(in: *std.Io.Reader, buffer: []u8) ReaderIndirect {
-        return .{
-            .in = in,
-            .interface = .{
-                .vtable = &.{
-                    .stream = stream,
-                    .readVec = readVec,
-                },
-                .buffer = buffer,
-                .seek = 0,
-                .end = 0,
-            },
-        };
-    }
-
-    fn readVec(r: *std.Io.Reader, _: [][]u8) std.Io.Reader.Error!usize {
-        try streamInner(r);
-        return 0;
-    }
-
-    fn stream(r: *std.Io.Reader, _: *std.Io.Writer, _: std.Io.Limit) std.Io.Reader.StreamError!usize {
-        try streamInner(r);
-        return 0;
-    }
-
-    fn streamInner(r: *std.Io.Reader) std.Io.Reader.Error!void {
-        const r_indirect: *ReaderIndirect = @alignCast(@fieldParentPtr("interface", r));
-
-        // If there's no room remaining in the buffer at all, make room.
-        if (r.buffer.len == r.end) {
-            try r.rebase(r.buffer.len);
-        }
-
-        var writer: std.Io.Writer = .{
-            .buffer = r.buffer,
-            .end = r.end,
-            .vtable = &.{
-                .drain = std.Io.Writer.unreachableDrain,
-                .rebase = std.Io.Writer.unreachableRebase,
-            },
-        };
-        defer r.end = writer.end;
-
-        r_indirect.in.streamExact(&writer, r.buffer.len - r.end) catch |err| switch (err) {
-            // Only forward EndOfStream if no new bytes were written to the buffer
-            error.EndOfStream => |e| if (r.end == writer.end) {
-                return e;
-            },
-            error.WriteFailed => unreachable,
-            else => |e| return e,
-        };
-    }
-};

package/std/zig/llvm/BitcodeReader.zig

@@ -154,11 +154,7 @@ pub fn next(bc: *BitcodeReader) !?Item {
             Abbrev.Builtin.enter_subblock.toRecordId() => {
                 const block_id: u32 = @intCast(record.operands[0]);
                 switch (block_id) {
-                    Block.block_info => {
-                        try bc.startBlock(Block.block_info, @intCast(record.operands[1]));
-                        try bc.parseBlockInfoBlock();
-                        try bc.endBlock();
-                    },
+                    Block.block_info => try bc.parseBlockInfoBlock(),
                     Block.first_reserved...Block.last_standard => return error.UnsupportedBlockId,
                     else => {
                         try bc.startBlock(block_id, @intCast(record.operands[1]));

package/std/zig/system/linux.zig

@@ -358,11 +358,14 @@ fn CpuinfoParser(comptime impl: anytype) type {
     return struct {
         fn parse(arch: Target.Cpu.Arch, reader: *std.Io.Reader) !?Target.Cpu {
             var obj: impl = .{};
-            while (try reader.takeDelimiter('\n')) |line| {
+            while (reader.takeDelimiterExclusive('\n')) |line| {
                 const colon_pos = mem.indexOfScalar(u8, line, ':') orelse continue;
                 const key = mem.trimEnd(u8, line[0..colon_pos], " \t");
                 const value = mem.trimStart(u8, line[colon_pos + 1 ..], " \t");
                 if (!try obj.line_hook(key, value)) break;
+            } else |err| switch (err) {
+                error.EndOfStream => {},
+                else => |e| return e,
             }
             return obj.finalize(arch);
         }

package/std/zig/system.zig

@@ -102,7 +102,6 @@ pub fn getExternalExecutor(
                     else => "qemu-mips64el",
                 },
             },
-            .or1k => Executor{ .qemu = "qemu-or1k" },
             .powerpc => Executor{ .qemu = "qemu-ppc" },
             .powerpc64 => Executor{ .qemu = "qemu-ppc64" },
             .powerpc64le => Executor{ .qemu = "qemu-ppc64le" },
@@ -110,7 +109,7 @@ pub fn getExternalExecutor(
             .riscv64 => Executor{ .qemu = "qemu-riscv64" },
             .s390x => Executor{ .qemu = "qemu-s390x" },
             .sparc => Executor{
-                .qemu = if (candidate.cpu.has(.sparc, .v8plus))
+                .qemu = if (candidate.cpu.has(.sparc, .v9))
                     "qemu-sparc32plus"
                 else
                     "qemu-sparc",
@@ -122,7 +121,7 @@ pub fn getExternalExecutor(
                 else => Executor{ .qemu = "qemu-x86_64" },
             },
             .xtensa => Executor{ .qemu = "qemu-xtensa" },
-            else => bad_result,
+            else => return bad_result,
         };
     }
 

package/std/zon/parse.zig

@@ -717,7 +717,6 @@ const Parser = struct {
 
             elem.* = try self.parseExpr(array_info.child, nodes.at(@intCast(i)));
         }
-        if (array_info.sentinel()) |s| result[result.len] = s;
         return result;
     }
 

package/ubsan_rt.zig

@@ -627,7 +627,7 @@ fn exportHandler(
     // Work around x86_64 backend limitation.
     const linkage = if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) .internal else .weak;
     const N = "__ubsan_handle_" ++ sym_name;
-    @export(handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden });
+    @export(handler, .{ .name = N, .linkage = linkage });
 }
 
 fn exportHandlerWithAbort(
@@ -639,11 +639,11 @@ fn exportHandlerWithAbort(
     const linkage = if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) .internal else .weak;
     {
         const N = "__ubsan_handle_" ++ sym_name;
-        @export(handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden });
+        @export(handler, .{ .name = N, .linkage = linkage });
     }
     {
         const N = "__ubsan_handle_" ++ sym_name ++ "_abort";
-        @export(abort_handler, .{ .name = N, .linkage = linkage, .visibility = if (linkage == .internal) .default else .hidden });
+        @export(abort_handler, .{ .name = N, .linkage = linkage });
     }
 }
 

package/libc/musl/src/fenv/loongarch64/fenv-sf.c

@@ -1,3 +0,0 @@
-#ifdef __loongarch_soft_float
-#include "../fenv.c"
-#endif