@zigc/lib 0.16.0 → 0.17.0-dev.39

package/compiler_rt/mulXi3.zig

@@ -63,7 +63,7 @@ fn DoubleInt(comptime T: type) type {
     };
 }
 
-fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
+pub fn muldXi(comptime T: type, a: T, b: T) DoubleInt(T) {
     const DT = DoubleInt(T);
     const word_t = compiler_rt.HalveInt(DT, false);
     const bits_in_word_2 = @sizeOf(T) * 8 / 2;

package/compiler_rt/ssp.zig

@@ -24,7 +24,7 @@ extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.c) ?[*]u8
 comptime {
     @export(&__stack_chk_fail, .{ .name = if (builtin.os.tag == .openbsd) "__stack_smash_handler" else "__stack_chk_fail", .linkage = compiler_rt.linkage, .visibility = compiler_rt.visibility });
     symbol(&__chk_fail, "__chk_fail");
-    symbol(&__stack_chk_guard, "__stack_chk_guard");
+    symbol(&__stack_chk_guard, if (builtin.os.tag == .openbsd) "__guard_local" else "__stack_chk_guard");
     symbol(&__strcpy_chk, "__strcpy_chk");
     symbol(&__strncpy_chk, "__strncpy_chk");
     symbol(&__strcat_chk, "__strcat_chk");

package/compiler_rt/udivmodei4.zig

@@ -13,6 +13,8 @@ const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max s
 comptime {
     symbol(&__udivei4, "__udivei4");
     symbol(&__umodei4, "__umodei4");
+    symbol(&__udivei5, "__udivei5");
+    symbol(&__umodei5, "__umodei5");
 }
 
 /// Get the value of a limb.
@@ -132,6 +134,32 @@ pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) ca
     @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
 }
 
+pub fn __udivei5(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
+}
+
+pub fn __umodei5(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, t_p: [*]u8, bits: usize) callconv(.c) void {
+    @setRuntimeSafety(compiler_rt.test_safety);
+    const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits));
+    const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size]));
+    const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size]));
+    const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size]));
+    const tu: []u32 = @ptrCast(@alignCast(t_p[0..byte_size]));
+    _ = tu;
+    const tv: []u32 = @ptrCast(@alignCast(t_p[byte_size..][0..byte_size]));
+    _ = tv;
+    @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
+}
+
 test "__udivei4/__umodei4" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;

package/libc/musl/arch/mipsn32/syscall_arch.h

@@ -1,6 +1,9 @@
 #define __SYSCALL_LL_E(x) (x)
 #define __SYSCALL_LL_O(x) (x)
 
+#define __scc(X) sizeof(1?(X):0ULL) < 8 ? (unsigned long) (X) : (long long) (X)
+typedef long long syscall_arg_t;
+
 #define SYSCALL_RLIM_INFINITY (-1UL/2)
 
 #if __mips_isa_rev >= 6
@@ -13,9 +16,9 @@
 	"$14", "$15", "$24", "$25", "hi", "lo", "memory"
 #endif
 
-static inline long __syscall0(long n)
+static inline long __syscall0(long long n)
 {
-	register long r7 __asm__("$7");
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 	__asm__ __volatile__ (
 		"daddu $2,$0,%2 ; syscall"
@@ -25,10 +28,10 @@ static inline long __syscall0(long n)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall1(long n, long a)
+static inline long __syscall1(long long n, long long a)
 {
-	register long r4 __asm__("$4") = a;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 	__asm__ __volatile__ (
 		"daddu $2,$0,%2 ; syscall"
@@ -38,11 +41,11 @@ static inline long __syscall1(long n, long a)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall2(long n, long a, long b)
+static inline long __syscall2(long long n, long long a, long long b)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -53,12 +56,12 @@ static inline long __syscall2(long n, long a, long b)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall3(long n, long a, long b, long c)
+static inline long __syscall3(long long n, long long a, long long b, long long c)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7");
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7");
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -69,12 +72,12 @@ static inline long __syscall3(long n, long a, long b, long c)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall4(long n, long a, long b, long c, long d)
+static inline long __syscall4(long long n, long long a, long long b, long long c, long long d)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -85,13 +88,13 @@ static inline long __syscall4(long n, long a, long b, long c, long d)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall5(long n, long a, long b, long c, long d, long e)
+static inline long __syscall5(long long n, long long a, long long b, long long c, long long d, long long e)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
-	register long r8 __asm__("$8") = e;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
+	register long long r8 __asm__("$8") = e;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (
@@ -102,14 +105,14 @@ static inline long __syscall5(long n, long a, long b, long c, long d, long e)
 	return r7 && r2>0 ? -r2 : r2;
 }
 
-static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
+static inline long __syscall6(long long n, long long a, long long b, long long c, long long d, long long e, long long f)
 {
-	register long r4 __asm__("$4") = a;
-	register long r5 __asm__("$5") = b;
-	register long r6 __asm__("$6") = c;
-	register long r7 __asm__("$7") = d;
-	register long r8 __asm__("$8") = e;
-	register long r9 __asm__("$9") = f;
+	register long long r4 __asm__("$4") = a;
+	register long long r5 __asm__("$5") = b;
+	register long long r6 __asm__("$6") = c;
+	register long long r7 __asm__("$7") = d;
+	register long long r8 __asm__("$8") = e;
+	register long long r9 __asm__("$9") = f;
 	register long r2 __asm__("$2");
 
 	__asm__ __volatile__ (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0",
+  "version": "0.17.0-dev.39",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Step/Compile.zig

@@ -1393,7 +1393,6 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
         try zig_args.append("--debug-incremental");
     }
 
-    if (b.verbose_cimport) try zig_args.append("--verbose-cimport");
     if (b.verbose_air) try zig_args.append("--verbose-air");
     if (b.verbose_llvm_ir) |path| try zig_args.append(b.fmt("--verbose-llvm-ir={s}", .{path}));
     if (b.verbose_llvm_bc) |path| try zig_args.append(b.fmt("--verbose-llvm-bc={s}", .{path}));

package/std/Build.zig

@@ -38,7 +38,6 @@ verbose_cc: bool,
 verbose_air: bool,
 verbose_llvm_ir: ?[]const u8,
 verbose_llvm_bc: ?[]const u8,
-verbose_cimport: bool,
 verbose_llvm_cpu_features: bool,
 reference_trace: ?u32 = null,
 invalid_user_input: bool,
@@ -278,7 +277,6 @@ pub fn create(
         .verbose_air = false,
         .verbose_llvm_ir = null,
         .verbose_llvm_bc = null,
-        .verbose_cimport = false,
         .verbose_llvm_cpu_features = false,
         .invalid_user_input = false,
         .allocator = arena,
@@ -377,7 +375,6 @@ fn createChildOnly(
         .verbose_air = parent.verbose_air,
         .verbose_llvm_ir = parent.verbose_llvm_ir,
         .verbose_llvm_bc = parent.verbose_llvm_bc,
-        .verbose_cimport = parent.verbose_cimport,
         .verbose_llvm_cpu_features = parent.verbose_llvm_cpu_features,
         .reference_trace = parent.reference_trace,
         .invalid_user_input = false,

package/std/Io/Threaded.zig

@@ -10035,10 +10035,10 @@ fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!voi
     if (posix.SEEK == void) return error.Unseekable;
 
     if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
-        var result: u64 = undefined;
+        var result: i64 = undefined;
         const syscall: Syscall = try .start();
         while (true) {
-            switch (posix.errno(posix.system.llseek(file.handle, @bitCast(offset), &result, posix.SEEK.CUR))) {
+            switch (posix.errno(posix.system.llseek(file.handle, offset, &result, posix.SEEK.CUR))) {
                 .SUCCESS => {
                     syscall.finish();
                     return;
@@ -10149,8 +10149,8 @@ fn posixSeekTo(fd: posix.fd_t, offset: u64) File.SeekError!void {
     if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
         const syscall: Syscall = try .start();
         while (true) {
-            var result: u64 = undefined;
-            switch (posix.errno(posix.system.llseek(fd, offset, &result, posix.SEEK.SET))) {
+            var result: i64 = undefined;
+            switch (posix.errno(posix.system.llseek(fd, @bitCast(offset), &result, posix.SEEK.SET))) {
                 .SUCCESS => {
                     syscall.finish();
                     return;
@@ -15247,7 +15247,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
     const ru_ptr = if (child.request_resource_usage_statistics) &ru else null;
 
     if (have_wait4) {
-        var status: if (builtin.link_libc) c_int else u32 = undefined;
+        var status: if (builtin.link_libc) c_int else i32 = undefined;
         const syscall: Syscall = try .start();
         while (true) switch (posix.errno(posix.system.wait4(pid, &status, 0, ru_ptr))) {
             .SUCCESS => {
@@ -15290,7 +15290,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
         };
     }
 
-    var status: if (builtin.link_libc) c_int else u32 = undefined;
+    var status: if (builtin.link_libc) c_int else i32 = undefined;
     const syscall: Syscall = try .start();
     while (true) switch (posix.errno(posix.system.waitpid(pid, &status, 0))) {
         .SUCCESS => {
@@ -15332,7 +15332,7 @@ fn childKillPosix(child: *process.Child) !void {
     };
 
     if (have_wait4) {
-        var status: if (builtin.link_libc) c_int else u32 = undefined;
+        var status: if (builtin.link_libc) c_int else i32 = undefined;
         while (true) switch (posix.errno(posix.system.wait4(pid, &status, 0, null))) {
             .SUCCESS => return,
             .INTR => continue,
@@ -15352,7 +15352,7 @@ fn childKillPosix(child: *process.Child) !void {
         };
     }
 
-    var status: if (builtin.link_libc) c_int else u32 = undefined;
+    var status: if (builtin.link_libc) c_int else i32 = undefined;
     while (true) switch (posix.errno(posix.system.waitpid(pid, &status, 0))) {
         .SUCCESS => return,
         .INTR => continue,

package/std/Io/Writer.zig

@@ -551,64 +551,68 @@ pub fn writeAll(w: *Writer, bytes: []const u8) Error!void {
     while (index < bytes.len) index += try w.write(bytes[index..]);
 }
 
-/// Renders fmt string with args, calling `writer` with slices of bytes.
-/// If `writer` returns an error, the error is returned from `format` and
-/// `writer` is not called again.
+/// Renders `fmt` string with `args`, calling `w` with slices of bytes.
 ///
-/// The format string must be comptime-known and may contain placeholders following
-/// this format:
-/// `{[argument][specifier]:[fill][alignment][width].[precision]}`
+/// The format string must be comptime-known and may contain placeholders
+/// following this format:
+/// ```
+/// {[argument][specifier]:[fill][alignment][width].[precision]}
+/// ```
 ///
-/// Above, each word including its surrounding [ and ] is a parameter which you have to replace with something:
+/// Above, each word including its surrounding [ and ] is a parameter to be replaced with:
 ///
-/// - *argument* is either the numeric index or the field name of the argument that should be inserted
-///   - when using a field name, you are required to enclose the field name (an identifier) in square
-///     brackets, e.g. {[score]...} as opposed to the numeric index form which can be written e.g. {2...}
-/// - *specifier* is a type-dependent formatting option that determines how a type should formatted (see below)
-/// - *fill* is a single byte which is used to pad formatted numbers.
-/// - *alignment* is one of the three bytes '<', '^', or '>' to make numbers
+/// - **argument** is either the numeric index or the field name of the argument that should be inserted.
+///   - When using a field name, the field name (an identifier) must be enclosed in square
+///     brackets, e.g. `{[score]...}` as opposed to the numeric index form which can be written e.g. `{2...}`.
+/// - **specifier** is a type-dependent formatting option that determines how a type should formatted (see below).
+/// - **fill** is a single byte which is used to pad formatted numbers.
+/// - **alignment** is one of the three bytes '<', '^', or '>' to make numbers
 ///   left, center, or right-aligned, respectively.
 ///   - Not all specifiers support alignment.
-///   - Alignment is not Unicode-aware; appropriate only when used with raw bytes or ASCII.
-/// - *width* is the total width of the field in bytes. This only applies to number formatting.
-/// - *precision* specifies how many decimals a formatted number should have.
+///   - Alignment is not Unicode-aware; appropriate only when used with raw
+///     bytes or ASCII.
+/// - **width** is the total size of the field in bytes, only applicable to
+///   number formatting.
+/// - **precision** specifies how many decimals a formatted number should have.
 ///
-/// Note that most of the parameters are optional and may be omitted. Also you
-/// can leave out separators like `:` and `.` when all parameters after the
-/// separator are omitted.
+/// Most of the parameters are optional and may be omitted. The separators (':'
+/// and '.') may be omitted when all parameters afterwards are omitted.
 ///
-/// Only exception is the *fill* parameter. If a non-zero *fill* character is
-/// required at the same time as *width* is specified, one has to specify
-/// *alignment* as well, as otherwise the digit following `:` is interpreted as
-/// *width*, not *fill*.
+/// The **fill** parameter is an exception. If a non-zero **fill** character is
+/// required at the same time as **width** is specified, **alignment** is
+/// required, otherwise the digit following ':' is interpreted as **width**.
 ///
-/// The *specifier* has several options for types:
-/// - `x` and `X`: output numeric value in hexadecimal notation, or string in hexadecimal bytes
+/// **specifier** supports:
+/// - `x` and `X`: numeric value in hexadecimal notation, or string in hexadecimal bytes
 /// - `s`:
 ///   - for pointer-to-many and C pointers of u8, print as a C-string using zero-termination
 ///   - for slices of u8, print the entire slice as a string without zero-termination
 /// - `t`:
 ///   - for enums and tagged unions: prints the tag name
 ///   - for error sets: prints the error name
-/// - `b64`: output string as standard base64
-/// - `e`: output floating point value in scientific notation
-/// - `d`: output numeric value in decimal notation
-/// - `b`: output integer value in binary notation
-/// - `o`: output integer value in octal notation
-/// - `c`: output integer as an ASCII character. Integer type must have 8 bits at max.
-/// - `u`: output integer as an UTF-8 sequence. Integer type must have 21 bits at max.
-/// - `D`: output nanoseconds as duration
-/// - `B`: output bytes in SI units (decimal)
-/// - `Bi`: output bytes in IEC units (binary)
-/// - `?`: output optional value as either the unwrapped value, or `null`; may be followed by a format specifier for the underlying value.
-/// - `!`: output error union value as either the unwrapped value, or the formatted error value; may be followed by a format specifier for the underlying value.
-/// - `*`: output the address of the value instead of the value itself.
-/// - `any`: output a value of any type using its default format.
-/// - `f`: delegates to a method on the type named "format" with the signature `fn (*Writer, args: anytype) Writer.Error!void`.
+/// - `b64`: string as standard base64
+/// - `e`: floating point value in scientific notation
+/// - `d`: numeric value in decimal notation
+/// - `b`: integer value in binary notation
+/// - `o`: integer value in octal notation
+/// - `c`: integer as an ASCII character. Integer type must have 8 bits at max.
+/// - `u`: integer as an UTF-8 sequence. Integer type must have 21 bits at max.
+/// - `B`: bytes in SI units (decimal)
+/// - `Bi`: bytes in IEC units (binary)
+/// - `?`: optional value as either the unwrapped value, or `null`; may be
+///   followed by a format specifier for the underlying value.
+/// - `!`: error union value as either the unwrapped value, or the formatted
+///   error value; may be followed by a format specifier for the underlying
+///   value.
+/// - `*`: the address of the value instead of the value itself.
+/// - `any`: a value of any type using its default format.
+/// - `f`: delegates to the `format` method of the type, passing `*Writer` and
+///   expecting `Error!void` returned.
 ///
-/// A user type may be a `struct`, `vector`, `union` or `enum` type.
+/// A user type may be a struct, vector, union or enum type.
 ///
-/// To print literal curly braces, escape them by writing them twice, e.g. `{{` or `}}`.
+/// Literal curly braces can be escaped in the format string via doubling, e.g.
+/// `{{` or `}}`.
 pub fn print(w: *Writer, comptime fmt: []const u8, args: anytype) Error!void {
     const ArgsType = @TypeOf(args);
     const args_type_info = @typeInfo(ArgsType);

package/std/os/emscripten.zig

@@ -211,7 +211,7 @@ pub const W = struct {
     pub fn TERMSIG(s: u32) SIG {
         return @enumFromInt(s & 0x7f);
     }
-    pub fn STOPSIG(s: u32) u32 {
+    pub fn STOPSIG(s: u32) SIG {
         return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {

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),