Commit cfdc0f0e34b00a7e1a4dc23f1d6672f213bbf9ca | zig

lib/std/os/linux/aarch64.zig+27-27

...	...	@@ -14,33 +14,33 @@ const stack_t = linux.stack_t;
14	14	const sigset_t = linux.sigset_t;
15	15	const timespec = std.os.linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u64 {
18	18	return asm volatile ("svc #0"
19		: [ret] "={x0}" (-> usize),
	19	: [ret] "={x0}" (-> u64),
20	20	: [number] "{x8}" (@intFromEnum(number)),
21	21	: .{ .memory = true });
22	22	}
23	23
24		pub fn syscall1(number: SYS, arg1: usize) usize {
	24	pub fn syscall1(number: SYS, arg1: u64) u64 {
25	25	return asm volatile ("svc #0"
26		: [ret] "={x0}" (-> usize),
	26	: [ret] "={x0}" (-> u64),
27	27	: [number] "{x8}" (@intFromEnum(number)),
28	28	[arg1] "{x0}" (arg1),
29	29	: .{ .memory = true });
30	30	}
31	31
32		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	32	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
33	33	return asm volatile ("svc #0"
34		: [ret] "={x0}" (-> usize),
	34	: [ret] "={x0}" (-> u64),
35	35	: [number] "{x8}" (@intFromEnum(number)),
36	36	[arg1] "{x0}" (arg1),
37	37	[arg2] "{x1}" (arg2),
38	38	: .{ .memory = true });
39	39	}
40	40
41		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	41	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
42	42	return asm volatile ("svc #0"
43		: [ret] "={x0}" (-> usize),
	43	: [ret] "={x0}" (-> u64),
44	44	: [number] "{x8}" (@intFromEnum(number)),
45	45	[arg1] "{x0}" (arg1),
46	46	[arg2] "{x1}" (arg2),
...	...	@@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
48	48	: .{ .memory = true });
49	49	}
50	50
51		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	51	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
52	52	return asm volatile ("svc #0"
53		: [ret] "={x0}" (-> usize),
	53	: [ret] "={x0}" (-> u64),
54	54	: [number] "{x8}" (@intFromEnum(number)),
55	55	[arg1] "{x0}" (arg1),
56	56	[arg2] "{x1}" (arg2),
...	...	@@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
59	59	: .{ .memory = true });
60	60	}
61	61
62		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	62	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
63	63	return asm volatile ("svc #0"
64		: [ret] "={x0}" (-> usize),
	64	: [ret] "={x0}" (-> u64),
65	65	: [number] "{x8}" (@intFromEnum(number)),
66	66	[arg1] "{x0}" (arg1),
67	67	[arg2] "{x1}" (arg2),
...	...	@@ -73,15 +73,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
73	73
74	74	pub fn syscall6(
75	75	number: SYS,
76		arg1: usize,
77		arg2: usize,
78		arg3: usize,
79		arg4: usize,
80		arg5: usize,
81		arg6: usize,
82		) usize {
	76	arg1: u64,
	77	arg2: u64,
	78	arg3: u64,
	79	arg4: u64,
	80	arg5: u64,
	81	arg6: u64,
	82	) u64 {
83	83	return asm volatile ("svc #0"
84		: [ret] "={x0}" (-> usize),
	84	: [ret] "={x0}" (-> u64),
85	85	: [number] "{x8}" (@intFromEnum(number)),
86	86	[arg1] "{x0}" (arg1),
87	87	[arg2] "{x1}" (arg2),
...	...	@@ -92,7 +92,7 @@ pub fn syscall6(
92	92	: .{ .memory = true });
93	93	}
94	94
95		pub fn clone() callconv(.naked) usize {
	95	pub fn clone() callconv(.naked) u64 {
96	96	// __clone(func, stack, flags, arg, ptid, tls, ctid)
97	97	// x0, x1, w2, x3, x4, x5, x6
98	98	//
...	...	@@ -192,12 +192,12 @@ pub const Flock = extern struct {
192	192
193	193	pub const blksize_t = i32;
194	194	pub const nlink_t = u32;
195		pub const time_t = isize;
	195	pub const time_t = i64;
196	196	pub const mode_t = u32;
197		pub const off_t = isize;
198		pub const ino_t = usize;
199		pub const dev_t = usize;
200		pub const blkcnt_t = isize;
	197	pub const off_t = i64;
	198	pub const ino_t = u64;
	199	pub const dev_t = u64;
	200	pub const blkcnt_t = i64;
201	201
202	202	// The `stat` definition used by the Linux kernel.
203	203	pub const Stat = extern struct {
...	...	@@ -208,7 +208,7 @@ pub const Stat = extern struct {
208	208	uid: uid_t,
209	209	gid: gid_t,
210	210	rdev: dev_t,
211		__pad: usize,
	211	__pad: u64,
212	212	size: off_t,
213	213	blksize: blksize_t,
214	214	__pad2: i32,

lib/std/os/linux/arm.zig+22-22

...	...	@@ -13,33 +13,33 @@ const pid_t = linux.pid_t;
13	13	const sockaddr = linux.sockaddr;
14	14	const timespec = linux.timespec;
15	15
16		pub fn syscall0(number: SYS) usize {
	16	pub fn syscall0(number: SYS) u32 {
17	17	return asm volatile ("svc #0"
18		: [ret] "={r0}" (-> usize),
	18	: [ret] "={r0}" (-> u32),
19	19	: [number] "{r7}" (@intFromEnum(number)),
20	20	: .{ .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u32) u32 {
24	24	return asm volatile ("svc #0"
25		: [ret] "={r0}" (-> usize),
	25	: [ret] "={r0}" (-> u32),
26	26	: [number] "{r7}" (@intFromEnum(number)),
27	27	[arg1] "{r0}" (arg1),
28	28	: .{ .memory = true });
29	29	}
30	30
31		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	31	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32	32	return asm volatile ("svc #0"
33		: [ret] "={r0}" (-> usize),
	33	: [ret] "={r0}" (-> u32),
34	34	: [number] "{r7}" (@intFromEnum(number)),
35	35	[arg1] "{r0}" (arg1),
36	36	[arg2] "{r1}" (arg2),
37	37	: .{ .memory = true });
38	38	}
39	39
40		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	40	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41	41	return asm volatile ("svc #0"
42		: [ret] "={r0}" (-> usize),
	42	: [ret] "={r0}" (-> u32),
43	43	: [number] "{r7}" (@intFromEnum(number)),
44	44	[arg1] "{r0}" (arg1),
45	45	[arg2] "{r1}" (arg2),
...	...	@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47	47	: .{ .memory = true });
48	48	}
49	49
50		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	50	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51	51	return asm volatile ("svc #0"
52		: [ret] "={r0}" (-> usize),
	52	: [ret] "={r0}" (-> u32),
53	53	: [number] "{r7}" (@intFromEnum(number)),
54	54	[arg1] "{r0}" (arg1),
55	55	[arg2] "{r1}" (arg2),
...	...	@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58	58	: .{ .memory = true });
59	59	}
60	60
61		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	61	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62	62	return asm volatile ("svc #0"
63		: [ret] "={r0}" (-> usize),
	63	: [ret] "={r0}" (-> u32),
64	64	: [number] "{r7}" (@intFromEnum(number)),
65	65	[arg1] "{r0}" (arg1),
66	66	[arg2] "{r1}" (arg2),
...	...	@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
72	72
73	73	pub fn syscall6(
74	74	number: SYS,
75		arg1: usize,
76		arg2: usize,
77		arg3: usize,
78		arg4: usize,
79		arg5: usize,
80		arg6: usize,
81		) usize {
	75	arg1: u32,
	76	arg2: u32,
	77	arg3: u32,
	78	arg4: u32,
	79	arg5: u32,
	80	arg6: u32,
	81	) u32 {
82	82	return asm volatile ("svc #0"
83		: [ret] "={r0}" (-> usize),
	83	: [ret] "={r0}" (-> u32),
84	84	: [number] "{r7}" (@intFromEnum(number)),
85	85	[arg1] "{r0}" (arg1),
86	86	[arg2] "{r1}" (arg2),
...	...	@@ -91,7 +91,7 @@ pub fn syscall6(
91	91	: .{ .memory = true });
92	92	}
93	93
94		pub fn clone() callconv(.naked) usize {
	94	pub fn clone() callconv(.naked) u32 {
95	95	// __clone(func, stack, flags, arg, ptid, tls, ctid)
96	96	// r0, r1, r2, r3, +0, +4, +8
97	97	//
...	...	@@ -228,7 +228,7 @@ pub const Flock = extern struct {
228	228
229	229	pub const blksize_t = i32;
230	230	pub const nlink_t = u32;
231		pub const time_t = isize;
	231	pub const time_t = i32;
232	232	pub const mode_t = u32;
233	233	pub const off_t = i64;
234	234	pub const ino_t = u64;

lib/std/os/linux/hexagon.zig+21-21

...	...	@@ -13,33 +13,33 @@ const stack_t = linux.stack_t;
13	13	const sigset_t = linux.sigset_t;
14	14	const timespec = std.os.linux.timespec;
15	15
16		pub fn syscall0(number: SYS) usize {
	16	pub fn syscall0(number: SYS) u32 {
17	17	return asm volatile ("trap0(#1)"
18		: [ret] "={r0}" (-> usize),
	18	: [ret] "={r0}" (-> u32),
19	19	: [number] "{r6}" (@intFromEnum(number)),
20	20	: .{ .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u32) u32 {
24	24	return asm volatile ("trap0(#1)"
25		: [ret] "={r0}" (-> usize),
	25	: [ret] "={r0}" (-> u32),
26	26	: [number] "{r6}" (@intFromEnum(number)),
27	27	[arg1] "{r0}" (arg1),
28	28	: .{ .memory = true });
29	29	}
30	30
31		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	31	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32	32	return asm volatile ("trap0(#1)"
33		: [ret] "={r0}" (-> usize),
	33	: [ret] "={r0}" (-> u32),
34	34	: [number] "{r6}" (@intFromEnum(number)),
35	35	[arg1] "{r0}" (arg1),
36	36	[arg2] "{r1}" (arg2),
37	37	: .{ .memory = true });
38	38	}
39	39
40		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	40	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41	41	return asm volatile ("trap0(#1)"
42		: [ret] "={r0}" (-> usize),
	42	: [ret] "={r0}" (-> u32),
43	43	: [number] "{r6}" (@intFromEnum(number)),
44	44	[arg1] "{r0}" (arg1),
45	45	[arg2] "{r1}" (arg2),
...	...	@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47	47	: .{ .memory = true });
48	48	}
49	49
50		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	50	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51	51	return asm volatile ("trap0(#1)"
52		: [ret] "={r0}" (-> usize),
	52	: [ret] "={r0}" (-> u32),
53	53	: [number] "{r6}" (@intFromEnum(number)),
54	54	[arg1] "{r0}" (arg1),
55	55	[arg2] "{r1}" (arg2),
...	...	@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58	58	: .{ .memory = true });
59	59	}
60	60
61		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	61	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62	62	return asm volatile ("trap0(#1)"
63		: [ret] "={r0}" (-> usize),
	63	: [ret] "={r0}" (-> u32),
64	64	: [number] "{r6}" (@intFromEnum(number)),
65	65	[arg1] "{r0}" (arg1),
66	66	[arg2] "{r1}" (arg2),
...	...	@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
72	72
73	73	pub fn syscall6(
74	74	number: SYS,
75		arg1: usize,
76		arg2: usize,
77		arg3: usize,
78		arg4: usize,
79		arg5: usize,
80		arg6: usize,
81		) usize {
	75	arg1: u32,
	76	arg2: u32,
	77	arg3: u32,
	78	arg4: u32,
	79	arg5: u32,
	80	arg6: u32,
	81	) u32 {
82	82	return asm volatile ("trap0(#1)"
83		: [ret] "={r0}" (-> usize),
	83	: [ret] "={r0}" (-> u32),
84	84	: [number] "{r6}" (@intFromEnum(number)),
85	85	[arg1] "{r0}" (arg1),
86	86	[arg2] "{r1}" (arg2),
...	...	@@ -91,7 +91,7 @@ pub fn syscall6(
91	91	: .{ .memory = true });
92	92	}
93	93
94		pub fn clone() callconv(.naked) usize {
	94	pub fn clone() callconv(.naked) u32 {
95	95	// __clone(func, stack, flags, arg, ptid, tls, ctid)
96	96	// r0, r1, r2, r3, r4, r5, +0
97	97	//

lib/std/os/linux/loongarch64.zig+21-21

...	...	@@ -12,37 +12,37 @@ const sockaddr = linux.sockaddr;
12	12	const socklen_t = linux.socklen_t;
13	13	const timespec = linux.timespec;
14	14
15		pub fn syscall0(number: SYS) usize {
	15	pub fn syscall0(number: SYS) u64 {
16	16	return asm volatile (
17	17	\\ syscall 0
18		: [ret] "={$r4}" (-> usize),
	18	: [ret] "={$r4}" (-> u64),
19	19	: [number] "{$r11}" (@intFromEnum(number)),
20	20	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u64) u64 {
24	24	return asm volatile (
25	25	\\ syscall 0
26		: [ret] "={$r4}" (-> usize),
	26	: [ret] "={$r4}" (-> u64),
27	27	: [number] "{$r11}" (@intFromEnum(number)),
28	28	[arg1] "{$r4}" (arg1),
29	29	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
30	30	}
31	31
32		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	32	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
33	33	return asm volatile (
34	34	\\ syscall 0
35		: [ret] "={$r4}" (-> usize),
	35	: [ret] "={$r4}" (-> u64),
36	36	: [number] "{$r11}" (@intFromEnum(number)),
37	37	[arg1] "{$r4}" (arg1),
38	38	[arg2] "{$r5}" (arg2),
39	39	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
40	40	}
41	41
42		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	42	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
43	43	return asm volatile (
44	44	\\ syscall 0
45		: [ret] "={$r4}" (-> usize),
	45	: [ret] "={$r4}" (-> u64),
46	46	: [number] "{$r11}" (@intFromEnum(number)),
47	47	[arg1] "{$r4}" (arg1),
48	48	[arg2] "{$r5}" (arg2),
...	...	@@ -50,10 +50,10 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
50	50	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
51	51	}
52	52
53		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	53	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
54	54	return asm volatile (
55	55	\\ syscall 0
56		: [ret] "={$r4}" (-> usize),
	56	: [ret] "={$r4}" (-> u64),
57	57	: [number] "{$r11}" (@intFromEnum(number)),
58	58	[arg1] "{$r4}" (arg1),
59	59	[arg2] "{$r5}" (arg2),
...	...	@@ -62,10 +62,10 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
62	62	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
63	63	}
64	64
65		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	65	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
66	66	return asm volatile (
67	67	\\ syscall 0
68		: [ret] "={$r4}" (-> usize),
	68	: [ret] "={$r4}" (-> u64),
69	69	: [number] "{$r11}" (@intFromEnum(number)),
70	70	[arg1] "{$r4}" (arg1),
71	71	[arg2] "{$r5}" (arg2),
...	...	@@ -77,16 +77,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
77	77
78	78	pub fn syscall6(
79	79	number: SYS,
80		arg1: usize,
81		arg2: usize,
82		arg3: usize,
83		arg4: usize,
84		arg5: usize,
85		arg6: usize,
86		) usize {
	80	arg1: u64,
	81	arg2: u64,
	82	arg3: u64,
	83	arg4: u64,
	84	arg5: u64,
	85	arg6: u64,
	86	) u64 {
87	87	return asm volatile (
88	88	\\ syscall 0
89		: [ret] "={$r4}" (-> usize),
	89	: [ret] "={$r4}" (-> u64),
90	90	: [number] "{$r11}" (@intFromEnum(number)),
91	91	[arg1] "{$r4}" (arg1),
92	92	[arg2] "{$r5}" (arg2),
...	...	@@ -97,7 +97,7 @@ pub fn syscall6(
97	97	: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
98	98	}
99	99
100		pub fn clone() callconv(.naked) usize {
	100	pub fn clone() callconv(.naked) u64 {
101	101	// __clone(func, stack, flags, arg, ptid, tls, ctid)
102	102	// a0, a1, a2, a3, a4, a5, a6
103	103	// sys_clone(flags, stack, ptid, ctid, tls)

lib/std/os/linux/m68k.zig+21-21

...	...	@@ -11,33 +11,33 @@ const sockaddr = linux.sockaddr;
11	11	const socklen_t = linux.socklen_t;
12	12	const timespec = std.os.linux.timespec;
13	13
14		pub fn syscall0(number: SYS) usize {
	14	pub fn syscall0(number: SYS) u32 {
15	15	return asm volatile ("trap #0"
16		: [ret] "={d0}" (-> usize),
	16	: [ret] "={d0}" (-> u32),
17	17	: [number] "{d0}" (@intFromEnum(number)),
18	18	: .{ .memory = true });
19	19	}
20	20
21		pub fn syscall1(number: SYS, arg1: usize) usize {
	21	pub fn syscall1(number: SYS, arg1: u32) u32 {
22	22	return asm volatile ("trap #0"
23		: [ret] "={d0}" (-> usize),
	23	: [ret] "={d0}" (-> u32),
24	24	: [number] "{d0}" (@intFromEnum(number)),
25	25	[arg1] "{d1}" (arg1),
26	26	: .{ .memory = true });
27	27	}
28	28
29		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	29	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
30	30	return asm volatile ("trap #0"
31		: [ret] "={d0}" (-> usize),
	31	: [ret] "={d0}" (-> u32),
32	32	: [number] "{d0}" (@intFromEnum(number)),
33	33	[arg1] "{d1}" (arg1),
34	34	[arg2] "{d2}" (arg2),
35	35	: .{ .memory = true });
36	36	}
37	37
38		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	38	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
39	39	return asm volatile ("trap #0"
40		: [ret] "={d0}" (-> usize),
	40	: [ret] "={d0}" (-> u32),
41	41	: [number] "{d0}" (@intFromEnum(number)),
42	42	[arg1] "{d1}" (arg1),
43	43	[arg2] "{d2}" (arg2),
...	...	@@ -45,9 +45,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45	45	: .{ .memory = true });
46	46	}
47	47
48		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	48	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
49	49	return asm volatile ("trap #0"
50		: [ret] "={d0}" (-> usize),
	50	: [ret] "={d0}" (-> u32),
51	51	: [number] "{d0}" (@intFromEnum(number)),
52	52	[arg1] "{d1}" (arg1),
53	53	[arg2] "{d2}" (arg2),
...	...	@@ -56,9 +56,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
56	56	: .{ .memory = true });
57	57	}
58	58
59		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	59	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
60	60	return asm volatile ("trap #0"
61		: [ret] "={d0}" (-> usize),
	61	: [ret] "={d0}" (-> u32),
62	62	: [number] "{d0}" (@intFromEnum(number)),
63	63	[arg1] "{d1}" (arg1),
64	64	[arg2] "{d2}" (arg2),
...	...	@@ -70,15 +70,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
70	70
71	71	pub fn syscall6(
72	72	number: SYS,
73		arg1: usize,
74		arg2: usize,
75		arg3: usize,
76		arg4: usize,
77		arg5: usize,
78		arg6: usize,
79		) usize {
	73	arg1: u32,
	74	arg2: u32,
	75	arg3: u32,
	76	arg4: u32,
	77	arg5: u32,
	78	arg6: u32,
	79	) u32 {
80	80	return asm volatile ("trap #0"
81		: [ret] "={d0}" (-> usize),
	81	: [ret] "={d0}" (-> u32),
82	82	: [number] "{d0}" (@intFromEnum(number)),
83	83	[arg1] "{d1}" (arg1),
84	84	[arg2] "{d2}" (arg2),
...	...	@@ -89,7 +89,7 @@ pub fn syscall6(
89	89	: .{ .memory = true });
90	90	}
91	91
92		pub fn clone() callconv(.naked) usize {
	92	pub fn clone() callconv(.naked) u32 {
93	93	// __clone(func, stack, flags, arg, ptid, tls, ctid)
94	94	// +4, +8, +12, +16, +20, +24, +28
95	95	//

lib/std/os/linux/mips.zig+32-32

...	...	@@ -14,19 +14,19 @@ const sigset_t = linux.sigset_t;
14	14	const sockaddr = linux.sockaddr;
15	15	const timespec = linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u32 {
18	18	return asm volatile (
19	19	\\ syscall
20	20	\\ beq $7, $zero, 1f
21	21	\\ blez $2, 1f
22	22	\\ subu $2, $0, $2
23	23	\\ 1:
24		: [ret] "={$2}" (-> usize),
	24	: [ret] "={$2}" (-> u32),
25	25	: [number] "{$2}" (@intFromEnum(number)),
26	26	: .{ .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 });
27	27	}
28	28
29		pub fn syscall_pipe(fd: *[2]i32) usize {
	29	pub fn syscall_pipe(fd: *[2]i32) u32 {
30	30	return asm volatile (
31	31	\\ .set noat
32	32	\\ .set noreorder
...	...	@@ -39,47 +39,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
39	39	\\ sw $2, 0($4)
40	40	\\ sw $3, 4($4)
41	41	\\ 2:
42		: [ret] "={$2}" (-> usize),
	42	: [ret] "={$2}" (-> u32),
43	43	: [number] "{$2}" (@intFromEnum(SYS.pipe)),
44	44	[fd] "{$4}" (fd),
45	45	: .{ .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 });
46	46	}
47	47
48		pub fn syscall1(number: SYS, arg1: usize) usize {
	48	pub fn syscall1(number: SYS, arg1: u32) u32 {
49	49	return asm volatile (
50	50	\\ syscall
51	51	\\ beq $7, $zero, 1f
52	52	\\ blez $2, 1f
53	53	\\ subu $2, $0, $2
54	54	\\ 1:
55		: [ret] "={$2}" (-> usize),
	55	: [ret] "={$2}" (-> u32),
56	56	: [number] "{$2}" (@intFromEnum(number)),
57	57	[arg1] "{$4}" (arg1),
58	58	: .{ .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 });
59	59	}
60	60
61		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	61	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
62	62	return asm volatile (
63	63	\\ syscall
64	64	\\ beq $7, $zero, 1f
65	65	\\ blez $2, 1f
66	66	\\ subu $2, $0, $2
67	67	\\ 1:
68		: [ret] "={$2}" (-> usize),
	68	: [ret] "={$2}" (-> u32),
69	69	: [number] "{$2}" (@intFromEnum(number)),
70	70	[arg1] "{$4}" (arg1),
71	71	[arg2] "{$5}" (arg2),
72	72	: .{ .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 });
73	73	}
74	74
75		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	75	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
76	76	return asm volatile (
77	77	\\ syscall
78	78	\\ beq $7, $zero, 1f
79	79	\\ blez $2, 1f
80	80	\\ subu $2, $0, $2
81	81	\\ 1:
82		: [ret] "={$2}" (-> usize),
	82	: [ret] "={$2}" (-> u32),
83	83	: [number] "{$2}" (@intFromEnum(number)),
84	84	[arg1] "{$4}" (arg1),
85	85	[arg2] "{$5}" (arg2),
...	...	@@ -87,14 +87,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
87	87	: .{ .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 });
88	88	}
89	89
90		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	90	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
91	91	return asm volatile (
92	92	\\ syscall
93	93	\\ beq $7, $zero, 1f
94	94	\\ blez $2, 1f
95	95	\\ subu $2, $0, $2
96	96	\\ 1:
97		: [ret] "={$2}" (-> usize),
	97	: [ret] "={$2}" (-> u32),
98	98	: [number] "{$2}" (@intFromEnum(number)),
99	99	[arg1] "{$4}" (arg1),
100	100	[arg2] "{$5}" (arg2),
...	...	@@ -103,7 +103,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
103	103	: .{ .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 });
104	104	}
105	105
106		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	106	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
107	107	return asm volatile (
108	108	\\ .set noat
109	109	\\ subu $sp, $sp, 24
...	...	@@ -114,7 +114,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
114	114	\\ blez $2, 1f
115	115	\\ subu $2, $0, $2
116	116	\\ 1:
117		: [ret] "={$2}" (-> usize),
	117	: [ret] "={$2}" (-> u32),
118	118	: [number] "{$2}" (@intFromEnum(number)),
119	119	[arg1] "{$4}" (arg1),
120	120	[arg2] "{$5}" (arg2),
...	...	@@ -129,13 +129,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
129	129
130	130	pub fn syscall6(
131	131	number: SYS,
132		arg1: usize,
133		arg2: usize,
134		arg3: usize,
135		arg4: usize,
136		arg5: usize,
137		arg6: usize,
138		) usize {
	132	arg1: u32,
	133	arg2: u32,
	134	arg3: u32,
	135	arg4: u32,
	136	arg5: u32,
	137	arg6: u32,
	138	) u32 {
139	139	return asm volatile (
140	140	\\ .set noat
141	141	\\ subu $sp, $sp, 24
...	...	@@ -147,7 +147,7 @@ pub fn syscall6(
147	147	\\ blez $2, 1f
148	148	\\ subu $2, $0, $2
149	149	\\ 1:
150		: [ret] "={$2}" (-> usize),
	150	: [ret] "={$2}" (-> u32),
151	151	: [number] "{$2}" (@intFromEnum(number)),
152	152	[arg1] "{$4}" (arg1),
153	153	[arg2] "{$5}" (arg2),
...	...	@@ -160,14 +160,14 @@ pub fn syscall6(
160	160
161	161	pub fn syscall7(
162	162	number: SYS,
163		arg1: usize,
164		arg2: usize,
165		arg3: usize,
166		arg4: usize,
167		arg5: usize,
168		arg6: usize,
169		arg7: usize,
170		) usize {
	163	arg1: u32,
	164	arg2: u32,
	165	arg3: u32,
	166	arg4: u32,
	167	arg5: u32,
	168	arg6: u32,
	169	arg7: u32,
	170	) u32 {
171	171	return asm volatile (
172	172	\\ .set noat
173	173	\\ subu $sp, $sp, 32
...	...	@@ -180,7 +180,7 @@ pub fn syscall7(
180	180	\\ blez $2, 1f
181	181	\\ subu $2, $0, $2
182	182	\\ 1:
183		: [ret] "={$2}" (-> usize),
	183	: [ret] "={$2}" (-> u32),
184	184	: [number] "{$2}" (@intFromEnum(number)),
185	185	[arg1] "{$4}" (arg1),
186	186	[arg2] "{$5}" (arg2),
...	...	@@ -192,7 +192,7 @@ pub fn syscall7(
192	192	: .{ .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 });
193	193	}
194	194
195		pub fn clone() callconv(.naked) usize {
	195	pub fn clone() callconv(.naked) u32 {
196	196	// __clone(func, stack, flags, arg, ptid, tls, ctid)
197	197	// 3, 4, 5, 6, 7, 8, 9
198	198	//

lib/std/os/linux/mips64.zig+32-32

...	...	@@ -14,19 +14,19 @@ const sigset_t = linux.sigset_t;
14	14	const sockaddr = linux.sockaddr;
15	15	const timespec = linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u64 {
18	18	return asm volatile (
19	19	\\ syscall
20	20	\\ beq $7, $zero, 1f
21	21	\\ blez $2, 1f
22	22	\\ dsubu $2, $0, $2
23	23	\\ 1:
24		: [ret] "={$2}" (-> usize),
	24	: [ret] "={$2}" (-> u64),
25	25	: [number] "{$2}" (@intFromEnum(number)),
26	26	: .{ .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 });
27	27	}
28	28
29		pub fn syscall_pipe(fd: *[2]i32) usize {
	29	pub fn syscall_pipe(fd: *[2]i32) u64 {
30	30	return asm volatile (
31	31	\\ .set noat
32	32	\\ .set noreorder
...	...	@@ -39,13 +39,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
39	39	\\ sw $2, 0($4)
40	40	\\ sw $3, 4($4)
41	41	\\ 2:
42		: [ret] "={$2}" (-> usize),
	42	: [ret] "={$2}" (-> u64),
43	43	: [number] "{$2}" (@intFromEnum(SYS.pipe)),
44	44	[fd] "{$4}" (fd),
45	45	: .{ .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 });
46	46	}
47	47
48		pub fn syscall1(number: SYS, arg1: usize) usize {
	48	pub fn syscall1(number: SYS, arg1: u64) u64 {
49	49	return asm volatile (
50	50	\\ syscall
51	51	\\ beq $7, $zero, 1f
...	...	@@ -53,34 +53,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
53	53	\\ nop
54	54	\\ dsubu $2, $0, $2
55	55	\\ 1:
56		: [ret] "={$2}" (-> usize),
	56	: [ret] "={$2}" (-> u64),
57	57	: [number] "{$2}" (@intFromEnum(number)),
58	58	[arg1] "{$4}" (arg1),
59	59	: .{ .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 });
60	60	}
61	61
62		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	62	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
63	63	return asm volatile (
64	64	\\ syscall
65	65	\\ beq $7, $zero, 1f
66	66	\\ blez $2, 1f
67	67	\\ dsubu $2, $0, $2
68	68	\\ 1:
69		: [ret] "={$2}" (-> usize),
	69	: [ret] "={$2}" (-> u64),
70	70	: [number] "{$2}" (@intFromEnum(number)),
71	71	[arg1] "{$4}" (arg1),
72	72	[arg2] "{$5}" (arg2),
73	73	: .{ .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 });
74	74	}
75	75
76		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	76	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
77	77	return asm volatile (
78	78	\\ syscall
79	79	\\ beq $7, $zero, 1f
80	80	\\ blez $2, 1f
81	81	\\ dsubu $2, $0, $2
82	82	\\ 1:
83		: [ret] "={$2}" (-> usize),
	83	: [ret] "={$2}" (-> u64),
84	84	: [number] "{$2}" (@intFromEnum(number)),
85	85	[arg1] "{$4}" (arg1),
86	86	[arg2] "{$5}" (arg2),
...	...	@@ -88,14 +88,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
88	88	: .{ .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 });
89	89	}
90	90
91		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	91	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
92	92	return asm volatile (
93	93	\\ syscall
94	94	\\ beq $7, $zero, 1f
95	95	\\ blez $2, 1f
96	96	\\ dsubu $2, $0, $2
97	97	\\ 1:
98		: [ret] "={$2}" (-> usize),
	98	: [ret] "={$2}" (-> u64),
99	99	: [number] "{$2}" (@intFromEnum(number)),
100	100	[arg1] "{$4}" (arg1),
101	101	[arg2] "{$5}" (arg2),
...	...	@@ -104,14 +104,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
104	104	: .{ .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 });
105	105	}
106	106
107		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	107	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
108	108	return asm volatile (
109	109	\\ syscall
110	110	\\ beq $7, $zero, 1f
111	111	\\ blez $2, 1f
112	112	\\ dsubu $2, $0, $2
113	113	\\ 1:
114		: [ret] "={$2}" (-> usize),
	114	: [ret] "={$2}" (-> u64),
115	115	: [number] "{$2}" (@intFromEnum(number)),
116	116	[arg1] "{$4}" (arg1),
117	117	[arg2] "{$5}" (arg2),
...	...	@@ -123,20 +123,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
123	123
124	124	pub fn syscall6(
125	125	number: SYS,
126		arg1: usize,
127		arg2: usize,
128		arg3: usize,
129		arg4: usize,
130		arg5: usize,
131		arg6: usize,
132		) usize {
	126	arg1: u64,
	127	arg2: u64,
	128	arg3: u64,
	129	arg4: u64,
	130	arg5: u64,
	131	arg6: u64,
	132	) u64 {
133	133	return asm volatile (
134	134	\\ syscall
135	135	\\ beq $7, $zero, 1f
136	136	\\ blez $2, 1f
137	137	\\ dsubu $2, $0, $2
138	138	\\ 1:
139		: [ret] "={$2}" (-> usize),
	139	: [ret] "={$2}" (-> u64),
140	140	: [number] "{$2}" (@intFromEnum(number)),
141	141	[arg1] "{$4}" (arg1),
142	142	[arg2] "{$5}" (arg2),
...	...	@@ -149,21 +149,21 @@ pub fn syscall6(
149	149
150	150	pub fn syscall7(
151	151	number: SYS,
152		arg1: usize,
153		arg2: usize,
154		arg3: usize,
155		arg4: usize,
156		arg5: usize,
157		arg6: usize,
158		arg7: usize,
159		) usize {
	152	arg1: u64,
	153	arg2: u64,
	154	arg3: u64,
	155	arg4: u64,
	156	arg5: u64,
	157	arg6: u64,
	158	arg7: u64,
	159	) u64 {
160	160	return asm volatile (
161	161	\\ syscall
162	162	\\ beq $7, $zero, 1f
163	163	\\ blez $2, 1f
164	164	\\ dsubu $2, $0, $2
165	165	\\ 1:
166		: [ret] "={$2}" (-> usize),
	166	: [ret] "={$2}" (-> u64),
167	167	: [number] "{$2}" (@intFromEnum(number)),
168	168	[arg1] "{$4}" (arg1),
169	169	[arg2] "{$5}" (arg2),
...	...	@@ -175,7 +175,7 @@ pub fn syscall7(
175	175	: .{ .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	176	}
177	177
178		pub fn clone() callconv(.naked) usize {
	178	pub fn clone() callconv(.naked) u64 {
179	179	// __clone(func, stack, flags, arg, ptid, tls, ctid)
180	180	// 3, 4, 5, 6, 7, 8, 9
181	181	//

lib/std/os/linux/powerpc.zig+44-44

...	...	@@ -14,48 +14,48 @@ const sigset_t = linux.sigset_t;
14	14	const sockaddr = linux.sockaddr;
15	15	const timespec = linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u32 {
18	18	// r0 is both an input register and a clobber. musl and glibc achieve this with
19	19	// a "+" constraint, which isn't supported in Zig, so instead we separately list
20	20	// r0 as both an input and an output. (Listing it as an input and a clobber would
21	21	// cause the C backend to emit invalid code; see #25209.)
22		var r0_out: usize = undefined;
	22	var r0_out: u32 = undefined;
23	23	return asm volatile (
24	24	\\ sc
25	25	\\ bns+ 1f
26	26	\\ neg 3, 3
27	27	\\ 1:
28		: [ret] "={r3}" (-> usize),
	28	: [ret] "={r3}" (-> u32),
29	29	[r0_out] "={r0}" (r0_out),
30	30	: [number] "{r0}" (@intFromEnum(number)),
31	31	: .{ .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 });
32	32	}
33	33
34		pub fn syscall1(number: SYS, arg1: usize) usize {
	34	pub fn syscall1(number: SYS, arg1: u32) u32 {
35	35	// r0 is both an input and a clobber.
36		var r0_out: usize = undefined;
	36	var r0_out: u32 = undefined;
37	37	return asm volatile (
38	38	\\ sc
39	39	\\ bns+ 1f
40	40	\\ neg 3, 3
41	41	\\ 1:
42		: [ret] "={r3}" (-> usize),
	42	: [ret] "={r3}" (-> u32),
43	43	[r0_out] "={r0}" (r0_out),
44	44	: [number] "{r0}" (@intFromEnum(number)),
45	45	[arg1] "{r3}" (arg1),
46	46	: .{ .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 });
47	47	}
48	48
49		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	49	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
50	50	// These registers are both inputs and clobbers.
51		var r0_out: usize = undefined;
52		var r4_out: usize = undefined;
	51	var r0_out: u32 = undefined;
	52	var r4_out: u32 = undefined;
53	53	return asm volatile (
54	54	\\ sc
55	55	\\ bns+ 1f
56	56	\\ neg 3, 3
57	57	\\ 1:
58		: [ret] "={r3}" (-> usize),
	58	: [ret] "={r3}" (-> u32),
59	59	[r0_out] "={r0}" (r0_out),
60	60	[r4_out] "={r4}" (r4_out),
61	61	: [number] "{r0}" (@intFromEnum(number)),
...	...	@@ -64,17 +64,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
64	64	: .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
65	65	}
66	66
67		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	67	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
68	68	// These registers are both inputs and clobbers.
69		var r0_out: usize = undefined;
70		var r4_out: usize = undefined;
71		var r5_out: usize = undefined;
	69	var r0_out: u32 = undefined;
	70	var r4_out: u32 = undefined;
	71	var r5_out: u32 = undefined;
72	72	return asm volatile (
73	73	\\ sc
74	74	\\ bns+ 1f
75	75	\\ neg 3, 3
76	76	\\ 1:
77		: [ret] "={r3}" (-> usize),
	77	: [ret] "={r3}" (-> u32),
78	78	[r0_out] "={r0}" (r0_out),
79	79	[r4_out] "={r4}" (r4_out),
80	80	[r5_out] "={r5}" (r5_out),
...	...	@@ -85,18 +85,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
85	85	: .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
86	86	}
87	87
88		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	88	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
89	89	// These registers are both inputs and clobbers.
90		var r0_out: usize = undefined;
91		var r4_out: usize = undefined;
92		var r5_out: usize = undefined;
93		var r6_out: usize = undefined;
	90	var r0_out: u32 = undefined;
	91	var r4_out: u32 = undefined;
	92	var r5_out: u32 = undefined;
	93	var r6_out: u32 = undefined;
94	94	return asm volatile (
95	95	\\ sc
96	96	\\ bns+ 1f
97	97	\\ neg 3, 3
98	98	\\ 1:
99		: [ret] "={r3}" (-> usize),
	99	: [ret] "={r3}" (-> u32),
100	100	[r0_out] "={r0}" (r0_out),
101	101	[r4_out] "={r4}" (r4_out),
102	102	[r5_out] "={r5}" (r5_out),
...	...	@@ -109,19 +109,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109	109	: .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
110	110	}
111	111
112		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	112	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
113	113	// These registers are both inputs and clobbers.
114		var r0_out: usize = undefined;
115		var r4_out: usize = undefined;
116		var r5_out: usize = undefined;
117		var r6_out: usize = undefined;
118		var r7_out: usize = undefined;
	114	var r0_out: u32 = undefined;
	115	var r4_out: u32 = undefined;
	116	var r5_out: u32 = undefined;
	117	var r6_out: u32 = undefined;
	118	var r7_out: u32 = undefined;
119	119	return asm volatile (
120	120	\\ sc
121	121	\\ bns+ 1f
122	122	\\ neg 3, 3
123	123	\\ 1:
124		: [ret] "={r3}" (-> usize),
	124	: [ret] "={r3}" (-> u32),
125	125	[r0_out] "={r0}" (r0_out),
126	126	[r4_out] "={r4}" (r4_out),
127	127	[r5_out] "={r5}" (r5_out),
...	...	@@ -138,26 +138,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
138	138
139	139	pub fn syscall6(
140	140	number: SYS,
141		arg1: usize,
142		arg2: usize,
143		arg3: usize,
144		arg4: usize,
145		arg5: usize,
146		arg6: usize,
147		) usize {
	141	arg1: u32,
	142	arg2: u32,
	143	arg3: u32,
	144	arg4: u32,
	145	arg5: u32,
	146	arg6: u32,
	147	) u32 {
148	148	// These registers are both inputs and clobbers.
149		var r0_out: usize = undefined;
150		var r4_out: usize = undefined;
151		var r5_out: usize = undefined;
152		var r6_out: usize = undefined;
153		var r7_out: usize = undefined;
154		var r8_out: usize = undefined;
	149	var r0_out: u32 = undefined;
	150	var r4_out: u32 = undefined;
	151	var r5_out: u32 = undefined;
	152	var r6_out: u32 = undefined;
	153	var r7_out: u32 = undefined;
	154	var r8_out: u32 = undefined;
155	155	return asm volatile (
156	156	\\ sc
157	157	\\ bns+ 1f
158	158	\\ neg 3, 3
159	159	\\ 1:
160		: [ret] "={r3}" (-> usize),
	160	: [ret] "={r3}" (-> u32),
161	161	[r0_out] "={r0}" (r0_out),
162	162	[r4_out] "={r4}" (r4_out),
163	163	[r5_out] "={r5}" (r5_out),
...	...	@@ -174,7 +174,7 @@ pub fn syscall6(
174	174	: .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
175	175	}
176	176
177		pub fn clone() callconv(.naked) usize {
	177	pub fn clone() callconv(.naked) u32 {
178	178	// __clone(func, stack, flags, arg, ptid, tls, ctid)
179	179	// 3, 4, 5, 6, 7, 8, 9
180	180	//
...	...	@@ -303,7 +303,7 @@ pub const Flock = extern struct {
303	303
304	304	pub const blksize_t = i32;
305	305	pub const nlink_t = u32;
306		pub const time_t = isize;
	306	pub const time_t = i32;
307	307	pub const mode_t = u32;
308	308	pub const off_t = i64;
309	309	pub const ino_t = u64;

lib/std/os/linux/powerpc64.zig+43-43

...	...	@@ -14,48 +14,48 @@ const sigset_t = linux.sigset_t;
14	14	const sockaddr = linux.sockaddr;
15	15	const timespec = linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u64 {
18	18	// r0 is both an input register and a clobber. musl and glibc achieve this with
19	19	// a "+" constraint, which isn't supported in Zig, so instead we separately list
20	20	// r0 as both an input and an output. (Listing it as an input and a clobber would
21	21	// cause the C backend to emit invalid code; see #25209.)
22		var r0_out: usize = undefined;
	22	var r0_out: u64 = undefined;
23	23	return asm volatile (
24	24	\\ sc
25	25	\\ bns+ 1f
26	26	\\ neg 3, 3
27	27	\\ 1:
28		: [ret] "={r3}" (-> usize),
	28	: [ret] "={r3}" (-> u64),
29	29	[r0_out] "={r0}" (r0_out),
30	30	: [number] "{r0}" (@intFromEnum(number)),
31	31	: .{ .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 });
32	32	}
33	33
34		pub fn syscall1(number: SYS, arg1: usize) usize {
	34	pub fn syscall1(number: SYS, arg1: u64) u64 {
35	35	// r0 is both an input and a clobber.
36		var r0_out: usize = undefined;
	36	var r0_out: u64 = undefined;
37	37	return asm volatile (
38	38	\\ sc
39	39	\\ bns+ 1f
40	40	\\ neg 3, 3
41	41	\\ 1:
42		: [ret] "={r3}" (-> usize),
	42	: [ret] "={r3}" (-> u64),
43	43	[r0_out] "={r0}" (r0_out),
44	44	: [number] "{r0}" (@intFromEnum(number)),
45	45	[arg1] "{r3}" (arg1),
46	46	: .{ .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 });
47	47	}
48	48
49		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	49	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
50	50	// These registers are both inputs and clobbers.
51		var r0_out: usize = undefined;
52		var r4_out: usize = undefined;
	51	var r0_out: u64 = undefined;
	52	var r4_out: u64 = undefined;
53	53	return asm volatile (
54	54	\\ sc
55	55	\\ bns+ 1f
56	56	\\ neg 3, 3
57	57	\\ 1:
58		: [ret] "={r3}" (-> usize),
	58	: [ret] "={r3}" (-> u64),
59	59	[r0_out] "={r0}" (r0_out),
60	60	[r4_out] "={r4}" (r4_out),
61	61	: [number] "{r0}" (@intFromEnum(number)),
...	...	@@ -64,17 +64,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
64	64	: .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
65	65	}
66	66
67		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	67	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
68	68	// These registers are both inputs and clobbers.
69		var r0_out: usize = undefined;
70		var r4_out: usize = undefined;
71		var r5_out: usize = undefined;
	69	var r0_out: u64 = undefined;
	70	var r4_out: u64 = undefined;
	71	var r5_out: u64 = undefined;
72	72	return asm volatile (
73	73	\\ sc
74	74	\\ bns+ 1f
75	75	\\ neg 3, 3
76	76	\\ 1:
77		: [ret] "={r3}" (-> usize),
	77	: [ret] "={r3}" (-> u64),
78	78	[r0_out] "={r0}" (r0_out),
79	79	[r4_out] "={r4}" (r4_out),
80	80	[r5_out] "={r5}" (r5_out),
...	...	@@ -85,18 +85,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
85	85	: .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
86	86	}
87	87
88		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	88	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
89	89	// These registers are both inputs and clobbers.
90		var r0_out: usize = undefined;
91		var r4_out: usize = undefined;
92		var r5_out: usize = undefined;
93		var r6_out: usize = undefined;
	90	var r0_out: u64 = undefined;
	91	var r4_out: u64 = undefined;
	92	var r5_out: u64 = undefined;
	93	var r6_out: u64 = undefined;
94	94	return asm volatile (
95	95	\\ sc
96	96	\\ bns+ 1f
97	97	\\ neg 3, 3
98	98	\\ 1:
99		: [ret] "={r3}" (-> usize),
	99	: [ret] "={r3}" (-> u64),
100	100	[r0_out] "={r0}" (r0_out),
101	101	[r4_out] "={r4}" (r4_out),
102	102	[r5_out] "={r5}" (r5_out),
...	...	@@ -109,19 +109,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109	109	: .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
110	110	}
111	111
112		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	112	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
113	113	// These registers are both inputs and clobbers.
114		var r0_out: usize = undefined;
115		var r4_out: usize = undefined;
116		var r5_out: usize = undefined;
117		var r6_out: usize = undefined;
118		var r7_out: usize = undefined;
	114	var r0_out: u64 = undefined;
	115	var r4_out: u64 = undefined;
	116	var r5_out: u64 = undefined;
	117	var r6_out: u64 = undefined;
	118	var r7_out: u64 = undefined;
119	119	return asm volatile (
120	120	\\ sc
121	121	\\ bns+ 1f
122	122	\\ neg 3, 3
123	123	\\ 1:
124		: [ret] "={r3}" (-> usize),
	124	: [ret] "={r3}" (-> u64),
125	125	[r0_out] "={r0}" (r0_out),
126	126	[r4_out] "={r4}" (r4_out),
127	127	[r5_out] "={r5}" (r5_out),
...	...	@@ -138,26 +138,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
138	138
139	139	pub fn syscall6(
140	140	number: SYS,
141		arg1: usize,
142		arg2: usize,
143		arg3: usize,
144		arg4: usize,
145		arg5: usize,
146		arg6: usize,
147		) usize {
	141	arg1: u64,
	142	arg2: u64,
	143	arg3: u64,
	144	arg4: u64,
	145	arg5: u64,
	146	arg6: u64,
	147	) u64 {
148	148	// These registers are both inputs and clobbers.
149		var r0_out: usize = undefined;
150		var r4_out: usize = undefined;
151		var r5_out: usize = undefined;
152		var r6_out: usize = undefined;
153		var r7_out: usize = undefined;
154		var r8_out: usize = undefined;
	149	var r0_out: u64 = undefined;
	150	var r4_out: u64 = undefined;
	151	var r5_out: u64 = undefined;
	152	var r6_out: u64 = undefined;
	153	var r7_out: u64 = undefined;
	154	var r8_out: u64 = undefined;
155	155	return asm volatile (
156	156	\\ sc
157	157	\\ bns+ 1f
158	158	\\ neg 3, 3
159	159	\\ 1:
160		: [ret] "={r3}" (-> usize),
	160	: [ret] "={r3}" (-> u64),
161	161	[r0_out] "={r0}" (r0_out),
162	162	[r4_out] "={r4}" (r4_out),
163	163	[r5_out] "={r5}" (r5_out),
...	...	@@ -174,7 +174,7 @@ pub fn syscall6(
174	174	: .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
175	175	}
176	176
177		pub fn clone() callconv(.naked) usize {
	177	pub fn clone() callconv(.naked) u64 {
178	178	// __clone(func, stack, flags, arg, ptid, tls, ctid)
179	179	// 3, 4, 5, 6, 7, 8, 9
180	180	//

lib/std/os/linux/riscv32.zig+22-22

...	...	@@ -13,33 +13,33 @@ const sockaddr = linux.sockaddr;
13	13	const socklen_t = linux.socklen_t;
14	14	const timespec = std.os.linux.timespec;
15	15
16		pub fn syscall0(number: SYS) usize {
	16	pub fn syscall0(number: SYS) u32 {
17	17	return asm volatile ("ecall"
18		: [ret] "={x10}" (-> usize),
	18	: [ret] "={x10}" (-> u32),
19	19	: [number] "{x17}" (@intFromEnum(number)),
20	20	: .{ .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u32) u32 {
24	24	return asm volatile ("ecall"
25		: [ret] "={x10}" (-> usize),
	25	: [ret] "={x10}" (-> u32),
26	26	: [number] "{x17}" (@intFromEnum(number)),
27	27	[arg1] "{x10}" (arg1),
28	28	: .{ .memory = true });
29	29	}
30	30
31		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	31	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32	32	return asm volatile ("ecall"
33		: [ret] "={x10}" (-> usize),
	33	: [ret] "={x10}" (-> u32),
34	34	: [number] "{x17}" (@intFromEnum(number)),
35	35	[arg1] "{x10}" (arg1),
36	36	[arg2] "{x11}" (arg2),
37	37	: .{ .memory = true });
38	38	}
39	39
40		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	40	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41	41	return asm volatile ("ecall"
42		: [ret] "={x10}" (-> usize),
	42	: [ret] "={x10}" (-> u32),
43	43	: [number] "{x17}" (@intFromEnum(number)),
44	44	[arg1] "{x10}" (arg1),
45	45	[arg2] "{x11}" (arg2),
...	...	@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47	47	: .{ .memory = true });
48	48	}
49	49
50		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	50	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51	51	return asm volatile ("ecall"
52		: [ret] "={x10}" (-> usize),
	52	: [ret] "={x10}" (-> u32),
53	53	: [number] "{x17}" (@intFromEnum(number)),
54	54	[arg1] "{x10}" (arg1),
55	55	[arg2] "{x11}" (arg2),
...	...	@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58	58	: .{ .memory = true });
59	59	}
60	60
61		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	61	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62	62	return asm volatile ("ecall"
63		: [ret] "={x10}" (-> usize),
	63	: [ret] "={x10}" (-> u32),
64	64	: [number] "{x17}" (@intFromEnum(number)),
65	65	[arg1] "{x10}" (arg1),
66	66	[arg2] "{x11}" (arg2),
...	...	@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
72	72
73	73	pub fn syscall6(
74	74	number: SYS,
75		arg1: usize,
76		arg2: usize,
77		arg3: usize,
78		arg4: usize,
79		arg5: usize,
80		arg6: usize,
81		) usize {
	75	arg1: u32,
	76	arg2: u32,
	77	arg3: u32,
	78	arg4: u32,
	79	arg5: u32,
	80	arg6: u32,
	81	) u32 {
82	82	return asm volatile ("ecall"
83		: [ret] "={x10}" (-> usize),
	83	: [ret] "={x10}" (-> u32),
84	84	: [number] "{x17}" (@intFromEnum(number)),
85	85	[arg1] "{x10}" (arg1),
86	86	[arg2] "{x11}" (arg2),
...	...	@@ -91,7 +91,7 @@ pub fn syscall6(
91	91	: .{ .memory = true });
92	92	}
93	93
94		pub fn clone() callconv(.naked) usize {
	94	pub fn clone() callconv(.naked) u32 {
95	95	// __clone(func, stack, flags, arg, ptid, tls, ctid)
96	96	// a0, a1, a2, a3, a4, a5, a6
97	97	//
...	...	@@ -186,7 +186,7 @@ pub const Stat = extern struct {
186	186	uid: uid_t,
187	187	gid: gid_t,
188	188	rdev: dev_t,
189		__pad: usize,
	189	__pad: u32,
190	190	size: off_t,
191	191	blksize: blksize_t,
192	192	__pad2: i32,

lib/std/os/linux/riscv64.zig+22-22

...	...	@@ -13,33 +13,33 @@ const sockaddr = linux.sockaddr;
13	13	const socklen_t = linux.socklen_t;
14	14	const timespec = std.os.linux.timespec;
15	15
16		pub fn syscall0(number: SYS) usize {
	16	pub fn syscall0(number: SYS) u64 {
17	17	return asm volatile ("ecall"
18		: [ret] "={x10}" (-> usize),
	18	: [ret] "={x10}" (-> u64),
19	19	: [number] "{x17}" (@intFromEnum(number)),
20	20	: .{ .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u64) u64 {
24	24	return asm volatile ("ecall"
25		: [ret] "={x10}" (-> usize),
	25	: [ret] "={x10}" (-> u64),
26	26	: [number] "{x17}" (@intFromEnum(number)),
27	27	[arg1] "{x10}" (arg1),
28	28	: .{ .memory = true });
29	29	}
30	30
31		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	31	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
32	32	return asm volatile ("ecall"
33		: [ret] "={x10}" (-> usize),
	33	: [ret] "={x10}" (-> u64),
34	34	: [number] "{x17}" (@intFromEnum(number)),
35	35	[arg1] "{x10}" (arg1),
36	36	[arg2] "{x11}" (arg2),
37	37	: .{ .memory = true });
38	38	}
39	39
40		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	40	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
41	41	return asm volatile ("ecall"
42		: [ret] "={x10}" (-> usize),
	42	: [ret] "={x10}" (-> u64),
43	43	: [number] "{x17}" (@intFromEnum(number)),
44	44	[arg1] "{x10}" (arg1),
45	45	[arg2] "{x11}" (arg2),
...	...	@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47	47	: .{ .memory = true });
48	48	}
49	49
50		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	50	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
51	51	return asm volatile ("ecall"
52		: [ret] "={x10}" (-> usize),
	52	: [ret] "={x10}" (-> u64),
53	53	: [number] "{x17}" (@intFromEnum(number)),
54	54	[arg1] "{x10}" (arg1),
55	55	[arg2] "{x11}" (arg2),
...	...	@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58	58	: .{ .memory = true });
59	59	}
60	60
61		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	61	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
62	62	return asm volatile ("ecall"
63		: [ret] "={x10}" (-> usize),
	63	: [ret] "={x10}" (-> u64),
64	64	: [number] "{x17}" (@intFromEnum(number)),
65	65	[arg1] "{x10}" (arg1),
66	66	[arg2] "{x11}" (arg2),
...	...	@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
72	72
73	73	pub fn syscall6(
74	74	number: SYS,
75		arg1: usize,
76		arg2: usize,
77		arg3: usize,
78		arg4: usize,
79		arg5: usize,
80		arg6: usize,
81		) usize {
	75	arg1: u64,
	76	arg2: u64,
	77	arg3: u64,
	78	arg4: u64,
	79	arg5: u64,
	80	arg6: u64,
	81	) u64 {
82	82	return asm volatile ("ecall"
83		: [ret] "={x10}" (-> usize),
	83	: [ret] "={x10}" (-> u64),
84	84	: [number] "{x17}" (@intFromEnum(number)),
85	85	[arg1] "{x10}" (arg1),
86	86	[arg2] "{x11}" (arg2),
...	...	@@ -91,7 +91,7 @@ pub fn syscall6(
91	91	: .{ .memory = true });
92	92	}
93	93
94		pub fn clone() callconv(.naked) usize {
	94	pub fn clone() callconv(.naked) u64 {
95	95	// __clone(func, stack, flags, arg, ptid, tls, ctid)
96	96	// a0, a1, a2, a3, a4, a5, a6
97	97	//
...	...	@@ -186,7 +186,7 @@ pub const Stat = extern struct {
186	186	uid: uid_t,
187	187	gid: gid_t,
188	188	rdev: dev_t,
189		__pad: usize,
	189	__pad: u64,
190	190	size: off_t,
191	191	blksize: blksize_t,
192	192	__pad2: i32,

lib/std/os/linux/s390x.zig+15-15

...	...	@@ -13,33 +13,33 @@ const timespec = std.os.linux.timespec;
13	13	const stack_t = std.os.linux.stack_t;
14	14	const sigset_t = std.os.linux.sigset_t;
15	15
16		pub fn syscall0(number: SYS) usize {
	16	pub fn syscall0(number: SYS) u64 {
17	17	return asm volatile ("svc 0"
18		: [ret] "={r2}" (-> usize),
	18	: [ret] "={r2}" (-> u64),
19	19	: [number] "{r1}" (@intFromEnum(number)),
20	20	: .{ .memory = true });
21	21	}
22	22
23		pub fn syscall1(number: SYS, arg1: usize) usize {
	23	pub fn syscall1(number: SYS, arg1: u64) u64 {
24	24	return asm volatile ("svc 0"
25		: [ret] "={r2}" (-> usize),
	25	: [ret] "={r2}" (-> u64),
26	26	: [number] "{r1}" (@intFromEnum(number)),
27	27	[arg1] "{r2}" (arg1),
28	28	: .{ .memory = true });
29	29	}
30	30
31		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	31	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
32	32	return asm volatile ("svc 0"
33		: [ret] "={r2}" (-> usize),
	33	: [ret] "={r2}" (-> u64),
34	34	: [number] "{r1}" (@intFromEnum(number)),
35	35	[arg1] "{r2}" (arg1),
36	36	[arg2] "{r3}" (arg2),
37	37	: .{ .memory = true });
38	38	}
39	39
40		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	40	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
41	41	return asm volatile ("svc 0"
42		: [ret] "={r2}" (-> usize),
	42	: [ret] "={r2}" (-> u64),
43	43	: [number] "{r1}" (@intFromEnum(number)),
44	44	[arg1] "{r2}" (arg1),
45	45	[arg2] "{r3}" (arg2),
...	...	@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47	47	: .{ .memory = true });
48	48	}
49	49
50		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	50	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
51	51	return asm volatile ("svc 0"
52		: [ret] "={r2}" (-> usize),
	52	: [ret] "={r2}" (-> u64),
53	53	: [number] "{r1}" (@intFromEnum(number)),
54	54	[arg1] "{r2}" (arg1),
55	55	[arg2] "{r3}" (arg2),
...	...	@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58	58	: .{ .memory = true });
59	59	}
60	60
61		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	61	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
62	62	return asm volatile ("svc 0"
63		: [ret] "={r2}" (-> usize),
	63	: [ret] "={r2}" (-> u64),
64	64	: [number] "{r1}" (@intFromEnum(number)),
65	65	[arg1] "{r2}" (arg1),
66	66	[arg2] "{r3}" (arg2),
...	...	@@ -70,9 +70,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
70	70	: .{ .memory = true });
71	71	}
72	72
73		pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
	73	pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
74	74	return asm volatile ("svc 0"
75		: [ret] "={r2}" (-> usize),
	75	: [ret] "={r2}" (-> u64),
76	76	: [number] "{r1}" (@intFromEnum(number)),
77	77	[arg1] "{r2}" (arg1),
78	78	[arg2] "{r3}" (arg2),
...	...	@@ -83,7 +83,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
83	83	: .{ .memory = true });
84	84	}
85	85
86		pub fn clone() callconv(.naked) usize {
	86	pub fn clone() callconv(.naked) u64 {
87	87	asm volatile (
88	88	\\# int clone(
89	89	\\# fn, a = r2

lib/std/os/linux/sparc64.zig+29-29

...	...	@@ -15,7 +15,7 @@ const iovec = std.posix.iovec;
15	15	const iovec_const = std.posix.iovec_const;
16	16	const timespec = linux.timespec;
17	17
18		pub fn syscall_pipe(fd: *[2]i32) usize {
	18	pub fn syscall_pipe(fd: *[2]i32) u64 {
19	19	return asm volatile (
20	20	\\ mov %[arg], %%g3
21	21	\\ t 0x6d
...	...	@@ -29,13 +29,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
29	29	\\ st %%o1, [%%g3+4]
30	30	\\ clr %%o0
31	31	\\2:
32		: [ret] "={o0}" (-> usize),
	32	: [ret] "={o0}" (-> u64),
33	33	: [number] "{g1}" (@intFromEnum(SYS.pipe)),
34	34	[arg] "r" (fd),
35	35	: .{ .memory = true, .g3 = true });
36	36	}
37	37
38		pub fn syscall_fork() usize {
	38	pub fn syscall_fork() u64 {
39	39	// Linux/sparc64 fork() returns two values in %o0 and %o1:
40	40	// - On the parent's side, %o0 is the child's PID and %o1 is 0.
41	41	// - On the child's side, %o0 is the parent's PID and %o1 is 1.
...	...	@@ -52,58 +52,58 @@ pub fn syscall_fork() usize {
52	52	\\ dec %%o1
53	53	\\ and %%o1, %%o0, %%o0
54	54	\\ 2:
55		: [ret] "={o0}" (-> usize),
	55	: [ret] "={o0}" (-> u64),
56	56	: [number] "{g1}" (@intFromEnum(SYS.fork)),
57	57	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
58	58	}
59	59
60		pub fn syscall0(number: SYS) usize {
	60	pub fn syscall0(number: SYS) u64 {
61	61	return asm volatile (
62	62	\\ t 0x6d
63	63	\\ bcc,pt %%xcc, 1f
64	64	\\ nop
65	65	\\ neg %%o0
66	66	\\ 1:
67		: [ret] "={o0}" (-> usize),
	67	: [ret] "={o0}" (-> u64),
68	68	: [number] "{g1}" (@intFromEnum(number)),
69	69	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
70	70	}
71	71
72		pub fn syscall1(number: SYS, arg1: usize) usize {
	72	pub fn syscall1(number: SYS, arg1: u64) u64 {
73	73	return asm volatile (
74	74	\\ t 0x6d
75	75	\\ bcc,pt %%xcc, 1f
76	76	\\ nop
77	77	\\ neg %%o0
78	78	\\ 1:
79		: [ret] "={o0}" (-> usize),
	79	: [ret] "={o0}" (-> u64),
80	80	: [number] "{g1}" (@intFromEnum(number)),
81	81	[arg1] "{o0}" (arg1),
82	82	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
83	83	}
84	84
85		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	85	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
86	86	return asm volatile (
87	87	\\ t 0x6d
88	88	\\ bcc,pt %%xcc, 1f
89	89	\\ nop
90	90	\\ neg %%o0
91	91	\\ 1:
92		: [ret] "={o0}" (-> usize),
	92	: [ret] "={o0}" (-> u64),
93	93	: [number] "{g1}" (@intFromEnum(number)),
94	94	[arg1] "{o0}" (arg1),
95	95	[arg2] "{o1}" (arg2),
96	96	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
97	97	}
98	98
99		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	99	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
100	100	return asm volatile (
101	101	\\ t 0x6d
102	102	\\ bcc,pt %%xcc, 1f
103	103	\\ nop
104	104	\\ neg %%o0
105	105	\\ 1:
106		: [ret] "={o0}" (-> usize),
	106	: [ret] "={o0}" (-> u64),
107	107	: [number] "{g1}" (@intFromEnum(number)),
108	108	[arg1] "{o0}" (arg1),
109	109	[arg2] "{o1}" (arg2),
...	...	@@ -111,14 +111,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
111	111	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
112	112	}
113	113
114		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	114	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
115	115	return asm volatile (
116	116	\\ t 0x6d
117	117	\\ bcc,pt %%xcc, 1f
118	118	\\ nop
119	119	\\ neg %%o0
120	120	\\ 1:
121		: [ret] "={o0}" (-> usize),
	121	: [ret] "={o0}" (-> u64),
122	122	: [number] "{g1}" (@intFromEnum(number)),
123	123	[arg1] "{o0}" (arg1),
124	124	[arg2] "{o1}" (arg2),
...	...	@@ -127,14 +127,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
127	127	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
128	128	}
129	129
130		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	130	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
131	131	return asm volatile (
132	132	\\ t 0x6d
133	133	\\ bcc,pt %%xcc, 1f
134	134	\\ nop
135	135	\\ neg %%o0
136	136	\\ 1:
137		: [ret] "={o0}" (-> usize),
	137	: [ret] "={o0}" (-> u64),
138	138	: [number] "{g1}" (@intFromEnum(number)),
139	139	[arg1] "{o0}" (arg1),
140	140	[arg2] "{o1}" (arg2),
...	...	@@ -146,20 +146,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
146	146
147	147	pub fn syscall6(
148	148	number: SYS,
149		arg1: usize,
150		arg2: usize,
151		arg3: usize,
152		arg4: usize,
153		arg5: usize,
154		arg6: usize,
155		) usize {
	149	arg1: u64,
	150	arg2: u64,
	151	arg3: u64,
	152	arg4: u64,
	153	arg5: u64,
	154	arg6: u64,
	155	) u64 {
156	156	return asm volatile (
157	157	\\ t 0x6d
158	158	\\ bcc,pt %%xcc, 1f
159	159	\\ nop
160	160	\\ neg %%o0
161	161	\\ 1:
162		: [ret] "={o0}" (-> usize),
	162	: [ret] "={o0}" (-> u64),
163	163	: [number] "{g1}" (@intFromEnum(number)),
164	164	[arg1] "{o0}" (arg1),
165	165	[arg2] "{o1}" (arg2),
...	...	@@ -170,7 +170,7 @@ pub fn syscall6(
170	170	: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
171	171	}
172	172
173		pub fn clone() callconv(.naked) usize {
	173	pub fn clone() callconv(.naked) u64 {
174	174	// __clone(func, stack, flags, arg, ptid, tls, ctid)
175	175	// i0, i1, i2, i3, i4, i5, sp
176	176	//
...	...	@@ -274,12 +274,12 @@ pub const Flock = extern struct {
274	274
275	275	pub const off_t = i64;
276	276	pub const ino_t = u64;
277		pub const time_t = isize;
	277	pub const time_t = i64;
278	278	pub const mode_t = u32;
279		pub const dev_t = usize;
	279	pub const dev_t = u64;
280	280	pub const nlink_t = u32;
281		pub const blksize_t = isize;
282		pub const blkcnt_t = isize;
	281	pub const blksize_t = i64;
	282	pub const blkcnt_t = i64;
283	283
284	284	// The `stat64` definition used by the kernel.
285	285	pub const Stat = extern struct {

lib/std/os/linux/thumb.zig+27-27

...	...	@@ -7,53 +7,53 @@ const std = @import("../../std.zig");
7	7	const linux = std.os.linux;
8	8	const SYS = linux.SYS;
9	9
10		pub fn syscall0(number: SYS) usize {
11		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	10	pub fn syscall0(number: SYS) u32 {
	11	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
12	12	return asm volatile (
13	13	\\ str r7, [%[tmp], #4]
14	14	\\ ldr r7, [%[tmp]]
15	15	\\ svc #0
16	16	\\ ldr r7, [%[tmp], #4]
17		: [ret] "={r0}" (-> usize),
	17	: [ret] "={r0}" (-> u32),
18	18	: [tmp] "{r1}" (&buf),
19	19	: .{ .memory = true });
20	20	}
21	21
22		pub fn syscall1(number: SYS, arg1: usize) usize {
23		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	22	pub fn syscall1(number: SYS, arg1: u32) u32 {
	23	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
24	24	return asm volatile (
25	25	\\ str r7, [%[tmp], #4]
26	26	\\ ldr r7, [%[tmp]]
27	27	\\ svc #0
28	28	\\ ldr r7, [%[tmp], #4]
29		: [ret] "={r0}" (-> usize),
	29	: [ret] "={r0}" (-> u32),
30	30	: [tmp] "{r1}" (&buf),
31	31	[arg1] "{r0}" (arg1),
32	32	: .{ .memory = true });
33	33	}
34	34
35		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
36		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	35	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
	36	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
37	37	return asm volatile (
38	38	\\ str r7, [%[tmp], #4]
39	39	\\ ldr r7, [%[tmp]]
40	40	\\ svc #0
41	41	\\ ldr r7, [%[tmp], #4]
42		: [ret] "={r0}" (-> usize),
	42	: [ret] "={r0}" (-> u32),
43	43	: [tmp] "{r2}" (&buf),
44	44	[arg1] "{r0}" (arg1),
45	45	[arg2] "{r1}" (arg2),
46	46	: .{ .memory = true });
47	47	}
48	48
49		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
50		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	49	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
	50	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
51	51	return asm volatile (
52	52	\\ str r7, [%[tmp], #4]
53	53	\\ ldr r7, [%[tmp]]
54	54	\\ svc #0
55	55	\\ ldr r7, [%[tmp], #4]
56		: [ret] "={r0}" (-> usize),
	56	: [ret] "={r0}" (-> u32),
57	57	: [tmp] "{r3}" (&buf),
58	58	[arg1] "{r0}" (arg1),
59	59	[arg2] "{r1}" (arg2),
...	...	@@ -61,14 +61,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
61	61	: .{ .memory = true });
62	62	}
63	63
64		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
65		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	64	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
	65	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
66	66	return asm volatile (
67	67	\\ str r7, [%[tmp], #4]
68	68	\\ ldr r7, [%[tmp]]
69	69	\\ svc #0
70	70	\\ ldr r7, [%[tmp], #4]
71		: [ret] "={r0}" (-> usize),
	71	: [ret] "={r0}" (-> u32),
72	72	: [tmp] "{r4}" (&buf),
73	73	[arg1] "{r0}" (arg1),
74	74	[arg2] "{r1}" (arg2),
...	...	@@ -77,14 +77,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
77	77	: .{ .memory = true });
78	78	}
79	79
80		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
81		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	80	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
	81	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
82	82	return asm volatile (
83	83	\\ str r7, [%[tmp], #4]
84	84	\\ ldr r7, [%[tmp]]
85	85	\\ svc #0
86	86	\\ ldr r7, [%[tmp], #4]
87		: [ret] "={r0}" (-> usize),
	87	: [ret] "={r0}" (-> u32),
88	88	: [tmp] "{r5}" (&buf),
89	89	[arg1] "{r0}" (arg1),
90	90	[arg2] "{r1}" (arg2),
...	...	@@ -96,20 +96,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
96	96
97	97	pub fn syscall6(
98	98	number: SYS,
99		arg1: usize,
100		arg2: usize,
101		arg3: usize,
102		arg4: usize,
103		arg5: usize,
104		arg6: usize,
105		) usize {
106		var buf: [2]usize = .{ @intFromEnum(number), undefined };
	99	arg1: u32,
	100	arg2: u32,
	101	arg3: u32,
	102	arg4: u32,
	103	arg5: u32,
	104	arg6: u32,
	105	) u32 {
	106	var buf: [2]u32 = .{ @intFromEnum(number), undefined };
107	107	return asm volatile (
108	108	\\ str r7, [%[tmp], #4]
109	109	\\ ldr r7, [%[tmp]]
110	110	\\ svc #0
111	111	\\ ldr r7, [%[tmp], #4]
112		: [ret] "={r0}" (-> usize),
	112	: [ret] "={r0}" (-> u32),
113	113	: [tmp] "{r6}" (&buf),
114	114	[arg1] "{r0}" (arg1),
115	115	[arg2] "{r1}" (arg2),

lib/std/os/linux/x86.zig+25-25

...	...	@@ -14,33 +14,33 @@ const sigset_t = linux.sigset_t;
14	14	const sockaddr = linux.sockaddr;
15	15	const timespec = linux.timespec;
16	16
17		pub fn syscall0(number: SYS) usize {
	17	pub fn syscall0(number: SYS) u32 {
18	18	return asm volatile ("int $0x80"
19		: [ret] "={eax}" (-> usize),
	19	: [ret] "={eax}" (-> u32),
20	20	: [number] "{eax}" (@intFromEnum(number)),
21	21	: .{ .memory = true });
22	22	}
23	23
24		pub fn syscall1(number: SYS, arg1: usize) usize {
	24	pub fn syscall1(number: SYS, arg1: u32) u32 {
25	25	return asm volatile ("int $0x80"
26		: [ret] "={eax}" (-> usize),
	26	: [ret] "={eax}" (-> u32),
27	27	: [number] "{eax}" (@intFromEnum(number)),
28	28	[arg1] "{ebx}" (arg1),
29	29	: .{ .memory = true });
30	30	}
31	31
32		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	32	pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
33	33	return asm volatile ("int $0x80"
34		: [ret] "={eax}" (-> usize),
	34	: [ret] "={eax}" (-> u32),
35	35	: [number] "{eax}" (@intFromEnum(number)),
36	36	[arg1] "{ebx}" (arg1),
37	37	[arg2] "{ecx}" (arg2),
38	38	: .{ .memory = true });
39	39	}
40	40
41		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	41	pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
42	42	return asm volatile ("int $0x80"
43		: [ret] "={eax}" (-> usize),
	43	: [ret] "={eax}" (-> u32),
44	44	: [number] "{eax}" (@intFromEnum(number)),
45	45	[arg1] "{ebx}" (arg1),
46	46	[arg2] "{ecx}" (arg2),
...	...	@@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
48	48	: .{ .memory = true });
49	49	}
50	50
51		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	51	pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
52	52	return asm volatile ("int $0x80"
53		: [ret] "={eax}" (-> usize),
	53	: [ret] "={eax}" (-> u32),
54	54	: [number] "{eax}" (@intFromEnum(number)),
55	55	[arg1] "{ebx}" (arg1),
56	56	[arg2] "{ecx}" (arg2),
...	...	@@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
59	59	: .{ .memory = true });
60	60	}
61	61
62		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	62	pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
63	63	return asm volatile ("int $0x80"
64		: [ret] "={eax}" (-> usize),
	64	: [ret] "={eax}" (-> u32),
65	65	: [number] "{eax}" (@intFromEnum(number)),
66	66	[arg1] "{ebx}" (arg1),
67	67	[arg2] "{ecx}" (arg2),
...	...	@@ -73,20 +73,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
73	73
74	74	pub fn syscall6(
75	75	number: SYS,
76		arg1: usize,
77		arg2: usize,
78		arg3: usize,
79		arg4: usize,
80		arg5: usize,
81		arg6: usize,
82		) usize {
	76	arg1: u32,
	77	arg2: u32,
	78	arg3: u32,
	79	arg4: u32,
	80	arg5: u32,
	81	arg6: u32,
	82	) u32 {
83	83	// arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer
84	84	// and there are no more GPRs available; so we'll need a memory operand for it. Adding that
85	85	// memory operand means that on PIC we might need a reference to the GOT, which in turn needs
86	86	// its own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get
87	87	// right, because we can't touch esp or ebp until we're done with the memory input (as that
88	88	// input could be relative to esp or ebp).
89		const args56: [2]usize = .{ arg5, arg6 };
	89	const args56: [2]u32 = .{ arg5, arg6 };
90	90	return asm volatile (
91	91	\\ push %[args56]
92	92	\\ push %%ebp
...	...	@@ -99,7 +99,7 @@ pub fn syscall6(
99	99	\\ int $0x80
100	100	\\ pop %%ebp
101	101	\\ pop %%edi
102		: [ret] "={eax}" (-> usize),
	102	: [ret] "={eax}" (-> u32),
103	103	: [number] "{eax}" (@intFromEnum(number)),
104	104	[arg1] "{ebx}" (arg1),
105	105	[arg2] "{ecx}" (arg2),
...	...	@@ -109,16 +109,16 @@ pub fn syscall6(
109	109	: .{ .memory = true });
110	110	}
111	111
112		pub fn socketcall(call: usize, args: [*]const usize) usize {
	112	pub fn socketcall(call: u32, args: [*]const u32) u32 {
113	113	return asm volatile ("int $0x80"
114		: [ret] "={eax}" (-> usize),
	114	: [ret] "={eax}" (-> u32),
115	115	: [number] "{eax}" (@intFromEnum(SYS.socketcall)),
116	116	[arg1] "{ebx}" (call),
117	117	[arg2] "{ecx}" (@intFromPtr(args)),
118	118	: .{ .memory = true });
119	119	}
120	120
121		pub fn clone() callconv(.naked) usize {
	121	pub fn clone() callconv(.naked) u32 {
122	122	// __clone(func, stack, flags, arg, ptid, tls, ctid)
123	123	// +8, +12, +16, +20, +24, +28, +32
124	124	//
...	...	@@ -239,7 +239,7 @@ pub const Flock = extern struct {
239	239
240	240	pub const blksize_t = i32;
241	241	pub const nlink_t = u32;
242		pub const time_t = isize;
	242	pub const time_t = i32;
243	243	pub const mode_t = u32;
244	244	pub const off_t = i64;
245	245	pub const ino_t = u64;

lib/std/os/linux/x86_64.zig+29-29

...	...	@@ -16,33 +16,33 @@ const sockaddr = linux.sockaddr;
16	16	const socklen_t = linux.socklen_t;
17	17	const timespec = linux.timespec;
18	18
19		pub fn syscall0(number: SYS) usize {
	19	pub fn syscall0(number: SYS) u64 {
20	20	return asm volatile ("syscall"
21		: [ret] "={rax}" (-> usize),
	21	: [ret] "={rax}" (-> u64),
22	22	: [number] "{rax}" (@intFromEnum(number)),
23	23	: .{ .rcx = true, .r11 = true, .memory = true });
24	24	}
25	25
26		pub fn syscall1(number: SYS, arg1: usize) usize {
	26	pub fn syscall1(number: SYS, arg1: u64) u64 {
27	27	return asm volatile ("syscall"
28		: [ret] "={rax}" (-> usize),
	28	: [ret] "={rax}" (-> u64),
29	29	: [number] "{rax}" (@intFromEnum(number)),
30	30	[arg1] "{rdi}" (arg1),
31	31	: .{ .rcx = true, .r11 = true, .memory = true });
32	32	}
33	33
34		pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
	34	pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
35	35	return asm volatile ("syscall"
36		: [ret] "={rax}" (-> usize),
	36	: [ret] "={rax}" (-> u64),
37	37	: [number] "{rax}" (@intFromEnum(number)),
38	38	[arg1] "{rdi}" (arg1),
39	39	[arg2] "{rsi}" (arg2),
40	40	: .{ .rcx = true, .r11 = true, .memory = true });
41	41	}
42	42
43		pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
	43	pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
44	44	return asm volatile ("syscall"
45		: [ret] "={rax}" (-> usize),
	45	: [ret] "={rax}" (-> u64),
46	46	: [number] "{rax}" (@intFromEnum(number)),
47	47	[arg1] "{rdi}" (arg1),
48	48	[arg2] "{rsi}" (arg2),
...	...	@@ -50,9 +50,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
50	50	: .{ .rcx = true, .r11 = true, .memory = true });
51	51	}
52	52
53		pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
	53	pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
54	54	return asm volatile ("syscall"
55		: [ret] "={rax}" (-> usize),
	55	: [ret] "={rax}" (-> u64),
56	56	: [number] "{rax}" (@intFromEnum(number)),
57	57	[arg1] "{rdi}" (arg1),
58	58	[arg2] "{rsi}" (arg2),
...	...	@@ -61,9 +61,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
61	61	: .{ .rcx = true, .r11 = true, .memory = true });
62	62	}
63	63
64		pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
	64	pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
65	65	return asm volatile ("syscall"
66		: [ret] "={rax}" (-> usize),
	66	: [ret] "={rax}" (-> u64),
67	67	: [number] "{rax}" (@intFromEnum(number)),
68	68	[arg1] "{rdi}" (arg1),
69	69	[arg2] "{rsi}" (arg2),
...	...	@@ -75,15 +75,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
75	75
76	76	pub fn syscall6(
77	77	number: SYS,
78		arg1: usize,
79		arg2: usize,
80		arg3: usize,
81		arg4: usize,
82		arg5: usize,
83		arg6: usize,
84		) usize {
	78	arg1: u64,
	79	arg2: u64,
	80	arg3: u64,
	81	arg4: u64,
	82	arg5: u64,
	83	arg6: u64,
	84	) u64 {
85	85	return asm volatile ("syscall"
86		: [ret] "={rax}" (-> usize),
	86	: [ret] "={rax}" (-> u64),
87	87	: [number] "{rax}" (@intFromEnum(number)),
88	88	[arg1] "{rdi}" (arg1),
89	89	[arg2] "{rsi}" (arg2),
...	...	@@ -94,7 +94,7 @@ pub fn syscall6(
94	94	: .{ .rcx = true, .r11 = true, .memory = true });
95	95	}
96	96
97		pub fn clone() callconv(.naked) usize {
	97	pub fn clone() callconv(.naked) u64 {
98	98	asm volatile (
99	99	\\ movl $56,%%eax // SYS_clone
100	100	\\ movq %%rdi,%%r11
...	...	@@ -146,11 +146,11 @@ pub fn restore_rt() callconv(.naked) noreturn {
146	146	}
147	147	}
148	148
149		pub const mode_t = usize;
150		pub const time_t = isize;
151		pub const nlink_t = usize;
152		pub const blksize_t = isize;
153		pub const blkcnt_t = isize;
	149	pub const mode_t = u64;
	150	pub const time_t = i64;
	151	pub const nlink_t = u64;
	152	pub const blksize_t = i64;
	153	pub const blkcnt_t = i64;
154	154
155	155	pub const F = struct {
156	156	pub const DUPFD = 0;
...	...	@@ -206,7 +206,7 @@ pub const dev_t = u64;
206	206	pub const Stat = extern struct {
207	207	dev: dev_t,
208	208	ino: ino_t,
209		nlink: usize,
	209	nlink: u64,
210	210
211	211	mode: u32,
212	212	uid: uid_t,
...	...	@@ -214,13 +214,13 @@ pub const Stat = extern struct {
214	214	__pad0: u32,
215	215	rdev: dev_t,
216	216	size: off_t,
217		blksize: isize,
	217	blksize: i64,
218	218	blocks: i64,
219	219
220	220	atim: timespec,
221	221	mtim: timespec,
222	222	ctim: timespec,
223		__unused: [3]isize,
	223	__unused: [3]i64,
224	224
225	225	pub fn atime(self: @This()) timespec {
226	226	return self.atim;

author	Alex Rønne Petersen <alex@alexrp.com> 2025-10-16 23:39:11+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2025-10-17 01:20:33+02:00
log	cfdc0f0e34b00a7e1a4dc23f1d6672f213bbf9ca
tree	ce0d1478c80373c0167bf8708cc82ac8c546d2f2
parent	fc7a5f2ae49aa0a0c5e1f1dd1c5678ee3e49b1b6
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

std.os.linux: replace usize/isize in arch bits with fixed types for clarity