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

package/std/os/linux/riscv64.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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@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 ("ecall"
         : [ret] "={x10}" (-> u64),

package/std/os/linux/s390x.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] "={r2}" (-> u64),
         : [number] "{r1}" (@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] "={r2}" (-> u64),
         : [number] "{r1}" (@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] "={r2}" (-> u64),
         : [number] "{r1}" (@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] "={r2}" (-> u64),
         : [number] "{r1}" (@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] "={r2}" (-> u64),
         : [number] "{r1}" (@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] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
@@ -59,7 +88,15 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
         : .{ .memory = true });
 }
 
-pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
+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,
+) u64 {
     return asm volatile ("svc 0"
         : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),

package/std/os/linux/sparc64.zig

@@ -2,49 +2,26 @@ const builtin = @import("builtin");
 const std = @import("../../std.zig");
 const SYS = std.os.linux.SYS;
 
-pub fn syscall_pipe(fd: *[2]i32) u64 {
-    return asm volatile (
-        \\ mov %[arg], %%g3
-        \\ t 0x6d
-        \\ bcc,pt %%xcc, 1f
-        \\ nop
-        \\ # Return the error code
-        \\ ba 2f
-        \\ neg %%o0
-        \\1:
-        \\ st %%o0, [%%g3+0]
-        \\ st %%o1, [%%g3+4]
-        \\ clr %%o0
-        \\2:
-        : [ret] "={o0}" (-> u64),
-        : [number] "{g1}" (@intFromEnum(SYS.pipe)),
-          [arg] "r" (fd),
-        : .{ .memory = true, .g3 = true });
-}
+pub const syscall_arg_t = u64;
 
-pub fn syscall_fork() u64 {
-    // Linux/sparc64 fork() returns two values in %o0 and %o1:
-    // - On the parent's side, %o0 is the child's PID and %o1 is 0.
-    // - On the child's side, %o0 is the parent's PID and %o1 is 1.
-    // We need to clear the child's %o0 so that the return values
-    // conform to the libc convention.
+pub fn syscall0(
+    number: SYS,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
-        \\ ba 2f
         \\ neg %%o0
         \\ 1:
-        \\ # Clear the child's %%o0
-        \\ dec %%o1
-        \\ and %%o1, %%o0, %%o0
-        \\ 2:
         : [ret] "={o0}" (-> u64),
-        : [number] "{g1}" (@intFromEnum(SYS.fork)),
+        : [number] "{g1}" (@intFromEnum(number)),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall0(number: SYS) u64 {
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -53,10 +30,15 @@ pub fn syscall0(number: SYS) u64 {
         \\ 1:
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
+          [arg1] "{o0}" (arg1),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall1(number: SYS, arg1: u64) u64 {
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -66,10 +48,16 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
         : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
+          [arg2] "{o1}" (arg2),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -80,10 +68,17 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
+          [arg3] "{o2}" (arg3),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: 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 (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -95,10 +90,18 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
           [arg3] "{o2}" (arg3),
+          [arg4] "{o3}" (arg4),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: 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 (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -111,10 +114,19 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
           [arg2] "{o1}" (arg2),
           [arg3] "{o2}" (arg3),
           [arg4] "{o3}" (arg4),
+          [arg5] "{o4}" (arg5),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
+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,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
@@ -128,32 +140,51 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
           [arg3] "{o2}" (arg3),
           [arg4] "{o3}" (arg4),
           [arg5] "{o4}" (arg5),
+          [arg6] "{o5}" (arg6),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall6(
-    number: SYS,
-    arg1: u64,
-    arg2: u64,
-    arg3: u64,
-    arg4: u64,
-    arg5: u64,
-    arg6: u64,
+pub fn syscall_pipe(
+    fd: *[2]std.os.linux.fd_t,
 ) u64 {
+    return asm volatile (
+        \\ mov %[arg], %%g3
+        \\ t 0x6d
+        \\ bcc,pt %%xcc, 1f
+        \\ nop
+        \\ # Return the error code
+        \\ ba 2f
+        \\ neg %%o0
+        \\1:
+        \\ st %%o0, [%%g3+0]
+        \\ st %%o1, [%%g3+4]
+        \\ clr %%o0
+        \\2:
+        : [ret] "={o0}" (-> u64),
+        : [number] "{g1}" (@intFromEnum(SYS.pipe)),
+          [arg] "r" (fd),
+        : .{ .memory = true, .g3 = true });
+}
+
+pub fn syscall_fork() u64 {
+    // Linux/sparc64 fork() returns two values in %o0 and %o1:
+    // - On the parent's side, %o0 is the child's PID and %o1 is 0.
+    // - On the child's side, %o0 is the parent's PID and %o1 is 1.
+    // We need to clear the child's %o0 so that the return values
+    // conform to the libc convention.
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
+        \\ ba 2f
         \\ neg %%o0
         \\ 1:
+        \\ # Clear the child's %%o0
+        \\ dec %%o1
+        \\ and %%o1, %%o0, %%o0
+        \\ 2:
         : [ret] "={o0}" (-> u64),
-        : [number] "{g1}" (@intFromEnum(number)),
-          [arg1] "{o0}" (arg1),
-          [arg2] "{o1}" (arg2),
-          [arg3] "{o2}" (arg3),
-          [arg4] "{o3}" (arg4),
-          [arg5] "{o4}" (arg5),
-          [arg6] "{o5}" (arg6),
+        : [number] "{g1}" (@intFromEnum(SYS.fork)),
         : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 

package/std/os/linux/thumb.zig

@@ -5,9 +5,14 @@
 //! to break the frame chain.
 const std = @import("../../std.zig");
 const SYS = std.os.linux.SYS;
+const arm = @import("arm.zig");
 
-pub fn syscall0(number: SYS) u32 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+pub const syscall_arg_t = arm.syscall_arg_t;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -18,8 +23,11 @@ pub fn syscall0(number: SYS) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: u32) u32 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -31,8 +39,12 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+pub fn syscall2(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+) u32 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -45,8 +57,13 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+pub fn syscall3(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+) u32 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -60,8 +77,14 @@ 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 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+pub fn syscall4(
+    number: SYS,
+    arg1: syscall_arg_t,
+    arg2: syscall_arg_t,
+    arg3: syscall_arg_t,
+    arg4: syscall_arg_t,
+) u32 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -76,8 +99,15 @@ 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 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+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 {
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -95,14 +125,14 @@ 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 {
-    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
+    var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
@@ -119,22 +149,8 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub const clone = @import("arm.zig").clone;
+pub const clone = arm.clone;
 
-pub fn restore() callconv(.naked) noreturn {
-    asm volatile (
-        \\ mov r7, %[number]
-        \\ svc #0
-        :
-        : [number] "I" (@intFromEnum(SYS.sigreturn)),
-    );
-}
+pub const restore = arm.restore;
 
-pub fn restore_rt() callconv(.naked) noreturn {
-    asm volatile (
-        \\ mov r7, %[number]
-        \\ svc #0
-        :
-        : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
-    );
-}
+pub const restore_rt = arm.restore_rt;

package/std/os/linux/x32.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 = u64;
+
+pub fn syscall0(
+    number: SYS,
+) u32 {
     return asm volatile ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@intFromEnum(number)),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: u32) u32 {
+pub fn syscall1(
+    number: SYS,
+    arg1: syscall_arg_t,
+) u32 {
     return asm volatile ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@intFromEnum(number)),
@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
         : .{ .rcx = true, .r11 = true, .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 ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@intFromEnum(number)),
@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
         : .{ .rcx = true, .r11 = true, .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 ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@intFromEnum(number)),
@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
         : .{ .rcx = true, .r11 = true, .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 ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@intFromEnum(number)),
@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
         : .{ .rcx = true, .r11 = true, .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 ("syscall"
         : [ret] "={rax}" (-> u32),
         : [number] "{rax}" (@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 ("syscall"
         : [ret] "={rax}" (-> u32),