From 67023fc4bd8cef20a097b4cd7b97438625049b70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= Date: Wed, 15 Apr 2026 19:02:13 +0200 Subject: [PATCH] std.os.linux: fix syscall argument width for mipsn32 and x32 This required a thorough audit of every syscall wrapper in std.os.linux, so while I was here, I fixed some minor arch-specific bugs, improved some types, simplified some casts, and deleted some dead code. Note that lseek() in particular is still broken for n32 and x32 after this commit; this wrapper will require some special-casing in the arch bits due to its unusual return type width. closes https://github.com/ziglang/zig/issues/22464 closes https://codeberg.org/ziglang/zig/issues/31597 --- lib/c/fcntl.zig | 2 +- lib/std/Io/Threaded.zig | 16 +- lib/std/os/linux.zig | 813 +++++++++++++++---------------- lib/std/os/linux/aarch64.zig | 53 +- lib/std/os/linux/arc.zig | 53 +- lib/std/os/linux/arm.zig | 53 +- lib/std/os/linux/hexagon.zig | 44 +- lib/std/os/linux/loongarch32.zig | 53 +- lib/std/os/linux/loongarch64.zig | 53 +- lib/std/os/linux/m68k.zig | 54 +- lib/std/os/linux/mips.zig | 103 ++-- lib/std/os/linux/mips64.zig | 89 ++-- lib/std/os/linux/mipsn32.zig | 89 ++-- lib/std/os/linux/or1k.zig | 53 +- lib/std/os/linux/powerpc.zig | 53 +- lib/std/os/linux/powerpc64.zig | 53 +- lib/std/os/linux/riscv32.zig | 53 +- lib/std/os/linux/riscv64.zig | 53 +- lib/std/os/linux/s390x.zig | 51 +- lib/std/os/linux/sparc64.zig | 259 +++++----- lib/std/os/linux/thumb.zig | 88 ++-- lib/std/os/linux/x32.zig | 53 +- lib/std/os/linux/x86.zig | 55 ++- lib/std/os/linux/x86_64.zig | 53 +- 24 files changed, 1432 insertions(+), 867 deletions(-) diff --git a/lib/c/fcntl.zig b/lib/c/fcntl.zig index de3f0f2cfb..29788fa922 100644 --- a/lib/c/fcntl.zig +++ b/lib/c/fcntl.zig @@ -16,7 +16,7 @@ comptime { } fn fallocateLinux(fd: c_int, mode: c_int, offset: off_t, len: off_t) callconv(.c) c_int { - return errno(linux.fallocate(fd, mode, offset, len)); + return errno(linux.fallocate(fd, @bitCast(mode), offset, len)); } fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callconv(.c) c_int { diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig index f004a56ca9..a27efafe65 100644 --- a/lib/std/Io/Threaded.zig +++ b/lib/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, diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig index 6dbbc83288..777b9eadaf 100644 --- a/lib/std/os/linux.zig +++ b/lib/std/os/linux.zig @@ -59,6 +59,7 @@ const arch_bits = switch (native_arch) { const syscall_bits = if (native_arch.isThumb()) @import("linux/thumb.zig") else arch_bits; +pub const syscall_arg_t = syscall_bits.syscall_arg_t; pub const syscall0 = syscall_bits.syscall0; pub const syscall1 = syscall_bits.syscall1; pub const syscall2 = syscall_bits.syscall2; @@ -78,9 +79,9 @@ pub fn clone( stack: usize, flags: u32, arg: usize, - ptid: ?*i32, + ptid: ?*pid_t, tp: usize, // aka tls - ctid: ?*i32, + ctid: ?*pid_t, ) usize { // Can't directly call a naked function; cast to C calling convention first. return @as(*const fn ( @@ -88,9 +89,9 @@ pub fn clone( usize, u32, usize, - ?*i32, + ?*pid_t, usize, - ?*i32, + ?*pid_t, ) callconv(.c) usize, @ptrCast(&syscall_bits.clone))(func, stack, flags, arg, ptid, tp, ctid); } @@ -98,6 +99,8 @@ pub const ARCH = arch_bits.ARCH; pub const HWCAP = arch_bits.HWCAP; pub const SC = arch_bits.SC; pub const VDSO = arch_bits.VDSO; +pub const user_desc = arch_bits.user_desc; + pub const blkcnt_t = u64; pub const blksize_t = u32; pub const dev_t = u64; @@ -105,8 +108,13 @@ pub const ino_t = u64; pub const mode_t = u32; pub const nlink_t = u32; pub const off_t = i64; +pub const pid_t = i32; +pub const fd_t = i32; +pub const socket_t = fd_t; +pub const uid_t = u32; +pub const gid_t = u32; +pub const clock_t = isize; pub const time_t = arch_bits.time_t; -pub const user_desc = arch_bits.user_desc; pub const tls = @import("linux/tls.zig"); pub const BPF = @import("linux/bpf.zig"); @@ -613,13 +621,13 @@ pub fn brk(addr: usize) usize { return syscall1(.brk, addr); } -pub fn dup(old: i32) usize { - return syscall1(.dup, @as(usize, @bitCast(@as(isize, old)))); +pub fn dup(old: fd_t) usize { + return syscall1(.dup, @as(u32, @bitCast(old))); } -pub fn dup2(old: i32, new: i32) usize { +pub fn dup2(old: fd_t, new: fd_t) usize { if (@hasField(SYS, "dup2")) { - return syscall2(.dup2, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new)))); + return syscall2(.dup2, @as(u32, @bitCast(old)), @as(u32, @bitCast(new))); } else { if (old == new) { if (std.debug.runtime_safety) { @@ -628,13 +636,13 @@ pub fn dup2(old: i32, new: i32) usize { } return @as(usize, @intCast(old)); } else { - return syscall3(.dup3, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new))), 0); + return syscall3(.dup3, @as(u32, @bitCast(old)), @as(u32, @bitCast(new)), 0); } } } -pub fn dup3(old: i32, new: i32, flags: u32) usize { - return syscall3(.dup3, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new))), flags); +pub fn dup3(old: fd_t, new: fd_t, flags: u32) usize { + return syscall3(.dup3, @as(u32, @bitCast(old)), @as(u32, @bitCast(new)), flags); } pub fn chdir(path: [*:0]const u8) usize { @@ -642,7 +650,7 @@ pub fn chdir(path: [*:0]const u8) usize { } pub fn fchdir(fd: fd_t) usize { - return syscall1(.fchdir, @as(usize, @bitCast(@as(isize, fd)))); + return syscall1(.fchdir, @as(u32, @bitCast(fd))); } pub fn chroot(path: [*:0]const u8) usize { @@ -664,7 +672,7 @@ pub const EXECVEAT = packed struct(u32) { }; pub fn execveat(dirfd: fd_t, path: [*:0]const u8, argv: [*:null]const ?[*:0]const u8, envp: [*:null]const ?[*:0]const u8, flags: EXECVEAT) usize { - return syscall5(.execveat, fd_to_usize(dirfd), @intFromPtr(path), @intFromPtr(argv), @intFromPtr(envp), @as(u32, @bitCast(flags))); + return syscall5(.execveat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @intFromPtr(argv), @intFromPtr(envp), @as(u32, @bitCast(flags))); } pub fn fork() usize { @@ -686,28 +694,28 @@ pub inline fn vfork() usize { return @call(.always_inline, syscall0, .{.vfork}); } -pub fn futimens(fd: i32, times: ?*const [2]timespec) usize { +pub fn futimens(fd: fd_t, times: ?*const [2]timespec) usize { return utimensat(fd, null, times, 0); } -pub fn utimensat(dirfd: i32, path: ?[*:0]const u8, times: ?*const [2]timespec, flags: u32) usize { +pub fn utimensat(dirfd: fd_t, path: ?[*:0]const u8, times: ?*const [2]timespec, flags: u32) usize { return syscall4( if (@hasField(SYS, "utimensat") and native_arch != .hexagon) .utimensat else .utimensat_time64, - @as(usize, @bitCast(@as(isize, dirfd))), + @as(u32, @bitCast(dirfd)), @intFromPtr(path), @intFromPtr(times), flags, ); } -pub fn fallocate(fd: i32, mode: i32, offset: i64, length: i64) usize { - if (usize_bits < 64) { +pub fn fallocate(fd: fd_t, mode: mode_t, offset: off_t, length: off_t) usize { + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { const offset_halves = splitValue64(offset); const length_halves = splitValue64(length); return syscall6( .fallocate, - @as(usize, @bitCast(@as(isize, fd))), - @as(usize, @bitCast(@as(isize, mode))), + @as(u32, @bitCast(fd)), + mode, offset_halves[0], offset_halves[1], length_halves[0], @@ -716,8 +724,8 @@ pub fn fallocate(fd: i32, mode: i32, offset: i64, length: i64) usize { } else { return syscall4( .fallocate, - @as(usize, @bitCast(@as(isize, fd))), - @as(usize, @bitCast(@as(isize, mode))), + @as(u32, @bitCast(fd)), + mode, @as(u64, @bitCast(offset)), @as(u64, @bitCast(length)), ); @@ -888,19 +896,19 @@ pub fn getcwd(buf: [*]u8, size: usize) usize { return syscall2(.getcwd, @intFromPtr(buf), size); } -pub fn getdents(fd: i32, dirp: [*]u8, len: usize) usize { +pub fn getdents(fd: fd_t, dirp: [*]u8, len: usize) usize { return syscall3( .getdents, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(dirp), @min(len, maxInt(c_int)), ); } -pub fn getdents64(fd: i32, dirp: [*]u8, len: usize) usize { +pub fn getdents64(fd: fd_t, dirp: [*]u8, len: usize) usize { return syscall3( .getdents64, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(dirp), @min(len, maxInt(c_int)), ); @@ -910,12 +918,12 @@ pub fn inotify_init1(flags: u32) usize { return syscall1(.inotify_init1, flags); } -pub fn inotify_add_watch(fd: i32, pathname: [*:0]const u8, mask: u32) usize { - return syscall3(.inotify_add_watch, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(pathname), mask); +pub fn inotify_add_watch(fd: fd_t, pathname: [*:0]const u8, mask: u32) usize { + return syscall3(.inotify_add_watch, @as(u32, @bitCast(fd)), @intFromPtr(pathname), mask); } -pub fn inotify_rm_watch(fd: i32, wd: i32) usize { - return syscall2(.inotify_rm_watch, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, wd)))); +pub fn inotify_rm_watch(fd: fd_t, wd: fd_t) usize { + return syscall2(.inotify_rm_watch, @as(u32, @bitCast(fd)), @as(u32, @bitCast(wd))); } pub fn fanotify_init(flags: fanotify.InitFlags, event_f_flags: u32) usize { @@ -929,24 +937,24 @@ pub fn fanotify_mark( dirfd: fd_t, pathname: ?[*:0]const u8, ) usize { - if (usize_bits < 64) { + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { const mask_halves = splitValue64(@bitCast(mask)); return syscall6( .fanotify_mark, - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @as(u32, @bitCast(flags)), mask_halves[0], mask_halves[1], - @bitCast(@as(isize, dirfd)), + @as(u32, @bitCast(dirfd)), @intFromPtr(pathname), ); } else { return syscall5( .fanotify_mark, - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @as(u32, @bitCast(flags)), - @bitCast(mask), - @bitCast(@as(isize, dirfd)), + @as(u64, @bitCast(mask)), + @as(u32, @bitCast(dirfd)), @intFromPtr(pathname), ); } @@ -955,7 +963,7 @@ pub fn fanotify_mark( pub fn name_to_handle_at( dirfd: fd_t, pathname: [*:0]const u8, - handle: *std.os.linux.file_handle, + handle: *file_handle, mount_id: *i32, flags: u32, ) usize { @@ -973,27 +981,27 @@ pub fn readlink(noalias path: [*:0]const u8, noalias buf_ptr: [*]u8, buf_len: us if (@hasField(SYS, "readlink")) { return syscall3(.readlink, @intFromPtr(path), @intFromPtr(buf_ptr), buf_len); } else { - return syscall4(.readlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len); + return syscall4(.readlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len); } } -pub fn readlinkat(dirfd: i32, noalias path: [*:0]const u8, noalias buf_ptr: [*]u8, buf_len: usize) usize { - return syscall4(.readlinkat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len); +pub fn readlinkat(dirfd: fd_t, noalias path: [*:0]const u8, noalias buf_ptr: [*]u8, buf_len: usize) usize { + return syscall4(.readlinkat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len); } pub fn mkdir(path: [*:0]const u8, mode: mode_t) usize { if (@hasField(SYS, "mkdir")) { return syscall2(.mkdir, @intFromPtr(path), mode); } else { - return syscall3(.mkdirat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), mode); + return syscall3(.mkdirat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), mode); } } -pub fn mkdirat(dirfd: i32, path: [*:0]const u8, mode: mode_t) usize { - return syscall3(.mkdirat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode); +pub fn mkdirat(dirfd: fd_t, path: [*:0]const u8, mode: mode_t) usize { + return syscall3(.mkdirat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode); } -pub fn mknod(path: [*:0]const u8, mode: u32, dev: u32) usize { +pub fn mknod(path: [*:0]const u8, mode: mode_t, dev: dev_t) usize { if (@hasField(SYS, "mknod")) { return syscall3(.mknod, @intFromPtr(path), mode, dev); } else { @@ -1001,8 +1009,8 @@ pub fn mknod(path: [*:0]const u8, mode: u32, dev: u32) usize { } } -pub fn mknodat(dirfd: i32, path: [*:0]const u8, mode: u32, dev: u32) usize { - return syscall4(.mknodat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, dev); +pub fn mknodat(dirfd: dev_t, path: [*:0]const u8, mode: mode_t, dev: dev_t) usize { + return syscall4(.mknodat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode, dev); } pub fn mount(special: ?[*:0]const u8, dir: [*:0]const u8, fstype: ?[*:0]const u8, flags: u32, data: usize) usize { @@ -1038,7 +1046,14 @@ pub const MOVE_MOUNT = packed struct(u32) { }; pub fn move_mount(from_dirfd: fd_t, from_path: [*:0]const u8, to_dirfd: fd_t, to_path: [*:0]const u8, flags: MOVE_MOUNT) usize { - return syscall5(.move_mount, fd_to_usize(from_dirfd), @intFromPtr(from_path), fd_to_usize(to_dirfd), @intFromPtr(to_path), @as(u32, @bitCast(flags))); + return syscall5( + .move_mount, + @as(u32, @bitCast(from_dirfd)), + @intFromPtr(from_path), + @as(u32, @bitCast(to_dirfd)), + @intFromPtr(to_path), + @as(u32, @bitCast(flags)), + ); } pub const MOUNT_ATTR = packed struct(u32) { @@ -1070,7 +1085,7 @@ pub const MOUNT_ATTR = packed struct(u32) { }; pub fn mount_setattr(dirfd: fd_t, path: [*:0]const u8, flags: MOUNT_ATTR) usize { - return syscall3(.mount_setattr, fd_to_usize(dirfd), @intFromPtr(path), @as(u32, @bitCast(flags))); + return syscall3(.mount_setattr, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags))); } pub const FSOPEN = packed struct(u32) { @@ -1103,7 +1118,7 @@ pub const FSCONFIG_CMD = enum(u32) { }; pub fn fsconfig(fd: fd_t, cmd: FSCONFIG_CMD, key: ?[*:0]const u8, value: ?[*:0]const u8, aux: u32) usize { - return syscall5(.fsconfig, fd_to_usize(fd), @intFromEnum(cmd), @intFromPtr(key), @intFromPtr(value), aux); + return syscall5(.fsconfig, @as(u32, @bitCast(fd)), @intFromEnum(cmd), @intFromPtr(key), @intFromPtr(value), aux); } pub const FSMOUNT = packed struct(u32) { @@ -1113,7 +1128,7 @@ pub const FSMOUNT = packed struct(u32) { }; pub fn fsmount(fsfd: fd_t, flags: FSMOUNT, attr_flags: MOUNT_ATTR) usize { - return syscall3(.fsmount, fd_to_usize(fsfd), @as(u32, @bitCast(flags)), @as(u32, @bitCast(attr_flags))); + return syscall3(.fsmount, @as(u32, @bitCast(fsfd)), @as(u32, @bitCast(flags)), @as(u32, @bitCast(attr_flags))); } pub const FSPICK = packed struct(u32) { @@ -1126,7 +1141,7 @@ pub const FSPICK = packed struct(u32) { }; pub fn fspick(dirfd: fd_t, path: [*:0]const u8, flags: FSPICK) usize { - return syscall3(.fspick, fd_to_usize(dirfd), @intFromPtr(path), @as(u32, @bitCast(flags))); + return syscall3(.fspick, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags))); } pub fn pivot_root(new_root: [*:0]const u8, put_old: [*:0]const u8) usize { @@ -1141,7 +1156,7 @@ fn mmap2Unit() u64 { }; } -pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, offset: i64) usize { +pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: fd_t, offset: off_t) usize { if (@hasField(SYS, "mmap2")) { return syscall6( .mmap2, @@ -1149,7 +1164,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off length, @as(u32, @bitCast(prot)), @as(u32, @bitCast(flags)), - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @truncate(@as(u64, @bitCast(offset)) / mmap2Unit()), ); } else { @@ -1162,7 +1177,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off length, @as(u32, @bitCast(prot)), @as(u32, @bitCast(flags)), - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @as(u64, @bitCast(offset)), }), ) else syscall6( @@ -1171,7 +1186,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off length, @as(u32, @bitCast(prot)), @as(u32, @bitCast(flags)), - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @as(u64, @bitCast(offset)), ); } @@ -1278,70 +1293,142 @@ pub fn ppoll(fds: [*]pollfd, n: nfds_t, timeout: ?*timespec, sigmask: ?*const si ); } -pub fn read(fd: i32, buf: [*]u8, count: usize) usize { - return syscall3(.read, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(buf), count); +pub fn read(fd: fd_t, buf: [*]u8, count: usize) usize { + return syscall3(.read, @as(u32, @bitCast(fd)), @intFromPtr(buf), count); } -pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: i64) usize { +pub fn pread(fd: fd_t, buf: [*]u8, count: usize, offset: off_t) usize { + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { + const offset_halves = splitValue64(offset); + if (require_aligned_register_pair) { + return syscall6( + .pread64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + 0, + offset_halves[0], + offset_halves[1], + ); + } else { + return syscall5( + .pread64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + offset_halves[0], + offset_halves[1], + ); + } + } else { + return syscall4( + .pread64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + @as(u64, @bitCast(offset)), + ); + } +} + +pub fn readv(fd: fd_t, iov: [*]const iovec, count: usize) usize { + return syscall3(.readv, @as(u32, @bitCast(fd)), @intFromPtr(iov), count); +} + +pub fn preadv(fd: fd_t, iov: [*]const iovec, count: usize, offset: off_t) usize { const offset_u: u64 = @bitCast(offset); return syscall5( .preadv, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(iov), count, // Kernel expects the offset is split into largest natural word-size. // See following link for detail: // https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=601cc11d054ae4b5e9b5babec3d8e4667a2cb9b5 - @as(usize, @truncate(offset_u)), - if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0, + @truncate(offset_u), + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0, ); } -pub fn preadv2(fd: i32, iov: [*]const iovec, count: usize, offset: i64, flags: kernel_rwf) usize { +pub fn preadv2(fd: fd_t, iov: [*]const iovec, count: usize, offset: off_t, flags: kernel_rwf) usize { const offset_u: u64 = @bitCast(offset); return syscall6( .preadv2, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(iov), count, // See comments in preadv - @as(usize, @truncate(offset_u)), - if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0, + @truncate(offset_u), + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0, flags, ); } -pub fn readv(fd: i32, iov: [*]const iovec, count: usize) usize { - return syscall3(.readv, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(iov), count); +pub fn write(fd: fd_t, buf: [*]const u8, count: usize) usize { + return syscall3(.write, @as(u32, @bitCast(fd)), @intFromPtr(buf), count); } -pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize { - return syscall3(.writev, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(iov), count); +pub fn pwrite(fd: fd_t, buf: [*]const u8, count: usize, offset: off_t) usize { + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { + const offset_halves = splitValue64(offset); + if (require_aligned_register_pair) { + return syscall6( + .pwrite64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + 0, + offset_halves[0], + offset_halves[1], + ); + } else { + return syscall5( + .pwrite64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + offset_halves[0], + offset_halves[1], + ); + } + } else { + return syscall4( + .pwrite64, + @as(u32, @bitCast(fd)), + @intFromPtr(buf), + count, + @as(u64, @bitCast(offset)), + ); + } } -pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: i64) usize { +pub fn writev(fd: fd_t, iov: [*]const iovec_const, count: usize) usize { + return syscall3(.writev, @as(u32, @bitCast(fd)), @intFromPtr(iov), count); +} + +pub fn pwritev(fd: fd_t, iov: [*]const iovec_const, count: usize, offset: off_t) usize { const offset_u: u64 = @bitCast(offset); return syscall5( .pwritev, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(iov), count, // See comments in preadv - @as(usize, @truncate(offset_u)), - if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0, + @truncate(offset_u), + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0, ); } -pub fn pwritev2(fd: i32, iov: [*]const iovec_const, count: usize, offset: i64, flags: kernel_rwf) usize { +pub fn pwritev2(fd: fd_t, iov: [*]const iovec_const, count: usize, offset: off_t, flags: kernel_rwf) usize { const offset_u: u64 = @bitCast(offset); return syscall6( .pwritev2, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(iov), count, // See comments in preadv - @as(usize, @truncate(offset_u)), - if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0, + @truncate(offset_u), + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0, flags, ); } @@ -1350,7 +1437,7 @@ pub fn rmdir(path: [*:0]const u8) usize { if (@hasField(SYS, "rmdir")) { return syscall1(.rmdir, @intFromPtr(path)); } else { - return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), AT.REMOVEDIR); + return syscall3(.unlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), AT.REMOVEDIR); } } @@ -1358,54 +1445,15 @@ pub fn symlink(existing: [*:0]const u8, new: [*:0]const u8) usize { if (@hasField(SYS, "symlink")) { return syscall2(.symlink, @intFromPtr(existing), @intFromPtr(new)); } else { - return syscall3(.symlinkat, @intFromPtr(existing), @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(new)); + return syscall3(.symlinkat, @intFromPtr(existing), @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(new)); } } -pub fn symlinkat(existing: [*:0]const u8, newfd: i32, newpath: [*:0]const u8) usize { - return syscall3(.symlinkat, @intFromPtr(existing), @as(usize, @bitCast(@as(isize, newfd))), @intFromPtr(newpath)); +pub fn symlinkat(existing: [*:0]const u8, newfd: fd_t, newpath: [*:0]const u8) usize { + return syscall3(.symlinkat, @intFromPtr(existing), @as(u32, @bitCast(newfd)), @intFromPtr(newpath)); } -pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: i64) usize { - if (@hasField(SYS, "pread64") and usize_bits < 64) { - const offset_halves = splitValue64(offset); - if (require_aligned_register_pair) { - return syscall6( - .pread64, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - 0, - offset_halves[0], - offset_halves[1], - ); - } else { - return syscall5( - .pread64, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - offset_halves[0], - offset_halves[1], - ); - } - } else { - // Some architectures (eg. 64bit SPARC) pread is called pread64. - const syscall_number = if (!@hasField(SYS, "pread") and @hasField(SYS, "pread64")) - .pread64 - else - .pread; - return syscall4( - syscall_number, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - @as(u64, @bitCast(offset)), - ); - } -} - -pub fn access(path: [*:0]const u8, mode: u32) usize { +pub fn access(path: [*:0]const u8, mode: mode_t) usize { if (@hasField(SYS, "access")) { return syscall2(.access, @intFromPtr(path), mode); } else { @@ -1413,19 +1461,19 @@ pub fn access(path: [*:0]const u8, mode: u32) usize { } } -pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize { +pub fn faccessat(dirfd: fd_t, path: [*:0]const u8, mode: mode_t, flags: u32) usize { if (flags == 0) { - return syscall3(.faccessat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode); + return syscall3(.faccessat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode); } - return syscall4(.faccessat2, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, flags); + return syscall4(.faccessat2, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode, flags); } pub fn acct(path: [*:0]const u8) usize { return syscall1(.acct, @intFromPtr(path)); } -pub fn pipe(fd: *[2]i32) usize { - if (comptime (native_arch.isMIPS() or native_arch.isSPARC())) { +pub fn pipe(fd: *[2]fd_t) usize { + if (native_arch.isMIPS() or native_arch.isSPARC()) { return syscall_pipe(fd); } else if (@hasField(SYS, "pipe")) { return syscall1(.pipe, @intFromPtr(fd)); @@ -1434,21 +1482,17 @@ pub fn pipe(fd: *[2]i32) usize { } } -pub fn pipe2(fd: *[2]i32, flags: O) usize { +pub fn pipe2(fd: *[2]fd_t, flags: O) usize { return syscall2(.pipe2, @intFromPtr(fd), @as(u32, @bitCast(flags))); } -pub fn write(fd: i32, buf: [*]const u8, count: usize) usize { - return syscall3(.write, @bitCast(@as(isize, fd)), @intFromPtr(buf), count); -} - -pub fn ftruncate(fd: i32, length: i64) usize { - if (@hasField(SYS, "ftruncate64") and usize_bits < 64) { +pub fn ftruncate(fd: fd_t, length: off_t) usize { + if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { const length_halves = splitValue64(length); if (require_aligned_register_pair) { return syscall4( .ftruncate64, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), 0, length_halves[0], length_halves[1], @@ -1456,7 +1500,7 @@ pub fn ftruncate(fd: i32, length: i64) usize { } else { return syscall3( .ftruncate64, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), length_halves[0], length_halves[1], ); @@ -1464,48 +1508,8 @@ pub fn ftruncate(fd: i32, length: i64) usize { } else { return syscall2( .ftruncate, - @as(usize, @bitCast(@as(isize, fd))), - @as(usize, @bitCast(length)), - ); - } -} - -pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: i64) usize { - if (@hasField(SYS, "pwrite64") and usize_bits < 64) { - const offset_halves = splitValue64(offset); - - if (require_aligned_register_pair) { - return syscall6( - .pwrite64, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - 0, - offset_halves[0], - offset_halves[1], - ); - } else { - return syscall5( - .pwrite64, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - offset_halves[0], - offset_halves[1], - ); - } - } else { - // Some architectures (eg. 64bit SPARC) pwrite is called pwrite64. - const syscall_number = if (!@hasField(SYS, "pwrite") and @hasField(SYS, "pwrite64")) - .pwrite64 - else - .pwrite; - return syscall4( - syscall_number, - @as(usize, @bitCast(@as(isize, fd))), - @intFromPtr(buf), - count, - @as(u64, @bitCast(offset)), + @as(u32, @bitCast(fd)), + @as(u64, @bitCast(length)), ); } } @@ -1516,50 +1520,50 @@ pub fn rename(old: [*:0]const u8, new: [*:0]const u8) usize { } else if (@hasField(SYS, "renameat")) { return syscall4( .renameat, - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(old), - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(new), ); } else { return syscall5( .renameat2, - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(old), - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(new), 0, ); } } -pub fn renameat(oldfd: i32, oldpath: [*:0]const u8, newfd: i32, newpath: [*:0]const u8) usize { +pub fn renameat(oldfd: fd_t, oldpath: [*:0]const u8, newfd: fd_t, newpath: [*:0]const u8) usize { if (@hasField(SYS, "renameat")) { return syscall4( .renameat, - @as(usize, @bitCast(@as(isize, oldfd))), + @as(u32, @bitCast(oldfd)), @intFromPtr(oldpath), - @as(usize, @bitCast(@as(isize, newfd))), + @as(u32, @bitCast(newfd)), @intFromPtr(newpath), ); } else { return syscall5( .renameat2, - @as(usize, @bitCast(@as(isize, oldfd))), + @as(u32, @bitCast(oldfd)), @intFromPtr(oldpath), - @as(usize, @bitCast(@as(isize, newfd))), + @as(u32, @bitCast(newfd)), @intFromPtr(newpath), 0, ); } } -pub fn renameat2(oldfd: i32, oldpath: [*:0]const u8, newfd: i32, newpath: [*:0]const u8, flags: RENAME) usize { +pub fn renameat2(oldfd: fd_t, oldpath: [*:0]const u8, newfd: fd_t, newpath: [*:0]const u8, flags: RENAME) usize { return syscall5( .renameat2, - @as(usize, @bitCast(@as(isize, oldfd))), + @as(u32, @bitCast(oldfd)), @intFromPtr(oldpath), - @as(usize, @bitCast(@as(isize, newfd))), + @as(u32, @bitCast(newfd)), @intFromPtr(newpath), @as(u32, @bitCast(flags)), ); @@ -1571,7 +1575,7 @@ pub fn open(path: [*:0]const u8, flags: O, perm: mode_t) usize { } else { return syscall4( .openat, - @bitCast(@as(isize, AT.FDCWD)), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), @as(u32, @bitCast(flags)), perm, @@ -1583,13 +1587,13 @@ pub fn create(path: [*:0]const u8, perm: mode_t) usize { return syscall2(.creat, @intFromPtr(path), perm); } -pub fn openat(dirfd: i32, path: [*:0]const u8, flags: O, mode: mode_t) usize { +pub fn openat(dirfd: fd_t, path: [*:0]const u8, flags: O, mode: mode_t) usize { // dirfd could be negative, for example AT.FDCWD is -100 - return syscall4(.openat, @bitCast(@as(isize, dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)), mode); + return syscall4(.openat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)), mode); } /// See also `clone` (from the arch-specific include) -pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: *i32, child_tid: *i32, newtls: usize) usize { +pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: *pid_t, child_tid: *pid_t, newtls: usize) usize { return syscall5(.clone, flags, child_stack_ptr, @intFromPtr(parent_tid), @intFromPtr(child_tid), newtls); } @@ -1604,7 +1608,7 @@ pub fn set_tid_address(tidptr: ?*pid_t) pid_t { } pub fn close(fd: fd_t) usize { - return syscall1(.close, @as(usize, @bitCast(@as(isize, fd)))); + return syscall1(.close, @as(u32, @bitCast(fd))); } pub const CLOSE_RANGE = packed struct(u32) { @@ -1616,11 +1620,11 @@ pub const CLOSE_RANGE = packed struct(u32) { }; pub fn close_range(first: fd_t, last: fd_t, flags: CLOSE_RANGE) usize { - return syscall3(.close_range, fd_to_usize(first), fd_to_usize(last), @as(u32, @bitCast(flags))); + return syscall3(.close_range, @as(u32, @bitCast(first)), @as(u32, @bitCast(last)), @as(u32, @bitCast(flags))); } -pub fn fchmod(fd: i32, mode: mode_t) usize { - return syscall2(.fchmod, @as(usize, @bitCast(@as(isize, fd))), mode); +pub fn fchmod(fd: fd_t, mode: mode_t) usize { + return syscall2(.fchmod, @as(u32, @bitCast(fd)), mode); } pub fn chmod(path: [*:0]const u8, mode: mode_t) usize { @@ -1631,16 +1635,16 @@ pub fn chmod(path: [*:0]const u8, mode: mode_t) usize { } } -pub fn fchown(fd: i32, owner: uid_t, group: gid_t) usize { +pub fn fchown(fd: fd_t, owner: uid_t, group: gid_t) usize { if (@hasField(SYS, "fchown32")) { - return syscall3(.fchown32, @as(usize, @bitCast(@as(isize, fd))), owner, group); + return syscall3(.fchown32, @as(u32, @bitCast(fd)), owner, group); } else { - return syscall3(.fchown, @as(usize, @bitCast(@as(isize, fd))), owner, group); + return syscall3(.fchown, @as(u32, @bitCast(fd)), owner, group); } } -pub fn fchownat(fd: i32, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: u32) usize { - return syscall5(.fchownat, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(path), owner, group, flags); +pub fn fchownat(fd: fd_t, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: u32) usize { + return syscall5(.fchownat, @as(u32, @bitCast(fd)), @intFromPtr(path), owner, group, flags); } pub fn chown(path: [*:0]const u8, owner: uid_t, group: gid_t) usize { @@ -1663,40 +1667,40 @@ pub fn lchown(path: [*:0]const u8, owner: uid_t, group: gid_t) usize { } } -pub fn fchmodat(fd: i32, path: [*:0]const u8, mode: mode_t) usize { - return syscall3(.fchmodat, @bitCast(@as(isize, fd)), @intFromPtr(path), mode); +pub fn fchmodat(fd: fd_t, path: [*:0]const u8, mode: mode_t) usize { + return syscall3(.fchmodat, @as(u32, @bitCast(fd)), @intFromPtr(path), mode); } -pub fn fchmodat2(fd: i32, path: [*:0]const u8, mode: mode_t, flags: u32) usize { - return syscall4(.fchmodat2, @bitCast(@as(isize, fd)), @intFromPtr(path), mode, flags); +pub fn fchmodat2(fd: fd_t, path: [*:0]const u8, mode: mode_t, flags: u32) usize { + return syscall4(.fchmodat2, @as(u32, @bitCast(fd)), @intFromPtr(path), mode, flags); } /// Can only be called on 32 bit systems. For 64 bit see `lseek`. -pub fn llseek(fd: i32, offset: u64, result: ?*u64, whence: usize) usize { +pub fn llseek(fd: fd_t, offset: off_t, result: ?*off_t, whence: u32) usize { // NOTE: The offset parameter splitting is independent from the target // endianness. return syscall5( .llseek, - @as(usize, @bitCast(@as(isize, fd))), - @as(usize, @truncate(offset >> 32)), - @as(usize, @truncate(offset)), + @as(u32, @bitCast(fd)), + @truncate(@as(u64, @bitCast(offset >> 32))), + @truncate(@as(u64, @bitCast(offset))), @intFromPtr(result), whence, ); } /// Can only be called on 64 bit systems. For 32 bit see `llseek`. -pub fn lseek(fd: i32, offset: i64, whence: usize) usize { - return syscall3(.lseek, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(offset)), whence); +pub fn lseek(fd: fd_t, offset: off_t, whence: u32) usize { + return syscall3(.lseek, @as(u32, @bitCast(fd)), @as(u64, @bitCast(offset)), whence); } pub fn exit(status: i32) noreturn { - _ = syscall1(.exit, @as(usize, @bitCast(@as(isize, status)))); + _ = syscall1(.exit, @as(u32, @bitCast(status))); unreachable; } pub fn exit_group(status: i32) noreturn { - _ = syscall1(.exit_group, @as(usize, @bitCast(@as(isize, status)))); + _ = syscall1(.exit_group, @as(u32, @bitCast(status))); unreachable; } @@ -1762,15 +1766,15 @@ pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize { } pub fn kill(pid: pid_t, sig: SIG) usize { - return syscall2(.kill, @as(usize, @bitCast(@as(isize, pid))), @intFromEnum(sig)); + return syscall2(.kill, @as(u32, @bitCast(pid)), @intFromEnum(sig)); } pub fn tkill(tid: pid_t, sig: SIG) usize { - return syscall2(.tkill, @as(usize, @bitCast(@as(isize, tid))), @intFromEnum(sig)); + return syscall2(.tkill, @as(u32, @bitCast(tid)), @intFromEnum(sig)); } pub fn tgkill(tgid: pid_t, tid: pid_t, sig: SIG) usize { - return syscall3(.tgkill, @as(usize, @bitCast(@as(isize, tgid))), @as(usize, @bitCast(@as(isize, tid))), @intFromEnum(sig)); + return syscall3(.tgkill, @as(u32, @bitCast(tgid)), @as(u32, @bitCast(tid)), @intFromEnum(sig)); } pub fn link(oldpath: [*:0]const u8, newpath: [*:0]const u8) usize { @@ -1783,9 +1787,9 @@ pub fn link(oldpath: [*:0]const u8, newpath: [*:0]const u8) usize { } else { return syscall5( .linkat, - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(oldpath), - @as(usize, @bitCast(@as(isize, AT.FDCWD))), + @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(newpath), 0, ); @@ -1795,9 +1799,9 @@ pub fn link(oldpath: [*:0]const u8, newpath: [*:0]const u8) usize { pub fn linkat(oldfd: fd_t, oldpath: [*:0]const u8, newfd: fd_t, newpath: [*:0]const u8, flags: u32) usize { return syscall5( .linkat, - @as(usize, @bitCast(@as(isize, oldfd))), + @as(u32, @bitCast(oldfd)), @intFromPtr(oldpath), - @as(usize, @bitCast(@as(isize, newfd))), + @as(u32, @bitCast(newfd)), @intFromPtr(newpath), flags, ); @@ -1807,33 +1811,33 @@ pub fn unlink(path: [*:0]const u8) usize { if (@hasField(SYS, "unlink")) { return syscall1(.unlink, @intFromPtr(path)); } else { - return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), 0); + return syscall3(.unlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), 0); } } -pub fn unlinkat(dirfd: i32, path: [*:0]const u8, flags: u32) usize { - return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), flags); +pub fn unlinkat(dirfd: fd_t, path: [*:0]const u8, flags: u32) usize { + return syscall3(.unlinkat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), flags); } -pub fn waitpid(pid: pid_t, status: *u32, flags: u32) usize { - return syscall4(.wait4, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(status), flags, 0); +pub fn waitpid(pid: pid_t, status: *i32, flags: u32) usize { + return syscall4(.wait4, @as(u32, @bitCast(pid)), @intFromPtr(status), flags, 0); } -pub fn wait4(pid: pid_t, status: *u32, flags: u32, usage: ?*rusage) usize { +pub fn wait4(pid: pid_t, status: *i32, flags: u32, usage: ?*rusage) usize { return syscall4( .wait4, - @as(usize, @bitCast(@as(isize, pid))), + @as(u32, @bitCast(pid)), @intFromPtr(status), flags, @intFromPtr(usage), ); } -pub fn waitid(id_type: P, id: i32, infop: *siginfo_t, flags: u32, usage: ?*rusage) usize { +pub fn waitid(id_type: P, id: pid_t, infop: *siginfo_t, flags: u32, usage: ?*rusage) usize { return syscall5( .waitid, @intFromEnum(id_type), - @as(usize, @bitCast(@as(isize, id))), + @as(u32, @bitCast(id)), @intFromPtr(infop), flags, @intFromPtr(usage), @@ -1932,14 +1936,14 @@ pub const Flock = extern struct { pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) usize { if (@hasField(SYS, "fcntl64")) { - return syscall3(.fcntl64, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg); + return syscall3(.fcntl64, @as(u32, @bitCast(fd)), @as(u32, @bitCast(cmd)), arg); } else { - return syscall3(.fcntl, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg); + return syscall3(.fcntl, @as(u32, @bitCast(fd)), @as(u32, @bitCast(cmd)), arg); } } pub fn flock(fd: fd_t, operation: i32) usize { - return syscall2(.flock, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, operation)))); + return syscall2(.flock, @as(u32, @bitCast(fd)), @as(u32, @bitCast(operation))); } pub const Elf_Symndx = if (native_arch == .s390x) u64 else u32; @@ -1979,7 +1983,7 @@ fn init_vdso_clock_gettime(clk: clockid_t, ts: *timespec) callconv(.c) usize { pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize { return syscall2( if (@hasField(SYS, "clock_getres") and native_arch != .hexagon) .clock_getres else .clock_getres_time64, - @as(usize, @intFromEnum(clk_id)), + @intFromEnum(clk_id), @intFromPtr(tp), ); } @@ -1987,7 +1991,7 @@ pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize { pub fn clock_settime(clk_id: clockid_t, tp: *const timespec) usize { return syscall2( if (@hasField(SYS, "clock_settime") and native_arch != .hexagon) .clock_settime else .clock_settime64, - @as(usize, @intFromEnum(clk_id)), + @intFromEnum(clk_id), @intFromPtr(tp), ); } @@ -2141,11 +2145,11 @@ pub fn setresgid(rgid: gid_t, egid: gid_t, sgid: gid_t) usize { } pub fn setpgid(pid: pid_t, pgid: pid_t) usize { - return syscall2(.setpgid, @intCast(pid), @intCast(pgid)); + return syscall2(.setpgid, @as(u32, @bitCast(pid)), @as(u32, @bitCast(pgid))); } pub fn getpgid(pid: pid_t) usize { - return syscall1(.getpgid, @intCast(pid)); + return syscall1(.getpgid, @as(u32, @bitCast(pid))); } pub fn getgroups(size: usize, list: ?[*]gid_t) usize { @@ -2169,7 +2173,7 @@ pub fn setsid() usize { } pub fn getsid(pid: pid_t) usize { - return syscall1(.getsid, @intCast(pid)); + return syscall1(.getsid, @as(u32, @bitCast(pid))); } pub fn getpid() pid_t { @@ -2240,8 +2244,6 @@ pub fn sigaction(sig: SIG, noalias act: ?*const Sigaction, noalias oact: ?*Sigac return 0; } -const usize_bits = @typeInfo(usize).int.bits; - /// Defined as one greater than the largest defined signal number. pub const NSIG = if (is_mips) 128 else 65; @@ -2302,18 +2304,18 @@ pub fn sigismember(set: *const sigset_t, sig: SIG) bool { return ((set.*)[index.word] & index.mask) != 0; } -pub fn getsockname(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize { +pub fn getsockname(fd: fd_t, noalias addr: *sockaddr, noalias len: *socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.getsockname, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len) }); + return socketcall(SC.getsockname, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len) }); } - return syscall3(.getsockname, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len)); + return syscall3(.getsockname, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len)); } -pub fn getpeername(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize { +pub fn getpeername(fd: fd_t, noalias addr: *sockaddr, noalias len: *socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.getpeername, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len) }); + return socketcall(SC.getpeername, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len) }); } - return syscall3(.getpeername, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len)); + return syscall3(.getpeername, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len)); } pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize { @@ -2323,58 +2325,52 @@ pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize { return syscall3(.socket, domain, socket_type, protocol); } -pub fn setsockopt(fd: i32, level: i32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize { +pub fn setsockopt(fd: fd_t, level: i32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.setsockopt, &[5]usize{ @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen)) }); + return socketcall(SC.setsockopt, &[5]usize{ @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen)) }); } - return syscall5(.setsockopt, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen))); + return syscall5(.setsockopt, @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen))); } -pub fn getsockopt(fd: i32, level: i32, optname: u32, noalias optval: [*]u8, noalias optlen: *socklen_t) usize { +pub fn getsockopt(fd: fd_t, level: i32, optname: u32, noalias optval: [*]u8, noalias optlen: *socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.getsockopt, &[5]usize{ @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen) }); + return socketcall(SC.getsockopt, &[5]usize{ @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen) }); } - return syscall5(.getsockopt, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen)); + return syscall5(.getsockopt, @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen)); } -pub fn sendmsg(fd: i32, msg: *const msghdr_const, flags: u32) usize { - const fd_usize = @as(usize, @bitCast(@as(isize, fd))); - const msg_usize = @intFromPtr(msg); +pub fn sendmsg(fd: fd_t, msg: *const msghdr_const, flags: u32) usize { if (native_arch == .x86) { - return socketcall(SC.sendmsg, &[3]usize{ fd_usize, msg_usize, flags }); + return socketcall(SC.sendmsg, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(msg), flags }); } else { - return syscall3(.sendmsg, fd_usize, msg_usize, flags); + return syscall3(.sendmsg, @as(u32, @bitCast(fd)), @intFromPtr(msg), flags); } } -pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr, vlen: u32, flags: u32) usize { - return syscall4(.sendmmsg, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(msgvec), vlen, flags); +pub fn sendmmsg(fd: fd_t, msgvec: [*]mmsghdr, vlen: u32, flags: u32) usize { + return syscall4(.sendmmsg, @as(u32, @bitCast(fd)), @intFromPtr(msgvec), vlen, flags); } -pub fn connect(fd: i32, addr: *const anyopaque, len: socklen_t) usize { - const fd_usize = @as(usize, @bitCast(@as(isize, fd))); - const addr_usize = @intFromPtr(addr); +pub fn connect(fd: fd_t, addr: *const anyopaque, len: socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.connect, &[3]usize{ fd_usize, addr_usize, len }); + return socketcall(SC.connect, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), len }); } else { - return syscall3(.connect, fd_usize, addr_usize, len); + return syscall3(.connect, @as(u32, @bitCast(fd)), @intFromPtr(addr), len); } } -pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize { - const fd_usize = @as(usize, @bitCast(@as(isize, fd))); - const msg_usize = @intFromPtr(msg); +pub fn recvmsg(fd: fd_t, msg: *msghdr, flags: u32) usize { if (native_arch == .x86) { - return socketcall(SC.recvmsg, &[3]usize{ fd_usize, msg_usize, flags }); + return socketcall(SC.recvmsg, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(msg), flags }); } else { - return syscall3(.recvmsg, fd_usize, msg_usize, flags); + return syscall3(.recvmsg, @as(u32, @bitCast(fd)), @intFromPtr(msg), flags); } } -pub fn recvmmsg(fd: i32, msgvec: ?[*]mmsghdr, vlen: u32, flags: u32, timeout: ?*timespec) usize { +pub fn recvmmsg(fd: fd_t, msgvec: ?[*]mmsghdr, vlen: u32, flags: u32, timeout: ?*timespec) usize { return syscall5( if (@hasField(SYS, "recvmmsg") and native_arch != .hexagon) .recvmmsg else .recvmmsg_time64, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(msgvec), vlen, flags, @@ -2383,43 +2379,39 @@ pub fn recvmmsg(fd: i32, msgvec: ?[*]mmsghdr, vlen: u32, flags: u32, timeout: ?* } pub fn recvfrom( - fd: i32, + fd: fd_t, noalias buf: [*]u8, len: usize, flags: u32, noalias addr: ?*sockaddr, noalias alen: ?*socklen_t, ) usize { - const fd_usize = @as(usize, @bitCast(@as(isize, fd))); - const buf_usize = @intFromPtr(buf); - const addr_usize = @intFromPtr(addr); - const alen_usize = @intFromPtr(alen); if (native_arch == .x86) { - return socketcall(SC.recvfrom, &[6]usize{ fd_usize, buf_usize, len, flags, addr_usize, alen_usize }); + return socketcall(SC.recvfrom, &[6]usize{ @as(u32, @bitCast(fd)), @intFromPtr(buf), len, flags, @intFromPtr(addr), @intFromPtr(alen) }); } else { - return syscall6(.recvfrom, fd_usize, buf_usize, len, flags, addr_usize, alen_usize); + return syscall6(.recvfrom, @as(u32, @bitCast(fd)), @intFromPtr(buf), len, flags, @intFromPtr(addr), @intFromPtr(alen)); } } -pub fn shutdown(fd: i32, how: i32) usize { +pub fn shutdown(fd: fd_t, how: i32) usize { if (native_arch == .x86) { - return socketcall(SC.shutdown, &[2]usize{ @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, how))) }); + return socketcall(SC.shutdown, &[2]usize{ @as(u32, @bitCast(fd)), @as(u32, @bitCast(how)) }); } - return syscall2(.shutdown, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, how)))); + return syscall2(.shutdown, @as(u32, @bitCast(fd)), @as(u32, @bitCast(how))); } -pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize { +pub fn bind(fd: fd_t, addr: *const sockaddr, len: socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.bind, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @as(usize, @intCast(len)) }); + return socketcall(SC.bind, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), len }); } - return syscall3(.bind, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @as(usize, @intCast(len))); + return syscall3(.bind, @as(u32, @bitCast(fd)), @intFromPtr(addr), len); } -pub fn listen(fd: i32, backlog: u32) usize { +pub fn listen(fd: fd_t, backlog: u32) usize { if (native_arch == .x86) { - return socketcall(SC.listen, &[2]usize{ @as(usize, @bitCast(@as(isize, fd))), backlog }); + return socketcall(SC.listen, &[2]usize{ @as(u32, @bitCast(fd)), backlog }); } - return syscall2(.listen, @as(usize, @bitCast(@as(isize, fd))), backlog); + return syscall2(.listen, @as(u32, @bitCast(fd)), backlog); } pub fn sendto(fd: i32, buf: [*]const u8, len: usize, flags: u32, addr: ?*const sockaddr, alen: socklen_t) usize { @@ -2429,51 +2421,41 @@ pub fn sendto(fd: i32, buf: [*]const u8, len: usize, flags: u32, addr: ?*const s return syscall6(.sendto, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(buf), len, flags, @intFromPtr(addr), @as(usize, @intCast(alen))); } -pub fn sendfile(outfd: i32, infd: i32, offset: ?*i64, count: usize) usize { - if (@hasField(SYS, "sendfile64")) { - return syscall4( - .sendfile64, - @as(usize, @bitCast(@as(isize, outfd))), - @as(usize, @bitCast(@as(isize, infd))), - @intFromPtr(offset), - count, - ); - } else { - return syscall4( - .sendfile, - @as(usize, @bitCast(@as(isize, outfd))), - @as(usize, @bitCast(@as(isize, infd))), - @intFromPtr(offset), - count, - ); - } +pub fn sendfile(outfd: fd_t, infd: fd_t, offset: ?*off_t, count: usize) usize { + return syscall4( + if (@hasField(SYS, "sendfile64")) .sendfile64 else .sendfile, + @as(u32, @bitCast(outfd)), + @as(u32, @bitCast(infd)), + @intFromPtr(offset), + count, + ); } -pub fn socketpair(domain: u32, socket_type: u32, protocol: u32, fd: *[2]i32) usize { +pub fn socketpair(domain: u32, socket_type: u32, protocol: u32, fd: *[2]fd_t) usize { if (native_arch == .x86) { return socketcall(SC.socketpair, &[4]usize{ domain, socket_type, protocol, @intFromPtr(fd) }); } return syscall4(.socketpair, domain, socket_type, protocol, @intFromPtr(fd)); } -pub fn accept(fd: i32, noalias addr: ?*sockaddr, noalias len: ?*socklen_t) usize { +pub fn accept(fd: fd_t, noalias addr: ?*sockaddr, noalias len: ?*socklen_t) usize { if (native_arch == .x86) { - return socketcall(SC.accept, &[4]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), 0 }); + return socketcall(SC.accept, &[4]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), 0 }); } return accept4(fd, addr, len, 0); } -pub fn accept4(fd: i32, noalias addr: ?*sockaddr, noalias len: ?*socklen_t, flags: u32) usize { +pub fn accept4(fd: fd_t, noalias addr: ?*sockaddr, noalias len: ?*socklen_t, flags: u32) usize { if (native_arch == .x86) { - return socketcall(SC.accept4, &[4]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), flags }); + return socketcall(SC.accept4, &[4]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), flags }); } - return syscall4(.accept4, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), flags); + return syscall4(.accept4, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), flags); } -pub fn statx(dirfd: i32, path: [*:0]const u8, flags: u32, mask: STATX, statx_buf: *Statx) usize { +pub fn statx(dirfd: fd_t, path: [*:0]const u8, flags: u32, mask: STATX, statx_buf: *Statx) usize { return syscall5( .statx, - @as(usize, @bitCast(@as(isize, dirfd))), + @as(u32, @bitCast(dirfd)), @intFromPtr(path), flags, @as(u32, @bitCast(mask)), @@ -2490,7 +2472,7 @@ pub fn llistxattr(path: [*:0]const u8, list: [*]u8, size: usize) usize { } pub fn flistxattr(fd: fd_t, list: [*]u8, size: usize) usize { - return syscall3(.flistxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(list), size); + return syscall3(.flistxattr, @as(u32, @bitCast(fd)), @intFromPtr(list), size); } pub fn getxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]u8, size: usize) usize { @@ -2502,7 +2484,7 @@ pub fn lgetxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]u8, size: u } pub fn fgetxattr(fd: fd_t, name: [*:0]const u8, value: [*]u8, size: usize) usize { - return syscall4(.fgetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size); + return syscall4(.fgetxattr, @as(u32, @bitCast(fd)), @intFromPtr(name), @intFromPtr(value), size); } pub fn setxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]const u8, size: usize, flags: usize) usize { @@ -2514,7 +2496,7 @@ pub fn lsetxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]const u8, s } pub fn fsetxattr(fd: fd_t, name: [*:0]const u8, value: [*]const u8, size: usize, flags: usize) usize { - return syscall5(.fsetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size, flags); + return syscall5(.fsetxattr, @as(u32, @bitCast(fd)), @intFromPtr(name), @intFromPtr(value), size, flags); } pub fn removexattr(path: [*:0]const u8, name: [*:0]const u8) usize { @@ -2525,8 +2507,8 @@ pub fn lremovexattr(path: [*:0]const u8, name: [*:0]const u8) usize { return syscall2(.lremovexattr, @intFromPtr(path), @intFromPtr(name)); } -pub fn fremovexattr(fd: usize, name: [*:0]const u8) usize { - return syscall2(.fremovexattr, fd, @intFromPtr(name)); +pub fn fremovexattr(fd: fd_t, name: [*:0]const u8) usize { + return syscall2(.fremovexattr, @as(u32, @bitCast(fd)), @intFromPtr(name)); } pub const sched_param = extern struct { @@ -2556,27 +2538,27 @@ pub const SCHED = packed struct(i32) { }; pub fn sched_setparam(pid: pid_t, param: *const sched_param) usize { - return syscall2(.sched_setparam, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(param)); + return syscall2(.sched_setparam, @as(u32, @bitCast(pid)), @intFromPtr(param)); } pub fn sched_getparam(pid: pid_t, param: *sched_param) usize { - return syscall2(.sched_getparam, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(param)); + return syscall2(.sched_getparam, @as(u32, @bitCast(pid)), @intFromPtr(param)); } pub fn sched_setscheduler(pid: pid_t, policy: SCHED, param: *const sched_param) usize { - return syscall3(.sched_setscheduler, @as(usize, @bitCast(@as(isize, pid))), @intCast(@as(u32, @bitCast(policy))), @intFromPtr(param)); + return syscall3(.sched_setscheduler, @as(u32, @bitCast(pid)), @as(u32, @bitCast(policy)), @intFromPtr(param)); } pub fn sched_getscheduler(pid: pid_t) usize { - return syscall1(.sched_getscheduler, @as(usize, @bitCast(@as(isize, pid)))); + return syscall1(.sched_getscheduler, @as(u32, @bitCast(pid))); } pub fn sched_get_priority_max(policy: SCHED) usize { - return syscall1(.sched_get_priority_max, @intCast(@as(u32, @bitCast(policy)))); + return syscall1(.sched_get_priority_max, @as(u32, @bitCast(policy))); } pub fn sched_get_priority_min(policy: SCHED) usize { - return syscall1(.sched_get_priority_min, @intCast(@as(u32, @bitCast(policy)))); + return syscall1(.sched_get_priority_min, @as(u32, @bitCast(policy))); } pub fn getcpu(cpu: ?*usize, node: ?*usize) usize { @@ -2595,24 +2577,24 @@ pub const sched_attr = extern struct { period: u64 = 0, }; -pub fn sched_setattr(pid: pid_t, attr: *const sched_attr, flags: usize) usize { - return syscall3(.sched_setattr, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(attr), flags); +pub fn sched_setattr(pid: pid_t, attr: *const sched_attr, flags: u32) usize { + return syscall3(.sched_setattr, @as(u32, @bitCast(pid)), @intFromPtr(attr), flags); } -pub fn sched_getattr(pid: pid_t, attr: *sched_attr, size: usize, flags: usize) usize { - return syscall4(.sched_getattr, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(attr), size, flags); +pub fn sched_getattr(pid: pid_t, attr: *sched_attr, size: u32, flags: u32) usize { + return syscall4(.sched_getattr, @as(u32, @bitCast(pid)), @intFromPtr(attr), size, flags); } pub fn sched_rr_get_interval(pid: pid_t, tp: *timespec) usize { - return syscall2(.sched_rr_get_interval, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(tp)); + return syscall2(.sched_rr_get_interval, @as(u32, @bitCast(pid)), @intFromPtr(tp)); } pub fn sched_yield() usize { return syscall0(.sched_yield); } -pub fn sched_getaffinity(pid: pid_t, size: usize, set: *cpu_set_t) usize { - const rc = syscall3(.sched_getaffinity, @as(usize, @bitCast(@as(isize, pid))), size, @intFromPtr(set)); +pub fn sched_getaffinity(pid: pid_t, size: u32, set: *cpu_set_t) usize { + const rc = syscall3(.sched_getaffinity, @as(u32, @bitCast(pid)), size, @intFromPtr(set)); if (@as(isize, @bitCast(rc)) < 0) return rc; if (rc < size) @memset(@as([*]u8, @ptrCast(set))[rc..size], 0); return 0; @@ -2620,7 +2602,7 @@ pub fn sched_getaffinity(pid: pid_t, size: usize, set: *cpu_set_t) usize { pub fn sched_setaffinity(pid: pid_t, set: *const cpu_set_t) !void { const size = @sizeOf(cpu_set_t); - const rc = syscall3(.sched_setaffinity, @as(usize, @bitCast(@as(isize, pid))), size, @intFromPtr(set)); + const rc = syscall3(.sched_setaffinity, @as(u32, @bitCast(pid)), size, @intFromPtr(set)); switch (errno(rc)) { .SUCCESS => return, @@ -2632,25 +2614,25 @@ pub fn epoll_create() usize { return epoll_create1(0); } -pub fn epoll_create1(flags: usize) usize { +pub fn epoll_create1(flags: u32) usize { return syscall1(.epoll_create1, flags); } -pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: ?*epoll_event) usize { - return syscall4(.epoll_ctl, @as(usize, @bitCast(@as(isize, epoll_fd))), @as(usize, @intCast(op)), @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(ev)); +pub fn epoll_ctl(epoll_fd: fd_t, op: u32, fd: fd_t, ev: ?*epoll_event) usize { + return syscall4(.epoll_ctl, @as(u32, @bitCast(epoll_fd)), op, @as(u32, @bitCast(fd)), @intFromPtr(ev)); } -pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32) usize { +pub fn epoll_wait(epoll_fd: fd_t, events: [*]epoll_event, maxevents: u32, timeout: i32) usize { return epoll_pwait(epoll_fd, events, maxevents, timeout, null); } -pub fn epoll_pwait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32, sigmask: ?*const sigset_t) usize { +pub fn epoll_pwait(epoll_fd: fd_t, events: [*]epoll_event, maxevents: u32, timeout: i32, sigmask: ?*const sigset_t) usize { return syscall6( .epoll_pwait, - @as(usize, @bitCast(@as(isize, epoll_fd))), + @as(u32, @bitCast(epoll_fd)), @intFromPtr(events), - @as(usize, @intCast(maxevents)), - @as(usize, @bitCast(@as(isize, timeout))), + maxevents, + @as(u32, @bitCast(timeout)), @intFromPtr(sigmask), NSIG / 8, ); @@ -2673,18 +2655,18 @@ pub const itimerspec = extern struct { it_value: timespec, }; -pub fn timerfd_gettime(fd: i32, curr_value: *itimerspec) usize { +pub fn timerfd_gettime(fd: fd_t, curr_value: *itimerspec) usize { return syscall2( if (@hasField(SYS, "timerfd_gettime") and native_arch != .hexagon) .timerfd_gettime else .timerfd_gettime64, - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @intFromPtr(curr_value), ); } -pub fn timerfd_settime(fd: i32, flags: TFD.TIMER, new_value: *const itimerspec, old_value: ?*itimerspec) usize { +pub fn timerfd_settime(fd: fd_t, flags: TFD.TIMER, new_value: *const itimerspec, old_value: ?*itimerspec) usize { return syscall4( if (@hasField(SYS, "timerfd_settime") and native_arch != .hexagon) .timerfd_settime else .timerfd_settime64, - @bitCast(@as(isize, fd)), + @as(u32, @bitCast(fd)), @as(u32, @bitCast(flags)), @intFromPtr(new_value), @intFromPtr(old_value), @@ -2699,11 +2681,11 @@ pub const ITIMER = enum(i32) { }; pub fn getitimer(which: i32, curr_value: *itimerspec) usize { - return syscall2(.getitimer, @as(usize, @bitCast(@as(isize, which))), @intFromPtr(curr_value)); + return syscall2(.getitimer, @as(u32, @bitCast(which)), @intFromPtr(curr_value)); } pub fn setitimer(which: i32, new_value: *const itimerspec, old_value: ?*itimerspec) usize { - return syscall3(.setitimer, @as(usize, @bitCast(@as(isize, which))), @intFromPtr(new_value), @intFromPtr(old_value)); + return syscall3(.setitimer, @as(u32, @bitCast(which)), @intFromPtr(new_value), @intFromPtr(old_value)); } pub fn unshare(flags: usize) usize { @@ -2711,7 +2693,7 @@ pub fn unshare(flags: usize) usize { } pub fn setns(fd: fd_t, flags: u32) usize { - return syscall2(.setns, @as(usize, @bitCast(@as(isize, fd))), flags); + return syscall2(.setns, @as(u32, @bitCast(fd)), flags); } pub fn capget(hdrp: *cap_user_header_t, datap: *cap_user_data_t) usize { @@ -2734,12 +2716,12 @@ pub fn io_uring_setup(entries: u32, p: *io_uring_params) usize { return syscall2(.io_uring_setup, entries, @intFromPtr(p)); } -pub fn io_uring_enter(fd: i32, to_submit: u32, min_complete: u32, flags: u32, sig: ?*sigset_t) usize { - return syscall6(.io_uring_enter, @as(usize, @bitCast(@as(isize, fd))), to_submit, min_complete, flags, @intFromPtr(sig), NSIG / 8); +pub fn io_uring_enter(fd: fd_t, to_submit: u32, min_complete: u32, flags: u32, sig: ?*sigset_t) usize { + return syscall6(.io_uring_enter, @as(u32, @bitCast(fd)), to_submit, min_complete, flags, @intFromPtr(sig), NSIG / 8); } -pub fn io_uring_register(fd: i32, opcode: IORING_REGISTER, arg: ?*const anyopaque, nr_args: u32) usize { - return syscall4(.io_uring_register, @as(usize, @bitCast(@as(isize, fd))), @intFromEnum(opcode), @intFromPtr(arg), nr_args); +pub fn io_uring_register(fd: fd_t, opcode: IORING_REGISTER, arg: ?*const anyopaque, nr_args: u32) usize { + return syscall4(.io_uring_register, @as(u32, @bitCast(fd)), @intFromEnum(opcode), @intFromPtr(arg), nr_args); } pub fn memfd_create(name: [*:0]const u8, flags: u32) usize { @@ -2747,43 +2729,43 @@ pub fn memfd_create(name: [*:0]const u8, flags: u32) usize { } pub fn getrusage(who: i32, usage: *rusage) usize { - return syscall2(.getrusage, @as(usize, @bitCast(@as(isize, who))), @intFromPtr(usage)); + return syscall2(.getrusage, @as(u32, @bitCast(who)), @intFromPtr(usage)); } pub fn tcgetattr(fd: fd_t, termios_p: *termios) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CGETS, @intFromPtr(termios_p)); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CGETS, @intFromPtr(termios_p)); } pub fn tcsetattr(fd: fd_t, optional_action: TCSA, termios_p: *const termios) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CSETS + @intFromEnum(optional_action), @intFromPtr(termios_p)); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSETS + @intFromEnum(optional_action), @intFromPtr(termios_p)); } pub fn tcgetpgrp(fd: fd_t, pgrp: *pid_t) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.IOCGPGRP, @intFromPtr(pgrp)); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.IOCGPGRP, @intFromPtr(pgrp)); } pub fn tcsetpgrp(fd: fd_t, pgrp: *const pid_t) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.IOCSPGRP, @intFromPtr(pgrp)); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.IOCSPGRP, @intFromPtr(pgrp)); } pub fn tcdrain(fd: fd_t) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CSBRK, 1); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSBRK, 1); } pub fn ioctl(fd: fd_t, request: u32, arg: usize) usize { - return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), request, arg); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), request, arg); } pub fn signalfd(fd: fd_t, mask: *const sigset_t, flags: u32) usize { - return syscall4(.signalfd4, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(mask), NSIG / 8, flags); + return syscall4(.signalfd4, @as(u32, @bitCast(fd)), @intFromPtr(mask), NSIG / 8, flags); } -pub fn copy_file_range(fd_in: fd_t, off_in: ?*i64, fd_out: fd_t, off_out: ?*i64, len: usize, flags: u32) usize { +pub fn copy_file_range(fd_in: fd_t, off_in: ?*off_t, fd_out: fd_t, off_out: ?*off_t, len: usize, flags: u32) usize { return syscall6( .copy_file_range, - @as(usize, @bitCast(@as(isize, fd_in))), + @as(u32, @bitCast(fd_in)), @intFromPtr(off_in), - @as(usize, @bitCast(@as(isize, fd_out))), + @as(u32, @bitCast(fd_out)), @intFromPtr(off_out), len, flags, @@ -2799,19 +2781,19 @@ pub fn sync() void { } pub fn syncfs(fd: fd_t) usize { - return syscall1(.syncfs, @as(usize, @bitCast(@as(isize, fd)))); + return syscall1(.syncfs, @as(u32, @bitCast(fd))); } pub fn fsync(fd: fd_t) usize { - return syscall1(.fsync, @as(usize, @bitCast(@as(isize, fd)))); + return syscall1(.fsync, @as(u32, @bitCast(fd))); } pub fn fdatasync(fd: fd_t) usize { - return syscall1(.fdatasync, @as(usize, @bitCast(@as(isize, fd)))); + return syscall1(.fdatasync, @as(u32, @bitCast(fd))); } pub fn prctl(option: i32, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { - return syscall5(.prctl, @as(usize, @bitCast(@as(isize, option))), arg2, arg3, arg4, arg5); + return syscall5(.prctl, @as(u32, @bitCast(option)), arg2, arg3, arg4, arg5); } pub fn getrlimit(resource: rlimit_resource, rlim: *rlimit) usize { @@ -2827,8 +2809,8 @@ pub fn setrlimit(resource: rlimit_resource, rlim: *const rlimit) usize { pub fn prlimit(pid: pid_t, resource: rlimit_resource, new_limit: ?*const rlimit, old_limit: ?*rlimit) usize { return syscall4( .prlimit64, - @as(usize, @bitCast(@as(isize, pid))), - @as(usize, @bitCast(@as(isize, @intFromEnum(resource)))), + @as(u32, @bitCast(pid)), + @as(u32, @bitCast(@as(i32, @intFromEnum(resource)))), @intFromPtr(new_limit), @intFromPtr(old_limit), ); @@ -2843,14 +2825,14 @@ pub fn madvise(address: [*]u8, len: usize, advice: u32) usize { } pub fn pidfd_open(pid: pid_t, flags: u32) usize { - return syscall2(.pidfd_open, @as(usize, @bitCast(@as(isize, pid))), flags); + return syscall2(.pidfd_open, @as(u32, @bitCast(pid)), flags); } pub fn pidfd_getfd(pidfd: fd_t, targetfd: fd_t, flags: u32) usize { return syscall3( .pidfd_getfd, - @as(usize, @bitCast(@as(isize, pidfd))), - @as(usize, @bitCast(@as(isize, targetfd))), + @as(u32, @bitCast(pidfd)), + @as(u32, @bitCast(targetfd)), flags, ); } @@ -2858,7 +2840,7 @@ pub fn pidfd_getfd(pidfd: fd_t, targetfd: fd_t, flags: u32) usize { pub fn pidfd_send_signal(pidfd: fd_t, sig: SIG, info: ?*siginfo_t, flags: u32) usize { return syscall4( .pidfd_send_signal, - @as(usize, @bitCast(@as(isize, pidfd))), + @as(u32, @bitCast(pidfd)), @intFromEnum(sig), @intFromPtr(info), flags, @@ -2868,7 +2850,7 @@ pub fn pidfd_send_signal(pidfd: fd_t, sig: SIG, info: ?*siginfo_t, flags: u32) u pub fn process_vm_readv(pid: pid_t, local: []const iovec, remote: []const iovec_const, flags: usize) usize { return syscall6( .process_vm_readv, - @as(usize, @bitCast(@as(isize, pid))), + @as(u32, @bitCast(pid)), @intFromPtr(local.ptr), local.len, @intFromPtr(remote.ptr), @@ -2880,7 +2862,7 @@ pub fn process_vm_readv(pid: pid_t, local: []const iovec, remote: []const iovec_ pub fn process_vm_writev(pid: pid_t, local: []const iovec_const, remote: []const iovec_const, flags: usize) usize { return syscall6( .process_vm_writev, - @as(usize, @bitCast(@as(isize, pid))), + @as(u32, @bitCast(pid)), @intFromPtr(local.ptr), local.len, @intFromPtr(remote.ptr), @@ -2890,31 +2872,16 @@ pub fn process_vm_writev(pid: pid_t, local: []const iovec_const, remote: []const } pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize { - if (comptime native_arch.isArm() or native_arch == .hexagon or native_arch.isPowerPC32()) { - // These architectures reorder the arguments so that a register is not skipped to align the - // register number that `offset` is passed in. - - const offset_halves = splitValue64(offset); - const length_halves = splitValue64(len); - - return syscall6( - .fadvise64_64, - @as(usize, @bitCast(@as(isize, fd))), - advice, - offset_halves[0], - offset_halves[1], - length_halves[0], - length_halves[1], - ); - } else if (native_arch.isMIPS32()) { - // MIPS O32 does not deal with the register alignment issue, so pass a dummy value. + if (native_arch.isMIPS32()) { + // MIPS O32 weirdly differs from the other architectures that require + // aligned register pairs for this specific syscall. const offset_halves = splitValue64(offset); const length_halves = splitValue64(len); return syscall7( .fadvise64, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), 0, offset_halves[0], offset_halves[1], @@ -2922,18 +2889,26 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize { length_halves[1], advice, ); - } else if (comptime usize_bits < 64) { - // Other 32-bit architectures do not require register alignment. - + } else if (require_aligned_register_pair) { const offset_halves = splitValue64(offset); const length_halves = splitValue64(len); return syscall6( - switch (builtin.abi) { - .gnuabin32, .gnux32, .muslabin32, .muslx32 => .fadvise64, - else => .fadvise64_64, - }, - @as(usize, @bitCast(@as(isize, fd))), + .fadvise64_64, + @as(u32, @bitCast(fd)), + advice, + offset_halves[0], + offset_halves[1], + length_halves[0], + length_halves[1], + ); + } else if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) { + const offset_halves = splitValue64(offset); + const length_halves = splitValue64(len); + + return syscall6( + .fadvise64_64, + @as(u32, @bitCast(fd)), offset_halves[0], offset_halves[1], length_halves[0], @@ -2941,14 +2916,11 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize { advice, ); } else { - // On 64-bit architectures, fadvise64_64 and fadvise64 are the same. Generally, older ports - // call it fadvise64 (x86, PowerPC, etc), while newer ports call it fadvise64_64 (RISC-V, - // LoongArch, etc). SPARC is the odd one out because it has both. return syscall4( - if (@hasField(SYS, "fadvise64_64")) .fadvise64_64 else .fadvise64, - @as(usize, @bitCast(@as(isize, fd))), - @as(usize, @bitCast(offset)), - @as(usize, @bitCast(len)), + .fadvise64, + @as(u32, @bitCast(fd)), + @as(u64, @bitCast(offset)), + @as(u64, @bitCast(len)), advice, ); } @@ -2964,9 +2936,9 @@ pub fn perf_event_open( return syscall5( .perf_event_open, @intFromPtr(attr), - @as(usize, @bitCast(@as(isize, pid))), - @as(usize, @bitCast(@as(isize, cpu))), - @as(usize, @bitCast(@as(isize, group_fd))), + @as(u32, @bitCast(pid)), + @as(u32, @bitCast(cpu)), + @as(u32, @bitCast(group_fd)), flags, ); } @@ -2985,7 +2957,7 @@ pub fn ptrace( return syscall5( .ptrace, req, - @as(usize, @bitCast(@as(isize, pid))), + @as(u32, @bitCast(pid)), addr, data, addr2, @@ -3007,14 +2979,14 @@ pub fn cachestat( ) usize { return syscall4( .cachestat, - @as(usize, @bitCast(@as(isize, fd))), + @as(u32, @bitCast(fd)), @intFromPtr(cstat_range), @intFromPtr(cstat), flags, ); } -pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize { +pub fn map_shadow_stack(addr: usize, size: usize, flags: u32) usize { return syscall3(.map_shadow_stack, addr, size, flags); } @@ -3678,13 +3650,6 @@ pub const E = switch (native_arch) { }, }; -pub const pid_t = i32; -pub const fd_t = i32; -pub const socket_t = i32; -pub const uid_t = u32; -pub const gid_t = u32; -pub const clock_t = isize; - pub const NAME_MAX = 255; pub const PATH_MAX = 4096; pub const IOV_MAX = 1024; @@ -10176,7 +10141,3 @@ pub const cmsghdr = extern struct { level: i32, type: i32, }; - -inline fn fd_to_usize(fd: fd_t) usize { - return @as(usize, @bitCast(@as(isize, fd))); -} diff --git a/lib/std/os/linux/aarch64.zig b/lib/std/os/linux/aarch64.zig index ddf1a61a25..6242ed9ff0 100644 --- a/lib/std/os/linux/aarch64.zig +++ b/lib/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), diff --git a/lib/std/os/linux/arc.zig b/lib/std/os/linux/arc.zig index 2db12030ec..9176546859 100644 --- a/lib/std/os/linux/arc.zig +++ b/lib/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), diff --git a/lib/std/os/linux/arm.zig b/lib/std/os/linux/arm.zig index 0bcdaaf319..87e3b48b37 100644 --- a/lib/std/os/linux/arm.zig +++ b/lib/std/os/linux/arm.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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), : [number] "{r7}" (@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 ("svc #0" : [ret] "={r0}" (-> u32), diff --git a/lib/std/os/linux/hexagon.zig b/lib/std/os/linux/hexagon.zig index ff5331467d..ef410e0a45 100644 --- a/lib/std/os/linux/hexagon.zig +++ b/lib/std/os/linux/hexagon.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 ("trap0(#1)" : [ret] "={r0}" (-> u32), : [number] "{r6}" (@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 ("trap0(#1)" : [ret] "={r0}" (-> u32), : [number] "{r6}" (@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 ("trap0(#1)" : [ret] "={r0}" (-> u32), : [number] "{r6}" (@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 ("trap0(#1)" : [ret] "={r0}" (-> u32), : [number] "{r6}" (@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 ("trap0(#1)" : [ret] "={r0}" (-> u32), : [number] "{r6}" (@intFromEnum(number)), @@ -61,12 +83,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 ("trap0(#1)" : [ret] "={r0}" (-> u32), diff --git a/lib/std/os/linux/loongarch32.zig b/lib/std/os/linux/loongarch32.zig index ffd6386a58..c5d1589aa3 100644 --- a/lib/std/os/linux/loongarch32.zig +++ b/lib/std/os/linux/loongarch32.zig @@ -2,7 +2,11 @@ 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 ( \\ syscall 0 : [ret] "={$r4}" (-> u32), @@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u32 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = 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 0 : [ret] "={$r4}" (-> u32), @@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = 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 0 : [ret] "={$r4}" (-> u32), @@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = 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 0 : [ret] "={$r4}" (-> u32), @@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = 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 0 : [ret] "={$r4}" (-> u32), @@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = 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 0 : [ret] "={$r4}" (-> u32), @@ -67,12 +96,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 0 diff --git a/lib/std/os/linux/loongarch64.zig b/lib/std/os/linux/loongarch64.zig index 8e7677f276..283a4de134 100644 --- a/lib/std/os/linux/loongarch64.zig +++ b/lib/std/os/linux/loongarch64.zig @@ -2,7 +2,11 @@ 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 ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u64 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); } -pub fn syscall1(number: SYS, arg1: u64) u64 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u64 { return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .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 ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .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 ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .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 ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 { : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .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 ( \\ syscall 0 : [ret] "={$r4}" (-> u64), @@ -67,12 +96,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 ( \\ syscall 0 diff --git a/lib/std/os/linux/m68k.zig b/lib/std/os/linux/m68k.zig index 2c5f13aa63..8a5cabc17c 100644 --- a/lib/std/os/linux/m68k.zig +++ b/lib/std/os/linux/m68k.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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), : [number] "{d0}" (@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 #0" : [ret] "={d0}" (-> u32), @@ -144,5 +173,4 @@ pub fn restore_rt() callconv(.naked) noreturn { pub const time_t = i32; -// No VDSO used as of glibc 112a0ae18b831bf31f44d81b82666980312511d6. pub const VDSO = void; diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig index bcca7d1ef2..262219005d 100644 --- a/lib/std/os/linux/mips.zig +++ b/lib/std/os/linux/mips.zig @@ -2,7 +2,11 @@ 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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u32 { : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } -pub fn syscall_pipe(fd: *[2]i32) u32 { - return asm volatile ( - \\ syscall - \\ beq $a3, $zero, 1f - \\ blez $v0, 2f - \\ subu $v0, $zero, $v0 - \\ b 2f - \\1: - \\ sw $v0, 0($a0) - \\ sw $v1, 4($a0) - \\2: - : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), - [fd] "{$4}" (fd), - : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 { : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 { : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 { : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -92,7 +97,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 { // NOTE: The o32 calling convention requires the callee to reserve 16 bytes for // the first four arguments even though they're passed in $a0-$a3. -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 ( \\ subu $sp, $sp, 24 \\ sw %[arg5], 16($sp) @@ -114,12 +126,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 ( \\ subu $sp, $sp, 24 @@ -144,13 +156,13 @@ pub fn syscall6( pub fn syscall7( number: SYS, - arg1: u32, - arg2: u32, - arg3: u32, - arg4: u32, - arg5: u32, - arg6: u32, - arg7: 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, + arg7: syscall_arg_t, ) u32 { return asm volatile ( \\ subu $sp, $sp, 32 @@ -175,6 +187,25 @@ pub fn syscall7( : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } +pub fn syscall_pipe( + fd: *[2]std.os.linux.fd_t, +) u32 { + return asm volatile ( + \\ syscall + \\ beq $a3, $zero, 1f + \\ blez $v0, 2f + \\ subu $v0, $zero, $v0 + \\ b 2f + \\1: + \\ sw $v0, 0($a0) + \\ sw $v1, 4($a0) + \\2: + : [ret] "={$2}" (-> u32), + : [number] "{$2}" (@intFromEnum(SYS.pipe)), + [fd] "{$4}" (fd), + : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); +} + pub fn clone() callconv(.naked) u32 { // __clone(func, stack, flags, arg, ptid, tls, ctid) // a0, a1, a2, a3, +0, +4, +8 diff --git a/lib/std/os/linux/mips64.zig b/lib/std/os/linux/mips64.zig index ec5681b513..5e70cfc6dc 100644 --- a/lib/std/os/linux/mips64.zig +++ b/lib/std/os/linux/mips64.zig @@ -2,7 +2,11 @@ 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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u64 { : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } -pub fn syscall_pipe(fd: *[2]i32) u64 { - return asm volatile ( - \\ syscall - \\ beq $a3, $zero, 1f - \\ blez $v0, 2f - \\ dsubu $v0, $zero, $v0 - \\ b 2f - \\1: - \\ sw $v0, 0($a0) - \\ sw $v1, 4($a0) - \\2: - : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), - [fd] "{$4}" (fd), - : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); -} - -pub fn syscall1(number: SYS, arg1: u64) u64 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u64 { return asm volatile ( \\ syscall \\ beq $a3, $zero, 1f @@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 { : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 { : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 { : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -89,7 +94,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 { : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .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 ( \\ syscall \\ beq $a3, $zero, 1f @@ -108,12 +120,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 ( \\ syscall @@ -132,6 +144,25 @@ pub fn syscall6( : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } +pub fn syscall_pipe( + fd: *[2]std.os.linux.fd_t, +) u64 { + return asm volatile ( + \\ syscall + \\ beq $a3, $zero, 1f + \\ blez $v0, 2f + \\ dsubu $v0, $zero, $v0 + \\ b 2f + \\1: + \\ sw $v0, 0($a0) + \\ sw $v1, 4($a0) + \\2: + : [ret] "={$2}" (-> u64), + : [number] "{$2}" (@intFromEnum(SYS.pipe)), + [fd] "{$4}" (fd), + : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); +} + pub fn clone() callconv(.naked) u64 { // __clone(func, stack, flags, arg, ptid, tls, ctid) // a0, a1, a2, a3, a4, a5, a6 diff --git a/lib/std/os/linux/mipsn32.zig b/lib/std/os/linux/mipsn32.zig index 4f7c7d60fd..04b240af9f 100644 --- a/lib/std/os/linux/mipsn32.zig +++ b/lib/std/os/linux/mipsn32.zig @@ -2,7 +2,11 @@ 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 \\ beq $a3, $zero, 1f @@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u32 { : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } -pub fn syscall_pipe(fd: *[2]i32) u32 { - return asm volatile ( - \\ syscall - \\ beq $a3, $zero, 1f - \\ blez $v0, 2f - \\ subu $v0, $zero, $v0 - \\ b 2f - \\1: - \\ sw $v0, 0($a0) - \\ sw $v1, 4($a0) - \\2: - : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), - [fd] "{$4}" (fd), - : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 { : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 { : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 { : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -89,7 +94,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 { : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = 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 \\ beq $a3, $zero, 1f @@ -108,12 +120,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 @@ -132,6 +144,25 @@ pub fn syscall6( : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } +pub fn syscall_pipe( + fd: *[2]std.os.linux.fd_t, +) u32 { + return asm volatile ( + \\ syscall + \\ beq $a3, $zero, 1f + \\ blez $v0, 2f + \\ subu $v0, $zero, $v0 + \\ b 2f + \\1: + \\ sw $v0, 0($a0) + \\ sw $v1, 4($a0) + \\2: + : [ret] "={$2}" (-> u32), + : [number] "{$2}" (@intFromEnum(SYS.pipe)), + [fd] "{$4}" (fd), + : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); +} + pub fn clone() callconv(.naked) u32 { // __clone(func, stack, flags, arg, ptid, tls, ctid) // a0, a1, a2, a3, a4, a5, a6 diff --git a/lib/std/os/linux/or1k.zig b/lib/std/os/linux/or1k.zig index 45352e4791..620fd4c736 100644 --- a/lib/std/os/linux/or1k.zig +++ b/lib/std/os/linux/or1k.zig @@ -2,7 +2,11 @@ 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 ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u32 { : .{ .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = true, .memory = true }); } -pub fn syscall1(number: SYS, arg1: u32) u32 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u32 { return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 { : .{ .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = 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 ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 { : .{ .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = 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 ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 { : .{ .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = 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 ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 { : .{ .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = 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 ( \\ l.sys 1 : [ret] "={r11}" (-> u32), @@ -67,12 +96,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 ( \\ l.sys 1 diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig index 78c6aadda7..7d7212de93 100644 --- a/lib/std/os/linux/powerpc.zig +++ b/lib/std/os/linux/powerpc.zig @@ -2,7 +2,11 @@ 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 { // 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 @@ -19,7 +23,10 @@ pub fn syscall0(number: SYS) u32 { : .{ .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: u32) u32 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u32 { // r0 is both an input and a clobber. var r0_out: u32 = undefined; return asm volatile ( @@ -34,7 +41,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 { : .{ .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: u32, arg2: u32) u32 { +pub fn syscall2( + number: SYS, + arg1: syscall_arg_t, + arg2: syscall_arg_t, +) u32 { // These registers are both inputs and clobbers. var r0_out: u32 = undefined; var r4_out: u32 = undefined; @@ -52,7 +63,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 { : .{ .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: u32, arg2: u32, arg3: u32) u32 { +pub fn syscall3( + number: SYS, + arg1: syscall_arg_t, + arg2: syscall_arg_t, + arg3: syscall_arg_t, +) u32 { // These registers are both inputs and clobbers. var r0_out: u32 = undefined; var r4_out: u32 = undefined; @@ -73,7 +89,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 { : .{ .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: 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 { // These registers are both inputs and clobbers. var r0_out: u32 = undefined; var r4_out: u32 = undefined; @@ -97,7 +119,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 { : .{ .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: 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 { // These registers are both inputs and clobbers. var r0_out: u32 = undefined; var r4_out: u32 = undefined; @@ -126,12 +155,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 { // These registers are both inputs and clobbers. var r0_out: u32 = undefined; diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig index f4375a4545..84a60f7c1f 100644 --- a/lib/std/os/linux/powerpc64.zig +++ b/lib/std/os/linux/powerpc64.zig @@ -2,7 +2,11 @@ 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 { // 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 @@ -19,7 +23,10 @@ pub fn syscall0(number: SYS) u64 { : .{ .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: u64) u64 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u64 { // r0 is both an input and a clobber. var r0_out: u64 = undefined; return asm volatile ( @@ -34,7 +41,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 { : .{ .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: u64, arg2: u64) u64 { +pub fn syscall2( + number: SYS, + arg1: syscall_arg_t, + arg2: syscall_arg_t, +) u64 { // These registers are both inputs and clobbers. var r0_out: u64 = undefined; var r4_out: u64 = undefined; @@ -52,7 +63,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 { : .{ .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: u64, arg2: u64, arg3: u64) u64 { +pub fn syscall3( + number: SYS, + arg1: syscall_arg_t, + arg2: syscall_arg_t, + arg3: syscall_arg_t, +) u64 { // These registers are both inputs and clobbers. var r0_out: u64 = undefined; var r4_out: u64 = undefined; @@ -73,7 +89,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 { : .{ .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: 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 { // These registers are both inputs and clobbers. var r0_out: u64 = undefined; var r4_out: u64 = undefined; @@ -97,7 +119,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 { : .{ .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: 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 { // These registers are both inputs and clobbers. var r0_out: u64 = undefined; var r4_out: u64 = undefined; @@ -126,12 +155,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 { // These registers are both inputs and clobbers. var r0_out: u64 = undefined; diff --git a/lib/std/os/linux/riscv32.zig b/lib/std/os/linux/riscv32.zig index c1b216b38e..42b30ee9ff 100644 --- a/lib/std/os/linux/riscv32.zig +++ b/lib/std/os/linux/riscv32.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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), : [number] "{x17}" (@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 ("ecall" : [ret] "={x10}" (-> u32), diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig index 50a456836a..9aa51c2b24 100644 --- a/lib/std/os/linux/riscv64.zig +++ b/lib/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), diff --git a/lib/std/os/linux/s390x.zig b/lib/std/os/linux/s390x.zig index 17a558e83d..e93d39a0d8 100644 --- a/lib/std/os/linux/s390x.zig +++ b/lib/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)), diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig index 59880bba87..dfd7f6c660 100644 --- a/lib/std/os/linux/sparc64.zig +++ b/lib/std/os/linux/sparc64.zig @@ -2,7 +2,151 @@ const builtin = @import("builtin"); const std = @import("../../std.zig"); const SYS = std.os.linux.SYS; -pub fn syscall_pipe(fd: *[2]i32) u64 { +pub const syscall_arg_t = u64; + +pub fn syscall0( + number: SYS, +) u64 { + return asm volatile ( + \\ t 0x6d + \\ bcc,pt %%xcc, 1f + \\ nop + \\ neg %%o0 + \\ 1: + : [ret] "={o0}" (-> u64), + : [number] "{g1}" (@intFromEnum(number)), + : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); +} + +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u64 { + return asm volatile ( + \\ t 0x6d + \\ bcc,pt %%xcc, 1f + \\ nop + \\ neg %%o0 + \\ 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 syscall2( + number: SYS, + arg1: syscall_arg_t, + arg2: syscall_arg_t, +) u64 { + return asm volatile ( + \\ t 0x6d + \\ bcc,pt %%xcc, 1f + \\ nop + \\ neg %%o0 + \\ 1: + : [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 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 + \\ nop + \\ neg %%o0 + \\ 1: + : [ret] "={o0}" (-> 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 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 + \\ nop + \\ neg %%o0 + \\ 1: + : [ret] "={o0}" (-> u64), + : [number] "{g1}" (@intFromEnum(number)), + [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 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 + \\ nop + \\ neg %%o0 + \\ 1: + : [ret] "={o0}" (-> u64), + : [number] "{g1}" (@intFromEnum(number)), + [arg1] "{o0}" (arg1), + [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 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 + \\ nop + \\ neg %%o0 + \\ 1: + : [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), + : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); +} + +pub fn syscall_pipe( + fd: *[2]std.os.linux.fd_t, +) u64 { return asm volatile ( \\ mov %[arg], %%g3 \\ t 0x6d @@ -44,119 +188,6 @@ pub fn syscall_fork() u64 { : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } -pub fn syscall0(number: SYS) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), - : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); -} - -pub fn syscall1(number: SYS, arg1: u64) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 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 syscall2(number: SYS, arg1: u64, arg2: u64) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [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 syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [ret] "={o0}" (-> 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 syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), - [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 syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), - [arg1] "{o0}" (arg1), - [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 syscall6( - number: SYS, - arg1: u64, - arg2: u64, - arg3: u64, - arg4: u64, - arg5: u64, - arg6: u64, -) u64 { - return asm volatile ( - \\ t 0x6d - \\ bcc,pt %%xcc, 1f - \\ nop - \\ neg %%o0 - \\ 1: - : [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), - : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); -} - pub fn clone() callconv(.naked) u64 { // __clone(func, stack, flags, arg, ptid, tls, ctid) // i0, i1, i2, i3, i4, i5, sp diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig index 90200da744..ca0be89097 100644 --- a/lib/std/os/linux/thumb.zig +++ b/lib/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; diff --git a/lib/std/os/linux/x32.zig b/lib/std/os/linux/x32.zig index 97deb7640f..d26833d9a1 100644 --- a/lib/std/os/linux/x32.zig +++ b/lib/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), diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig index e95afe23a6..375f631572 100644 --- a/lib/std/os/linux/x86.zig +++ b/lib/std/os/linux/x86.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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 ("int $0x80" : [ret] "={eax}" (-> u32), : [number] "{eax}" (@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 { // arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer // and there are no more GPRs available; so we'll need a memory operand for it. Adding that @@ -74,7 +103,7 @@ pub fn syscall6( // *its* own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get // right, because we can't touch esp or ebp until we're done with the memory input (as that // input could be relative to esp or ebp). - const args56: [2]u32 = .{ arg5, arg6 }; + const args56: [2]syscall_arg_t = .{ arg5, arg6 }; return asm volatile ( \\ push %[args56] \\ push %%ebp diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig index cab71d03e0..adda8b4d03 100644 --- a/lib/std/os/linux/x86_64.zig +++ b/lib/std/os/linux/x86_64.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 ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@intFromEnum(number)), : .{ .rcx = true, .r11 = true, .memory = true }); } -pub fn syscall1(number: SYS, arg1: u64) u64 { +pub fn syscall1( + number: SYS, + arg1: syscall_arg_t, +) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@intFromEnum(number)), @@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 { : .{ .rcx = true, .r11 = true, .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 ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@intFromEnum(number)), @@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 { : .{ .rcx = true, .r11 = true, .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 ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@intFromEnum(number)), @@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 { : .{ .rcx = true, .r11 = true, .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 ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@intFromEnum(number)), @@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 { : .{ .rcx = true, .r11 = true, .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 ("syscall" : [ret] "={rax}" (-> u64), : [number] "{rax}" (@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 ("syscall" : [ret] "={rax}" (-> u64),