Commit cfa0ada9e191237340a8293d89b92c8e59fc01c3 | zig

author	Alex Rønne Petersen <alex@alexrp.com> 2026-04-16 16:08:04+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-04-16 16:08:04+02:00
log	cfa0ada9e191237340a8293d89b92c8e59fc01c3
tree	1ca11347e4b9025466314c774956428b691006b9
parent	d0226ac301140cb552dfc3da24cea7693d29c64f
parent	6315c1a19061c4efaa45b32f54aef0994e48c3b8

Merge pull request '`std.os.linux`: fix syscall argument width for mipsn32 and x32' (#31894) from alexrp/zig:mipsn32-x32-fixes into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/31894

25 files changed, 1404 insertions(+), 844 deletions(-)

lib
- c
  - fcntl.zig
- libc
  - musl
    arch
    mipsn32
    syscall_arch.h
- std
  - Io
    Threaded.zig
  - os
    linux.zig
    linux
    aarch64.zig
    arc.zig
    arm.zig
    hexagon.zig
    loongarch32.zig
    loongarch64.zig
    m68k.zig
    mips.zig
    mips64.zig
    mipsn32.zig
    or1k.zig
    powerpc.zig
    powerpc64.zig
    riscv32.zig
    riscv64.zig
    s390x.zig
    sparc64.zig
    thumb.zig
    x32.zig
    x86.zig
    x86_64.zig

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/libc/musl/arch/mipsn32/syscall_arch.h+35-32

...	...	@@ -1,6 +1,9 @@
1	1	#define __SYSCALL_LL_E(x) (x)
2	2	#define __SYSCALL_LL_O(x) (x)
3	3
	4	#define __scc(X) sizeof(1?(X):0ULL) < 8 ? (unsigned long) (X) : (long long) (X)
	5	typedef long long syscall_arg_t;
	6
4	7	#define SYSCALL_RLIM_INFINITY (-1UL/2)
5	8
6	9	#if __mips_isa_rev >= 6
...	...	@@ -13,9 +16,9 @@
13	16	"$14", "$15", "$24", "$25", "hi", "lo", "memory"
14	17	#endif
15	18
16		static inline long __syscall0(long n)
	19	static inline long __syscall0(long long n)
17	20	{
18		register long r7 __asm__("$7");
	21	register long long r7 __asm__("$7");
19	22	register long r2 __asm__("$2");
20	23	__asm__ __volatile__ (
21	24	"daddu $2,$0,%2 ; syscall"
...	...	@@ -25,10 +28,10 @@ static inline long __syscall0(long n)
25	28	return r7 && r2>0 ? -r2 : r2;
26	29	}
27	30
28		static inline long __syscall1(long n, long a)
	31	static inline long __syscall1(long long n, long long a)
29	32	{
30		register long r4 __asm__("$4") = a;
31		register long r7 __asm__("$7");
	33	register long long r4 __asm__("$4") = a;
	34	register long long r7 __asm__("$7");
32	35	register long r2 __asm__("$2");
33	36	__asm__ __volatile__ (
34	37	"daddu $2,$0,%2 ; syscall"
...	...	@@ -38,11 +41,11 @@ static inline long __syscall1(long n, long a)
38	41	return r7 && r2>0 ? -r2 : r2;
39	42	}
40	43
41		static inline long __syscall2(long n, long a, long b)
	44	static inline long __syscall2(long long n, long long a, long long b)
42	45	{
43		register long r4 __asm__("$4") = a;
44		register long r5 __asm__("$5") = b;
45		register long r7 __asm__("$7");
	46	register long long r4 __asm__("$4") = a;
	47	register long long r5 __asm__("$5") = b;
	48	register long long r7 __asm__("$7");
46	49	register long r2 __asm__("$2");
47	50
48	51	__asm__ __volatile__ (
...	...	@@ -53,12 +56,12 @@ static inline long __syscall2(long n, long a, long b)
53	56	return r7 && r2>0 ? -r2 : r2;
54	57	}
55	58
56		static inline long __syscall3(long n, long a, long b, long c)
	59	static inline long __syscall3(long long n, long long a, long long b, long long c)
57	60	{
58		register long r4 __asm__("$4") = a;
59		register long r5 __asm__("$5") = b;
60		register long r6 __asm__("$6") = c;
61		register long r7 __asm__("$7");
	61	register long long r4 __asm__("$4") = a;
	62	register long long r5 __asm__("$5") = b;
	63	register long long r6 __asm__("$6") = c;
	64	register long long r7 __asm__("$7");
62	65	register long r2 __asm__("$2");
63	66
64	67	__asm__ __volatile__ (
...	...	@@ -69,12 +72,12 @@ static inline long __syscall3(long n, long a, long b, long c)
69	72	return r7 && r2>0 ? -r2 : r2;
70	73	}
71	74
72		static inline long __syscall4(long n, long a, long b, long c, long d)
	75	static inline long __syscall4(long long n, long long a, long long b, long long c, long long d)
73	76	{
74		register long r4 __asm__("$4") = a;
75		register long r5 __asm__("$5") = b;
76		register long r6 __asm__("$6") = c;
77		register long r7 __asm__("$7") = d;
	77	register long long r4 __asm__("$4") = a;
	78	register long long r5 __asm__("$5") = b;
	79	register long long r6 __asm__("$6") = c;
	80	register long long r7 __asm__("$7") = d;
78	81	register long r2 __asm__("$2");
79	82
80	83	__asm__ __volatile__ (
...	...	@@ -85,13 +88,13 @@ static inline long __syscall4(long n, long a, long b, long c, long d)
85	88	return r7 && r2>0 ? -r2 : r2;
86	89	}
87	90
88		static inline long __syscall5(long n, long a, long b, long c, long d, long e)
	91	static inline long __syscall5(long long n, long long a, long long b, long long c, long long d, long long e)
89	92	{
90		register long r4 __asm__("$4") = a;
91		register long r5 __asm__("$5") = b;
92		register long r6 __asm__("$6") = c;
93		register long r7 __asm__("$7") = d;
94		register long r8 __asm__("$8") = e;
	93	register long long r4 __asm__("$4") = a;
	94	register long long r5 __asm__("$5") = b;
	95	register long long r6 __asm__("$6") = c;
	96	register long long r7 __asm__("$7") = d;
	97	register long long r8 __asm__("$8") = e;
95	98	register long r2 __asm__("$2");
96	99
97	100	__asm__ __volatile__ (
...	...	@@ -102,14 +105,14 @@ static inline long __syscall5(long n, long a, long b, long c, long d, long e)
102	105	return r7 && r2>0 ? -r2 : r2;
103	106	}
104	107
105		static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
	108	static inline long __syscall6(long long n, long long a, long long b, long long c, long long d, long long e, long long f)
106	109	{
107		register long r4 __asm__("$4") = a;
108		register long r5 __asm__("$5") = b;
109		register long r6 __asm__("$6") = c;
110		register long r7 __asm__("$7") = d;
111		register long r8 __asm__("$8") = e;
112		register long r9 __asm__("$9") = f;
	110	register long long r4 __asm__("$4") = a;
	111	register long long r5 __asm__("$5") = b;
	112	register long long r6 __asm__("$6") = c;
	113	register long long r7 __asm__("$7") = d;
	114	register long long r8 __asm__("$8") = e;
	115	register long long r9 __asm__("$9") = f;
113	116	register long r2 __asm__("$2");
114	117
115	118	__asm__ __volatile__ (

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+386-432

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

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-13

...	...	@@ -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
...	...	@@ -87,7 +116,6 @@ pub fn syscall6(
87	116	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
88	117	}
89	118
90		// FIXME
91	119	pub fn clone() callconv(.naked) u32 {
92	120	// __clone(func, stack, flags, arg, ptid, tls, ctid)
93	121	// a0, a1, a2, a3, a4, a5, a6

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