@zigc/lib 0.15.1 → 0.15.2-test.99

package/std/fs/File.zig

@@ -1242,7 +1242,7 @@ pub const Reader = struct {
     pub fn seekBy(r: *Reader, offset: i64) Reader.SeekError!void {
         switch (r.mode) {
             .positional, .positional_reading => {
-                setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset));
+                setLogicalPos(r, @intCast(@as(i64, @intCast(logicalPos(r))) + offset));
             },
             .streaming, .streaming_reading => {
                 if (posix.SEEK == void) {
@@ -1251,7 +1251,7 @@ pub const Reader = struct {
                 }
                 const seek_err = r.seek_err orelse e: {
                     if (posix.lseek_CUR(r.file.handle, offset)) |_| {
-                        setPosAdjustingBuffer(r, @intCast(@as(i64, @intCast(r.pos)) + offset));
+                        setLogicalPos(r, @intCast(@as(i64, @intCast(logicalPos(r))) + offset));
                         return;
                     } else |err| {
                         r.seek_err = err;
@@ -1275,16 +1275,17 @@ pub const Reader = struct {
     pub fn seekTo(r: *Reader, offset: u64) Reader.SeekError!void {
         switch (r.mode) {
             .positional, .positional_reading => {
-                setPosAdjustingBuffer(r, offset);
+                setLogicalPos(r, offset);
             },
             .streaming, .streaming_reading => {
-                if (offset >= r.pos) return Reader.seekBy(r, @intCast(offset - r.pos));
+                const logical_pos = logicalPos(r);
+                if (offset >= logical_pos) return Reader.seekBy(r, @intCast(offset - logical_pos));
                 if (r.seek_err) |err| return err;
                 posix.lseek_SET(r.file.handle, offset) catch |err| {
                     r.seek_err = err;
                     return err;
                 };
-                setPosAdjustingBuffer(r, offset);
+                setLogicalPos(r, offset);
             },
             .failure => return r.seek_err.?,
         }
@@ -1294,7 +1295,7 @@ pub const Reader = struct {
         return r.pos - r.interface.bufferedLen();
     }
 
-    fn setPosAdjustingBuffer(r: *Reader, offset: u64) void {
+    fn setLogicalPos(r: *Reader, offset: u64) void {
         const logical_pos = logicalPos(r);
         if (offset < logical_pos or offset >= r.pos) {
             r.interface.seek = 0;
@@ -1322,13 +1323,15 @@ pub const Reader = struct {
             },
             .positional_reading => {
                 const dest = limit.slice(try w.writableSliceGreedy(1));
-                const n = try readPositional(r, dest);
+                var data: [1][]u8 = .{dest};
+                const n = try readVecPositional(r, &data);
                 w.advance(n);
                 return n;
             },
             .streaming_reading => {
                 const dest = limit.slice(try w.writableSliceGreedy(1));
-                const n = try readStreaming(r, dest);
+                var data: [1][]u8 = .{dest};
+                const n = try readVecStreaming(r, &data);
                 w.advance(n);
                 return n;
             },
@@ -1339,92 +1342,98 @@ pub const Reader = struct {
     fn readVec(io_reader: *std.Io.Reader, data: [][]u8) std.Io.Reader.Error!usize {
         const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
         switch (r.mode) {
-            .positional, .positional_reading => {
-                if (is_windows) {
-                    // Unfortunately, `ReadFileScatter` cannot be used since it
-                    // requires page alignment.
-                    if (io_reader.seek == io_reader.end) {
-                        io_reader.seek = 0;
-                        io_reader.end = 0;
-                    }
-                    const first = data[0];
-                    if (first.len >= io_reader.buffer.len - io_reader.end) {
-                        return readPositional(r, first);
-                    } else {
-                        io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]);
-                        return 0;
-                    }
-                }
-                var iovecs_buffer: [max_buffers_len]posix.iovec = undefined;
-                const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data);
-                const dest = iovecs_buffer[0..dest_n];
-                assert(dest[0].len > 0);
-                const n = posix.preadv(r.file.handle, dest, r.pos) catch |err| switch (err) {
-                    error.Unseekable => {
-                        r.mode = r.mode.toStreaming();
-                        const pos = r.pos;
-                        if (pos != 0) {
-                            r.pos = 0;
-                            r.seekBy(@intCast(pos)) catch {
-                                r.mode = .failure;
-                                return error.ReadFailed;
-                            };
-                        }
-                        return 0;
-                    },
-                    else => |e| {
-                        r.err = e;
+            .positional, .positional_reading => return readVecPositional(r, data),
+            .streaming, .streaming_reading => return readVecStreaming(r, data),
+            .failure => return error.ReadFailed,
+        }
+    }
+
+    fn readVecPositional(r: *Reader, data: [][]u8) std.Io.Reader.Error!usize {
+        const io_reader = &r.interface;
+        if (is_windows) {
+            // Unfortunately, `ReadFileScatter` cannot be used since it
+            // requires page alignment.
+            if (io_reader.seek == io_reader.end) {
+                io_reader.seek = 0;
+                io_reader.end = 0;
+            }
+            const first = data[0];
+            if (first.len >= io_reader.buffer.len - io_reader.end) {
+                return readPositional(r, first);
+            } else {
+                io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]);
+                return 0;
+            }
+        }
+        var iovecs_buffer: [max_buffers_len]posix.iovec = undefined;
+        const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data);
+        const dest = iovecs_buffer[0..dest_n];
+        assert(dest[0].len > 0);
+        const n = posix.preadv(r.file.handle, dest, r.pos) catch |err| switch (err) {
+            error.Unseekable => {
+                r.mode = r.mode.toStreaming();
+                const pos = r.pos;
+                if (pos != 0) {
+                    r.pos = 0;
+                    r.seekBy(@intCast(pos)) catch {
+                        r.mode = .failure;
                         return error.ReadFailed;
-                    },
-                };
-                if (n == 0) {
-                    r.size = r.pos;
-                    return error.EndOfStream;
-                }
-                r.pos += n;
-                if (n > data_size) {
-                    io_reader.end += n - data_size;
-                    return data_size;
+                    };
                 }
-                return n;
+                return 0;
             },
-            .streaming, .streaming_reading => {
-                if (is_windows) {
-                    // Unfortunately, `ReadFileScatter` cannot be used since it
-                    // requires page alignment.
-                    if (io_reader.seek == io_reader.end) {
-                        io_reader.seek = 0;
-                        io_reader.end = 0;
-                    }
-                    const first = data[0];
-                    if (first.len >= io_reader.buffer.len - io_reader.end) {
-                        return readPositional(r, first);
-                    } else {
-                        io_reader.end += try readPositional(r, io_reader.buffer[io_reader.end..]);
-                        return 0;
-                    }
-                }
-                var iovecs_buffer: [max_buffers_len]posix.iovec = undefined;
-                const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data);
-                const dest = iovecs_buffer[0..dest_n];
-                assert(dest[0].len > 0);
-                const n = posix.readv(r.file.handle, dest) catch |err| {
-                    r.err = err;
-                    return error.ReadFailed;
-                };
-                if (n == 0) {
-                    r.size = r.pos;
-                    return error.EndOfStream;
-                }
-                r.pos += n;
-                if (n > data_size) {
-                    io_reader.end += n - data_size;
-                    return data_size;
-                }
-                return n;
+            else => |e| {
+                r.err = e;
+                return error.ReadFailed;
             },
-            .failure => return error.ReadFailed,
+        };
+        if (n == 0) {
+            r.size = r.pos;
+            return error.EndOfStream;
+        }
+        r.pos += n;
+        if (n > data_size) {
+            io_reader.end += n - data_size;
+            return data_size;
         }
+        return n;
+    }
+
+    fn readVecStreaming(r: *Reader, data: [][]u8) std.Io.Reader.Error!usize {
+        const io_reader = &r.interface;
+        if (is_windows) {
+            // Unfortunately, `ReadFileScatter` cannot be used since it
+            // requires page alignment.
+            if (io_reader.seek == io_reader.end) {
+                io_reader.seek = 0;
+                io_reader.end = 0;
+            }
+            const first = data[0];
+            if (first.len >= io_reader.buffer.len - io_reader.end) {
+                return readStreaming(r, first);
+            } else {
+                io_reader.end += try readStreaming(r, io_reader.buffer[io_reader.end..]);
+                return 0;
+            }
+        }
+        var iovecs_buffer: [max_buffers_len]posix.iovec = undefined;
+        const dest_n, const data_size = try io_reader.writableVectorPosix(&iovecs_buffer, data);
+        const dest = iovecs_buffer[0..dest_n];
+        assert(dest[0].len > 0);
+        const n = posix.readv(r.file.handle, dest) catch |err| {
+            r.err = err;
+            return error.ReadFailed;
+        };
+        if (n == 0) {
+            r.size = r.pos;
+            return error.EndOfStream;
+        }
+        r.pos += n;
+        if (n > data_size) {
+            io_reader.end += n - data_size;
+            return data_size;
+        }
+        return n;
     }
 
     fn discard(io_reader: *std.Io.Reader, limit: std.Io.Limit) std.Io.Reader.Error!usize {
@@ -1493,7 +1502,7 @@ pub const Reader = struct {
         }
     }
 
-    pub fn readPositional(r: *Reader, dest: []u8) std.Io.Reader.Error!usize {
+    fn readPositional(r: *Reader, dest: []u8) std.Io.Reader.Error!usize {
         const n = r.file.pread(dest, r.pos) catch |err| switch (err) {
             error.Unseekable => {
                 r.mode = r.mode.toStreaming();
@@ -1520,7 +1529,7 @@ pub const Reader = struct {
         return n;
     }
 
-    pub fn readStreaming(r: *Reader, dest: []u8) std.Io.Reader.Error!usize {
+    fn readStreaming(r: *Reader, dest: []u8) std.Io.Reader.Error!usize {
         const n = r.file.read(dest) catch |err| {
             r.err = err;
             return error.ReadFailed;
@@ -1533,14 +1542,6 @@ pub const Reader = struct {
         return n;
     }
 
-    pub fn read(r: *Reader, dest: []u8) std.Io.Reader.Error!usize {
-        switch (r.mode) {
-            .positional, .positional_reading => return readPositional(r, dest),
-            .streaming, .streaming_reading => return readStreaming(r, dest),
-            .failure => return error.ReadFailed,
-        }
-    }
-
     pub fn atEnd(r: *Reader) bool {
         // Even if stat fails, size is set when end is encountered.
         const size = r.size orelse return false;
@@ -1783,7 +1784,7 @@ pub const Writer = struct {
     ) std.Io.Writer.FileError!usize {
         const reader_buffered = file_reader.interface.buffered();
         if (reader_buffered.len >= @intFromEnum(limit))
-            return sendFileBuffered(io_w, file_reader, reader_buffered);
+            return sendFileBuffered(io_w, file_reader, limit.slice(reader_buffered));
         const writer_buffered = io_w.buffered();
         const file_limit = @intFromEnum(limit) - reader_buffered.len;
         const w: *Writer = @alignCast(@fieldParentPtr("interface", io_w));
@@ -1855,7 +1856,7 @@ pub const Writer = struct {
                 return error.EndOfStream;
             }
             const consumed = io_w.consume(@intCast(sbytes));
-            file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed;
+            file_reader.seekBy(@intCast(consumed)) catch return error.ReadFailed;
             return consumed;
         }
 
@@ -1916,7 +1917,7 @@ pub const Writer = struct {
                 return error.EndOfStream;
             }
             const consumed = io_w.consume(@bitCast(len));
-            file_reader.seekTo(file_reader.pos + consumed) catch return error.ReadFailed;
+            file_reader.seekBy(@intCast(consumed)) catch return error.ReadFailed;
             return consumed;
         }
 
@@ -1967,7 +1968,7 @@ pub const Writer = struct {
 
         const copy_file_range = switch (native_os) {
             .freebsd => std.os.freebsd.copy_file_range,
-            .linux => if (std.c.versionCheck(if (builtin.abi.isAndroid()) .{ .major = 34, .minor = 0, .patch = 0 } else .{ .major = 2, .minor = 27, .patch = 0 })) std.os.linux.wrapped.copy_file_range else {},
+            .linux => std.os.linux.wrapped.copy_file_range,
             else => {},
         };
         if (@TypeOf(copy_file_range) != void) cfr: {
@@ -2049,7 +2050,7 @@ pub const Writer = struct {
         reader_buffered: []const u8,
     ) std.Io.Writer.FileError!usize {
         const n = try drain(io_w, &.{reader_buffered}, 1);
-        file_reader.seekTo(file_reader.pos + n) catch return error.ReadFailed;
+        file_reader.seekBy(@intCast(n)) catch return error.ReadFailed;
         return n;
     }
 

package/std/http/Client.zig

@@ -1375,7 +1375,7 @@ pub const basic_authorization = struct {
         var buf: [max_user_len + 1 + max_password_len]u8 = undefined;
         var w: Writer = .fixed(&buf);
         const user: Uri.Component = uri.user orelse .empty;
-        const password: Uri.Component = uri.user orelse .empty;
+        const password: Uri.Component = uri.password orelse .empty;
         user.formatUser(&w) catch unreachable;
         w.writeByte(':') catch unreachable;
         password.formatPassword(&w) catch unreachable;
@@ -1797,9 +1797,10 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult {
 
     if (options.payload) |payload| {
         req.transfer_encoding = .{ .content_length = payload.len };
-        var body = try req.sendBody(&.{});
+        var body = try req.sendBodyUnflushed(&.{});
         try body.writer.writeAll(payload);
         try body.end();
+        try req.connection.?.flush();
     } else {
         try req.sendBodiless();
     }

package/std/json/static.zig

@@ -567,8 +567,8 @@ pub fn innerParseFromValue(
             switch (source) {
                 .float => |f| {
                     if (@round(f) != f) return error.InvalidNumber;
-                    if (f > std.math.maxInt(T)) return error.Overflow;
-                    if (f < std.math.minInt(T)) return error.Overflow;
+                    if (f > @as(@TypeOf(f), @floatFromInt(std.math.maxInt(T)))) return error.Overflow;
+                    if (f < @as(@TypeOf(f), @floatFromInt(std.math.minInt(T)))) return error.Overflow;
                     return @as(T, @intFromFloat(f));
                 },
                 .integer => |i| {
@@ -770,7 +770,7 @@ fn sliceToInt(comptime T: type, slice: []const u8) !T {
     // Try to coerce a float to an integer.
     const float = try std.fmt.parseFloat(f128, slice);
     if (@round(float) != float) return error.InvalidNumber;
-    if (float > std.math.maxInt(T) or float < std.math.minInt(T)) return error.Overflow;
+    if (float > @as(f128, @floatFromInt(std.math.maxInt(T))) or float < @as(f128, @floatFromInt(std.math.minInt(T)))) return error.Overflow;
     return @as(T, @intCast(@as(i128, @intFromFloat(float))));
 }
 

package/std/math/big/int.zig

@@ -786,11 +786,10 @@ pub const Mutable = struct {
         assert(rma.limbs.ptr != b.limbs.ptr); // illegal aliasing
 
         if (a.limbs.len == 1 and b.limbs.len == 1) {
-            const ov = @mulWithOverflow(a.limbs[0], b.limbs[0]);
-            rma.limbs[0] = ov[0];
-            if (ov[1] == 0) {
+            rma.limbs[0], const overflow_bit = @mulWithOverflow(a.limbs[0], b.limbs[0]);
+            if (overflow_bit == 0) {
                 rma.len = 1;
-                rma.positive = (a.positive == b.positive);
+                rma.positive = (a.positive == b.positive) or rma.limbs[0] == 0;
                 return;
             }
         }

package/std/math/powi.zig

@@ -13,6 +13,7 @@ const testing = std.testing;
 /// Errors:
 ///  - Overflow: Integer overflow or Infinity
 ///  - Underflow: Absolute value of result smaller than 1
+///
 /// Edge case rules ordered by precedence:
 ///  - powi(T, x, 0)   = 1 unless T is i1, i0, u0
 ///  - powi(T, 0, x)   = 0 when x > 0

package/std/mem/Allocator.zig

@@ -358,8 +358,10 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) t: {
     return mem.bytesAsSlice(T, new_memory);
 }
 
-/// This function requests a new byte size for an existing allocation, which
+/// This function requests a new size for an existing allocation, which
 /// can be larger, smaller, or the same size as the old memory allocation.
+/// The result is an array of `new_n` items of the same type as the existing
+/// allocation.
 ///
 /// If `new_n` is 0, this is the same as `free` and it always succeeds.
 ///

package/std/mem.zig

@@ -3785,6 +3785,7 @@ test rotate {
 
 /// Replace needle with replacement as many times as possible, writing to an output buffer which is assumed to be of
 /// appropriate size. Use replacementSize to calculate an appropriate buffer size.
+/// The `input` and `output` slices must not overlap.
 /// The needle must not be empty.
 /// Returns the number of replacements made.
 pub fn replace(comptime T: type, input: []const T, needle: []const T, replacement: []const T, output: []T) usize {
@@ -4484,7 +4485,8 @@ pub fn doNotOptimizeAway(val: anytype) void {
             } else doNotOptimizeAway(&val);
         },
         .float => {
-            if ((t.float.bits == 32 or t.float.bits == 64) and builtin.zig_backend != .stage2_c) {
+            // https://github.com/llvm/llvm-project/issues/159200
+            if ((t.float.bits == 32 or t.float.bits == 64) and builtin.zig_backend != .stage2_c and !builtin.cpu.arch.isLoongArch()) {
                 asm volatile (""
                     :
                     : [_] "rm" (val),

package/std/net.zig

@@ -1393,7 +1393,7 @@ fn parseHosts(
     br: *Io.Reader,
 ) error{ OutOfMemory, ReadFailed }!void {
     while (true) {
-        const line = br.takeDelimiterExclusive('\n') catch |err| switch (err) {
+        const line = br.takeDelimiter('\n') catch |err| switch (err) {
             error.StreamTooLong => {
                 // Skip lines that are too long.
                 _ = br.discardDelimiterInclusive('\n') catch |e| switch (e) {
@@ -1403,7 +1403,8 @@ fn parseHosts(
                 continue;
             },
             error.ReadFailed => return error.ReadFailed,
-            error.EndOfStream => break,
+        } orelse {
+            break; // end of stream
         };
         var split_it = mem.splitScalar(u8, line, '#');
         const no_comment_line = split_it.first();

package/std/os/linux/bpf.zig

@@ -642,7 +642,7 @@ pub const Insn = packed struct {
             .dst = @intFromEnum(dst),
             .src = @intFromEnum(src),
             .off = 0,
-            .imm = @as(i32, @intCast(@as(u32, @truncate(imm)))),
+            .imm = @as(i32, @bitCast(@as(u32, @truncate(imm)))),
         };
     }
 
@@ -652,7 +652,7 @@ pub const Insn = packed struct {
             .dst = 0,
             .src = 0,
             .off = 0,
-            .imm = @as(i32, @intCast(@as(u32, @truncate(imm >> 32)))),
+            .imm = @as(i32, @bitCast(@as(u32, @truncate(imm >> 32)))),
         };
     }
 

package/std/os/linux/powerpc.zig

@@ -15,84 +15,125 @@ 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .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 });
 }
 
 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .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 });
 }
 
 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = 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, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .memory = true, .cr0 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
 pub fn syscall6(
@@ -104,12 +145,25 @@ 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),
@@ -117,7 +171,7 @@ pub fn syscall6(
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
           [arg6] "{r8}" (arg6),
-        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
+        : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -193,11 +247,19 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    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 });
+    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 }),
+    }
 }
 
 pub const F = struct {