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

package/std/heap/BufferFirstAllocator.zig

@@ -0,0 +1,165 @@
+//! An allocator that attempts to allocate from the given buffer, falling back to
+//! `fallback_allocator` if this fails.
+
+const std = @import("../std.zig");
+const heap = std.heap;
+const testing = std.testing;
+
+const Alignment = std.mem.Alignment;
+const Allocator = std.mem.Allocator;
+const FixedBufferAllocator = std.heap.FixedBufferAllocator;
+
+const BufferFirstAllocator = @This();
+
+fallback_allocator: Allocator,
+fixed_buffer_allocator: FixedBufferAllocator,
+
+pub fn init(buffer: []u8, fallback_allocator: Allocator) BufferFirstAllocator {
+    return .{
+        .fallback_allocator = fallback_allocator,
+        .fixed_buffer_allocator = .init(buffer),
+    };
+}
+
+pub fn allocator(self: *BufferFirstAllocator) Allocator {
+    return .{
+        .ptr = self,
+        .vtable = &.{
+            .alloc = alloc,
+            .resize = resize,
+            .remap = remap,
+            .free = free,
+        },
+    };
+}
+
+fn alloc(
+    ctx: *anyopaque,
+    len: usize,
+    alignment: Alignment,
+    ra: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
+        return self.fallback_allocator.rawAlloc(len, alignment, ra);
+}
+
+fn resize(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    ra: usize,
+) bool {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
+    } else {
+        return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
+    }
+}
+
+fn remap(
+    context: *anyopaque,
+    memory: []u8,
+    alignment: Alignment,
+    new_len: usize,
+    return_address: usize,
+) ?[*]u8 {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(context));
+    if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
+        return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
+    } else {
+        return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
+    }
+}
+
+fn free(
+    ctx: *anyopaque,
+    buf: []u8,
+    alignment: Alignment,
+    ra: usize,
+) void {
+    const self: *BufferFirstAllocator = @ptrCast(@alignCast(ctx));
+    if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
+        return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
+    } else {
+        return self.fallback_allocator.rawFree(buf, alignment, ra);
+    }
+}
+
+test "BufferFirstAllocator" {
+    // Buffer first specific tests
+    {
+        var buffer: [10]u8 = undefined;
+        var bfa_state: BufferFirstAllocator = .init(&buffer, std.testing.allocator);
+        const bfa = bfa_state.allocator();
+
+        // We're under the limit, so we should be allocated in the buffer
+        const txt0 = "hellowrld";
+        const buf0 = try bfa.create(@TypeOf(txt0.*));
+        buf0.* = txt0.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf0.ptr));
+
+        // We're now over the limit, so we should be allocated from the fallback
+        const txt1 = "test!";
+        const buf1 = try bfa.create(@TypeOf(txt1.*));
+        buf1.* = txt1.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf1.ptr));
+
+        // Free the allocation that took up space in the buffer
+        try testing.expectEqualStrings(txt0, buf0);
+        bfa.destroy(buf0);
+
+        // The next allocation would go in the buffer, but it's too big so it doesn't
+        const txt2 = "qwertyqwerty";
+        const buf2 = try bfa.create(@TypeOf(txt2.*));
+        buf2.* = txt2.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf2.ptr));
+
+        // The next allocation is smaller and fits in the buffer
+        const txt3 = "dvorak";
+        const buf3 = try bfa.create(@TypeOf(txt3.*));
+        buf3.* = txt3.*;
+        try testing.expect(bfa_state.fixed_buffer_allocator.ownsPtr(buf3.ptr));
+
+        // The remainder in the buffer is too small for the following allocation so it falls back
+        const txt4 = "moretext";
+        const buf4 = try bfa.create(@TypeOf(txt4.*));
+        buf4.* = txt4.*;
+        try testing.expect(!bfa_state.fixed_buffer_allocator.ownsPtr(buf4.ptr));
+
+        // Check equality on the remaining buffers and free them
+        try testing.expectEqualStrings(txt1, buf1);
+        bfa.destroy(buf1);
+        try testing.expectEqualStrings(txt2, buf2);
+        bfa.destroy(buf2);
+        try testing.expectEqualStrings(txt3, buf3);
+        bfa.destroy(buf3);
+        try testing.expectEqualStrings(txt4, buf4);
+        bfa.destroy(buf4);
+
+        try testing.expectEqual(0, bfa_state.fixed_buffer_allocator.end_index);
+    }
+
+    // Standard allocator tests
+    {
+        var buf: [4096]u8 = undefined;
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocator(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAligned(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorLargeAlignment(bfa.allocator());
+        }
+        {
+            var bfa: BufferFirstAllocator = .init(&buf, std.testing.allocator);
+            try heap.testAllocatorAlignedShrink(bfa.allocator());
+        }
+    }
+}

package/std/heap.zig

@@ -12,6 +12,7 @@ const Alignment = std.mem.Alignment;
 pub const ArenaAllocator = @import("heap/ArenaAllocator.zig");
 pub const SmpAllocator = @import("heap/SmpAllocator.zig");
 pub const FixedBufferAllocator = @import("heap/FixedBufferAllocator.zig");
+pub const BufferFirstAllocator = @import("heap/BufferFirstAllocator.zig");
 pub const PageAllocator = @import("heap/PageAllocator.zig");
 pub const WasmAllocator = if (builtin.single_threaded) BrkAllocator else @compileError("unimplemented");
 pub const BrkAllocator = @import("heap/BrkAllocator.zig");
@@ -367,113 +368,6 @@ pub const brk_allocator: Allocator = .{
     .vtable = &BrkAllocator.vtable,
 };
 
-/// Returns a `StackFallbackAllocator` allocating using either a
-/// `FixedBufferAllocator` on an array of size `size` and falling back to
-/// `fallback_allocator` if that fails.
-pub fn stackFallback(comptime size: usize, fallback_allocator: Allocator) StackFallbackAllocator(size) {
-    return StackFallbackAllocator(size){
-        .buffer = undefined,
-        .fallback_allocator = fallback_allocator,
-        .fixed_buffer_allocator = undefined,
-    };
-}
-
-/// An allocator that attempts to allocate using a
-/// `FixedBufferAllocator` using an array of size `size`. If the
-/// allocation fails, it will fall back to using
-/// `fallback_allocator`. Easily created with `stackFallback`.
-pub fn StackFallbackAllocator(comptime size: usize) type {
-    return struct {
-        const Self = @This();
-
-        buffer: [size]u8,
-        fallback_allocator: Allocator,
-        fixed_buffer_allocator: FixedBufferAllocator,
-        get_called: if (std.debug.runtime_safety) bool else void =
-            if (std.debug.runtime_safety) false else {},
-
-        /// This function both fetches a `Allocator` interface to this
-        /// allocator *and* resets the internal buffer allocator.
-        pub fn get(self: *Self) Allocator {
-            if (std.debug.runtime_safety) {
-                assert(!self.get_called); // `get` called multiple times; instead use `const allocator = stackFallback(N).get();`
-                self.get_called = true;
-            }
-            self.fixed_buffer_allocator = FixedBufferAllocator.init(self.buffer[0..]);
-            return .{
-                .ptr = self,
-                .vtable = &.{
-                    .alloc = alloc,
-                    .resize = resize,
-                    .remap = remap,
-                    .free = free,
-                },
-            };
-        }
-
-        /// Unlike most std allocators `StackFallbackAllocator` modifies
-        /// its internal state before returning an implementation of
-        /// the`Allocator` interface and therefore also doesn't use
-        /// the usual `.allocator()` method.
-        pub const allocator = @compileError("use 'const allocator = stackFallback(N).get();' instead");
-
-        fn alloc(
-            ctx: *anyopaque,
-            len: usize,
-            alignment: Alignment,
-            ra: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            return FixedBufferAllocator.alloc(&self.fixed_buffer_allocator, len, alignment, ra) orelse
-                return self.fallback_allocator.rawAlloc(len, alignment, ra);
-        }
-
-        fn resize(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            ra: usize,
-        ) bool {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, alignment, new_len, ra);
-            } else {
-                return self.fallback_allocator.rawResize(buf, alignment, new_len, ra);
-            }
-        }
-
-        fn remap(
-            context: *anyopaque,
-            memory: []u8,
-            alignment: Alignment,
-            new_len: usize,
-            return_address: usize,
-        ) ?[*]u8 {
-            const self: *Self = @ptrCast(@alignCast(context));
-            if (self.fixed_buffer_allocator.ownsPtr(memory.ptr)) {
-                return FixedBufferAllocator.remap(&self.fixed_buffer_allocator, memory, alignment, new_len, return_address);
-            } else {
-                return self.fallback_allocator.rawRemap(memory, alignment, new_len, return_address);
-            }
-        }
-
-        fn free(
-            ctx: *anyopaque,
-            buf: []u8,
-            alignment: Alignment,
-            ra: usize,
-        ) void {
-            const self: *Self = @ptrCast(@alignCast(ctx));
-            if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
-                return FixedBufferAllocator.free(&self.fixed_buffer_allocator, buf, alignment, ra);
-            } else {
-                return self.fallback_allocator.rawFree(buf, alignment, ra);
-            }
-        }
-    };
-}
-
 test c_allocator {
     if (builtin.link_libc) {
         try testAllocator(c_allocator);
@@ -524,25 +418,6 @@ test ArenaAllocator {
     try testAllocatorAlignedShrink(allocator);
 }
 
-test "StackFallbackAllocator" {
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocator(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAligned(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorLargeAlignment(stack_allocator.get());
-    }
-    {
-        var stack_allocator = stackFallback(4096, std.testing.allocator);
-        try testAllocatorAlignedShrink(stack_allocator.get());
-    }
-}
-
 /// This one should not try alignments that exceed what C malloc can handle.
 pub fn testAllocator(base_allocator: mem.Allocator) !void {
     var validationAllocator = mem.validationWrap(base_allocator);
@@ -1011,6 +886,7 @@ test {
     _ = ArenaAllocator;
     _ = DebugAllocator(.{});
     _ = FixedBufferAllocator;
+    _ = BufferFirstAllocator;
     if (builtin.single_threaded) {
         if (builtin.cpu.arch.isWasm() or (builtin.os.tag == .linux and !builtin.link_libc)) {
             _ = brk_allocator;

package/std/http/Client.zig

@@ -4,8 +4,6 @@
 //!
 //! TLS support may be disabled via `std.options.http_disable_tls`.
 //!
-//! TODO all the lockUncancelable in this file should be changed to regular lock and
-//! `error.Canceled` added to more error sets.
 const Client = @This();
 
 const builtin = @import("builtin");
@@ -84,8 +82,8 @@ pub const ConnectionPool = struct {
     /// If no connection is found, null is returned.
     ///
     /// Threadsafe.
-    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) ?*Connection {
-        pool.mutex.lockUncancelable(io);
+    pub fn findConnection(pool: *ConnectionPool, io: Io, criteria: Criteria) Io.Cancelable!?*Connection {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         var next = pool.free.last;
@@ -113,8 +111,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Acquires an existing connection from the connection pool. This function is threadsafe.
-    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn acquire(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         return pool.acquireUnsafe(connection);
@@ -150,8 +148,8 @@ pub const ConnectionPool = struct {
     }
 
     /// Adds a newly created node to the pool of used connections. This function is threadsafe.
-    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn addUsed(pool: *ConnectionPool, io: Io, connection: *Connection) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
         pool.used.append(&connection.pool_node);
@@ -162,18 +160,15 @@ pub const ConnectionPool = struct {
     /// If the new size is smaller than the current size, then idle connections will be closed until the pool is the new size.
     ///
     /// Threadsafe.
-    pub fn resize(pool: *ConnectionPool, io: Io, allocator: Allocator, new_size: usize) void {
-        pool.mutex.lockUncancelable(io);
+    pub fn resize(pool: *ConnectionPool, io: Io, new_size: usize) Io.Cancelable!void {
+        try pool.mutex.lock(io);
         defer pool.mutex.unlock(io);
 
-        const next = pool.free.first;
-        _ = next;
         while (pool.free_len > new_size) {
-            const popped = pool.free.popFirst() orelse unreachable;
+            const popped: *Connection = @alignCast(@fieldParentPtr("pool_node", pool.free.popFirst().?));
             pool.free_len -= 1;
 
-            popped.data.close(allocator);
-            allocator.destroy(popped);
+            popped.destroy(io);
         }
 
         pool.free_size = new_size;
@@ -1323,7 +1318,7 @@ pub fn initDefaultProxies(client: *Client, arena: Allocator, environ_map: *const
     const io = client.io;
 
     // Prevent any new connections from being created.
-    client.connection_pool.mutex.lockUncancelable(io);
+    try client.connection_pool.mutex.lock(io);
     defer client.connection_pool.mutex.unlock(io);
 
     assert(client.connection_pool.used.first == null); // There are active requests.
@@ -1418,7 +1413,7 @@ pub const basic_authorization = struct {
 
 pub const ConnectTcpError = error{
     TlsInitializationFailed,
-} || Allocator.Error || HostName.ConnectError;
+} || Allocator.Error || HostName.ConnectError || Io.Cancelable;
 
 /// Reuses a `Connection` if one matching `host` and `port` is already open.
 ///
@@ -1451,7 +1446,7 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
     const proxied_host = options.proxied_host orelse host;
     const proxied_port = options.proxied_port orelse port;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = protocol,
@@ -1469,18 +1464,20 @@ pub fn connectTcpOptions(client: *Client, options: ConnectTcpOptions) ConnectTcp
                 error.Canceled => |e| return e,
                 else => return error.TlsInitializationFailed,
             };
-            client.connection_pool.addUsed(io, &tc.connection);
+            errdefer tc.destroy();
+            try client.connection_pool.addUsed(io, &tc.connection);
             return &tc.connection;
         },
         .plain => {
             const pc = try Connection.Plain.create(client, proxied_host, proxied_port, stream);
-            client.connection_pool.addUsed(io, &pc.connection);
+            errdefer pc.destroy();
+            try client.connection_pool.addUsed(io, &pc.connection);
             return &pc.connection;
         },
     }
 }
 
-pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError;
+pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{NameTooLong} || std.posix.ConnectError || Io.Cancelable;
 
 /// Connect to `path` as a unix domain socket. This will reuse a connection if one is already open.
 ///
@@ -1488,7 +1485,7 @@ pub const ConnectUnixError = Allocator.Error || std.posix.SocketError || error{N
 pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connection {
     const io = client.io;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = path,
         .port = 0,
         .protocol = .plain,
@@ -1512,7 +1509,7 @@ pub fn connectUnix(client: *Client, path: []const u8) ConnectUnixError!*Connecti
     };
     errdefer client.allocator.free(conn.data.host);
 
-    client.connection_pool.addUsed(conn);
+    try client.connection_pool.addUsed(conn);
 
     return &conn.data;
 }
@@ -1530,7 +1527,7 @@ pub fn connectProxied(
     const io = client.io;
     if (!proxy.supports_connect) return error.TunnelNotSupported;
 
-    if (client.connection_pool.findConnection(io, .{
+    if (try client.connection_pool.findConnection(io, .{
         .host = proxied_host,
         .port = proxied_port,
         .protocol = proxy.protocol,

package/std/os/linux/aarch64.zig

@@ -2,14 +2,21 @@ const builtin = @import("builtin");
 const std = @import("../../std.zig");
 const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) u64 {
+pub const syscall_arg_t = u64;
+
+pub fn syscall0(
+    number: SYS,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: u64) u64 {
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
+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,
+) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
 
 pub fn syscall6(
     number: SYS,
-    arg1: u64,
-    arg2: u64,
-    arg3: u64,
-    arg4: u64,
-    arg5: u64,
-    arg6: u64,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+    arg5: syscall_arg_t,
+    arg6: syscall_arg_t,
 ) u64 {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> u64),

package/std/os/linux/arc.zig

@@ -2,14 +2,21 @@ const builtin = @import("builtin");
 const std = @import("../../std.zig");
 const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) u32 {
+pub const syscall_arg_t = u32;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
     return asm volatile ("trap_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: u32) u32 {
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
     return asm volatile ("trap_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
     return asm volatile ("trap_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
     return asm volatile ("trap_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+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_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+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_s 0"
         : [ret] "={r0}" (-> u32),
         : [number] "{r8}" (@intFromEnum(number)),
@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
 
 pub fn syscall6(
     number: SYS,
-    arg1: u32,
-    arg2: u32,
-    arg3: u32,
-    arg4: u32,
-    arg5: u32,
-    arg6: u32,
+    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_s 0"
         : [ret] "={r0}" (-> u32),