Commit 67023fc4bd8cef20a097b4cd7b97438625049b70 | zig

author	Alex Rønne Petersen <alex@alexrp.com> 2026-04-15 19:02:13+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-04-16 16:00:21+02:00
log	67023fc4bd8cef20a097b4cd7b97438625049b70
tree	18586447e7775ae5f25ceb307a0caee0b340888a
parent	ab2f9ca50341ce6115f2839281a6e3c640271583
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

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

24 files changed, 1366 insertions(+), 801 deletions(-)

lib/c/fcntl.zig+1-1

...	...	@@ -16,7 +16,7 @@ comptime {
16	16	}
17	17
18	18	fn fallocateLinux(fd: c_int, mode: c_int, offset: off_t, len: off_t) callconv(.c) c_int {
19		return errno(linux.fallocate(fd, mode, offset, len));
	19	return errno(linux.fallocate(fd, @bitCast(mode), offset, len));
20	20	}
21	21
22	22	fn posix_fadviseLinux(fd: c_int, offset: off_t, len: off_t, advice: c_int) callconv(.c) c_int {

lib/std/Io/Threaded.zig+8-8

...	...	@@ -10035,10 +10035,10 @@ fn fileSeekBy(userdata: ?*anyopaque, file: File, offset: i64) File.SeekError!voi
10035	10035	if (posix.SEEK == void) return error.Unseekable;
10036	10036
10037	10037	if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
10038		var result: u64 = undefined;
	10038	var result: i64 = undefined;
10039	10039	const syscall: Syscall = try .start();
10040	10040	while (true) {
10041		switch (posix.errno(posix.system.llseek(file.handle, @bitCast(offset), &result, posix.SEEK.CUR))) {
	10041	switch (posix.errno(posix.system.llseek(file.handle, offset, &result, posix.SEEK.CUR))) {
10042	10042	.SUCCESS => {
10043	10043	syscall.finish();
10044	10044	return;
...	...	@@ -10149,8 +10149,8 @@ fn posixSeekTo(fd: posix.fd_t, offset: u64) File.SeekError!void {
10149	10149	if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
10150	10150	const syscall: Syscall = try .start();
10151	10151	while (true) {
10152		var result: u64 = undefined;
10153		switch (posix.errno(posix.system.llseek(fd, offset, &result, posix.SEEK.SET))) {
	10152	var result: i64 = undefined;
	10153	switch (posix.errno(posix.system.llseek(fd, @bitCast(offset), &result, posix.SEEK.SET))) {
10154	10154	.SUCCESS => {
10155	10155	syscall.finish();
10156	10156	return;
...	...	@@ -15247,7 +15247,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
15247	15247	const ru_ptr = if (child.request_resource_usage_statistics) &ru else null;
15248	15248
15249	15249	if (have_wait4) {
15250		var status: if (builtin.link_libc) c_int else u32 = undefined;
	15250	var status: if (builtin.link_libc) c_int else i32 = undefined;
15251	15251	const syscall: Syscall = try .start();
15252	15252	while (true) switch (posix.errno(posix.system.wait4(pid, &status, 0, ru_ptr))) {
15253	15253	.SUCCESS => {
...	...	@@ -15290,7 +15290,7 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T
15290	15290	};
15291	15291	}
15292	15292
15293		var status: if (builtin.link_libc) c_int else u32 = undefined;
	15293	var status: if (builtin.link_libc) c_int else i32 = undefined;
15294	15294	const syscall: Syscall = try .start();
15295	15295	while (true) switch (posix.errno(posix.system.waitpid(pid, &status, 0))) {
15296	15296	.SUCCESS => {
...	...	@@ -15332,7 +15332,7 @@ fn childKillPosix(child: *process.Child) !void {
15332	15332	};
15333	15333
15334	15334	if (have_wait4) {
15335		var status: if (builtin.link_libc) c_int else u32 = undefined;
	15335	var status: if (builtin.link_libc) c_int else i32 = undefined;
15336	15336	while (true) switch (posix.errno(posix.system.wait4(pid, &status, 0, null))) {
15337	15337	.SUCCESS => return,
15338	15338	.INTR => continue,
...	...	@@ -15352,7 +15352,7 @@ fn childKillPosix(child: *process.Child) !void {
15352	15352	};
15353	15353	}
15354	15354
15355		var status: if (builtin.link_libc) c_int else u32 = undefined;
	15355	var status: if (builtin.link_libc) c_int else i32 = undefined;
15356	15356	while (true) switch (posix.errno(posix.system.waitpid(pid, &status, 0))) {
15357	15357	.SUCCESS => return,
15358	15358	.INTR => continue,

lib/std/os/linux.zig+383-422

...	...	@@ -59,6 +59,7 @@ const arch_bits = switch (native_arch) {
59	59
60	60	const syscall_bits = if (native_arch.isThumb()) @import("linux/thumb.zig") else arch_bits;
61	61
	62	pub const syscall_arg_t = syscall_bits.syscall_arg_t;
62	63	pub const syscall0 = syscall_bits.syscall0;
63	64	pub const syscall1 = syscall_bits.syscall1;
64	65	pub const syscall2 = syscall_bits.syscall2;
...	...	@@ -78,9 +79,9 @@ pub fn clone(
78	79	stack: usize,
79	80	flags: u32,
80	81	arg: usize,
81		ptid: ?*i32,
	82	ptid: ?*pid_t,
82	83	tp: usize, // aka tls
83		ctid: ?*i32,
	84	ctid: ?*pid_t,
84	85	) usize {
85	86	// Can't directly call a naked function; cast to C calling convention first.
86	87	return @as(*const fn (
...	...	@@ -88,9 +89,9 @@ pub fn clone(
88	89	usize,
89	90	u32,
90	91	usize,
91		?*i32,
	92	?*pid_t,
92	93	usize,
93		?*i32,
	94	?*pid_t,
94	95	) callconv(.c) usize, @ptrCast(&syscall_bits.clone))(func, stack, flags, arg, ptid, tp, ctid);
95	96	}
96	97
...	...	@@ -98,6 +99,8 @@ pub const ARCH = arch_bits.ARCH;
98	99	pub const HWCAP = arch_bits.HWCAP;
99	100	pub const SC = arch_bits.SC;
100	101	pub const VDSO = arch_bits.VDSO;
	102	pub const user_desc = arch_bits.user_desc;
	103
101	104	pub const blkcnt_t = u64;
102	105	pub const blksize_t = u32;
103	106	pub const dev_t = u64;
...	...	@@ -105,8 +108,13 @@ pub const ino_t = u64;
105	108	pub const mode_t = u32;
106	109	pub const nlink_t = u32;
107	110	pub const off_t = i64;
	111	pub const pid_t = i32;
	112	pub const fd_t = i32;
	113	pub const socket_t = fd_t;
	114	pub const uid_t = u32;
	115	pub const gid_t = u32;
	116	pub const clock_t = isize;
108	117	pub const time_t = arch_bits.time_t;
109		pub const user_desc = arch_bits.user_desc;
110	118
111	119	pub const tls = @import("linux/tls.zig");
112	120	pub const BPF = @import("linux/bpf.zig");
...	...	@@ -613,13 +621,13 @@ pub fn brk(addr: usize) usize {
613	621	return syscall1(.brk, addr);
614	622	}
615	623
616		pub fn dup(old: i32) usize {
617		return syscall1(.dup, @as(usize, @bitCast(@as(isize, old))));
	624	pub fn dup(old: fd_t) usize {
	625	return syscall1(.dup, @as(u32, @bitCast(old)));
618	626	}
619	627
620		pub fn dup2(old: i32, new: i32) usize {
	628	pub fn dup2(old: fd_t, new: fd_t) usize {
621	629	if (@hasField(SYS, "dup2")) {
622		return syscall2(.dup2, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new))));
	630	return syscall2(.dup2, @as(u32, @bitCast(old)), @as(u32, @bitCast(new)));
623	631	} else {
624	632	if (old == new) {
625	633	if (std.debug.runtime_safety) {
...	...	@@ -628,13 +636,13 @@ pub fn dup2(old: i32, new: i32) usize {
628	636	}
629	637	return @as(usize, @intCast(old));
630	638	} else {
631		return syscall3(.dup3, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new))), 0);
	639	return syscall3(.dup3, @as(u32, @bitCast(old)), @as(u32, @bitCast(new)), 0);
632	640	}
633	641	}
634	642	}
635	643
636		pub fn dup3(old: i32, new: i32, flags: u32) usize {
637		return syscall3(.dup3, @as(usize, @bitCast(@as(isize, old))), @as(usize, @bitCast(@as(isize, new))), flags);
	644	pub fn dup3(old: fd_t, new: fd_t, flags: u32) usize {
	645	return syscall3(.dup3, @as(u32, @bitCast(old)), @as(u32, @bitCast(new)), flags);
638	646	}
639	647
640	648	pub fn chdir(path: [*:0]const u8) usize {
...	...	@@ -642,7 +650,7 @@ pub fn chdir(path: [*:0]const u8) usize {
642	650	}
643	651
644	652	pub fn fchdir(fd: fd_t) usize {
645		return syscall1(.fchdir, @as(usize, @bitCast(@as(isize, fd))));
	653	return syscall1(.fchdir, @as(u32, @bitCast(fd)));
646	654	}
647	655
648	656	pub fn chroot(path: [*:0]const u8) usize {
...	...	@@ -664,7 +672,7 @@ pub const EXECVEAT = packed struct(u32) {
664	672	};
665	673
666	674	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 {
667		return syscall5(.execveat, fd_to_usize(dirfd), @intFromPtr(path), @intFromPtr(argv), @intFromPtr(envp), @as(u32, @bitCast(flags)));
	675	return syscall5(.execveat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @intFromPtr(argv), @intFromPtr(envp), @as(u32, @bitCast(flags)));
668	676	}
669	677
670	678	pub fn fork() usize {
...	...	@@ -686,28 +694,28 @@ pub inline fn vfork() usize {
686	694	return @call(.always_inline, syscall0, .{.vfork});
687	695	}
688	696
689		pub fn futimens(fd: i32, times: ?*const [2]timespec) usize {
	697	pub fn futimens(fd: fd_t, times: ?*const [2]timespec) usize {
690	698	return utimensat(fd, null, times, 0);
691	699	}
692	700
693		pub fn utimensat(dirfd: i32, path: ?[:0]const u8, times: ?const [2]timespec, flags: u32) usize {
	701	pub fn utimensat(dirfd: fd_t, path: ?[:0]const u8, times: ?const [2]timespec, flags: u32) usize {
694	702	return syscall4(
695	703	if (@hasField(SYS, "utimensat") and native_arch != .hexagon) .utimensat else .utimensat_time64,
696		@as(usize, @bitCast(@as(isize, dirfd))),
	704	@as(u32, @bitCast(dirfd)),
697	705	@intFromPtr(path),
698	706	@intFromPtr(times),
699	707	flags,
700	708	);
701	709	}
702	710
703		pub fn fallocate(fd: i32, mode: i32, offset: i64, length: i64) usize {
704		if (usize_bits < 64) {
	711	pub fn fallocate(fd: fd_t, mode: mode_t, offset: off_t, length: off_t) usize {
	712	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
705	713	const offset_halves = splitValue64(offset);
706	714	const length_halves = splitValue64(length);
707	715	return syscall6(
708	716	.fallocate,
709		@as(usize, @bitCast(@as(isize, fd))),
710		@as(usize, @bitCast(@as(isize, mode))),
	717	@as(u32, @bitCast(fd)),
	718	mode,
711	719	offset_halves[0],
712	720	offset_halves[1],
713	721	length_halves[0],
...	...	@@ -716,8 +724,8 @@ pub fn fallocate(fd: i32, mode: i32, offset: i64, length: i64) usize {
716	724	} else {
717	725	return syscall4(
718	726	.fallocate,
719		@as(usize, @bitCast(@as(isize, fd))),
720		@as(usize, @bitCast(@as(isize, mode))),
	727	@as(u32, @bitCast(fd)),
	728	mode,
721	729	@as(u64, @bitCast(offset)),
722	730	@as(u64, @bitCast(length)),
723	731	);
...	...	@@ -888,19 +896,19 @@ pub fn getcwd(buf: [*]u8, size: usize) usize {
888	896	return syscall2(.getcwd, @intFromPtr(buf), size);
889	897	}
890	898
891		pub fn getdents(fd: i32, dirp: [*]u8, len: usize) usize {
	899	pub fn getdents(fd: fd_t, dirp: [*]u8, len: usize) usize {
892	900	return syscall3(
893	901	.getdents,
894		@as(usize, @bitCast(@as(isize, fd))),
	902	@as(u32, @bitCast(fd)),
895	903	@intFromPtr(dirp),
896	904	@min(len, maxInt(c_int)),
897	905	);
898	906	}
899	907
900		pub fn getdents64(fd: i32, dirp: [*]u8, len: usize) usize {
	908	pub fn getdents64(fd: fd_t, dirp: [*]u8, len: usize) usize {
901	909	return syscall3(
902	910	.getdents64,
903		@as(usize, @bitCast(@as(isize, fd))),
	911	@as(u32, @bitCast(fd)),
904	912	@intFromPtr(dirp),
905	913	@min(len, maxInt(c_int)),
906	914	);
...	...	@@ -910,12 +918,12 @@ pub fn inotify_init1(flags: u32) usize {
910	918	return syscall1(.inotify_init1, flags);
911	919	}
912	920
913		pub fn inotify_add_watch(fd: i32, pathname: [*:0]const u8, mask: u32) usize {
914		return syscall3(.inotify_add_watch, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(pathname), mask);
	921	pub fn inotify_add_watch(fd: fd_t, pathname: [*:0]const u8, mask: u32) usize {
	922	return syscall3(.inotify_add_watch, @as(u32, @bitCast(fd)), @intFromPtr(pathname), mask);
915	923	}
916	924
917		pub fn inotify_rm_watch(fd: i32, wd: i32) usize {
918		return syscall2(.inotify_rm_watch, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, wd))));
	925	pub fn inotify_rm_watch(fd: fd_t, wd: fd_t) usize {
	926	return syscall2(.inotify_rm_watch, @as(u32, @bitCast(fd)), @as(u32, @bitCast(wd)));
919	927	}
920	928
921	929	pub fn fanotify_init(flags: fanotify.InitFlags, event_f_flags: u32) usize {
...	...	@@ -929,24 +937,24 @@ pub fn fanotify_mark(
929	937	dirfd: fd_t,
930	938	pathname: ?[*:0]const u8,
931	939	) usize {
932		if (usize_bits < 64) {
	940	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
933	941	const mask_halves = splitValue64(@bitCast(mask));
934	942	return syscall6(
935	943	.fanotify_mark,
936		@bitCast(@as(isize, fd)),
	944	@as(u32, @bitCast(fd)),
937	945	@as(u32, @bitCast(flags)),
938	946	mask_halves[0],
939	947	mask_halves[1],
940		@bitCast(@as(isize, dirfd)),
	948	@as(u32, @bitCast(dirfd)),
941	949	@intFromPtr(pathname),
942	950	);
943	951	} else {
944	952	return syscall5(
945	953	.fanotify_mark,
946		@bitCast(@as(isize, fd)),
	954	@as(u32, @bitCast(fd)),
947	955	@as(u32, @bitCast(flags)),
948		@bitCast(mask),
949		@bitCast(@as(isize, dirfd)),
	956	@as(u64, @bitCast(mask)),
	957	@as(u32, @bitCast(dirfd)),
950	958	@intFromPtr(pathname),
951	959	);
952	960	}
...	...	@@ -955,7 +963,7 @@ pub fn fanotify_mark(
955	963	pub fn name_to_handle_at(
956	964	dirfd: fd_t,
957	965	pathname: [*:0]const u8,
958		handle: *std.os.linux.file_handle,
	966	handle: *file_handle,
959	967	mount_id: *i32,
960	968	flags: u32,
961	969	) usize {
...	...	@@ -973,27 +981,27 @@ pub fn readlink(noalias path: [:0]const u8, noalias buf_ptr: []u8, buf_len: us
973	981	if (@hasField(SYS, "readlink")) {
974	982	return syscall3(.readlink, @intFromPtr(path), @intFromPtr(buf_ptr), buf_len);
975	983	} else {
976		return syscall4(.readlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len);
	984	return syscall4(.readlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len);
977	985	}
978	986	}
979	987
980		pub fn readlinkat(dirfd: i32, noalias path: [:0]const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
981		return syscall4(.readlinkat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len);
	988	pub fn readlinkat(dirfd: fd_t, noalias path: [:0]const u8, noalias buf_ptr: []u8, buf_len: usize) usize {
	989	return syscall4(.readlinkat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @intFromPtr(buf_ptr), buf_len);
982	990	}
983	991
984	992	pub fn mkdir(path: [*:0]const u8, mode: mode_t) usize {
985	993	if (@hasField(SYS, "mkdir")) {
986	994	return syscall2(.mkdir, @intFromPtr(path), mode);
987	995	} else {
988		return syscall3(.mkdirat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), mode);
	996	return syscall3(.mkdirat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), mode);
989	997	}
990	998	}
991	999
992		pub fn mkdirat(dirfd: i32, path: [*:0]const u8, mode: mode_t) usize {
993		return syscall3(.mkdirat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode);
	1000	pub fn mkdirat(dirfd: fd_t, path: [*:0]const u8, mode: mode_t) usize {
	1001	return syscall3(.mkdirat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode);
994	1002	}
995	1003
996		pub fn mknod(path: [*:0]const u8, mode: u32, dev: u32) usize {
	1004	pub fn mknod(path: [*:0]const u8, mode: mode_t, dev: dev_t) usize {
997	1005	if (@hasField(SYS, "mknod")) {
998	1006	return syscall3(.mknod, @intFromPtr(path), mode, dev);
999	1007	} else {
...	...	@@ -1001,8 +1009,8 @@ pub fn mknod(path: [*:0]const u8, mode: u32, dev: u32) usize {
1001	1009	}
1002	1010	}
1003	1011
1004		pub fn mknodat(dirfd: i32, path: [*:0]const u8, mode: u32, dev: u32) usize {
1005		return syscall4(.mknodat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, dev);
	1012	pub fn mknodat(dirfd: dev_t, path: [*:0]const u8, mode: mode_t, dev: dev_t) usize {
	1013	return syscall4(.mknodat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode, dev);
1006	1014	}
1007	1015
1008	1016	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) {
1038	1046	};
1039	1047
1040	1048	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 {
1041		return syscall5(.move_mount, fd_to_usize(from_dirfd), @intFromPtr(from_path), fd_to_usize(to_dirfd), @intFromPtr(to_path), @as(u32, @bitCast(flags)));
	1049	return syscall5(
	1050	.move_mount,
	1051	@as(u32, @bitCast(from_dirfd)),
	1052	@intFromPtr(from_path),
	1053	@as(u32, @bitCast(to_dirfd)),
	1054	@intFromPtr(to_path),
	1055	@as(u32, @bitCast(flags)),
	1056	);
1042	1057	}
1043	1058
1044	1059	pub const MOUNT_ATTR = packed struct(u32) {
...	...	@@ -1070,7 +1085,7 @@ pub const MOUNT_ATTR = packed struct(u32) {
1070	1085	};
1071	1086
1072	1087	pub fn mount_setattr(dirfd: fd_t, path: [*:0]const u8, flags: MOUNT_ATTR) usize {
1073		return syscall3(.mount_setattr, fd_to_usize(dirfd), @intFromPtr(path), @as(u32, @bitCast(flags)));
	1088	return syscall3(.mount_setattr, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)));
1074	1089	}
1075	1090
1076	1091	pub const FSOPEN = packed struct(u32) {
...	...	@@ -1103,7 +1118,7 @@ pub const FSCONFIG_CMD = enum(u32) {
1103	1118	};
1104	1119
1105	1120	pub fn fsconfig(fd: fd_t, cmd: FSCONFIG_CMD, key: ?[:0]const u8, value: ?[:0]const u8, aux: u32) usize {
1106		return syscall5(.fsconfig, fd_to_usize(fd), @intFromEnum(cmd), @intFromPtr(key), @intFromPtr(value), aux);
	1121	return syscall5(.fsconfig, @as(u32, @bitCast(fd)), @intFromEnum(cmd), @intFromPtr(key), @intFromPtr(value), aux);
1107	1122	}
1108	1123
1109	1124	pub const FSMOUNT = packed struct(u32) {
...	...	@@ -1113,7 +1128,7 @@ pub const FSMOUNT = packed struct(u32) {
1113	1128	};
1114	1129
1115	1130	pub fn fsmount(fsfd: fd_t, flags: FSMOUNT, attr_flags: MOUNT_ATTR) usize {
1116		return syscall3(.fsmount, fd_to_usize(fsfd), @as(u32, @bitCast(flags)), @as(u32, @bitCast(attr_flags)));
	1131	return syscall3(.fsmount, @as(u32, @bitCast(fsfd)), @as(u32, @bitCast(flags)), @as(u32, @bitCast(attr_flags)));
1117	1132	}
1118	1133
1119	1134	pub const FSPICK = packed struct(u32) {
...	...	@@ -1126,7 +1141,7 @@ pub const FSPICK = packed struct(u32) {
1126	1141	};
1127	1142
1128	1143	pub fn fspick(dirfd: fd_t, path: [*:0]const u8, flags: FSPICK) usize {
1129		return syscall3(.fspick, fd_to_usize(dirfd), @intFromPtr(path), @as(u32, @bitCast(flags)));
	1144	return syscall3(.fspick, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)));
1130	1145	}
1131	1146
1132	1147	pub fn pivot_root(new_root: [:0]const u8, put_old: [:0]const u8) usize {
...	...	@@ -1141,7 +1156,7 @@ fn mmap2Unit() u64 {
1141	1156	};
1142	1157	}
1143	1158
1144		pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, offset: i64) usize {
	1159	pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: fd_t, offset: off_t) usize {
1145	1160	if (@hasField(SYS, "mmap2")) {
1146	1161	return syscall6(
1147	1162	.mmap2,
...	...	@@ -1149,7 +1164,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off
1149	1164	length,
1150	1165	@as(u32, @bitCast(prot)),
1151	1166	@as(u32, @bitCast(flags)),
1152		@bitCast(@as(isize, fd)),
	1167	@as(u32, @bitCast(fd)),
1153	1168	@truncate(@as(u64, @bitCast(offset)) / mmap2Unit()),
1154	1169	);
1155	1170	} else {
...	...	@@ -1162,7 +1177,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off
1162	1177	length,
1163	1178	@as(u32, @bitCast(prot)),
1164	1179	@as(u32, @bitCast(flags)),
1165		@bitCast(@as(isize, fd)),
	1180	@as(u32, @bitCast(fd)),
1166	1181	@as(u64, @bitCast(offset)),
1167	1182	}),
1168	1183	) else syscall6(
...	...	@@ -1171,7 +1186,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: PROT, flags: MAP, fd: i32, off
1171	1186	length,
1172	1187	@as(u32, @bitCast(prot)),
1173	1188	@as(u32, @bitCast(flags)),
1174		@bitCast(@as(isize, fd)),
	1189	@as(u32, @bitCast(fd)),
1175	1190	@as(u64, @bitCast(offset)),
1176	1191	);
1177	1192	}
...	...	@@ -1278,70 +1293,142 @@ pub fn ppoll(fds: []pollfd, n: nfds_t, timeout: ?timespec, sigmask: ?*const si
1278	1293	);
1279	1294	}
1280	1295
1281		pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
1282		return syscall3(.read, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(buf), count);
	1296	pub fn read(fd: fd_t, buf: [*]u8, count: usize) usize {
	1297	return syscall3(.read, @as(u32, @bitCast(fd)), @intFromPtr(buf), count);
	1298	}
	1299
	1300	pub fn pread(fd: fd_t, buf: [*]u8, count: usize, offset: off_t) usize {
	1301	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
	1302	const offset_halves = splitValue64(offset);
	1303	if (require_aligned_register_pair) {
	1304	return syscall6(
	1305	.pread64,
	1306	@as(u32, @bitCast(fd)),
	1307	@intFromPtr(buf),
	1308	count,
	1309	0,
	1310	offset_halves[0],
	1311	offset_halves[1],
	1312	);
	1313	} else {
	1314	return syscall5(
	1315	.pread64,
	1316	@as(u32, @bitCast(fd)),
	1317	@intFromPtr(buf),
	1318	count,
	1319	offset_halves[0],
	1320	offset_halves[1],
	1321	);
	1322	}
	1323	} else {
	1324	return syscall4(
	1325	.pread64,
	1326	@as(u32, @bitCast(fd)),
	1327	@intFromPtr(buf),
	1328	count,
	1329	@as(u64, @bitCast(offset)),
	1330	);
	1331	}
	1332	}
	1333
	1334	pub fn readv(fd: fd_t, iov: [*]const iovec, count: usize) usize {
	1335	return syscall3(.readv, @as(u32, @bitCast(fd)), @intFromPtr(iov), count);
1283	1336	}
1284	1337
1285		pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: i64) usize {
	1338	pub fn preadv(fd: fd_t, iov: [*]const iovec, count: usize, offset: off_t) usize {
1286	1339	const offset_u: u64 = @bitCast(offset);
1287	1340	return syscall5(
1288	1341	.preadv,
1289		@as(usize, @bitCast(@as(isize, fd))),
	1342	@as(u32, @bitCast(fd)),
1290	1343	@intFromPtr(iov),
1291	1344	count,
1292	1345	// Kernel expects the offset is split into largest natural word-size.
1293	1346	// See following link for detail:
1294	1347	// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=601cc11d054ae4b5e9b5babec3d8e4667a2cb9b5
1295		@as(usize, @truncate(offset_u)),
1296		if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0,
	1348	@truncate(offset_u),
	1349	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0,
1297	1350	);
1298	1351	}
1299	1352
1300		pub fn preadv2(fd: i32, iov: [*]const iovec, count: usize, offset: i64, flags: kernel_rwf) usize {
	1353	pub fn preadv2(fd: fd_t, iov: [*]const iovec, count: usize, offset: off_t, flags: kernel_rwf) usize {
1301	1354	const offset_u: u64 = @bitCast(offset);
1302	1355	return syscall6(
1303	1356	.preadv2,
1304		@as(usize, @bitCast(@as(isize, fd))),
	1357	@as(u32, @bitCast(fd)),
1305	1358	@intFromPtr(iov),
1306	1359	count,
1307	1360	// See comments in preadv
1308		@as(usize, @truncate(offset_u)),
1309		if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0,
	1361	@truncate(offset_u),
	1362	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0,
1310	1363	flags,
1311	1364	);
1312	1365	}
1313	1366
1314		pub fn readv(fd: i32, iov: [*]const iovec, count: usize) usize {
1315		return syscall3(.readv, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(iov), count);
	1367	pub fn write(fd: fd_t, buf: [*]const u8, count: usize) usize {
	1368	return syscall3(.write, @as(u32, @bitCast(fd)), @intFromPtr(buf), count);
	1369	}
	1370
	1371	pub fn pwrite(fd: fd_t, buf: [*]const u8, count: usize, offset: off_t) usize {
	1372	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
	1373	const offset_halves = splitValue64(offset);
	1374	if (require_aligned_register_pair) {
	1375	return syscall6(
	1376	.pwrite64,
	1377	@as(u32, @bitCast(fd)),
	1378	@intFromPtr(buf),
	1379	count,
	1380	0,
	1381	offset_halves[0],
	1382	offset_halves[1],
	1383	);
	1384	} else {
	1385	return syscall5(
	1386	.pwrite64,
	1387	@as(u32, @bitCast(fd)),
	1388	@intFromPtr(buf),
	1389	count,
	1390	offset_halves[0],
	1391	offset_halves[1],
	1392	);
	1393	}
	1394	} else {
	1395	return syscall4(
	1396	.pwrite64,
	1397	@as(u32, @bitCast(fd)),
	1398	@intFromPtr(buf),
	1399	count,
	1400	@as(u64, @bitCast(offset)),
	1401	);
	1402	}
1316	1403	}
1317	1404
1318		pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize {
1319		return syscall3(.writev, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(iov), count);
	1405	pub fn writev(fd: fd_t, iov: [*]const iovec_const, count: usize) usize {
	1406	return syscall3(.writev, @as(u32, @bitCast(fd)), @intFromPtr(iov), count);
1320	1407	}
1321	1408
1322		pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: i64) usize {
	1409	pub fn pwritev(fd: fd_t, iov: [*]const iovec_const, count: usize, offset: off_t) usize {
1323	1410	const offset_u: u64 = @bitCast(offset);
1324	1411	return syscall5(
1325	1412	.pwritev,
1326		@as(usize, @bitCast(@as(isize, fd))),
	1413	@as(u32, @bitCast(fd)),
1327	1414	@intFromPtr(iov),
1328	1415	count,
1329	1416	// See comments in preadv
1330		@as(usize, @truncate(offset_u)),
1331		if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0,
	1417	@truncate(offset_u),
	1418	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0,
1332	1419	);
1333	1420	}
1334	1421
1335		pub fn pwritev2(fd: i32, iov: [*]const iovec_const, count: usize, offset: i64, flags: kernel_rwf) usize {
	1422	pub fn pwritev2(fd: fd_t, iov: [*]const iovec_const, count: usize, offset: off_t, flags: kernel_rwf) usize {
1336	1423	const offset_u: u64 = @bitCast(offset);
1337	1424	return syscall6(
1338	1425	.pwritev2,
1339		@as(usize, @bitCast(@as(isize, fd))),
	1426	@as(u32, @bitCast(fd)),
1340	1427	@intFromPtr(iov),
1341	1428	count,
1342	1429	// See comments in preadv
1343		@as(usize, @truncate(offset_u)),
1344		if (usize_bits < 64) @as(usize, @truncate(offset_u >> 32)) else 0,
	1430	@truncate(offset_u),
	1431	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) @truncate(offset_u >> 32) else 0,
1345	1432	flags,
1346	1433	);
1347	1434	}
...	...	@@ -1350,7 +1437,7 @@ pub fn rmdir(path: [*:0]const u8) usize {
1350	1437	if (@hasField(SYS, "rmdir")) {
1351	1438	return syscall1(.rmdir, @intFromPtr(path));
1352	1439	} else {
1353		return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), AT.REMOVEDIR);
	1440	return syscall3(.unlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), AT.REMOVEDIR);
1354	1441	}
1355	1442	}
1356	1443
...	...	@@ -1358,54 +1445,15 @@ pub fn symlink(existing: [:0]const u8, new: [:0]const u8) usize {
1358	1445	if (@hasField(SYS, "symlink")) {
1359	1446	return syscall2(.symlink, @intFromPtr(existing), @intFromPtr(new));
1360	1447	} else {
1361		return syscall3(.symlinkat, @intFromPtr(existing), @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(new));
	1448	return syscall3(.symlinkat, @intFromPtr(existing), @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(new));
1362	1449	}
1363	1450	}
1364	1451
1365		pub fn symlinkat(existing: [:0]const u8, newfd: i32, newpath: [:0]const u8) usize {
1366		return syscall3(.symlinkat, @intFromPtr(existing), @as(usize, @bitCast(@as(isize, newfd))), @intFromPtr(newpath));
	1452	pub fn symlinkat(existing: [:0]const u8, newfd: fd_t, newpath: [:0]const u8) usize {
	1453	return syscall3(.symlinkat, @intFromPtr(existing), @as(u32, @bitCast(newfd)), @intFromPtr(newpath));
1367	1454	}
1368	1455
1369		pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: i64) usize {
1370		if (@hasField(SYS, "pread64") and usize_bits < 64) {
1371		const offset_halves = splitValue64(offset);
1372		if (require_aligned_register_pair) {
1373		return syscall6(
1374		.pread64,
1375		@as(usize, @bitCast(@as(isize, fd))),
1376		@intFromPtr(buf),
1377		count,
1378		0,
1379		offset_halves[0],
1380		offset_halves[1],
1381		);
1382		} else {
1383		return syscall5(
1384		.pread64,
1385		@as(usize, @bitCast(@as(isize, fd))),
1386		@intFromPtr(buf),
1387		count,
1388		offset_halves[0],
1389		offset_halves[1],
1390		);
1391		}
1392		} else {
1393		// Some architectures (eg. 64bit SPARC) pread is called pread64.
1394		const syscall_number = if (!@hasField(SYS, "pread") and @hasField(SYS, "pread64"))
1395		.pread64
1396		else
1397		.pread;
1398		return syscall4(
1399		syscall_number,
1400		@as(usize, @bitCast(@as(isize, fd))),
1401		@intFromPtr(buf),
1402		count,
1403		@as(u64, @bitCast(offset)),
1404		);
1405		}
1406		}
1407
1408		pub fn access(path: [*:0]const u8, mode: u32) usize {
	1456	pub fn access(path: [*:0]const u8, mode: mode_t) usize {
1409	1457	if (@hasField(SYS, "access")) {
1410	1458	return syscall2(.access, @intFromPtr(path), mode);
1411	1459	} else {
...	...	@@ -1413,19 +1461,19 @@ pub fn access(path: [*:0]const u8, mode: u32) usize {
1413	1461	}
1414	1462	}
1415	1463
1416		pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize {
	1464	pub fn faccessat(dirfd: fd_t, path: [*:0]const u8, mode: mode_t, flags: u32) usize {
1417	1465	if (flags == 0) {
1418		return syscall3(.faccessat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode);
	1466	return syscall3(.faccessat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode);
1419	1467	}
1420		return syscall4(.faccessat2, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), mode, flags);
	1468	return syscall4(.faccessat2, @as(u32, @bitCast(dirfd)), @intFromPtr(path), mode, flags);
1421	1469	}
1422	1470
1423	1471	pub fn acct(path: [*:0]const u8) usize {
1424	1472	return syscall1(.acct, @intFromPtr(path));
1425	1473	}
1426	1474
1427		pub fn pipe(fd: *[2]i32) usize {
1428		if (comptime (native_arch.isMIPS() or native_arch.isSPARC())) {
	1475	pub fn pipe(fd: *[2]fd_t) usize {
	1476	if (native_arch.isMIPS() or native_arch.isSPARC()) {
1429	1477	return syscall_pipe(fd);
1430	1478	} else if (@hasField(SYS, "pipe")) {
1431	1479	return syscall1(.pipe, @intFromPtr(fd));
...	...	@@ -1434,21 +1482,17 @@ pub fn pipe(fd: *[2]i32) usize {
1434	1482	}
1435	1483	}
1436	1484
1437		pub fn pipe2(fd: *[2]i32, flags: O) usize {
	1485	pub fn pipe2(fd: *[2]fd_t, flags: O) usize {
1438	1486	return syscall2(.pipe2, @intFromPtr(fd), @as(u32, @bitCast(flags)));
1439	1487	}
1440	1488
1441		pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
1442		return syscall3(.write, @bitCast(@as(isize, fd)), @intFromPtr(buf), count);
1443		}
1444
1445		pub fn ftruncate(fd: i32, length: i64) usize {
1446		if (@hasField(SYS, "ftruncate64") and usize_bits < 64) {
	1489	pub fn ftruncate(fd: fd_t, length: off_t) usize {
	1490	if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
1447	1491	const length_halves = splitValue64(length);
1448	1492	if (require_aligned_register_pair) {
1449	1493	return syscall4(
1450	1494	.ftruncate64,
1451		@as(usize, @bitCast(@as(isize, fd))),
	1495	@as(u32, @bitCast(fd)),
1452	1496	0,
1453	1497	length_halves[0],
1454	1498	length_halves[1],
...	...	@@ -1456,7 +1500,7 @@ pub fn ftruncate(fd: i32, length: i64) usize {
1456	1500	} else {
1457	1501	return syscall3(
1458	1502	.ftruncate64,
1459		@as(usize, @bitCast(@as(isize, fd))),
	1503	@as(u32, @bitCast(fd)),
1460	1504	length_halves[0],
1461	1505	length_halves[1],
1462	1506	);
...	...	@@ -1464,48 +1508,8 @@ pub fn ftruncate(fd: i32, length: i64) usize {
1464	1508	} else {
1465	1509	return syscall2(
1466	1510	.ftruncate,
1467		@as(usize, @bitCast(@as(isize, fd))),
1468		@as(usize, @bitCast(length)),
1469		);
1470		}
1471		}
1472
1473		pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: i64) usize {
1474		if (@hasField(SYS, "pwrite64") and usize_bits < 64) {
1475		const offset_halves = splitValue64(offset);
1476
1477		if (require_aligned_register_pair) {
1478		return syscall6(
1479		.pwrite64,
1480		@as(usize, @bitCast(@as(isize, fd))),
1481		@intFromPtr(buf),
1482		count,
1483		0,
1484		offset_halves[0],
1485		offset_halves[1],
1486		);
1487		} else {
1488		return syscall5(
1489		.pwrite64,
1490		@as(usize, @bitCast(@as(isize, fd))),
1491		@intFromPtr(buf),
1492		count,
1493		offset_halves[0],
1494		offset_halves[1],
1495		);
1496		}
1497		} else {
1498		// Some architectures (eg. 64bit SPARC) pwrite is called pwrite64.
1499		const syscall_number = if (!@hasField(SYS, "pwrite") and @hasField(SYS, "pwrite64"))
1500		.pwrite64
1501		else
1502		.pwrite;
1503		return syscall4(
1504		syscall_number,
1505		@as(usize, @bitCast(@as(isize, fd))),
1506		@intFromPtr(buf),
1507		count,
1508		@as(u64, @bitCast(offset)),
	1511	@as(u32, @bitCast(fd)),
	1512	@as(u64, @bitCast(length)),
1509	1513	);
1510	1514	}
1511	1515	}
...	...	@@ -1516,50 +1520,50 @@ pub fn rename(old: [:0]const u8, new: [:0]const u8) usize {
1516	1520	} else if (@hasField(SYS, "renameat")) {
1517	1521	return syscall4(
1518	1522	.renameat,
1519		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1523	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1520	1524	@intFromPtr(old),
1521		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1525	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1522	1526	@intFromPtr(new),
1523	1527	);
1524	1528	} else {
1525	1529	return syscall5(
1526	1530	.renameat2,
1527		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1531	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1528	1532	@intFromPtr(old),
1529		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1533	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1530	1534	@intFromPtr(new),
1531	1535	0,
1532	1536	);
1533	1537	}
1534	1538	}
1535	1539
1536		pub fn renameat(oldfd: i32, oldpath: [:0]const u8, newfd: i32, newpath: [:0]const u8) usize {
	1540	pub fn renameat(oldfd: fd_t, oldpath: [:0]const u8, newfd: fd_t, newpath: [:0]const u8) usize {
1537	1541	if (@hasField(SYS, "renameat")) {
1538	1542	return syscall4(
1539	1543	.renameat,
1540		@as(usize, @bitCast(@as(isize, oldfd))),
	1544	@as(u32, @bitCast(oldfd)),
1541	1545	@intFromPtr(oldpath),
1542		@as(usize, @bitCast(@as(isize, newfd))),
	1546	@as(u32, @bitCast(newfd)),
1543	1547	@intFromPtr(newpath),
1544	1548	);
1545	1549	} else {
1546	1550	return syscall5(
1547	1551	.renameat2,
1548		@as(usize, @bitCast(@as(isize, oldfd))),
	1552	@as(u32, @bitCast(oldfd)),
1549	1553	@intFromPtr(oldpath),
1550		@as(usize, @bitCast(@as(isize, newfd))),
	1554	@as(u32, @bitCast(newfd)),
1551	1555	@intFromPtr(newpath),
1552	1556	0,
1553	1557	);
1554	1558	}
1555	1559	}
1556	1560
1557		pub fn renameat2(oldfd: i32, oldpath: [:0]const u8, newfd: i32, newpath: [:0]const u8, flags: RENAME) usize {
	1561	pub fn renameat2(oldfd: fd_t, oldpath: [:0]const u8, newfd: fd_t, newpath: [:0]const u8, flags: RENAME) usize {
1558	1562	return syscall5(
1559	1563	.renameat2,
1560		@as(usize, @bitCast(@as(isize, oldfd))),
	1564	@as(u32, @bitCast(oldfd)),
1561	1565	@intFromPtr(oldpath),
1562		@as(usize, @bitCast(@as(isize, newfd))),
	1566	@as(u32, @bitCast(newfd)),
1563	1567	@intFromPtr(newpath),
1564	1568	@as(u32, @bitCast(flags)),
1565	1569	);
...	...	@@ -1571,7 +1575,7 @@ pub fn open(path: [*:0]const u8, flags: O, perm: mode_t) usize {
1571	1575	} else {
1572	1576	return syscall4(
1573	1577	.openat,
1574		@bitCast(@as(isize, AT.FDCWD)),
	1578	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1575	1579	@intFromPtr(path),
1576	1580	@as(u32, @bitCast(flags)),
1577	1581	perm,
...	...	@@ -1583,13 +1587,13 @@ pub fn create(path: [*:0]const u8, perm: mode_t) usize {
1583	1587	return syscall2(.creat, @intFromPtr(path), perm);
1584	1588	}
1585	1589
1586		pub fn openat(dirfd: i32, path: [*:0]const u8, flags: O, mode: mode_t) usize {
	1590	pub fn openat(dirfd: fd_t, path: [*:0]const u8, flags: O, mode: mode_t) usize {
1587	1591	// dirfd could be negative, for example AT.FDCWD is -100
1588		return syscall4(.openat, @bitCast(@as(isize, dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)), mode);
	1592	return syscall4(.openat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), @as(u32, @bitCast(flags)), mode);
1589	1593	}
1590	1594
1591	1595	/// See also `clone` (from the arch-specific include)
1592		pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: i32, child_tid: i32, newtls: usize) usize {
	1596	pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: pid_t, child_tid: pid_t, newtls: usize) usize {
1593	1597	return syscall5(.clone, flags, child_stack_ptr, @intFromPtr(parent_tid), @intFromPtr(child_tid), newtls);
1594	1598	}
1595	1599
...	...	@@ -1604,7 +1608,7 @@ pub fn set_tid_address(tidptr: ?*pid_t) pid_t {
1604	1608	}
1605	1609
1606	1610	pub fn close(fd: fd_t) usize {
1607		return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
	1611	return syscall1(.close, @as(u32, @bitCast(fd)));
1608	1612	}
1609	1613
1610	1614	pub const CLOSE_RANGE = packed struct(u32) {
...	...	@@ -1616,11 +1620,11 @@ pub const CLOSE_RANGE = packed struct(u32) {
1616	1620	};
1617	1621
1618	1622	pub fn close_range(first: fd_t, last: fd_t, flags: CLOSE_RANGE) usize {
1619		return syscall3(.close_range, fd_to_usize(first), fd_to_usize(last), @as(u32, @bitCast(flags)));
	1623	return syscall3(.close_range, @as(u32, @bitCast(first)), @as(u32, @bitCast(last)), @as(u32, @bitCast(flags)));
1620	1624	}
1621	1625
1622		pub fn fchmod(fd: i32, mode: mode_t) usize {
1623		return syscall2(.fchmod, @as(usize, @bitCast(@as(isize, fd))), mode);
	1626	pub fn fchmod(fd: fd_t, mode: mode_t) usize {
	1627	return syscall2(.fchmod, @as(u32, @bitCast(fd)), mode);
1624	1628	}
1625	1629
1626	1630	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 {
1631	1635	}
1632	1636	}
1633	1637
1634		pub fn fchown(fd: i32, owner: uid_t, group: gid_t) usize {
	1638	pub fn fchown(fd: fd_t, owner: uid_t, group: gid_t) usize {
1635	1639	if (@hasField(SYS, "fchown32")) {
1636		return syscall3(.fchown32, @as(usize, @bitCast(@as(isize, fd))), owner, group);
	1640	return syscall3(.fchown32, @as(u32, @bitCast(fd)), owner, group);
1637	1641	} else {
1638		return syscall3(.fchown, @as(usize, @bitCast(@as(isize, fd))), owner, group);
	1642	return syscall3(.fchown, @as(u32, @bitCast(fd)), owner, group);
1639	1643	}
1640	1644	}
1641	1645
1642		pub fn fchownat(fd: i32, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: u32) usize {
1643		return syscall5(.fchownat, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(path), owner, group, flags);
	1646	pub fn fchownat(fd: fd_t, path: [*:0]const u8, owner: uid_t, group: gid_t, flags: u32) usize {
	1647	return syscall5(.fchownat, @as(u32, @bitCast(fd)), @intFromPtr(path), owner, group, flags);
1644	1648	}
1645	1649
1646	1650	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 {
1663	1667	}
1664	1668	}
1665	1669
1666		pub fn fchmodat(fd: i32, path: [*:0]const u8, mode: mode_t) usize {
1667		return syscall3(.fchmodat, @bitCast(@as(isize, fd)), @intFromPtr(path), mode);
	1670	pub fn fchmodat(fd: fd_t, path: [*:0]const u8, mode: mode_t) usize {
	1671	return syscall3(.fchmodat, @as(u32, @bitCast(fd)), @intFromPtr(path), mode);
1668	1672	}
1669	1673
1670		pub fn fchmodat2(fd: i32, path: [*:0]const u8, mode: mode_t, flags: u32) usize {
1671		return syscall4(.fchmodat2, @bitCast(@as(isize, fd)), @intFromPtr(path), mode, flags);
	1674	pub fn fchmodat2(fd: fd_t, path: [*:0]const u8, mode: mode_t, flags: u32) usize {
	1675	return syscall4(.fchmodat2, @as(u32, @bitCast(fd)), @intFromPtr(path), mode, flags);
1672	1676	}
1673	1677
1674	1678	/// Can only be called on 32 bit systems. For 64 bit see `lseek`.
1675		pub fn llseek(fd: i32, offset: u64, result: ?*u64, whence: usize) usize {
	1679	pub fn llseek(fd: fd_t, offset: off_t, result: ?*off_t, whence: u32) usize {
1676	1680	// NOTE: The offset parameter splitting is independent from the target
1677	1681	// endianness.
1678	1682	return syscall5(
1679	1683	.llseek,
1680		@as(usize, @bitCast(@as(isize, fd))),
1681		@as(usize, @truncate(offset >> 32)),
1682		@as(usize, @truncate(offset)),
	1684	@as(u32, @bitCast(fd)),
	1685	@truncate(@as(u64, @bitCast(offset >> 32))),
	1686	@truncate(@as(u64, @bitCast(offset))),
1683	1687	@intFromPtr(result),
1684	1688	whence,
1685	1689	);
1686	1690	}
1687	1691
1688	1692	/// Can only be called on 64 bit systems. For 32 bit see `llseek`.
1689		pub fn lseek(fd: i32, offset: i64, whence: usize) usize {
1690		return syscall3(.lseek, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(offset)), whence);
	1693	pub fn lseek(fd: fd_t, offset: off_t, whence: u32) usize {
	1694	return syscall3(.lseek, @as(u32, @bitCast(fd)), @as(u64, @bitCast(offset)), whence);
1691	1695	}
1692	1696
1693	1697	pub fn exit(status: i32) noreturn {
1694		_ = syscall1(.exit, @as(usize, @bitCast(@as(isize, status))));
	1698	_ = syscall1(.exit, @as(u32, @bitCast(status)));
1695	1699	unreachable;
1696	1700	}
1697	1701
1698	1702	pub fn exit_group(status: i32) noreturn {
1699		_ = syscall1(.exit_group, @as(usize, @bitCast(@as(isize, status))));
	1703	_ = syscall1(.exit_group, @as(u32, @bitCast(status)));
1700	1704	unreachable;
1701	1705	}
1702	1706
...	...	@@ -1762,15 +1766,15 @@ pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize {
1762	1766	}
1763	1767
1764	1768	pub fn kill(pid: pid_t, sig: SIG) usize {
1765		return syscall2(.kill, @as(usize, @bitCast(@as(isize, pid))), @intFromEnum(sig));
	1769	return syscall2(.kill, @as(u32, @bitCast(pid)), @intFromEnum(sig));
1766	1770	}
1767	1771
1768	1772	pub fn tkill(tid: pid_t, sig: SIG) usize {
1769		return syscall2(.tkill, @as(usize, @bitCast(@as(isize, tid))), @intFromEnum(sig));
	1773	return syscall2(.tkill, @as(u32, @bitCast(tid)), @intFromEnum(sig));
1770	1774	}
1771	1775
1772	1776	pub fn tgkill(tgid: pid_t, tid: pid_t, sig: SIG) usize {
1773		return syscall3(.tgkill, @as(usize, @bitCast(@as(isize, tgid))), @as(usize, @bitCast(@as(isize, tid))), @intFromEnum(sig));
	1777	return syscall3(.tgkill, @as(u32, @bitCast(tgid)), @as(u32, @bitCast(tid)), @intFromEnum(sig));
1774	1778	}
1775	1779
1776	1780	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 {
1783	1787	} else {
1784	1788	return syscall5(
1785	1789	.linkat,
1786		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1790	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1787	1791	@intFromPtr(oldpath),
1788		@as(usize, @bitCast(@as(isize, AT.FDCWD))),
	1792	@as(u32, @bitCast(@as(i32, AT.FDCWD))),
1789	1793	@intFromPtr(newpath),
1790	1794	0,
1791	1795	);
...	...	@@ -1795,9 +1799,9 @@ pub fn link(oldpath: [:0]const u8, newpath: [:0]const u8) usize {
1795	1799	pub fn linkat(oldfd: fd_t, oldpath: [:0]const u8, newfd: fd_t, newpath: [:0]const u8, flags: u32) usize {
1796	1800	return syscall5(
1797	1801	.linkat,
1798		@as(usize, @bitCast(@as(isize, oldfd))),
	1802	@as(u32, @bitCast(oldfd)),
1799	1803	@intFromPtr(oldpath),
1800		@as(usize, @bitCast(@as(isize, newfd))),
	1804	@as(u32, @bitCast(newfd)),
1801	1805	@intFromPtr(newpath),
1802	1806	flags,
1803	1807	);
...	...	@@ -1807,33 +1811,33 @@ pub fn unlink(path: [*:0]const u8) usize {
1807	1811	if (@hasField(SYS, "unlink")) {
1808	1812	return syscall1(.unlink, @intFromPtr(path));
1809	1813	} else {
1810		return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, AT.FDCWD))), @intFromPtr(path), 0);
	1814	return syscall3(.unlinkat, @as(u32, @bitCast(@as(i32, AT.FDCWD))), @intFromPtr(path), 0);
1811	1815	}
1812	1816	}
1813	1817
1814		pub fn unlinkat(dirfd: i32, path: [*:0]const u8, flags: u32) usize {
1815		return syscall3(.unlinkat, @as(usize, @bitCast(@as(isize, dirfd))), @intFromPtr(path), flags);
	1818	pub fn unlinkat(dirfd: fd_t, path: [*:0]const u8, flags: u32) usize {
	1819	return syscall3(.unlinkat, @as(u32, @bitCast(dirfd)), @intFromPtr(path), flags);
1816	1820	}
1817	1821
1818		pub fn waitpid(pid: pid_t, status: *u32, flags: u32) usize {
1819		return syscall4(.wait4, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(status), flags, 0);
	1822	pub fn waitpid(pid: pid_t, status: *i32, flags: u32) usize {
	1823	return syscall4(.wait4, @as(u32, @bitCast(pid)), @intFromPtr(status), flags, 0);
1820	1824	}
1821	1825
1822		pub fn wait4(pid: pid_t, status: u32, flags: u32, usage: ?rusage) usize {
	1826	pub fn wait4(pid: pid_t, status: i32, flags: u32, usage: ?rusage) usize {
1823	1827	return syscall4(
1824	1828	.wait4,
1825		@as(usize, @bitCast(@as(isize, pid))),
	1829	@as(u32, @bitCast(pid)),
1826	1830	@intFromPtr(status),
1827	1831	flags,
1828	1832	@intFromPtr(usage),
1829	1833	);
1830	1834	}
1831	1835
1832		pub fn waitid(id_type: P, id: i32, infop: siginfo_t, flags: u32, usage: ?rusage) usize {
	1836	pub fn waitid(id_type: P, id: pid_t, infop: siginfo_t, flags: u32, usage: ?rusage) usize {
1833	1837	return syscall5(
1834	1838	.waitid,
1835	1839	@intFromEnum(id_type),
1836		@as(usize, @bitCast(@as(isize, id))),
	1840	@as(u32, @bitCast(id)),
1837	1841	@intFromPtr(infop),
1838	1842	flags,
1839	1843	@intFromPtr(usage),
...	...	@@ -1932,14 +1936,14 @@ pub const Flock = extern struct {
1932	1936
1933	1937	pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) usize {
1934	1938	if (@hasField(SYS, "fcntl64")) {
1935		return syscall3(.fcntl64, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg);
	1939	return syscall3(.fcntl64, @as(u32, @bitCast(fd)), @as(u32, @bitCast(cmd)), arg);
1936	1940	} else {
1937		return syscall3(.fcntl, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg);
	1941	return syscall3(.fcntl, @as(u32, @bitCast(fd)), @as(u32, @bitCast(cmd)), arg);
1938	1942	}
1939	1943	}
1940	1944
1941	1945	pub fn flock(fd: fd_t, operation: i32) usize {
1942		return syscall2(.flock, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, operation))));
	1946	return syscall2(.flock, @as(u32, @bitCast(fd)), @as(u32, @bitCast(operation)));
1943	1947	}
1944	1948
1945	1949	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 {
1979	1983	pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize {
1980	1984	return syscall2(
1981	1985	if (@hasField(SYS, "clock_getres") and native_arch != .hexagon) .clock_getres else .clock_getres_time64,
1982		@as(usize, @intFromEnum(clk_id)),
	1986	@intFromEnum(clk_id),
1983	1987	@intFromPtr(tp),
1984	1988	);
1985	1989	}
...	...	@@ -1987,7 +1991,7 @@ pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize {
1987	1991	pub fn clock_settime(clk_id: clockid_t, tp: *const timespec) usize {
1988	1992	return syscall2(
1989	1993	if (@hasField(SYS, "clock_settime") and native_arch != .hexagon) .clock_settime else .clock_settime64,
1990		@as(usize, @intFromEnum(clk_id)),
	1994	@intFromEnum(clk_id),
1991	1995	@intFromPtr(tp),
1992	1996	);
1993	1997	}
...	...	@@ -2141,11 +2145,11 @@ pub fn setresgid(rgid: gid_t, egid: gid_t, sgid: gid_t) usize {
2141	2145	}
2142	2146
2143	2147	pub fn setpgid(pid: pid_t, pgid: pid_t) usize {
2144		return syscall2(.setpgid, @intCast(pid), @intCast(pgid));
	2148	return syscall2(.setpgid, @as(u32, @bitCast(pid)), @as(u32, @bitCast(pgid)));
2145	2149	}
2146	2150
2147	2151	pub fn getpgid(pid: pid_t) usize {
2148		return syscall1(.getpgid, @intCast(pid));
	2152	return syscall1(.getpgid, @as(u32, @bitCast(pid)));
2149	2153	}
2150	2154
2151	2155	pub fn getgroups(size: usize, list: ?[*]gid_t) usize {
...	...	@@ -2169,7 +2173,7 @@ pub fn setsid() usize {
2169	2173	}
2170	2174
2171	2175	pub fn getsid(pid: pid_t) usize {
2172		return syscall1(.getsid, @intCast(pid));
	2176	return syscall1(.getsid, @as(u32, @bitCast(pid)));
2173	2177	}
2174	2178
2175	2179	pub fn getpid() pid_t {
...	...	@@ -2240,8 +2244,6 @@ pub fn sigaction(sig: SIG, noalias act: ?const Sigaction, noalias oact: ?Sigac
2240	2244	return 0;
2241	2245	}
2242	2246
2243		const usize_bits = @typeInfo(usize).int.bits;
2244
2245	2247	/// Defined as one greater than the largest defined signal number.
2246	2248	pub const NSIG = if (is_mips) 128 else 65;
2247	2249
...	...	@@ -2302,18 +2304,18 @@ pub fn sigismember(set: *const sigset_t, sig: SIG) bool {
2302	2304	return ((set.*)[index.word] & index.mask) != 0;
2303	2305	}
2304	2306
2305		pub fn getsockname(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
	2307	pub fn getsockname(fd: fd_t, noalias addr: sockaddr, noalias len: socklen_t) usize {
2306	2308	if (native_arch == .x86) {
2307		return socketcall(SC.getsockname, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len) });
	2309	return socketcall(SC.getsockname, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len) });
2308	2310	}
2309		return syscall3(.getsockname, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len));
	2311	return syscall3(.getsockname, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len));
2310	2312	}
2311	2313
2312		pub fn getpeername(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
	2314	pub fn getpeername(fd: fd_t, noalias addr: sockaddr, noalias len: socklen_t) usize {
2313	2315	if (native_arch == .x86) {
2314		return socketcall(SC.getpeername, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len) });
	2316	return socketcall(SC.getpeername, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len) });
2315	2317	}
2316		return syscall3(.getpeername, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len));
	2318	return syscall3(.getpeername, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len));
2317	2319	}
2318	2320
2319	2321	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 {
2323	2325	return syscall3(.socket, domain, socket_type, protocol);
2324	2326	}
2325	2327
2326		pub fn setsockopt(fd: i32, level: i32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
	2328	pub fn setsockopt(fd: fd_t, level: i32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
2327	2329	if (native_arch == .x86) {
2328		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)) });
	2330	return socketcall(SC.setsockopt, &[5]usize{ @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen)) });
2329	2331	}
2330		return syscall5(.setsockopt, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen)));
	2332	return syscall5(.setsockopt, @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @as(usize, @intCast(optlen)));
2331	2333	}
2332	2334
2333		pub fn getsockopt(fd: i32, level: i32, optname: u32, noalias optval: []u8, noalias optlen: socklen_t) usize {
	2335	pub fn getsockopt(fd: fd_t, level: i32, optname: u32, noalias optval: []u8, noalias optlen: socklen_t) usize {
2334	2336	if (native_arch == .x86) {
2335		return socketcall(SC.getsockopt, &[5]usize{ @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen) });
	2337	return socketcall(SC.getsockopt, &[5]usize{ @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen) });
2336	2338	}
2337		return syscall5(.getsockopt, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen));
	2339	return syscall5(.getsockopt, @as(u32, @bitCast(fd)), @as(usize, @bitCast(@as(isize, level))), optname, @intFromPtr(optval), @intFromPtr(optlen));
2338	2340	}
2339	2341
2340		pub fn sendmsg(fd: i32, msg: *const msghdr_const, flags: u32) usize {
2341		const fd_usize = @as(usize, @bitCast(@as(isize, fd)));
2342		const msg_usize = @intFromPtr(msg);
	2342	pub fn sendmsg(fd: fd_t, msg: *const msghdr_const, flags: u32) usize {
2343	2343	if (native_arch == .x86) {
2344		return socketcall(SC.sendmsg, &[3]usize{ fd_usize, msg_usize, flags });
	2344	return socketcall(SC.sendmsg, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(msg), flags });
2345	2345	} else {
2346		return syscall3(.sendmsg, fd_usize, msg_usize, flags);
	2346	return syscall3(.sendmsg, @as(u32, @bitCast(fd)), @intFromPtr(msg), flags);
2347	2347	}
2348	2348	}
2349	2349
2350		pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr, vlen: u32, flags: u32) usize {
2351		return syscall4(.sendmmsg, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(msgvec), vlen, flags);
	2350	pub fn sendmmsg(fd: fd_t, msgvec: [*]mmsghdr, vlen: u32, flags: u32) usize {
	2351	return syscall4(.sendmmsg, @as(u32, @bitCast(fd)), @intFromPtr(msgvec), vlen, flags);
2352	2352	}
2353	2353
2354		pub fn connect(fd: i32, addr: *const anyopaque, len: socklen_t) usize {
2355		const fd_usize = @as(usize, @bitCast(@as(isize, fd)));
2356		const addr_usize = @intFromPtr(addr);
	2354	pub fn connect(fd: fd_t, addr: *const anyopaque, len: socklen_t) usize {
2357	2355	if (native_arch == .x86) {
2358		return socketcall(SC.connect, &[3]usize{ fd_usize, addr_usize, len });
	2356	return socketcall(SC.connect, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), len });
2359	2357	} else {
2360		return syscall3(.connect, fd_usize, addr_usize, len);
	2358	return syscall3(.connect, @as(u32, @bitCast(fd)), @intFromPtr(addr), len);
2361	2359	}
2362	2360	}
2363	2361
2364		pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
2365		const fd_usize = @as(usize, @bitCast(@as(isize, fd)));
2366		const msg_usize = @intFromPtr(msg);
	2362	pub fn recvmsg(fd: fd_t, msg: *msghdr, flags: u32) usize {
2367	2363	if (native_arch == .x86) {
2368		return socketcall(SC.recvmsg, &[3]usize{ fd_usize, msg_usize, flags });
	2364	return socketcall(SC.recvmsg, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(msg), flags });
2369	2365	} else {
2370		return syscall3(.recvmsg, fd_usize, msg_usize, flags);
	2366	return syscall3(.recvmsg, @as(u32, @bitCast(fd)), @intFromPtr(msg), flags);
2371	2367	}
2372	2368	}
2373	2369
2374		pub fn recvmmsg(fd: i32, msgvec: ?[]mmsghdr, vlen: u32, flags: u32, timeout: ?timespec) usize {
	2370	pub fn recvmmsg(fd: fd_t, msgvec: ?[]mmsghdr, vlen: u32, flags: u32, timeout: ?timespec) usize {
2375	2371	return syscall5(
2376	2372	if (@hasField(SYS, "recvmmsg") and native_arch != .hexagon) .recvmmsg else .recvmmsg_time64,
2377		@as(usize, @bitCast(@as(isize, fd))),
	2373	@as(u32, @bitCast(fd)),
2378	2374	@intFromPtr(msgvec),
2379	2375	vlen,
2380	2376	flags,
...	...	@@ -2383,43 +2379,39 @@ pub fn recvmmsg(fd: i32, msgvec: ?[]mmsghdr, vlen: u32, flags: u32, timeout: ?
2383	2379	}
2384	2380
2385	2381	pub fn recvfrom(
2386		fd: i32,
	2382	fd: fd_t,
2387	2383	noalias buf: [*]u8,
2388	2384	len: usize,
2389	2385	flags: u32,
2390	2386	noalias addr: ?*sockaddr,
2391	2387	noalias alen: ?*socklen_t,
2392	2388	) usize {
2393		const fd_usize = @as(usize, @bitCast(@as(isize, fd)));
2394		const buf_usize = @intFromPtr(buf);
2395		const addr_usize = @intFromPtr(addr);
2396		const alen_usize = @intFromPtr(alen);
2397	2389	if (native_arch == .x86) {
2398		return socketcall(SC.recvfrom, &[6]usize{ fd_usize, buf_usize, len, flags, addr_usize, alen_usize });
	2390	return socketcall(SC.recvfrom, &[6]usize{ @as(u32, @bitCast(fd)), @intFromPtr(buf), len, flags, @intFromPtr(addr), @intFromPtr(alen) });
2399	2391	} else {
2400		return syscall6(.recvfrom, fd_usize, buf_usize, len, flags, addr_usize, alen_usize);
	2392	return syscall6(.recvfrom, @as(u32, @bitCast(fd)), @intFromPtr(buf), len, flags, @intFromPtr(addr), @intFromPtr(alen));
2401	2393	}
2402	2394	}
2403	2395
2404		pub fn shutdown(fd: i32, how: i32) usize {
	2396	pub fn shutdown(fd: fd_t, how: i32) usize {
2405	2397	if (native_arch == .x86) {
2406		return socketcall(SC.shutdown, &[2]usize{ @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, how))) });
	2398	return socketcall(SC.shutdown, &[2]usize{ @as(u32, @bitCast(fd)), @as(u32, @bitCast(how)) });
2407	2399	}
2408		return syscall2(.shutdown, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, how))));
	2400	return syscall2(.shutdown, @as(u32, @bitCast(fd)), @as(u32, @bitCast(how)));
2409	2401	}
2410	2402
2411		pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
	2403	pub fn bind(fd: fd_t, addr: *const sockaddr, len: socklen_t) usize {
2412	2404	if (native_arch == .x86) {
2413		return socketcall(SC.bind, &[3]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @as(usize, @intCast(len)) });
	2405	return socketcall(SC.bind, &[3]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), len });
2414	2406	}
2415		return syscall3(.bind, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @as(usize, @intCast(len)));
	2407	return syscall3(.bind, @as(u32, @bitCast(fd)), @intFromPtr(addr), len);
2416	2408	}
2417	2409
2418		pub fn listen(fd: i32, backlog: u32) usize {
	2410	pub fn listen(fd: fd_t, backlog: u32) usize {
2419	2411	if (native_arch == .x86) {
2420		return socketcall(SC.listen, &[2]usize{ @as(usize, @bitCast(@as(isize, fd))), backlog });
	2412	return socketcall(SC.listen, &[2]usize{ @as(u32, @bitCast(fd)), backlog });
2421	2413	}
2422		return syscall2(.listen, @as(usize, @bitCast(@as(isize, fd))), backlog);
	2414	return syscall2(.listen, @as(u32, @bitCast(fd)), backlog);
2423	2415	}
2424	2416
2425	2417	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
2429	2421	return syscall6(.sendto, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(buf), len, flags, @intFromPtr(addr), @as(usize, @intCast(alen)));
2430	2422	}
2431	2423
2432		pub fn sendfile(outfd: i32, infd: i32, offset: ?*i64, count: usize) usize {
2433		if (@hasField(SYS, "sendfile64")) {
2434		return syscall4(
2435		.sendfile64,
2436		@as(usize, @bitCast(@as(isize, outfd))),
2437		@as(usize, @bitCast(@as(isize, infd))),
2438		@intFromPtr(offset),
2439		count,
2440		);
2441		} else {
2442		return syscall4(
2443		.sendfile,
2444		@as(usize, @bitCast(@as(isize, outfd))),
2445		@as(usize, @bitCast(@as(isize, infd))),
2446		@intFromPtr(offset),
2447		count,
2448		);
2449		}
	2424	pub fn sendfile(outfd: fd_t, infd: fd_t, offset: ?*off_t, count: usize) usize {
	2425	return syscall4(
	2426	if (@hasField(SYS, "sendfile64")) .sendfile64 else .sendfile,
	2427	@as(u32, @bitCast(outfd)),
	2428	@as(u32, @bitCast(infd)),
	2429	@intFromPtr(offset),
	2430	count,
	2431	);
2450	2432	}
2451	2433
2452		pub fn socketpair(domain: u32, socket_type: u32, protocol: u32, fd: *[2]i32) usize {
	2434	pub fn socketpair(domain: u32, socket_type: u32, protocol: u32, fd: *[2]fd_t) usize {
2453	2435	if (native_arch == .x86) {
2454	2436	return socketcall(SC.socketpair, &[4]usize{ domain, socket_type, protocol, @intFromPtr(fd) });
2455	2437	}
2456	2438	return syscall4(.socketpair, domain, socket_type, protocol, @intFromPtr(fd));
2457	2439	}
2458	2440
2459		pub fn accept(fd: i32, noalias addr: ?sockaddr, noalias len: ?socklen_t) usize {
	2441	pub fn accept(fd: fd_t, noalias addr: ?sockaddr, noalias len: ?socklen_t) usize {
2460	2442	if (native_arch == .x86) {
2461		return socketcall(SC.accept, &[4]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), 0 });
	2443	return socketcall(SC.accept, &[4]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), 0 });
2462	2444	}
2463	2445	return accept4(fd, addr, len, 0);
2464	2446	}
2465	2447
2466		pub fn accept4(fd: i32, noalias addr: ?sockaddr, noalias len: ?socklen_t, flags: u32) usize {
	2448	pub fn accept4(fd: fd_t, noalias addr: ?sockaddr, noalias len: ?socklen_t, flags: u32) usize {
2467	2449	if (native_arch == .x86) {
2468		return socketcall(SC.accept4, &[4]usize{ @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), flags });
	2450	return socketcall(SC.accept4, &[4]usize{ @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), flags });
2469	2451	}
2470		return syscall4(.accept4, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(addr), @intFromPtr(len), flags);
	2452	return syscall4(.accept4, @as(u32, @bitCast(fd)), @intFromPtr(addr), @intFromPtr(len), flags);
2471	2453	}
2472	2454
2473		pub fn statx(dirfd: i32, path: [:0]const u8, flags: u32, mask: STATX, statx_buf: Statx) usize {
	2455	pub fn statx(dirfd: fd_t, path: [:0]const u8, flags: u32, mask: STATX, statx_buf: Statx) usize {
2474	2456	return syscall5(
2475	2457	.statx,
2476		@as(usize, @bitCast(@as(isize, dirfd))),
	2458	@as(u32, @bitCast(dirfd)),
2477	2459	@intFromPtr(path),
2478	2460	flags,
2479	2461	@as(u32, @bitCast(mask)),
...	...	@@ -2490,7 +2472,7 @@ pub fn llistxattr(path: [:0]const u8, list: []u8, size: usize) usize {
2490	2472	}
2491	2473
2492	2474	pub fn flistxattr(fd: fd_t, list: [*]u8, size: usize) usize {
2493		return syscall3(.flistxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(list), size);
	2475	return syscall3(.flistxattr, @as(u32, @bitCast(fd)), @intFromPtr(list), size);
2494	2476	}
2495	2477
2496	2478	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
2502	2484	}
2503	2485
2504	2486	pub fn fgetxattr(fd: fd_t, name: [:0]const u8, value: []u8, size: usize) usize {
2505		return syscall4(.fgetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size);
	2487	return syscall4(.fgetxattr, @as(u32, @bitCast(fd)), @intFromPtr(name), @intFromPtr(value), size);
2506	2488	}
2507	2489
2508	2490	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
2514	2496	}
2515	2497
2516	2498	pub fn fsetxattr(fd: fd_t, name: [:0]const u8, value: []const u8, size: usize, flags: usize) usize {
2517		return syscall5(.fsetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size, flags);
	2499	return syscall5(.fsetxattr, @as(u32, @bitCast(fd)), @intFromPtr(name), @intFromPtr(value), size, flags);
2518	2500	}
2519	2501
2520	2502	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 {
2525	2507	return syscall2(.lremovexattr, @intFromPtr(path), @intFromPtr(name));
2526	2508	}
2527	2509
2528		pub fn fremovexattr(fd: usize, name: [*:0]const u8) usize {
2529		return syscall2(.fremovexattr, fd, @intFromPtr(name));
	2510	pub fn fremovexattr(fd: fd_t, name: [*:0]const u8) usize {
	2511	return syscall2(.fremovexattr, @as(u32, @bitCast(fd)), @intFromPtr(name));
2530	2512	}
2531	2513
2532	2514	pub const sched_param = extern struct {
...	...	@@ -2556,27 +2538,27 @@ pub const SCHED = packed struct(i32) {
2556	2538	};
2557	2539
2558	2540	pub fn sched_setparam(pid: pid_t, param: *const sched_param) usize {
2559		return syscall2(.sched_setparam, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(param));
	2541	return syscall2(.sched_setparam, @as(u32, @bitCast(pid)), @intFromPtr(param));
2560	2542	}
2561	2543
2562	2544	pub fn sched_getparam(pid: pid_t, param: *sched_param) usize {
2563		return syscall2(.sched_getparam, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(param));
	2545	return syscall2(.sched_getparam, @as(u32, @bitCast(pid)), @intFromPtr(param));
2564	2546	}
2565	2547
2566	2548	pub fn sched_setscheduler(pid: pid_t, policy: SCHED, param: *const sched_param) usize {
2567		return syscall3(.sched_setscheduler, @as(usize, @bitCast(@as(isize, pid))), @intCast(@as(u32, @bitCast(policy))), @intFromPtr(param));
	2549	return syscall3(.sched_setscheduler, @as(u32, @bitCast(pid)), @as(u32, @bitCast(policy)), @intFromPtr(param));
2568	2550	}
2569	2551
2570	2552	pub fn sched_getscheduler(pid: pid_t) usize {
2571		return syscall1(.sched_getscheduler, @as(usize, @bitCast(@as(isize, pid))));
	2553	return syscall1(.sched_getscheduler, @as(u32, @bitCast(pid)));
2572	2554	}
2573	2555
2574	2556	pub fn sched_get_priority_max(policy: SCHED) usize {
2575		return syscall1(.sched_get_priority_max, @intCast(@as(u32, @bitCast(policy))));
	2557	return syscall1(.sched_get_priority_max, @as(u32, @bitCast(policy)));
2576	2558	}
2577	2559
2578	2560	pub fn sched_get_priority_min(policy: SCHED) usize {
2579		return syscall1(.sched_get_priority_min, @intCast(@as(u32, @bitCast(policy))));
	2561	return syscall1(.sched_get_priority_min, @as(u32, @bitCast(policy)));
2580	2562	}
2581	2563
2582	2564	pub fn getcpu(cpu: ?usize, node: ?usize) usize {
...	...	@@ -2595,24 +2577,24 @@ pub const sched_attr = extern struct {
2595	2577	period: u64 = 0,
2596	2578	};
2597	2579
2598		pub fn sched_setattr(pid: pid_t, attr: *const sched_attr, flags: usize) usize {
2599		return syscall3(.sched_setattr, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(attr), flags);
	2580	pub fn sched_setattr(pid: pid_t, attr: *const sched_attr, flags: u32) usize {
	2581	return syscall3(.sched_setattr, @as(u32, @bitCast(pid)), @intFromPtr(attr), flags);
2600	2582	}
2601	2583
2602		pub fn sched_getattr(pid: pid_t, attr: *sched_attr, size: usize, flags: usize) usize {
2603		return syscall4(.sched_getattr, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(attr), size, flags);
	2584	pub fn sched_getattr(pid: pid_t, attr: *sched_attr, size: u32, flags: u32) usize {
	2585	return syscall4(.sched_getattr, @as(u32, @bitCast(pid)), @intFromPtr(attr), size, flags);
2604	2586	}
2605	2587
2606	2588	pub fn sched_rr_get_interval(pid: pid_t, tp: *timespec) usize {
2607		return syscall2(.sched_rr_get_interval, @as(usize, @bitCast(@as(isize, pid))), @intFromPtr(tp));
	2589	return syscall2(.sched_rr_get_interval, @as(u32, @bitCast(pid)), @intFromPtr(tp));
2608	2590	}
2609	2591
2610	2592	pub fn sched_yield() usize {
2611	2593	return syscall0(.sched_yield);
2612	2594	}
2613	2595
2614		pub fn sched_getaffinity(pid: pid_t, size: usize, set: *cpu_set_t) usize {
2615		const rc = syscall3(.sched_getaffinity, @as(usize, @bitCast(@as(isize, pid))), size, @intFromPtr(set));
	2596	pub fn sched_getaffinity(pid: pid_t, size: u32, set: *cpu_set_t) usize {
	2597	const rc = syscall3(.sched_getaffinity, @as(u32, @bitCast(pid)), size, @intFromPtr(set));
2616	2598	if (@as(isize, @bitCast(rc)) < 0) return rc;
2617	2599	if (rc < size) @memset(@as([*]u8, @ptrCast(set))[rc..size], 0);
2618	2600	return 0;
...	...	@@ -2620,7 +2602,7 @@ pub fn sched_getaffinity(pid: pid_t, size: usize, set: *cpu_set_t) usize {
2620	2602
2621	2603	pub fn sched_setaffinity(pid: pid_t, set: *const cpu_set_t) !void {
2622	2604	const size = @sizeOf(cpu_set_t);
2623		const rc = syscall3(.sched_setaffinity, @as(usize, @bitCast(@as(isize, pid))), size, @intFromPtr(set));
	2605	const rc = syscall3(.sched_setaffinity, @as(u32, @bitCast(pid)), size, @intFromPtr(set));
2624	2606
2625	2607	switch (errno(rc)) {
2626	2608	.SUCCESS => return,
...	...	@@ -2632,25 +2614,25 @@ pub fn epoll_create() usize {
2632	2614	return epoll_create1(0);
2633	2615	}
2634	2616
2635		pub fn epoll_create1(flags: usize) usize {
	2617	pub fn epoll_create1(flags: u32) usize {
2636	2618	return syscall1(.epoll_create1, flags);
2637	2619	}
2638	2620
2639		pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: ?*epoll_event) usize {
2640		return syscall4(.epoll_ctl, @as(usize, @bitCast(@as(isize, epoll_fd))), @as(usize, @intCast(op)), @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(ev));
	2621	pub fn epoll_ctl(epoll_fd: fd_t, op: u32, fd: fd_t, ev: ?*epoll_event) usize {
	2622	return syscall4(.epoll_ctl, @as(u32, @bitCast(epoll_fd)), op, @as(u32, @bitCast(fd)), @intFromPtr(ev));
2641	2623	}
2642	2624
2643		pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32) usize {
	2625	pub fn epoll_wait(epoll_fd: fd_t, events: [*]epoll_event, maxevents: u32, timeout: i32) usize {
2644	2626	return epoll_pwait(epoll_fd, events, maxevents, timeout, null);
2645	2627	}
2646	2628
2647		pub fn epoll_pwait(epoll_fd: i32, events: []epoll_event, maxevents: u32, timeout: i32, sigmask: ?const sigset_t) usize {
	2629	pub fn epoll_pwait(epoll_fd: fd_t, events: []epoll_event, maxevents: u32, timeout: i32, sigmask: ?const sigset_t) usize {
2648	2630	return syscall6(
2649	2631	.epoll_pwait,
2650		@as(usize, @bitCast(@as(isize, epoll_fd))),
	2632	@as(u32, @bitCast(epoll_fd)),
2651	2633	@intFromPtr(events),
2652		@as(usize, @intCast(maxevents)),
2653		@as(usize, @bitCast(@as(isize, timeout))),
	2634	maxevents,
	2635	@as(u32, @bitCast(timeout)),
2654	2636	@intFromPtr(sigmask),
2655	2637	NSIG / 8,
2656	2638	);
...	...	@@ -2673,18 +2655,18 @@ pub const itimerspec = extern struct {
2673	2655	it_value: timespec,
2674	2656	};
2675	2657
2676		pub fn timerfd_gettime(fd: i32, curr_value: *itimerspec) usize {
	2658	pub fn timerfd_gettime(fd: fd_t, curr_value: *itimerspec) usize {
2677	2659	return syscall2(
2678	2660	if (@hasField(SYS, "timerfd_gettime") and native_arch != .hexagon) .timerfd_gettime else .timerfd_gettime64,
2679		@bitCast(@as(isize, fd)),
	2661	@as(u32, @bitCast(fd)),
2680	2662	@intFromPtr(curr_value),
2681	2663	);
2682	2664	}
2683	2665
2684		pub fn timerfd_settime(fd: i32, flags: TFD.TIMER, new_value: const itimerspec, old_value: ?itimerspec) usize {
	2666	pub fn timerfd_settime(fd: fd_t, flags: TFD.TIMER, new_value: const itimerspec, old_value: ?itimerspec) usize {
2685	2667	return syscall4(
2686	2668	if (@hasField(SYS, "timerfd_settime") and native_arch != .hexagon) .timerfd_settime else .timerfd_settime64,
2687		@bitCast(@as(isize, fd)),
	2669	@as(u32, @bitCast(fd)),
2688	2670	@as(u32, @bitCast(flags)),
2689	2671	@intFromPtr(new_value),
2690	2672	@intFromPtr(old_value),
...	...	@@ -2699,11 +2681,11 @@ pub const ITIMER = enum(i32) {
2699	2681	};
2700	2682
2701	2683	pub fn getitimer(which: i32, curr_value: *itimerspec) usize {
2702		return syscall2(.getitimer, @as(usize, @bitCast(@as(isize, which))), @intFromPtr(curr_value));
	2684	return syscall2(.getitimer, @as(u32, @bitCast(which)), @intFromPtr(curr_value));
2703	2685	}
2704	2686
2705	2687	pub fn setitimer(which: i32, new_value: const itimerspec, old_value: ?itimerspec) usize {
2706		return syscall3(.setitimer, @as(usize, @bitCast(@as(isize, which))), @intFromPtr(new_value), @intFromPtr(old_value));
	2688	return syscall3(.setitimer, @as(u32, @bitCast(which)), @intFromPtr(new_value), @intFromPtr(old_value));
2707	2689	}
2708	2690
2709	2691	pub fn unshare(flags: usize) usize {
...	...	@@ -2711,7 +2693,7 @@ pub fn unshare(flags: usize) usize {
2711	2693	}
2712	2694
2713	2695	pub fn setns(fd: fd_t, flags: u32) usize {
2714		return syscall2(.setns, @as(usize, @bitCast(@as(isize, fd))), flags);
	2696	return syscall2(.setns, @as(u32, @bitCast(fd)), flags);
2715	2697	}
2716	2698
2717	2699	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 {
2734	2716	return syscall2(.io_uring_setup, entries, @intFromPtr(p));
2735	2717	}
2736	2718
2737		pub fn io_uring_enter(fd: i32, to_submit: u32, min_complete: u32, flags: u32, sig: ?*sigset_t) usize {
2738		return syscall6(.io_uring_enter, @as(usize, @bitCast(@as(isize, fd))), to_submit, min_complete, flags, @intFromPtr(sig), NSIG / 8);
	2719	pub fn io_uring_enter(fd: fd_t, to_submit: u32, min_complete: u32, flags: u32, sig: ?*sigset_t) usize {
	2720	return syscall6(.io_uring_enter, @as(u32, @bitCast(fd)), to_submit, min_complete, flags, @intFromPtr(sig), NSIG / 8);
2739	2721	}
2740	2722
2741		pub fn io_uring_register(fd: i32, opcode: IORING_REGISTER, arg: ?*const anyopaque, nr_args: u32) usize {
2742		return syscall4(.io_uring_register, @as(usize, @bitCast(@as(isize, fd))), @intFromEnum(opcode), @intFromPtr(arg), nr_args);
	2723	pub fn io_uring_register(fd: fd_t, opcode: IORING_REGISTER, arg: ?*const anyopaque, nr_args: u32) usize {
	2724	return syscall4(.io_uring_register, @as(u32, @bitCast(fd)), @intFromEnum(opcode), @intFromPtr(arg), nr_args);
2743	2725	}
2744	2726
2745	2727	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 {
2747	2729	}
2748	2730
2749	2731	pub fn getrusage(who: i32, usage: *rusage) usize {
2750		return syscall2(.getrusage, @as(usize, @bitCast(@as(isize, who))), @intFromPtr(usage));
	2732	return syscall2(.getrusage, @as(u32, @bitCast(who)), @intFromPtr(usage));
2751	2733	}
2752	2734
2753	2735	pub fn tcgetattr(fd: fd_t, termios_p: *termios) usize {
2754		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CGETS, @intFromPtr(termios_p));
	2736	return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CGETS, @intFromPtr(termios_p));
2755	2737	}
2756	2738
2757	2739	pub fn tcsetattr(fd: fd_t, optional_action: TCSA, termios_p: *const termios) usize {
2758		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CSETS + @intFromEnum(optional_action), @intFromPtr(termios_p));
	2740	return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSETS + @intFromEnum(optional_action), @intFromPtr(termios_p));
2759	2741	}
2760	2742
2761	2743	pub fn tcgetpgrp(fd: fd_t, pgrp: *pid_t) usize {
2762		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.IOCGPGRP, @intFromPtr(pgrp));
	2744	return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.IOCGPGRP, @intFromPtr(pgrp));
2763	2745	}
2764	2746
2765	2747	pub fn tcsetpgrp(fd: fd_t, pgrp: *const pid_t) usize {
2766		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.IOCSPGRP, @intFromPtr(pgrp));
	2748	return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.IOCSPGRP, @intFromPtr(pgrp));
2767	2749	}
2768	2750
2769	2751	pub fn tcdrain(fd: fd_t) usize {
2770		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), T.CSBRK, 1);
	2752	return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSBRK, 1);
2771	2753	}
2772	2754
2773	2755	pub fn ioctl(fd: fd_t, request: u32, arg: usize) usize {
2774		return syscall3(.ioctl, @as(usize, @bitCast(@as(isize, fd))), request, arg);
	2756	return syscall3(.ioctl, @as(u32, @bitCast(fd)), request, arg);
2775	2757	}
2776	2758
2777	2759	pub fn signalfd(fd: fd_t, mask: *const sigset_t, flags: u32) usize {
2778		return syscall4(.signalfd4, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(mask), NSIG / 8, flags);
	2760	return syscall4(.signalfd4, @as(u32, @bitCast(fd)), @intFromPtr(mask), NSIG / 8, flags);
2779	2761	}
2780	2762
2781		pub fn copy_file_range(fd_in: fd_t, off_in: ?i64, fd_out: fd_t, off_out: ?i64, len: usize, flags: u32) usize {
	2763	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 {
2782	2764	return syscall6(
2783	2765	.copy_file_range,
2784		@as(usize, @bitCast(@as(isize, fd_in))),
	2766	@as(u32, @bitCast(fd_in)),
2785	2767	@intFromPtr(off_in),
2786		@as(usize, @bitCast(@as(isize, fd_out))),
	2768	@as(u32, @bitCast(fd_out)),
2787	2769	@intFromPtr(off_out),
2788	2770	len,
2789	2771	flags,
...	...	@@ -2799,19 +2781,19 @@ pub fn sync() void {
2799	2781	}
2800	2782
2801	2783	pub fn syncfs(fd: fd_t) usize {
2802		return syscall1(.syncfs, @as(usize, @bitCast(@as(isize, fd))));
	2784	return syscall1(.syncfs, @as(u32, @bitCast(fd)));
2803	2785	}
2804	2786
2805	2787	pub fn fsync(fd: fd_t) usize {
2806		return syscall1(.fsync, @as(usize, @bitCast(@as(isize, fd))));
	2788	return syscall1(.fsync, @as(u32, @bitCast(fd)));
2807	2789	}
2808	2790
2809	2791	pub fn fdatasync(fd: fd_t) usize {
2810		return syscall1(.fdatasync, @as(usize, @bitCast(@as(isize, fd))));
	2792	return syscall1(.fdatasync, @as(u32, @bitCast(fd)));
2811	2793	}
2812	2794
2813	2795	pub fn prctl(option: i32, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
2814		return syscall5(.prctl, @as(usize, @bitCast(@as(isize, option))), arg2, arg3, arg4, arg5);
	2796	return syscall5(.prctl, @as(u32, @bitCast(option)), arg2, arg3, arg4, arg5);
2815	2797	}
2816	2798
2817	2799	pub fn getrlimit(resource: rlimit_resource, rlim: *rlimit) usize {
...	...	@@ -2827,8 +2809,8 @@ pub fn setrlimit(resource: rlimit_resource, rlim: *const rlimit) usize {
2827	2809	pub fn prlimit(pid: pid_t, resource: rlimit_resource, new_limit: ?const rlimit, old_limit: ?rlimit) usize {
2828	2810	return syscall4(
2829	2811	.prlimit64,
2830		@as(usize, @bitCast(@as(isize, pid))),
2831		@as(usize, @bitCast(@as(isize, @intFromEnum(resource)))),
	2812	@as(u32, @bitCast(pid)),
	2813	@as(u32, @bitCast(@as(i32, @intFromEnum(resource)))),
2832	2814	@intFromPtr(new_limit),
2833	2815	@intFromPtr(old_limit),
2834	2816	);
...	...	@@ -2843,14 +2825,14 @@ pub fn madvise(address: [*]u8, len: usize, advice: u32) usize {
2843	2825	}
2844	2826
2845	2827	pub fn pidfd_open(pid: pid_t, flags: u32) usize {
2846		return syscall2(.pidfd_open, @as(usize, @bitCast(@as(isize, pid))), flags);
	2828	return syscall2(.pidfd_open, @as(u32, @bitCast(pid)), flags);
2847	2829	}
2848	2830
2849	2831	pub fn pidfd_getfd(pidfd: fd_t, targetfd: fd_t, flags: u32) usize {
2850	2832	return syscall3(
2851	2833	.pidfd_getfd,
2852		@as(usize, @bitCast(@as(isize, pidfd))),
2853		@as(usize, @bitCast(@as(isize, targetfd))),
	2834	@as(u32, @bitCast(pidfd)),
	2835	@as(u32, @bitCast(targetfd)),
2854	2836	flags,
2855	2837	);
2856	2838	}
...	...	@@ -2858,7 +2840,7 @@ pub fn pidfd_getfd(pidfd: fd_t, targetfd: fd_t, flags: u32) usize {
2858	2840	pub fn pidfd_send_signal(pidfd: fd_t, sig: SIG, info: ?*siginfo_t, flags: u32) usize {
2859	2841	return syscall4(
2860	2842	.pidfd_send_signal,
2861		@as(usize, @bitCast(@as(isize, pidfd))),
	2843	@as(u32, @bitCast(pidfd)),
2862	2844	@intFromEnum(sig),
2863	2845	@intFromPtr(info),
2864	2846	flags,
...	...	@@ -2868,7 +2850,7 @@ pub fn pidfd_send_signal(pidfd: fd_t, sig: SIG, info: ?*siginfo_t, flags: u32) u
2868	2850	pub fn process_vm_readv(pid: pid_t, local: []const iovec, remote: []const iovec_const, flags: usize) usize {
2869	2851	return syscall6(
2870	2852	.process_vm_readv,
2871		@as(usize, @bitCast(@as(isize, pid))),
	2853	@as(u32, @bitCast(pid)),
2872	2854	@intFromPtr(local.ptr),
2873	2855	local.len,
2874	2856	@intFromPtr(remote.ptr),
...	...	@@ -2880,7 +2862,7 @@ pub fn process_vm_readv(pid: pid_t, local: []const iovec, remote: []const iovec_
2880	2862	pub fn process_vm_writev(pid: pid_t, local: []const iovec_const, remote: []const iovec_const, flags: usize) usize {
2881	2863	return syscall6(
2882	2864	.process_vm_writev,
2883		@as(usize, @bitCast(@as(isize, pid))),
	2865	@as(u32, @bitCast(pid)),
2884	2866	@intFromPtr(local.ptr),
2885	2867	local.len,
2886	2868	@intFromPtr(remote.ptr),
...	...	@@ -2890,50 +2872,43 @@ pub fn process_vm_writev(pid: pid_t, local: []const iovec_const, remote: []const
2890	2872	}
2891	2873
2892	2874	pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
2893		if (comptime native_arch.isArm() or native_arch == .hexagon or native_arch.isPowerPC32()) {
2894		// These architectures reorder the arguments so that a register is not skipped to align the
2895		// register number that `offset` is passed in.
	2875	if (native_arch.isMIPS32()) {
	2876	// MIPS O32 weirdly differs from the other architectures that require
	2877	// aligned register pairs for this specific syscall.
2896	2878
2897	2879	const offset_halves = splitValue64(offset);
2898	2880	const length_halves = splitValue64(len);
2899	2881
2900		return syscall6(
2901		.fadvise64_64,
2902		@as(usize, @bitCast(@as(isize, fd))),
2903		advice,
	2882	return syscall7(
	2883	.fadvise64,
	2884	@as(u32, @bitCast(fd)),
	2885	0,
2904	2886	offset_halves[0],
2905	2887	offset_halves[1],
2906	2888	length_halves[0],
2907	2889	length_halves[1],
	2890	advice,
2908	2891	);
2909		} else if (native_arch.isMIPS32()) {
2910		// MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
2911
	2892	} else if (require_aligned_register_pair) {
2912	2893	const offset_halves = splitValue64(offset);
2913	2894	const length_halves = splitValue64(len);
2914	2895
2915		return syscall7(
2916		.fadvise64,
2917		@as(usize, @bitCast(@as(isize, fd))),
2918		0,
	2896	return syscall6(
	2897	.fadvise64_64,
	2898	@as(u32, @bitCast(fd)),
	2899	advice,
2919	2900	offset_halves[0],
2920	2901	offset_halves[1],
2921	2902	length_halves[0],
2922	2903	length_halves[1],
2923		advice,
2924	2904	);
2925		} else if (comptime usize_bits < 64) {
2926		// Other 32-bit architectures do not require register alignment.
2927
	2905	} else if (@sizeOf(syscall_arg_t) < @sizeOf(u64)) {
2928	2906	const offset_halves = splitValue64(offset);
2929	2907	const length_halves = splitValue64(len);
2930	2908
2931	2909	return syscall6(
2932		switch (builtin.abi) {
2933		.gnuabin32, .gnux32, .muslabin32, .muslx32 => .fadvise64,
2934		else => .fadvise64_64,
2935		},
2936		@as(usize, @bitCast(@as(isize, fd))),
	2910	.fadvise64_64,
	2911	@as(u32, @bitCast(fd)),
2937	2912	offset_halves[0],
2938	2913	offset_halves[1],
2939	2914	length_halves[0],
...	...	@@ -2941,14 +2916,11 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
2941	2916	advice,
2942	2917	);
2943	2918	} else {
2944		// On 64-bit architectures, fadvise64_64 and fadvise64 are the same. Generally, older ports
2945		// call it fadvise64 (x86, PowerPC, etc), while newer ports call it fadvise64_64 (RISC-V,
2946		// LoongArch, etc). SPARC is the odd one out because it has both.
2947	2919	return syscall4(
2948		if (@hasField(SYS, "fadvise64_64")) .fadvise64_64 else .fadvise64,
2949		@as(usize, @bitCast(@as(isize, fd))),
2950		@as(usize, @bitCast(offset)),
2951		@as(usize, @bitCast(len)),
	2920	.fadvise64,
	2921	@as(u32, @bitCast(fd)),
	2922	@as(u64, @bitCast(offset)),
	2923	@as(u64, @bitCast(len)),
2952	2924	advice,
2953	2925	);
2954	2926	}
...	...	@@ -2964,9 +2936,9 @@ pub fn perf_event_open(
2964	2936	return syscall5(
2965	2937	.perf_event_open,
2966	2938	@intFromPtr(attr),
2967		@as(usize, @bitCast(@as(isize, pid))),
2968		@as(usize, @bitCast(@as(isize, cpu))),
2969		@as(usize, @bitCast(@as(isize, group_fd))),
	2939	@as(u32, @bitCast(pid)),
	2940	@as(u32, @bitCast(cpu)),
	2941	@as(u32, @bitCast(group_fd)),
2970	2942	flags,
2971	2943	);
2972	2944	}
...	...	@@ -2985,7 +2957,7 @@ pub fn ptrace(
2985	2957	return syscall5(
2986	2958	.ptrace,
2987	2959	req,
2988		@as(usize, @bitCast(@as(isize, pid))),
	2960	@as(u32, @bitCast(pid)),
2989	2961	addr,
2990	2962	data,
2991	2963	addr2,
...	...	@@ -3007,14 +2979,14 @@ pub fn cachestat(
3007	2979	) usize {
3008	2980	return syscall4(
3009	2981	.cachestat,
3010		@as(usize, @bitCast(@as(isize, fd))),
	2982	@as(u32, @bitCast(fd)),
3011	2983	@intFromPtr(cstat_range),
3012	2984	@intFromPtr(cstat),
3013	2985	flags,
3014	2986	);
3015	2987	}
3016	2988
3017		pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
	2989	pub fn map_shadow_stack(addr: usize, size: usize, flags: u32) usize {
3018	2990	return syscall3(.map_shadow_stack, addr, size, flags);
3019	2991	}
3020	2992
...	...	@@ -3678,13 +3650,6 @@ pub const E = switch (native_arch) {
3678	3650	},
3679	3651	};
3680	3652
3681		pub const pid_t = i32;
3682		pub const fd_t = i32;
3683		pub const socket_t = i32;
3684		pub const uid_t = u32;
3685		pub const gid_t = u32;
3686		pub const clock_t = isize;
3687
3688	3653	pub const NAME_MAX = 255;
3689	3654	pub const PATH_MAX = 4096;
3690	3655	pub const IOV_MAX = 1024;
...	...	@@ -10176,7 +10141,3 @@ pub const cmsghdr = extern struct {
10176	10141	level: i32,
10177	10142	type: i32,
10178	10143	};
10179
10180		inline fn fd_to_usize(fd: fd_t) usize {
10181		return @as(usize, @bitCast(@as(isize, fd)));
10182		}

lib/std/os/linux/aarch64.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile ("svc #0"
7	11	: [ret] "={x0}" (-> u64),
8	12	: [number] "{x8}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u64) u64 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u64 {
13	20	return asm volatile ("svc #0"
14	21	: [ret] "={x0}" (-> u64),
15	22	: [number] "{x8}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u64 {
21	32	return asm volatile ("svc #0"
22	33	: [ret] "={x0}" (-> u64),
23	34	: [number] "{x8}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u64 {
30	46	return asm volatile ("svc #0"
31	47	: [ret] "={x0}" (-> u64),
32	48	: [number] "{x8}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u64 {
40	62	return asm volatile ("svc #0"
41	63	: [ret] "={x0}" (-> u64),
42	64	: [number] "{x8}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u64 {
51	80	return asm volatile ("svc #0"
52	81	: [ret] "={x0}" (-> u64),
53	82	: [number] "{x8}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u64,
65		arg2: u64,
66		arg3: u64,
67		arg4: u64,
68		arg5: u64,
69		arg6: u64,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u64 {
71	100	return asm volatile ("svc #0"
72	101	: [ret] "={x0}" (-> u64),

lib/std/os/linux/arc.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("trap_s 0"
7	11	: [ret] "={r0}" (-> u32),
8	12	: [number] "{r8}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("trap_s 0"
14	21	: [ret] "={r0}" (-> u32),
15	22	: [number] "{r8}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("trap_s 0"
22	33	: [ret] "={r0}" (-> u32),
23	34	: [number] "{r8}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("trap_s 0"
31	47	: [ret] "={r0}" (-> u32),
32	48	: [number] "{r8}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("trap_s 0"
41	63	: [ret] "={r0}" (-> u32),
42	64	: [number] "{r8}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("trap_s 0"
52	81	: [ret] "={r0}" (-> u32),
53	82	: [number] "{r8}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	return asm volatile ("trap_s 0"
72	101	: [ret] "={r0}" (-> u32),

lib/std/os/linux/arm.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("svc #0"
7	11	: [ret] "={r0}" (-> u32),
8	12	: [number] "{r7}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("svc #0"
14	21	: [ret] "={r0}" (-> u32),
15	22	: [number] "{r7}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("svc #0"
22	33	: [ret] "={r0}" (-> u32),
23	34	: [number] "{r7}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("svc #0"
31	47	: [ret] "={r0}" (-> u32),
32	48	: [number] "{r7}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("svc #0"
41	63	: [ret] "={r0}" (-> u32),
42	64	: [number] "{r7}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("svc #0"
52	81	: [ret] "={r0}" (-> u32),
53	82	: [number] "{r7}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	return asm volatile ("svc #0"
72	101	: [ret] "={r0}" (-> u32),

lib/std/os/linux/hexagon.zig+33-11

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("trap0(#1)"
7	11	: [ret] "={r0}" (-> u32),
8	12	: [number] "{r6}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("trap0(#1)"
14	21	: [ret] "={r0}" (-> u32),
15	22	: [number] "{r6}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("trap0(#1)"
22	33	: [ret] "={r0}" (-> u32),
23	34	: [number] "{r6}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("trap0(#1)"
31	47	: [ret] "={r0}" (-> u32),
32	48	: [number] "{r6}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("trap0(#1)"
41	63	: [ret] "={r0}" (-> u32),
42	64	: [number] "{r6}" (@intFromEnum(number)),
...	...	@@ -61,12 +83,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	83
62	84	pub fn syscall6(
63	85	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	86	arg1: syscall_arg_t,
	87	arg2: syscall_arg_t,
	88	arg3: syscall_arg_t,
	89	arg4: syscall_arg_t,
	90	arg5: syscall_arg_t,
	91	arg6: syscall_arg_t,
70	92	) u32 {
71	93	return asm volatile ("trap0(#1)"
72	94	: [ret] "={r0}" (-> u32),

lib/std/os/linux/loongarch32.zig+41-12

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile (
7	11	\\ syscall 0
8	12	: [ret] "={$r4}" (-> u32),
...	...	@@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u32 {
10	14	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
11	15	}
12	16
13		pub fn syscall1(number: SYS, arg1: u32) u32 {
	17	pub fn syscall1(
	18	number: SYS,
	19	arg1: syscall_arg_t,
	20	) u32 {
14	21	return asm volatile (
15	22	\\ syscall 0
16	23	: [ret] "={$r4}" (-> u32),
...	...	@@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
19	26	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
20	27	}
21	28
22		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	29	pub fn syscall2(
	30	number: SYS,
	31	arg1: syscall_arg_t,
	32	arg2: syscall_arg_t,
	33	) u32 {
23	34	return asm volatile (
24	35	\\ syscall 0
25	36	: [ret] "={$r4}" (-> u32),
...	...	@@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
29	40	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
30	41	}
31	42
32		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	43	pub fn syscall3(
	44	number: SYS,
	45	arg1: syscall_arg_t,
	46	arg2: syscall_arg_t,
	47	arg3: syscall_arg_t,
	48	) u32 {
33	49	return asm volatile (
34	50	\\ syscall 0
35	51	: [ret] "={$r4}" (-> u32),
...	...	@@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
40	56	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
41	57	}
42	58
43		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	59	pub fn syscall4(
	60	number: SYS,
	61	arg1: syscall_arg_t,
	62	arg2: syscall_arg_t,
	63	arg3: syscall_arg_t,
	64	arg4: syscall_arg_t,
	65	) u32 {
44	66	return asm volatile (
45	67	\\ syscall 0
46	68	: [ret] "={$r4}" (-> u32),
...	...	@@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
52	74	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
53	75	}
54	76
55		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	77	pub fn syscall5(
	78	number: SYS,
	79	arg1: syscall_arg_t,
	80	arg2: syscall_arg_t,
	81	arg3: syscall_arg_t,
	82	arg4: syscall_arg_t,
	83	arg5: syscall_arg_t,
	84	) u32 {
56	85	return asm volatile (
57	86	\\ syscall 0
58	87	: [ret] "={$r4}" (-> u32),
...	...	@@ -67,12 +96,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
67	96
68	97	pub fn syscall6(
69	98	number: SYS,
70		arg1: u32,
71		arg2: u32,
72		arg3: u32,
73		arg4: u32,
74		arg5: u32,
75		arg6: u32,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	arg6: syscall_arg_t,
76	105	) u32 {
77	106	return asm volatile (
78	107	\\ syscall 0

lib/std/os/linux/loongarch64.zig+41-12

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile (
7	11	\\ syscall 0
8	12	: [ret] "={$r4}" (-> u64),
...	...	@@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u64 {
10	14	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
11	15	}
12	16
13		pub fn syscall1(number: SYS, arg1: u64) u64 {
	17	pub fn syscall1(
	18	number: SYS,
	19	arg1: syscall_arg_t,
	20	) u64 {
14	21	return asm volatile (
15	22	\\ syscall 0
16	23	: [ret] "={$r4}" (-> u64),
...	...	@@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
19	26	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
20	27	}
21	28
22		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	29	pub fn syscall2(
	30	number: SYS,
	31	arg1: syscall_arg_t,
	32	arg2: syscall_arg_t,
	33	) u64 {
23	34	return asm volatile (
24	35	\\ syscall 0
25	36	: [ret] "={$r4}" (-> u64),
...	...	@@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
29	40	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
30	41	}
31	42
32		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	43	pub fn syscall3(
	44	number: SYS,
	45	arg1: syscall_arg_t,
	46	arg2: syscall_arg_t,
	47	arg3: syscall_arg_t,
	48	) u64 {
33	49	return asm volatile (
34	50	\\ syscall 0
35	51	: [ret] "={$r4}" (-> u64),
...	...	@@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
40	56	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
41	57	}
42	58
43		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	59	pub fn syscall4(
	60	number: SYS,
	61	arg1: syscall_arg_t,
	62	arg2: syscall_arg_t,
	63	arg3: syscall_arg_t,
	64	arg4: syscall_arg_t,
	65	) u64 {
44	66	return asm volatile (
45	67	\\ syscall 0
46	68	: [ret] "={$r4}" (-> u64),
...	...	@@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
52	74	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
53	75	}
54	76
55		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	77	pub fn syscall5(
	78	number: SYS,
	79	arg1: syscall_arg_t,
	80	arg2: syscall_arg_t,
	81	arg3: syscall_arg_t,
	82	arg4: syscall_arg_t,
	83	arg5: syscall_arg_t,
	84	) u64 {
56	85	return asm volatile (
57	86	\\ syscall 0
58	87	: [ret] "={$r4}" (-> u64),
...	...	@@ -67,12 +96,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
67	96
68	97	pub fn syscall6(
69	98	number: SYS,
70		arg1: u64,
71		arg2: u64,
72		arg3: u64,
73		arg4: u64,
74		arg5: u64,
75		arg6: u64,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	arg6: syscall_arg_t,
76	105	) u64 {
77	106	return asm volatile (
78	107	\\ syscall 0

lib/std/os/linux/m68k.zig+41-13

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("trap #0"
7	11	: [ret] "={d0}" (-> u32),
8	12	: [number] "{d0}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("trap #0"
14	21	: [ret] "={d0}" (-> u32),
15	22	: [number] "{d0}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("trap #0"
22	33	: [ret] "={d0}" (-> u32),
23	34	: [number] "{d0}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("trap #0"
31	47	: [ret] "={d0}" (-> u32),
32	48	: [number] "{d0}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("trap #0"
41	63	: [ret] "={d0}" (-> u32),
42	64	: [number] "{d0}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("trap #0"
52	81	: [ret] "={d0}" (-> u32),
53	82	: [number] "{d0}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	return asm volatile ("trap #0"
72	101	: [ret] "={d0}" (-> u32),
...	...	@@ -144,5 +173,4 @@ pub fn restore_rt() callconv(.naked) noreturn {
144	173
145	174	pub const time_t = i32;
146	175
147		// No VDSO used as of glibc 112a0ae18b831bf31f44d81b82666980312511d6.
148	176	pub const VDSO = void;

lib/std/os/linux/mips.zig+67-36

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile (
7	11	\\ syscall
8	12	\\ beq $a3, $zero, 1f
...	...	@@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u32 {
14	18	: .{ .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 });
15	19	}
16	20
17		pub fn syscall_pipe(fd: *[2]i32) u32 {
18		return asm volatile (
19		\\ syscall
20		\\ beq $a3, $zero, 1f
21		\\ blez $v0, 2f
22		\\ subu $v0, $zero, $v0
23		\\ b 2f
24		\\1:
25		\\ sw $v0, 0($a0)
26		\\ sw $v1, 4($a0)
27		\\2:
28		: [ret] "={$2}" (-> u32),
29		: [number] "{$2}" (@intFromEnum(SYS.pipe)),
30		[fd] "{$4}" (fd),
31		: .{ .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 });
32		}
33
34		pub fn syscall1(number: SYS, arg1: u32) u32 {
	21	pub fn syscall1(
	22	number: SYS,
	23	arg1: syscall_arg_t,
	24	) u32 {
35	25	return asm volatile (
36	26	\\ syscall
37	27	\\ beq $a3, $zero, 1f
...	...	@@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
44	34	: .{ .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 });
45	35	}
46	36
47		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	37	pub fn syscall2(
	38	number: SYS,
	39	arg1: syscall_arg_t,
	40	arg2: syscall_arg_t,
	41	) u32 {
48	42	return asm volatile (
49	43	\\ syscall
50	44	\\ beq $a3, $zero, 1f
...	...	@@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
58	52	: .{ .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 });
59	53	}
60	54
61		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	55	pub fn syscall3(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	) u32 {
62	61	return asm volatile (
63	62	\\ syscall
64	63	\\ beq $a3, $zero, 1f
...	...	@@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
73	72	: .{ .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 });
74	73	}
75	74
76		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	75	pub fn syscall4(
	76	number: SYS,
	77	arg1: syscall_arg_t,
	78	arg2: syscall_arg_t,
	79	arg3: syscall_arg_t,
	80	arg4: syscall_arg_t,
	81	) u32 {
77	82	return asm volatile (
78	83	\\ syscall
79	84	\\ beq $a3, $zero, 1f
...	...	@@ -92,7 +97,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
92	97	// NOTE: The o32 calling convention requires the callee to reserve 16 bytes for
93	98	// the first four arguments even though they're passed in $a0-$a3.
94	99
95		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	100	pub fn syscall5(
	101	number: SYS,
	102	arg1: syscall_arg_t,
	103	arg2: syscall_arg_t,
	104	arg3: syscall_arg_t,
	105	arg4: syscall_arg_t,
	106	arg5: syscall_arg_t,
	107	) u32 {
96	108	return asm volatile (
97	109	\\ subu $sp, $sp, 24
98	110	\\ sw %[arg5], 16($sp)
...	...	@@ -114,12 +126,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
114	126
115	127	pub fn syscall6(
116	128	number: SYS,
117		arg1: u32,
118		arg2: u32,
119		arg3: u32,
120		arg4: u32,
121		arg5: u32,
122		arg6: u32,
	129	arg1: syscall_arg_t,
	130	arg2: syscall_arg_t,
	131	arg3: syscall_arg_t,
	132	arg4: syscall_arg_t,
	133	arg5: syscall_arg_t,
	134	arg6: syscall_arg_t,
123	135	) u32 {
124	136	return asm volatile (
125	137	\\ subu $sp, $sp, 24
...	...	@@ -144,13 +156,13 @@ pub fn syscall6(
144	156
145	157	pub fn syscall7(
146	158	number: SYS,
147		arg1: u32,
148		arg2: u32,
149		arg3: u32,
150		arg4: u32,
151		arg5: u32,
152		arg6: u32,
153		arg7: u32,
	159	arg1: syscall_arg_t,
	160	arg2: syscall_arg_t,
	161	arg3: syscall_arg_t,
	162	arg4: syscall_arg_t,
	163	arg5: syscall_arg_t,
	164	arg6: syscall_arg_t,
	165	arg7: syscall_arg_t,
154	166	) u32 {
155	167	return asm volatile (
156	168	\\ subu $sp, $sp, 32
...	...	@@ -175,6 +187,25 @@ pub fn syscall7(
175	187	: .{ .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 });
176	188	}
177	189
	190	pub fn syscall_pipe(
	191	fd: *[2]std.os.linux.fd_t,
	192	) u32 {
	193	return asm volatile (
	194	\\ syscall
	195	\\ beq $a3, $zero, 1f
	196	\\ blez $v0, 2f
	197	\\ subu $v0, $zero, $v0
	198	\\ b 2f
	199	\\1:
	200	\\ sw $v0, 0($a0)
	201	\\ sw $v1, 4($a0)
	202	\\2:
	203	: [ret] "={$2}" (-> u32),
	204	: [number] "{$2}" (@intFromEnum(SYS.pipe)),
	205	[fd] "{$4}" (fd),
	206	: .{ .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 });
	207	}
	208
178	209	pub fn clone() callconv(.naked) u32 {
179	210	// __clone(func, stack, flags, arg, ptid, tls, ctid)
180	211	// a0, a1, a2, a3, +0, +4, +8

lib/std/os/linux/mips64.zig+60-29

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile (
7	11	\\ syscall
8	12	\\ beq $a3, $zero, 1f
...	...	@@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u64 {
14	18	: .{ .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 });
15	19	}
16	20
17		pub fn syscall_pipe(fd: *[2]i32) u64 {
18		return asm volatile (
19		\\ syscall
20		\\ beq $a3, $zero, 1f
21		\\ blez $v0, 2f
22		\\ dsubu $v0, $zero, $v0
23		\\ b 2f
24		\\1:
25		\\ sw $v0, 0($a0)
26		\\ sw $v1, 4($a0)
27		\\2:
28		: [ret] "={$2}" (-> u64),
29		: [number] "{$2}" (@intFromEnum(SYS.pipe)),
30		[fd] "{$4}" (fd),
31		: .{ .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 });
32		}
33
34		pub fn syscall1(number: SYS, arg1: u64) u64 {
	21	pub fn syscall1(
	22	number: SYS,
	23	arg1: syscall_arg_t,
	24	) u64 {
35	25	return asm volatile (
36	26	\\ syscall
37	27	\\ beq $a3, $zero, 1f
...	...	@@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
44	34	: .{ .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 });
45	35	}
46	36
47		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	37	pub fn syscall2(
	38	number: SYS,
	39	arg1: syscall_arg_t,
	40	arg2: syscall_arg_t,
	41	) u64 {
48	42	return asm volatile (
49	43	\\ syscall
50	44	\\ beq $a3, $zero, 1f
...	...	@@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
58	52	: .{ .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 });
59	53	}
60	54
61		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	55	pub fn syscall3(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	) u64 {
62	61	return asm volatile (
63	62	\\ syscall
64	63	\\ beq $a3, $zero, 1f
...	...	@@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
73	72	: .{ .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 });
74	73	}
75	74
76		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	75	pub fn syscall4(
	76	number: SYS,
	77	arg1: syscall_arg_t,
	78	arg2: syscall_arg_t,
	79	arg3: syscall_arg_t,
	80	arg4: syscall_arg_t,
	81	) u64 {
77	82	return asm volatile (
78	83	\\ syscall
79	84	\\ beq $a3, $zero, 1f
...	...	@@ -89,7 +94,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
89	94	: .{ .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 });
90	95	}
91	96
92		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	97	pub fn syscall5(
	98	number: SYS,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	) u64 {
93	105	return asm volatile (
94	106	\\ syscall
95	107	\\ beq $a3, $zero, 1f
...	...	@@ -108,12 +120,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
108	120
109	121	pub fn syscall6(
110	122	number: SYS,
111		arg1: u64,
112		arg2: u64,
113		arg3: u64,
114		arg4: u64,
115		arg5: u64,
116		arg6: u64,
	123	arg1: syscall_arg_t,
	124	arg2: syscall_arg_t,
	125	arg3: syscall_arg_t,
	126	arg4: syscall_arg_t,
	127	arg5: syscall_arg_t,
	128	arg6: syscall_arg_t,
117	129	) u64 {
118	130	return asm volatile (
119	131	\\ syscall
...	...	@@ -132,6 +144,25 @@ pub fn syscall6(
132	144	: .{ .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 });
133	145	}
134	146
	147	pub fn syscall_pipe(
	148	fd: *[2]std.os.linux.fd_t,
	149	) u64 {
	150	return asm volatile (
	151	\\ syscall
	152	\\ beq $a3, $zero, 1f
	153	\\ blez $v0, 2f
	154	\\ dsubu $v0, $zero, $v0
	155	\\ b 2f
	156	\\1:
	157	\\ sw $v0, 0($a0)
	158	\\ sw $v1, 4($a0)
	159	\\2:
	160	: [ret] "={$2}" (-> u64),
	161	: [number] "{$2}" (@intFromEnum(SYS.pipe)),
	162	[fd] "{$4}" (fd),
	163	: .{ .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 });
	164	}
	165
135	166	pub fn clone() callconv(.naked) u64 {
136	167	// __clone(func, stack, flags, arg, ptid, tls, ctid)
137	168	// a0, a1, a2, a3, a4, a5, a6

lib/std/os/linux/mipsn32.zig+60-29

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile (
7	11	\\ syscall
8	12	\\ beq $a3, $zero, 1f
...	...	@@ -14,24 +18,10 @@ pub fn syscall0(number: SYS) u32 {
14	18	: .{ .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 });
15	19	}
16	20
17		pub fn syscall_pipe(fd: *[2]i32) u32 {
18		return asm volatile (
19		\\ syscall
20		\\ beq $a3, $zero, 1f
21		\\ blez $v0, 2f
22		\\ subu $v0, $zero, $v0
23		\\ b 2f
24		\\1:
25		\\ sw $v0, 0($a0)
26		\\ sw $v1, 4($a0)
27		\\2:
28		: [ret] "={$2}" (-> u32),
29		: [number] "{$2}" (@intFromEnum(SYS.pipe)),
30		[fd] "{$4}" (fd),
31		: .{ .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 });
32		}
33
34		pub fn syscall1(number: SYS, arg1: u32) u32 {
	21	pub fn syscall1(
	22	number: SYS,
	23	arg1: syscall_arg_t,
	24	) u32 {
35	25	return asm volatile (
36	26	\\ syscall
37	27	\\ beq $a3, $zero, 1f
...	...	@@ -44,7 +34,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
44	34	: .{ .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 });
45	35	}
46	36
47		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	37	pub fn syscall2(
	38	number: SYS,
	39	arg1: syscall_arg_t,
	40	arg2: syscall_arg_t,
	41	) u32 {
48	42	return asm volatile (
49	43	\\ syscall
50	44	\\ beq $a3, $zero, 1f
...	...	@@ -58,7 +52,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
58	52	: .{ .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 });
59	53	}
60	54
61		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	55	pub fn syscall3(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	) u32 {
62	61	return asm volatile (
63	62	\\ syscall
64	63	\\ beq $a3, $zero, 1f
...	...	@@ -73,7 +72,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
73	72	: .{ .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 });
74	73	}
75	74
76		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	75	pub fn syscall4(
	76	number: SYS,
	77	arg1: syscall_arg_t,
	78	arg2: syscall_arg_t,
	79	arg3: syscall_arg_t,
	80	arg4: syscall_arg_t,
	81	) u32 {
77	82	return asm volatile (
78	83	\\ syscall
79	84	\\ beq $a3, $zero, 1f
...	...	@@ -89,7 +94,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
89	94	: .{ .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 });
90	95	}
91	96
92		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	97	pub fn syscall5(
	98	number: SYS,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	) u32 {
93	105	return asm volatile (
94	106	\\ syscall
95	107	\\ beq $a3, $zero, 1f
...	...	@@ -108,12 +120,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
108	120
109	121	pub fn syscall6(
110	122	number: SYS,
111		arg1: u32,
112		arg2: u32,
113		arg3: u32,
114		arg4: u32,
115		arg5: u32,
116		arg6: u32,
	123	arg1: syscall_arg_t,
	124	arg2: syscall_arg_t,
	125	arg3: syscall_arg_t,
	126	arg4: syscall_arg_t,
	127	arg5: syscall_arg_t,
	128	arg6: syscall_arg_t,
117	129	) u32 {
118	130	return asm volatile (
119	131	\\ syscall
...	...	@@ -132,6 +144,25 @@ pub fn syscall6(
132	144	: .{ .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 });
133	145	}
134	146
	147	pub fn syscall_pipe(
	148	fd: *[2]std.os.linux.fd_t,
	149	) u32 {
	150	return asm volatile (
	151	\\ syscall
	152	\\ beq $a3, $zero, 1f
	153	\\ blez $v0, 2f
	154	\\ subu $v0, $zero, $v0
	155	\\ b 2f
	156	\\1:
	157	\\ sw $v0, 0($a0)
	158	\\ sw $v1, 4($a0)
	159	\\2:
	160	: [ret] "={$2}" (-> u32),
	161	: [number] "{$2}" (@intFromEnum(SYS.pipe)),
	162	[fd] "{$4}" (fd),
	163	: .{ .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 });
	164	}
	165
135	166	pub fn clone() callconv(.naked) u32 {
136	167	// __clone(func, stack, flags, arg, ptid, tls, ctid)
137	168	// a0, a1, a2, a3, a4, a5, a6

lib/std/os/linux/or1k.zig+41-12

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile (
7	11	\\ l.sys 1
8	12	: [ret] "={r11}" (-> u32),
...	...	@@ -10,7 +14,10 @@ pub fn syscall0(number: SYS) u32 {
10	14	: .{ .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 });
11	15	}
12	16
13		pub fn syscall1(number: SYS, arg1: u32) u32 {
	17	pub fn syscall1(
	18	number: SYS,
	19	arg1: syscall_arg_t,
	20	) u32 {
14	21	return asm volatile (
15	22	\\ l.sys 1
16	23	: [ret] "={r11}" (-> u32),
...	...	@@ -19,7 +26,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
19	26	: .{ .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 });
20	27	}
21	28
22		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	29	pub fn syscall2(
	30	number: SYS,
	31	arg1: syscall_arg_t,
	32	arg2: syscall_arg_t,
	33	) u32 {
23	34	return asm volatile (
24	35	\\ l.sys 1
25	36	: [ret] "={r11}" (-> u32),
...	...	@@ -29,7 +40,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
29	40	: .{ .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 });
30	41	}
31	42
32		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	43	pub fn syscall3(
	44	number: SYS,
	45	arg1: syscall_arg_t,
	46	arg2: syscall_arg_t,
	47	arg3: syscall_arg_t,
	48	) u32 {
33	49	return asm volatile (
34	50	\\ l.sys 1
35	51	: [ret] "={r11}" (-> u32),
...	...	@@ -40,7 +56,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
40	56	: .{ .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 });
41	57	}
42	58
43		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	59	pub fn syscall4(
	60	number: SYS,
	61	arg1: syscall_arg_t,
	62	arg2: syscall_arg_t,
	63	arg3: syscall_arg_t,
	64	arg4: syscall_arg_t,
	65	) u32 {
44	66	return asm volatile (
45	67	\\ l.sys 1
46	68	: [ret] "={r11}" (-> u32),
...	...	@@ -52,7 +74,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
52	74	: .{ .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 });
53	75	}
54	76
55		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	77	pub fn syscall5(
	78	number: SYS,
	79	arg1: syscall_arg_t,
	80	arg2: syscall_arg_t,
	81	arg3: syscall_arg_t,
	82	arg4: syscall_arg_t,
	83	arg5: syscall_arg_t,
	84	) u32 {
56	85	return asm volatile (
57	86	\\ l.sys 1
58	87	: [ret] "={r11}" (-> u32),
...	...	@@ -67,12 +96,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
67	96
68	97	pub fn syscall6(
69	98	number: SYS,
70		arg1: u32,
71		arg2: u32,
72		arg3: u32,
73		arg4: u32,
74		arg5: u32,
75		arg6: u32,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	arg6: syscall_arg_t,
76	105	) u32 {
77	106	return asm volatile (
78	107	\\ l.sys 1

lib/std/os/linux/powerpc.zig+41-12

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	// r0 is both an input register and a clobber. musl and glibc achieve this with
7	11	// a "+" constraint, which isn't supported in Zig, so instead we separately list
8	12	// 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 {
19	23	: .{ .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 });
20	24	}
21	25
22		pub fn syscall1(number: SYS, arg1: u32) u32 {
	26	pub fn syscall1(
	27	number: SYS,
	28	arg1: syscall_arg_t,
	29	) u32 {
23	30	// r0 is both an input and a clobber.
24	31	var r0_out: u32 = undefined;
25	32	return asm volatile (
...	...	@@ -34,7 +41,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
34	41	: .{ .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 });
35	42	}
36	43
37		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	44	pub fn syscall2(
	45	number: SYS,
	46	arg1: syscall_arg_t,
	47	arg2: syscall_arg_t,
	48	) u32 {
38	49	// These registers are both inputs and clobbers.
39	50	var r0_out: u32 = undefined;
40	51	var r4_out: u32 = undefined;
...	...	@@ -52,7 +63,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
52	63	: .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
53	64	}
54	65
55		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	66	pub fn syscall3(
	67	number: SYS,
	68	arg1: syscall_arg_t,
	69	arg2: syscall_arg_t,
	70	arg3: syscall_arg_t,
	71	) u32 {
56	72	// These registers are both inputs and clobbers.
57	73	var r0_out: u32 = undefined;
58	74	var r4_out: u32 = undefined;
...	...	@@ -73,7 +89,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
73	89	: .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
74	90	}
75	91
76		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	92	pub fn syscall4(
	93	number: SYS,
	94	arg1: syscall_arg_t,
	95	arg2: syscall_arg_t,
	96	arg3: syscall_arg_t,
	97	arg4: syscall_arg_t,
	98	) u32 {
77	99	// These registers are both inputs and clobbers.
78	100	var r0_out: u32 = undefined;
79	101	var r4_out: u32 = undefined;
...	...	@@ -97,7 +119,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
97	119	: .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
98	120	}
99	121
100		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	122	pub fn syscall5(
	123	number: SYS,
	124	arg1: syscall_arg_t,
	125	arg2: syscall_arg_t,
	126	arg3: syscall_arg_t,
	127	arg4: syscall_arg_t,
	128	arg5: syscall_arg_t,
	129	) u32 {
101	130	// These registers are both inputs and clobbers.
102	131	var r0_out: u32 = undefined;
103	132	var r4_out: u32 = undefined;
...	...	@@ -126,12 +155,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
126	155
127	156	pub fn syscall6(
128	157	number: SYS,
129		arg1: u32,
130		arg2: u32,
131		arg3: u32,
132		arg4: u32,
133		arg5: u32,
134		arg6: u32,
	158	arg1: syscall_arg_t,
	159	arg2: syscall_arg_t,
	160	arg3: syscall_arg_t,
	161	arg4: syscall_arg_t,
	162	arg5: syscall_arg_t,
	163	arg6: syscall_arg_t,
135	164	) u32 {
136	165	// These registers are both inputs and clobbers.
137	166	var r0_out: u32 = undefined;

lib/std/os/linux/powerpc64.zig+41-12

...	...	@@ -2,7 +2,11 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	// r0 is both an input register and a clobber. musl and glibc achieve this with
7	11	// a "+" constraint, which isn't supported in Zig, so instead we separately list
8	12	// 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 {
19	23	: .{ .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 });
20	24	}
21	25
22		pub fn syscall1(number: SYS, arg1: u64) u64 {
	26	pub fn syscall1(
	27	number: SYS,
	28	arg1: syscall_arg_t,
	29	) u64 {
23	30	// r0 is both an input and a clobber.
24	31	var r0_out: u64 = undefined;
25	32	return asm volatile (
...	...	@@ -34,7 +41,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
34	41	: .{ .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 });
35	42	}
36	43
37		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	44	pub fn syscall2(
	45	number: SYS,
	46	arg1: syscall_arg_t,
	47	arg2: syscall_arg_t,
	48	) u64 {
38	49	// These registers are both inputs and clobbers.
39	50	var r0_out: u64 = undefined;
40	51	var r4_out: u64 = undefined;
...	...	@@ -52,7 +63,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
52	63	: .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
53	64	}
54	65
55		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	66	pub fn syscall3(
	67	number: SYS,
	68	arg1: syscall_arg_t,
	69	arg2: syscall_arg_t,
	70	arg3: syscall_arg_t,
	71	) u64 {
56	72	// These registers are both inputs and clobbers.
57	73	var r0_out: u64 = undefined;
58	74	var r4_out: u64 = undefined;
...	...	@@ -73,7 +89,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
73	89	: .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
74	90	}
75	91
76		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	92	pub fn syscall4(
	93	number: SYS,
	94	arg1: syscall_arg_t,
	95	arg2: syscall_arg_t,
	96	arg3: syscall_arg_t,
	97	arg4: syscall_arg_t,
	98	) u64 {
77	99	// These registers are both inputs and clobbers.
78	100	var r0_out: u64 = undefined;
79	101	var r4_out: u64 = undefined;
...	...	@@ -97,7 +119,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
97	119	: .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
98	120	}
99	121
100		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	122	pub fn syscall5(
	123	number: SYS,
	124	arg1: syscall_arg_t,
	125	arg2: syscall_arg_t,
	126	arg3: syscall_arg_t,
	127	arg4: syscall_arg_t,
	128	arg5: syscall_arg_t,
	129	) u64 {
101	130	// These registers are both inputs and clobbers.
102	131	var r0_out: u64 = undefined;
103	132	var r4_out: u64 = undefined;
...	...	@@ -126,12 +155,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
126	155
127	156	pub fn syscall6(
128	157	number: SYS,
129		arg1: u64,
130		arg2: u64,
131		arg3: u64,
132		arg4: u64,
133		arg5: u64,
134		arg6: u64,
	158	arg1: syscall_arg_t,
	159	arg2: syscall_arg_t,
	160	arg3: syscall_arg_t,
	161	arg4: syscall_arg_t,
	162	arg5: syscall_arg_t,
	163	arg6: syscall_arg_t,
135	164	) u64 {
136	165	// These registers are both inputs and clobbers.
137	166	var r0_out: u64 = undefined;

lib/std/os/linux/riscv32.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("ecall"
7	11	: [ret] "={x10}" (-> u32),
8	12	: [number] "{x17}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("ecall"
14	21	: [ret] "={x10}" (-> u32),
15	22	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("ecall"
22	33	: [ret] "={x10}" (-> u32),
23	34	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("ecall"
31	47	: [ret] "={x10}" (-> u32),
32	48	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("ecall"
41	63	: [ret] "={x10}" (-> u32),
42	64	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("ecall"
52	81	: [ret] "={x10}" (-> u32),
53	82	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	return asm volatile ("ecall"
72	101	: [ret] "={x10}" (-> u32),

lib/std/os/linux/riscv64.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile ("ecall"
7	11	: [ret] "={x10}" (-> u64),
8	12	: [number] "{x17}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u64) u64 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u64 {
13	20	return asm volatile ("ecall"
14	21	: [ret] "={x10}" (-> u64),
15	22	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u64 {
21	32	return asm volatile ("ecall"
22	33	: [ret] "={x10}" (-> u64),
23	34	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u64 {
30	46	return asm volatile ("ecall"
31	47	: [ret] "={x10}" (-> u64),
32	48	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u64 {
40	62	return asm volatile ("ecall"
41	63	: [ret] "={x10}" (-> u64),
42	64	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u64 {
51	80	return asm volatile ("ecall"
52	81	: [ret] "={x10}" (-> u64),
53	82	: [number] "{x17}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u64,
65		arg2: u64,
66		arg3: u64,
67		arg4: u64,
68		arg5: u64,
69		arg6: u64,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u64 {
71	100	return asm volatile ("ecall"
72	101	: [ret] "={x10}" (-> u64),

lib/std/os/linux/s390x.zig+44-7

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile ("svc 0"
7	11	: [ret] "={r2}" (-> u64),
8	12	: [number] "{r1}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u64) u64 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u64 {
13	20	return asm volatile ("svc 0"
14	21	: [ret] "={r2}" (-> u64),
15	22	: [number] "{r1}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u64 {
21	32	return asm volatile ("svc 0"
22	33	: [ret] "={r2}" (-> u64),
23	34	: [number] "{r1}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u64 {
30	46	return asm volatile ("svc 0"
31	47	: [ret] "={r2}" (-> u64),
32	48	: [number] "{r1}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u64 {
40	62	return asm volatile ("svc 0"
41	63	: [ret] "={r2}" (-> u64),
42	64	: [number] "{r1}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u64 {
51	80	return asm volatile ("svc 0"
52	81	: [ret] "={r2}" (-> u64),
53	82	: [number] "{r1}" (@intFromEnum(number)),
...	...	@@ -59,7 +88,15 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
59	88	: .{ .memory = true });
60	89	}
61	90
62		pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
	91	pub fn syscall6(
	92	number: SYS,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
	99	) u64 {
63	100	return asm volatile ("svc 0"
64	101	: [ret] "={r2}" (-> u64),
65	102	: [number] "{r1}" (@intFromEnum(number)),

lib/std/os/linux/sparc64.zig+83-52

...	...	@@ -2,49 +2,26 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall_pipe(fd: *[2]i32) u64 {
6		return asm volatile (
7		\\ mov %[arg], %%g3
8		\\ t 0x6d
9		\\ bcc,pt %%xcc, 1f
10		\\ nop
11		\\ # Return the error code
12		\\ ba 2f
13		\\ neg %%o0
14		\\1:
15		\\ st %%o0, [%%g3+0]
16		\\ st %%o1, [%%g3+4]
17		\\ clr %%o0
18		\\2:
19		: [ret] "={o0}" (-> u64),
20		: [number] "{g1}" (@intFromEnum(SYS.pipe)),
21		[arg] "r" (fd),
22		: .{ .memory = true, .g3 = true });
23		}
	5	pub const syscall_arg_t = u64;
24	6
25		pub fn syscall_fork() u64 {
26		// Linux/sparc64 fork() returns two values in %o0 and %o1:
27		// - On the parent's side, %o0 is the child's PID and %o1 is 0.
28		// - On the child's side, %o0 is the parent's PID and %o1 is 1.
29		// We need to clear the child's %o0 so that the return values
30		// conform to the libc convention.
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
31	10	return asm volatile (
32	11	\\ t 0x6d
33	12	\\ bcc,pt %%xcc, 1f
34	13	\\ nop
35		\\ ba 2f
36	14	\\ neg %%o0
37	15	\\ 1:
38		\\ # Clear the child's %%o0
39		\\ dec %%o1
40		\\ and %%o1, %%o0, %%o0
41		\\ 2:
42	16	: [ret] "={o0}" (-> u64),
43		: [number] "{g1}" (@intFromEnum(SYS.fork)),
	17	: [number] "{g1}" (@intFromEnum(number)),
44	18	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
45	19	}
46	20
47		pub fn syscall0(number: SYS) u64 {
	21	pub fn syscall1(
	22	number: SYS,
	23	arg1: syscall_arg_t,
	24	) u64 {
48	25	return asm volatile (
49	26	\\ t 0x6d
50	27	\\ bcc,pt %%xcc, 1f
...	...	@@ -53,10 +30,15 @@ pub fn syscall0(number: SYS) u64 {
53	30	\\ 1:
54	31	: [ret] "={o0}" (-> u64),
55	32	: [number] "{g1}" (@intFromEnum(number)),
	33	[arg1] "{o0}" (arg1),
56	34	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
57	35	}
58	36
59		pub fn syscall1(number: SYS, arg1: u64) u64 {
	37	pub fn syscall2(
	38	number: SYS,
	39	arg1: syscall_arg_t,
	40	arg2: syscall_arg_t,
	41	) u64 {
60	42	return asm volatile (
61	43	\\ t 0x6d
62	44	\\ bcc,pt %%xcc, 1f
...	...	@@ -66,10 +48,16 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
66	48	: [ret] "={o0}" (-> u64),
67	49	: [number] "{g1}" (@intFromEnum(number)),
68	50	[arg1] "{o0}" (arg1),
	51	[arg2] "{o1}" (arg2),
69	52	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
70	53	}
71	54
72		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	55	pub fn syscall3(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	) u64 {
73	61	return asm volatile (
74	62	\\ t 0x6d
75	63	\\ bcc,pt %%xcc, 1f
...	...	@@ -80,10 +68,17 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
80	68	: [number] "{g1}" (@intFromEnum(number)),
81	69	[arg1] "{o0}" (arg1),
82	70	[arg2] "{o1}" (arg2),
	71	[arg3] "{o2}" (arg3),
83	72	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
84	73	}
85	74
86		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	75	pub fn syscall4(
	76	number: SYS,
	77	arg1: syscall_arg_t,
	78	arg2: syscall_arg_t,
	79	arg3: syscall_arg_t,
	80	arg4: syscall_arg_t,
	81	) u64 {
87	82	return asm volatile (
88	83	\\ t 0x6d
89	84	\\ bcc,pt %%xcc, 1f
...	...	@@ -95,10 +90,18 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
95	90	[arg1] "{o0}" (arg1),
96	91	[arg2] "{o1}" (arg2),
97	92	[arg3] "{o2}" (arg3),
	93	[arg4] "{o3}" (arg4),
98	94	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
99	95	}
100	96
101		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	97	pub fn syscall5(
	98	number: SYS,
	99	arg1: syscall_arg_t,
	100	arg2: syscall_arg_t,
	101	arg3: syscall_arg_t,
	102	arg4: syscall_arg_t,
	103	arg5: syscall_arg_t,
	104	) u64 {
102	105	return asm volatile (
103	106	\\ t 0x6d
104	107	\\ bcc,pt %%xcc, 1f
...	...	@@ -111,10 +114,19 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
111	114	[arg2] "{o1}" (arg2),
112	115	[arg3] "{o2}" (arg3),
113	116	[arg4] "{o3}" (arg4),
	117	[arg5] "{o4}" (arg5),
114	118	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
115	119	}
116	120
117		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	121	pub fn syscall6(
	122	number: SYS,
	123	arg1: syscall_arg_t,
	124	arg2: syscall_arg_t,
	125	arg3: syscall_arg_t,
	126	arg4: syscall_arg_t,
	127	arg5: syscall_arg_t,
	128	arg6: syscall_arg_t,
	129	) u64 {
118	130	return asm volatile (
119	131	\\ t 0x6d
120	132	\\ bcc,pt %%xcc, 1f
...	...	@@ -128,32 +140,51 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
128	140	[arg3] "{o2}" (arg3),
129	141	[arg4] "{o3}" (arg4),
130	142	[arg5] "{o4}" (arg5),
	143	[arg6] "{o5}" (arg6),
131	144	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
132	145	}
133	146
134		pub fn syscall6(
135		number: SYS,
136		arg1: u64,
137		arg2: u64,
138		arg3: u64,
139		arg4: u64,
140		arg5: u64,
141		arg6: u64,
	147	pub fn syscall_pipe(
	148	fd: *[2]std.os.linux.fd_t,
142	149	) u64 {
	150	return asm volatile (
	151	\\ mov %[arg], %%g3
	152	\\ t 0x6d
	153	\\ bcc,pt %%xcc, 1f
	154	\\ nop
	155	\\ # Return the error code
	156	\\ ba 2f
	157	\\ neg %%o0
	158	\\1:
	159	\\ st %%o0, [%%g3+0]
	160	\\ st %%o1, [%%g3+4]
	161	\\ clr %%o0
	162	\\2:
	163	: [ret] "={o0}" (-> u64),
	164	: [number] "{g1}" (@intFromEnum(SYS.pipe)),
	165	[arg] "r" (fd),
	166	: .{ .memory = true, .g3 = true });
	167	}
	168
	169	pub fn syscall_fork() u64 {
	170	// Linux/sparc64 fork() returns two values in %o0 and %o1:
	171	// - On the parent's side, %o0 is the child's PID and %o1 is 0.
	172	// - On the child's side, %o0 is the parent's PID and %o1 is 1.
	173	// We need to clear the child's %o0 so that the return values
	174	// conform to the libc convention.
143	175	return asm volatile (
144	176	\\ t 0x6d
145	177	\\ bcc,pt %%xcc, 1f
146	178	\\ nop
	179	\\ ba 2f
147	180	\\ neg %%o0
148	181	\\ 1:
	182	\\ # Clear the child's %%o0
	183	\\ dec %%o1
	184	\\ and %%o1, %%o0, %%o0
	185	\\ 2:
149	186	: [ret] "={o0}" (-> u64),
150		: [number] "{g1}" (@intFromEnum(number)),
151		[arg1] "{o0}" (arg1),
152		[arg2] "{o1}" (arg2),
153		[arg3] "{o2}" (arg3),
154		[arg4] "{o3}" (arg4),
155		[arg5] "{o4}" (arg5),
156		[arg6] "{o5}" (arg6),
	187	: [number] "{g1}" (@intFromEnum(SYS.fork)),
157	188	: .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
158	189	}
159	190

lib/std/os/linux/thumb.zig+52-36

...	...	@@ -5,9 +5,14 @@
5	5	//! to break the frame chain.
6	6	const std = @import("../../std.zig");
7	7	const SYS = std.os.linux.SYS;
	8	const arm = @import("arm.zig");
8	9
9		pub fn syscall0(number: SYS) u32 {
10		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	10	pub const syscall_arg_t = arm.syscall_arg_t;
	11
	12	pub fn syscall0(
	13	number: SYS,
	14	) u32 {
	15	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
11	16	return asm volatile (
12	17	\\ str r7, [%[tmp], #4]
13	18	\\ ldr r7, [%[tmp]]
...	...	@@ -18,8 +23,11 @@ pub fn syscall0(number: SYS) u32 {
18	23	: .{ .memory = true });
19	24	}
20	25
21		pub fn syscall1(number: SYS, arg1: u32) u32 {
22		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	26	pub fn syscall1(
	27	number: SYS,
	28	arg1: syscall_arg_t,
	29	) u32 {
	30	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
23	31	return asm volatile (
24	32	\\ str r7, [%[tmp], #4]
25	33	\\ ldr r7, [%[tmp]]
...	...	@@ -31,8 +39,12 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
31	39	: .{ .memory = true });
32	40	}
33	41
34		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
35		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	42	pub fn syscall2(
	43	number: SYS,
	44	arg1: syscall_arg_t,
	45	arg2: syscall_arg_t,
	46	) u32 {
	47	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
36	48	return asm volatile (
37	49	\\ str r7, [%[tmp], #4]
38	50	\\ ldr r7, [%[tmp]]
...	...	@@ -45,8 +57,13 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
45	57	: .{ .memory = true });
46	58	}
47	59
48		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
49		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	60	pub fn syscall3(
	61	number: SYS,
	62	arg1: syscall_arg_t,
	63	arg2: syscall_arg_t,
	64	arg3: syscall_arg_t,
	65	) u32 {
	66	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
50	67	return asm volatile (
51	68	\\ str r7, [%[tmp], #4]
52	69	\\ ldr r7, [%[tmp]]
...	...	@@ -60,8 +77,14 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
60	77	: .{ .memory = true });
61	78	}
62	79
63		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
64		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	80	pub fn syscall4(
	81	number: SYS,
	82	arg1: syscall_arg_t,
	83	arg2: syscall_arg_t,
	84	arg3: syscall_arg_t,
	85	arg4: syscall_arg_t,
	86	) u32 {
	87	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
65	88	return asm volatile (
66	89	\\ str r7, [%[tmp], #4]
67	90	\\ ldr r7, [%[tmp]]
...	...	@@ -76,8 +99,15 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
76	99	: .{ .memory = true });
77	100	}
78	101
79		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
80		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	102	pub fn syscall5(
	103	number: SYS,
	104	arg1: syscall_arg_t,
	105	arg2: syscall_arg_t,
	106	arg3: syscall_arg_t,
	107	arg4: syscall_arg_t,
	108	arg5: syscall_arg_t,
	109	) u32 {
	110	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
81	111	return asm volatile (
82	112	\\ str r7, [%[tmp], #4]
83	113	\\ ldr r7, [%[tmp]]
...	...	@@ -95,14 +125,14 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
95	125
96	126	pub fn syscall6(
97	127	number: SYS,
98		arg1: u32,
99		arg2: u32,
100		arg3: u32,
101		arg4: u32,
102		arg5: u32,
103		arg6: u32,
	128	arg1: syscall_arg_t,
	129	arg2: syscall_arg_t,
	130	arg3: syscall_arg_t,
	131	arg4: syscall_arg_t,
	132	arg5: syscall_arg_t,
	133	arg6: syscall_arg_t,
104	134	) u32 {
105		var buf: [2]u32 = .{ @intFromEnum(number), undefined };
	135	var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined };
106	136	return asm volatile (
107	137	\\ str r7, [%[tmp], #4]
108	138	\\ ldr r7, [%[tmp]]
...	...	@@ -119,22 +149,8 @@ pub fn syscall6(
119	149	: .{ .memory = true });
120	150	}
121	151
122		pub const clone = @import("arm.zig").clone;
	152	pub const clone = arm.clone;
123	153
124		pub fn restore() callconv(.naked) noreturn {
125		asm volatile (
126		\\ mov r7, %[number]
127		\\ svc #0
128		:
129		: [number] "I" (@intFromEnum(SYS.sigreturn)),
130		);
131		}
	154	pub const restore = arm.restore;
132	155
133		pub fn restore_rt() callconv(.naked) noreturn {
134		asm volatile (
135		\\ mov r7, %[number]
136		\\ svc #0
137		:
138		: [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
139		);
140		}
	156	pub const restore_rt = arm.restore_rt;

lib/std/os/linux/x32.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("syscall"
7	11	: [ret] "={rax}" (-> u32),
8	12	: [number] "{rax}" (@intFromEnum(number)),
9	13	: .{ .rcx = true, .r11 = true, .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("syscall"
14	21	: [ret] "={rax}" (-> u32),
15	22	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .rcx = true, .r11 = true, .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("syscall"
22	33	: [ret] "={rax}" (-> u32),
23	34	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .rcx = true, .r11 = true, .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("syscall"
31	47	: [ret] "={rax}" (-> u32),
32	48	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .rcx = true, .r11 = true, .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("syscall"
41	63	: [ret] "={rax}" (-> u32),
42	64	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .rcx = true, .r11 = true, .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("syscall"
52	81	: [ret] "={rax}" (-> u32),
53	82	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	return asm volatile ("syscall"
72	101	: [ret] "={rax}" (-> u32),

lib/std/os/linux/x86.zig+42-13

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u32 {
	5	pub const syscall_arg_t = u32;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u32 {
6	10	return asm volatile ("int $0x80"
7	11	: [ret] "={eax}" (-> u32),
8	12	: [number] "{eax}" (@intFromEnum(number)),
9	13	: .{ .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u32) u32 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u32 {
13	20	return asm volatile ("int $0x80"
14	21	: [ret] "={eax}" (-> u32),
15	22	: [number] "{eax}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u32) u32 {
17	24	: .{ .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u32 {
21	32	return asm volatile ("int $0x80"
22	33	: [ret] "={eax}" (-> u32),
23	34	: [number] "{eax}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
26	37	: .{ .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u32 {
30	46	return asm volatile ("int $0x80"
31	47	: [ret] "={eax}" (-> u32),
32	48	: [number] "{eax}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
36	52	: .{ .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u32 {
40	62	return asm volatile ("int $0x80"
41	63	: [ret] "={eax}" (-> u32),
42	64	: [number] "{eax}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
47	69	: .{ .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u32 {
51	80	return asm volatile ("int $0x80"
52	81	: [ret] "={eax}" (-> u32),
53	82	: [number] "{eax}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u32,
65		arg2: u32,
66		arg3: u32,
67		arg4: u32,
68		arg5: u32,
69		arg6: u32,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u32 {
71	100	// arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer
72	101	// 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(
74	103	// its own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get
75	104	// right, because we can't touch esp or ebp until we're done with the memory input (as that
76	105	// input could be relative to esp or ebp).
77		const args56: [2]u32 = .{ arg5, arg6 };
	106	const args56: [2]syscall_arg_t = .{ arg5, arg6 };
78	107	return asm volatile (
79	108	\\ push %[args56]
80	109	\\ push %%ebp

lib/std/os/linux/x86_64.zig+41-12

...	...	@@ -2,14 +2,21 @@ const builtin = @import("builtin");
2	2	const std = @import("../../std.zig");
3	3	const SYS = std.os.linux.SYS;
4	4
5		pub fn syscall0(number: SYS) u64 {
	5	pub const syscall_arg_t = u64;
	6
	7	pub fn syscall0(
	8	number: SYS,
	9	) u64 {
6	10	return asm volatile ("syscall"
7	11	: [ret] "={rax}" (-> u64),
8	12	: [number] "{rax}" (@intFromEnum(number)),
9	13	: .{ .rcx = true, .r11 = true, .memory = true });
10	14	}
11	15
12		pub fn syscall1(number: SYS, arg1: u64) u64 {
	16	pub fn syscall1(
	17	number: SYS,
	18	arg1: syscall_arg_t,
	19	) u64 {
13	20	return asm volatile ("syscall"
14	21	: [ret] "={rax}" (-> u64),
15	22	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -17,7 +24,11 @@ pub fn syscall1(number: SYS, arg1: u64) u64 {
17	24	: .{ .rcx = true, .r11 = true, .memory = true });
18	25	}
19	26
20		pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
	27	pub fn syscall2(
	28	number: SYS,
	29	arg1: syscall_arg_t,
	30	arg2: syscall_arg_t,
	31	) u64 {
21	32	return asm volatile ("syscall"
22	33	: [ret] "={rax}" (-> u64),
23	34	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -26,7 +37,12 @@ pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
26	37	: .{ .rcx = true, .r11 = true, .memory = true });
27	38	}
28	39
29		pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
	40	pub fn syscall3(
	41	number: SYS,
	42	arg1: syscall_arg_t,
	43	arg2: syscall_arg_t,
	44	arg3: syscall_arg_t,
	45	) u64 {
30	46	return asm volatile ("syscall"
31	47	: [ret] "={rax}" (-> u64),
32	48	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -36,7 +52,13 @@ pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
36	52	: .{ .rcx = true, .r11 = true, .memory = true });
37	53	}
38	54
39		pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
	55	pub fn syscall4(
	56	number: SYS,
	57	arg1: syscall_arg_t,
	58	arg2: syscall_arg_t,
	59	arg3: syscall_arg_t,
	60	arg4: syscall_arg_t,
	61	) u64 {
40	62	return asm volatile ("syscall"
41	63	: [ret] "={rax}" (-> u64),
42	64	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -47,7 +69,14 @@ pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
47	69	: .{ .rcx = true, .r11 = true, .memory = true });
48	70	}
49	71
50		pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
	72	pub fn syscall5(
	73	number: SYS,
	74	arg1: syscall_arg_t,
	75	arg2: syscall_arg_t,
	76	arg3: syscall_arg_t,
	77	arg4: syscall_arg_t,
	78	arg5: syscall_arg_t,
	79	) u64 {
51	80	return asm volatile ("syscall"
52	81	: [ret] "={rax}" (-> u64),
53	82	: [number] "{rax}" (@intFromEnum(number)),
...	...	@@ -61,12 +90,12 @@ pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u
61	90
62	91	pub fn syscall6(
63	92	number: SYS,
64		arg1: u64,
65		arg2: u64,
66		arg3: u64,
67		arg4: u64,
68		arg5: u64,
69		arg6: u64,
	93	arg1: syscall_arg_t,
	94	arg2: syscall_arg_t,
	95	arg3: syscall_arg_t,
	96	arg4: syscall_arg_t,
	97	arg5: syscall_arg_t,
	98	arg6: syscall_arg_t,
70	99	) u64 {
71	100	return asm volatile ("syscall"
72	101	: [ret] "={rax}" (-> u64),