Commit 49c9975484aeb4c1534626d0f975a938a795ebe2 | zig

lib/std/Thread.zig+9-9

...	...	@@ -700,7 +700,7 @@ const LinuxThreadImpl = struct {
700	700	\\ int $128
701	701	:
702	702	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
703		[len] "r" (self.mapped.len)
	703	[len] "r" (self.mapped.len),
704	704	: "memory"
705	705	),
706	706	.x86_64 => asm volatile (
...	...	@@ -713,7 +713,7 @@ const LinuxThreadImpl = struct {
713	713	\\ syscall
714	714	:
715	715	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
716		[len] "r" (self.mapped.len)
	716	[len] "r" (self.mapped.len),
717	717	: "memory"
718	718	),
719	719	.arm, .armeb, .thumb, .thumbeb => asm volatile (
...	...	@@ -726,7 +726,7 @@ const LinuxThreadImpl = struct {
726	726	\\ svc 0
727	727	:
728	728	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
729		[len] "r" (self.mapped.len)
	729	[len] "r" (self.mapped.len),
730	730	: "memory"
731	731	),
732	732	.aarch64, .aarch64_be, .aarch64_32 => asm volatile (
...	...	@@ -739,7 +739,7 @@ const LinuxThreadImpl = struct {
739	739	\\ svc 0
740	740	:
741	741	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
742		[len] "r" (self.mapped.len)
	742	[len] "r" (self.mapped.len),
743	743	: "memory"
744	744	),
745	745	.mips, .mipsel => asm volatile (
...	...	@@ -753,7 +753,7 @@ const LinuxThreadImpl = struct {
753	753	\\ syscall
754	754	:
755	755	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
756		[len] "r" (self.mapped.len)
	756	[len] "r" (self.mapped.len),
757	757	: "memory"
758	758	),
759	759	.mips64, .mips64el => asm volatile (
...	...	@@ -766,7 +766,7 @@ const LinuxThreadImpl = struct {
766	766	\\ syscall
767	767	:
768	768	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
769		[len] "r" (self.mapped.len)
	769	[len] "r" (self.mapped.len),
770	770	: "memory"
771	771	),
772	772	.powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile (
...	...	@@ -780,7 +780,7 @@ const LinuxThreadImpl = struct {
780	780	\\ blr
781	781	:
782	782	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
783		[len] "r" (self.mapped.len)
	783	[len] "r" (self.mapped.len),
784	784	: "memory"
785	785	),
786	786	.riscv64 => asm volatile (
...	...	@@ -793,7 +793,7 @@ const LinuxThreadImpl = struct {
793	793	\\ ecall
794	794	:
795	795	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
796		[len] "r" (self.mapped.len)
	796	[len] "r" (self.mapped.len),
797	797	: "memory"
798	798	),
799	799	.sparcv9 => asm volatile (
...	...	@@ -821,7 +821,7 @@ const LinuxThreadImpl = struct {
821	821	\\ t 0x6d
822	822	:
823	823	: [ptr] "r" (@ptrToInt(self.mapped.ptr)),
824		[len] "r" (self.mapped.len)
	824	[len] "r" (self.mapped.len),
825	825	: "memory"
826	826	),
827	827	else => \|cpu_arch\| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)),

lib/std/atomic/Atomic.zig+18-18

...	...	@@ -176,69 +176,69 @@ pub fn Atomic(comptime T: type) type {
176	176	2 => switch (op) {
177	177	.Set => asm volatile ("lock btsw %[bit], %[ptr]"
178	178	// LLVM doesn't support u1 flag register return values
179		: [result] "={@ccc}" (-> u8)
	179	: [result] "={@ccc}" (-> u8),
180	180	: [ptr] "*p" (&self.value),
181		[bit] "X" (@as(T, bit))
	181	[bit] "X" (@as(T, bit)),
182	182	: "cc", "memory"
183	183	),
184	184	.Reset => asm volatile ("lock btrw %[bit], %[ptr]"
185	185	// LLVM doesn't support u1 flag register return values
186		: [result] "={@ccc}" (-> u8)
	186	: [result] "={@ccc}" (-> u8),
187	187	: [ptr] "*p" (&self.value),
188		[bit] "X" (@as(T, bit))
	188	[bit] "X" (@as(T, bit)),
189	189	: "cc", "memory"
190	190	),
191	191	.Toggle => asm volatile ("lock btcw %[bit], %[ptr]"
192	192	// LLVM doesn't support u1 flag register return values
193		: [result] "={@ccc}" (-> u8)
	193	: [result] "={@ccc}" (-> u8),
194	194	: [ptr] "*p" (&self.value),
195		[bit] "X" (@as(T, bit))
	195	[bit] "X" (@as(T, bit)),
196	196	: "cc", "memory"
197	197	),
198	198	},
199	199	4 => switch (op) {
200	200	.Set => asm volatile ("lock btsl %[bit], %[ptr]"
201	201	// LLVM doesn't support u1 flag register return values
202		: [result] "={@ccc}" (-> u8)
	202	: [result] "={@ccc}" (-> u8),
203	203	: [ptr] "*p" (&self.value),
204		[bit] "X" (@as(T, bit))
	204	[bit] "X" (@as(T, bit)),
205	205	: "cc", "memory"
206	206	),
207	207	.Reset => asm volatile ("lock btrl %[bit], %[ptr]"
208	208	// LLVM doesn't support u1 flag register return values
209		: [result] "={@ccc}" (-> u8)
	209	: [result] "={@ccc}" (-> u8),
210	210	: [ptr] "*p" (&self.value),
211		[bit] "X" (@as(T, bit))
	211	[bit] "X" (@as(T, bit)),
212	212	: "cc", "memory"
213	213	),
214	214	.Toggle => asm volatile ("lock btcl %[bit], %[ptr]"
215	215	// LLVM doesn't support u1 flag register return values
216		: [result] "={@ccc}" (-> u8)
	216	: [result] "={@ccc}" (-> u8),
217	217	: [ptr] "*p" (&self.value),
218		[bit] "X" (@as(T, bit))
	218	[bit] "X" (@as(T, bit)),
219	219	: "cc", "memory"
220	220	),
221	221	},
222	222	8 => switch (op) {
223	223	.Set => asm volatile ("lock btsq %[bit], %[ptr]"
224	224	// LLVM doesn't support u1 flag register return values
225		: [result] "={@ccc}" (-> u8)
	225	: [result] "={@ccc}" (-> u8),
226	226	: [ptr] "*p" (&self.value),
227		[bit] "X" (@as(T, bit))
	227	[bit] "X" (@as(T, bit)),
228	228	: "cc", "memory"
229	229	),
230	230	.Reset => asm volatile ("lock btrq %[bit], %[ptr]"
231	231	// LLVM doesn't support u1 flag register return values
232		: [result] "={@ccc}" (-> u8)
	232	: [result] "={@ccc}" (-> u8),
233	233	: [ptr] "*p" (&self.value),
234		[bit] "X" (@as(T, bit))
	234	[bit] "X" (@as(T, bit)),
235	235	: "cc", "memory"
236	236	),
237	237	.Toggle => asm volatile ("lock btcq %[bit], %[ptr]"
238	238	// LLVM doesn't support u1 flag register return values
239		: [result] "={@ccc}" (-> u8)
	239	: [result] "={@ccc}" (-> u8),
240	240	: [ptr] "*p" (&self.value),
241		[bit] "X" (@as(T, bit))
	241	[bit] "X" (@as(T, bit)),
242	242	: "cc", "memory"
243	243	),
244	244	},

lib/std/crypto/aes/aesni.zig+12-12

...	...	@@ -34,9 +34,9 @@ pub const Block = struct {
34	34	return Block{
35	35	.repr = asm (
36	36	\\ vaesenc %[rk], %[in], %[out]
37		: [out] "=x" (-> BlockVec)
	37	: [out] "=x" (-> BlockVec),
38	38	: [in] "x" (block.repr),
39		[rk] "x" (round_key.repr)
	39	[rk] "x" (round_key.repr),
40	40	),
41	41	};
42	42	}
...	...	@@ -46,9 +46,9 @@ pub const Block = struct {
46	46	return Block{
47	47	.repr = asm (
48	48	\\ vaesenclast %[rk], %[in], %[out]
49		: [out] "=x" (-> BlockVec)
	49	: [out] "=x" (-> BlockVec),
50	50	: [in] "x" (block.repr),
51		[rk] "x" (round_key.repr)
	51	[rk] "x" (round_key.repr),
52	52	),
53	53	};
54	54	}
...	...	@@ -58,9 +58,9 @@ pub const Block = struct {
58	58	return Block{
59	59	.repr = asm (
60	60	\\ vaesdec %[rk], %[in], %[out]
61		: [out] "=x" (-> BlockVec)
	61	: [out] "=x" (-> BlockVec),
62	62	: [in] "x" (block.repr),
63		[rk] "x" (inv_round_key.repr)
	63	[rk] "x" (inv_round_key.repr),
64	64	),
65	65	};
66	66	}
...	...	@@ -70,9 +70,9 @@ pub const Block = struct {
70	70	return Block{
71	71	.repr = asm (
72	72	\\ vaesdeclast %[rk], %[in], %[out]
73		: [out] "=x" (-> BlockVec)
	73	: [out] "=x" (-> BlockVec),
74	74	: [in] "x" (block.repr),
75		[rk] "x" (inv_round_key.repr)
	75	[rk] "x" (inv_round_key.repr),
76	76	),
77	77	};
78	78	}
...	...	@@ -190,11 +190,11 @@ fn KeySchedule(comptime Aes: type) type {
190	190	\\ vpxor %[ts], %[r], %[r]
191	191	: [r] "=&x" (-> BlockVec),
192	192	[s] "=&x" (s),
193		[ts] "=&x" (ts)
	193	[ts] "=&x" (ts),
194	194	: [rc] "n" (rc),
195	195	[t] "x" (t),
196	196	[tx] "x" (tx),
197		[mask] "n" (@as(u8, if (second) 0xaa else 0xff))
	197	[mask] "n" (@as(u8, if (second) 0xaa else 0xff)),
198	198	);
199	199	}
200	200
...	...	@@ -235,8 +235,8 @@ fn KeySchedule(comptime Aes: type) type {
235	235	inv_round_keys[i] = Block{
236	236	.repr = asm (
237	237	\\ vaesimc %[rk], %[inv_rk]
238		: [inv_rk] "=x" (-> BlockVec)
239		: [rk] "x" (round_keys[rounds - i].repr)
	238	: [inv_rk] "=x" (-> BlockVec),
	239	: [rk] "x" (round_keys[rounds - i].repr),
240	240	),
241	241	};
242	242	}

lib/std/crypto/aes/armcrypto.zig+14-14

...	...	@@ -39,10 +39,10 @@ pub const Block = struct {
39	39	\\ aese %[out].16b, %[zero].16b
40	40	\\ aesmc %[out].16b, %[out].16b
41	41	\\ eor %[out].16b, %[out].16b, %[rk].16b
42		: [out] "=&x" (-> BlockVec)
	42	: [out] "=&x" (-> BlockVec),
43	43	: [in] "x" (block.repr),
44	44	[rk] "x" (round_key.repr),
45		[zero] "x" (zero)
	45	[zero] "x" (zero),
46	46	),
47	47	};
48	48	}
...	...	@@ -54,10 +54,10 @@ pub const Block = struct {
54	54	\\ mov %[out].16b, %[in].16b
55	55	\\ aese %[out].16b, %[zero].16b
56	56	\\ eor %[out].16b, %[out].16b, %[rk].16b
57		: [out] "=&x" (-> BlockVec)
	57	: [out] "=&x" (-> BlockVec),
58	58	: [in] "x" (block.repr),
59	59	[rk] "x" (round_key.repr),
60		[zero] "x" (zero)
	60	[zero] "x" (zero),
61	61	),
62	62	};
63	63	}
...	...	@@ -70,10 +70,10 @@ pub const Block = struct {
70	70	\\ aesd %[out].16b, %[zero].16b
71	71	\\ aesimc %[out].16b, %[out].16b
72	72	\\ eor %[out].16b, %[out].16b, %[rk].16b
73		: [out] "=&x" (-> BlockVec)
	73	: [out] "=&x" (-> BlockVec),
74	74	: [in] "x" (block.repr),
75	75	[rk] "x" (inv_round_key.repr),
76		[zero] "x" (zero)
	76	[zero] "x" (zero),
77	77	),
78	78	};
79	79	}
...	...	@@ -85,10 +85,10 @@ pub const Block = struct {
85	85	\\ mov %[out].16b, %[in].16b
86	86	\\ aesd %[out].16b, %[zero].16b
87	87	\\ eor %[out].16b, %[out].16b, %[rk].16b
88		: [out] "=&x" (-> BlockVec)
	88	: [out] "=&x" (-> BlockVec),
89	89	: [in] "x" (block.repr),
90	90	[rk] "x" (inv_round_key.repr),
91		[zero] "x" (zero)
	91	[zero] "x" (zero),
92	92	),
93	93	};
94	94	}
...	...	@@ -210,11 +210,11 @@ fn KeySchedule(comptime Aes: type) type {
210	210	[v1] "=&x" (v1),
211	211	[v2] "=&x" (v2),
212	212	[v3] "=&x" (v3),
213		[v4] "=&x" (v4)
	213	[v4] "=&x" (v4),
214	214	: [rc] "N" (rc),
215	215	[t] "x" (t),
216	216	[zero] "x" (zero),
217		[mask] "x" (mask1)
	217	[mask] "x" (mask1),
218	218	);
219	219	}
220	220
...	...	@@ -240,12 +240,12 @@ fn KeySchedule(comptime Aes: type) type {
240	240	[v1] "=&x" (v1),
241	241	[v2] "=&x" (v2),
242	242	[v3] "=&x" (v3),
243		[v4] "=&x" (v4)
	243	[v4] "=&x" (v4),
244	244	: [rc] "N" (if (second) @as(u8, 0) else rc),
245	245	[t] "x" (t),
246	246	[tx] "x" (tx),
247	247	[zero] "x" (zero),
248		[mask] "x" (if (second) mask2 else mask1)
	248	[mask] "x" (if (second) mask2 else mask1),
249	249	);
250	250	}
251	251
...	...	@@ -286,8 +286,8 @@ fn KeySchedule(comptime Aes: type) type {
286	286	inv_round_keys[i] = Block{
287	287	.repr = asm (
288	288	\\ aesimc %[inv_rk].16b, %[rk].16b
289		: [inv_rk] "=x" (-> BlockVec)
290		: [rk] "x" (round_keys[rounds - i].repr)
	289	: [inv_rk] "=x" (-> BlockVec),
	290	: [rk] "x" (round_keys[rounds - i].repr),
291	291	),
292	292	};
293	293	}

lib/std/crypto/ghash.zig+4-4

...	...	@@ -94,9 +94,9 @@ pub const Ghash = struct {
94	94	const Vector = std.meta.Vector;
95	95	const product = asm (
96	96	\\ vpclmulqdq $0x00, %[x], %[y], %[out]
97		: [out] "=x" (-> Vector(2, u64))
	97	: [out] "=x" (-> Vector(2, u64)),
98	98	: [x] "x" (@bitCast(Vector(2, u64), @as(u128, x))),
99		[y] "x" (@bitCast(Vector(2, u64), @as(u128, y)))
	99	[y] "x" (@bitCast(Vector(2, u64), @as(u128, y))),
100	100	);
101	101	return product[0];
102	102	}
...	...	@@ -105,9 +105,9 @@ pub const Ghash = struct {
105	105	const Vector = std.meta.Vector;
106	106	const product = asm (
107	107	\\ pmull %[out].1q, %[x].1d, %[y].1d
108		: [out] "=w" (-> Vector(2, u64))
	108	: [out] "=w" (-> Vector(2, u64)),
109	109	: [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))),
110		[y] "w" (@bitCast(Vector(2, u64), @as(u128, y)))
	110	[y] "w" (@bitCast(Vector(2, u64), @as(u128, y))),
111	111	);
112	112	return product[0];
113	113	}

lib/std/debug.zig+1-1

...	...	@@ -1634,7 +1634,7 @@ fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, comptime msg: u
1634	1634
1635	1635	pub fn dumpStackPointerAddr(prefix: []const u8) void {
1636	1636	const sp = asm (""
1637		: [argc] "={rsp}" (-> usize)
	1637	: [argc] "={rsp}" (-> usize),
1638	1638	);
1639	1639	std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp });
1640	1640	}

lib/std/mem.zig+1-1

...	...	@@ -2860,7 +2860,7 @@ pub fn alignForwardGeneric(comptime T: type, addr: T, alignment: T) T {
2860	2860	pub fn doNotOptimizeAway(val: anytype) void {
2861	2861	asm volatile (""
2862	2862	:
2863		: [val] "rm" (val)
	2863	: [val] "rm" (val),
2864	2864	: "memory"
2865	2865	);
2866	2866	}

lib/std/os/linux/arm-eabi.zig+16-16

...	...	@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
2	2
3	3	pub fn syscall0(number: SYS) usize {
4	4	return asm volatile ("svc #0"
5		: [ret] "={r0}" (-> usize)
6		: [number] "{r7}" (@enumToInt(number))
	5	: [ret] "={r0}" (-> usize),
	6	: [number] "{r7}" (@enumToInt(number)),
7	7	: "memory"
8	8	);
9	9	}
10	10
11	11	pub fn syscall1(number: SYS, arg1: usize) usize {
12	12	return asm volatile ("svc #0"
13		: [ret] "={r0}" (-> usize)
	13	: [ret] "={r0}" (-> usize),
14	14	: [number] "{r7}" (@enumToInt(number)),
15		[arg1] "{r0}" (arg1)
	15	[arg1] "{r0}" (arg1),
16	16	: "memory"
17	17	);
18	18	}
19	19
20	20	pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21	21	return asm volatile ("svc #0"
22		: [ret] "={r0}" (-> usize)
	22	: [ret] "={r0}" (-> usize),
23	23	: [number] "{r7}" (@enumToInt(number)),
24	24	[arg1] "{r0}" (arg1),
25		[arg2] "{r1}" (arg2)
	25	[arg2] "{r1}" (arg2),
26	26	: "memory"
27	27	);
28	28	}
29	29
30	30	pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31	31	return asm volatile ("svc #0"
32		: [ret] "={r0}" (-> usize)
	32	: [ret] "={r0}" (-> usize),
33	33	: [number] "{r7}" (@enumToInt(number)),
34	34	[arg1] "{r0}" (arg1),
35	35	[arg2] "{r1}" (arg2),
36		[arg3] "{r2}" (arg3)
	36	[arg3] "{r2}" (arg3),
37	37	: "memory"
38	38	);
39	39	}
40	40
41	41	pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42	42	return asm volatile ("svc #0"
43		: [ret] "={r0}" (-> usize)
	43	: [ret] "={r0}" (-> usize),
44	44	: [number] "{r7}" (@enumToInt(number)),
45	45	[arg1] "{r0}" (arg1),
46	46	[arg2] "{r1}" (arg2),
47	47	[arg3] "{r2}" (arg3),
48		[arg4] "{r3}" (arg4)
	48	[arg4] "{r3}" (arg4),
49	49	: "memory"
50	50	);
51	51	}
52	52
53	53	pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54	54	return asm volatile ("svc #0"
55		: [ret] "={r0}" (-> usize)
	55	: [ret] "={r0}" (-> usize),
56	56	: [number] "{r7}" (@enumToInt(number)),
57	57	[arg1] "{r0}" (arg1),
58	58	[arg2] "{r1}" (arg2),
59	59	[arg3] "{r2}" (arg3),
60	60	[arg4] "{r3}" (arg4),
61		[arg5] "{r4}" (arg5)
	61	[arg5] "{r4}" (arg5),
62	62	: "memory"
63	63	);
64	64	}
...	...	@@ -73,14 +73,14 @@ pub fn syscall6(
73	73	arg6: usize,
74	74	) usize {
75	75	return asm volatile ("svc #0"
76		: [ret] "={r0}" (-> usize)
	76	: [ret] "={r0}" (-> usize),
77	77	: [number] "{r7}" (@enumToInt(number)),
78	78	[arg1] "{r0}" (arg1),
79	79	[arg2] "{r1}" (arg2),
80	80	[arg3] "{r2}" (arg3),
81	81	[arg4] "{r3}" (arg4),
82	82	[arg5] "{r4}" (arg5),
83		[arg6] "{r5}" (arg6)
	83	[arg6] "{r5}" (arg6),
84	84	: "memory"
85	85	);
86	86	}
...	...	@@ -91,7 +91,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
91	91	pub fn restore() callconv(.Naked) void {
92	92	return asm volatile ("svc #0"
93	93	:
94		: [number] "{r7}" (@enumToInt(SYS.sigreturn))
	94	: [number] "{r7}" (@enumToInt(SYS.sigreturn)),
95	95	: "memory"
96	96	);
97	97	}
...	...	@@ -99,7 +99,7 @@ pub fn restore() callconv(.Naked) void {
99	99	pub fn restore_rt() callconv(.Naked) void {
100	100	return asm volatile ("svc #0"
101	101	:
102		: [number] "{r7}" (@enumToInt(SYS.rt_sigreturn))
	102	: [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)),
103	103	: "memory"
104	104	);
105	105	}

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

...	...	@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
2	2
3	3	pub fn syscall0(number: SYS) usize {
4	4	return asm volatile ("svc #0"
5		: [ret] "={x0}" (-> usize)
6		: [number] "{x8}" (@enumToInt(number))
	5	: [ret] "={x0}" (-> usize),
	6	: [number] "{x8}" (@enumToInt(number)),
7	7	: "memory", "cc"
8	8	);
9	9	}
10	10
11	11	pub fn syscall1(number: SYS, arg1: usize) usize {
12	12	return asm volatile ("svc #0"
13		: [ret] "={x0}" (-> usize)
	13	: [ret] "={x0}" (-> usize),
14	14	: [number] "{x8}" (@enumToInt(number)),
15		[arg1] "{x0}" (arg1)
	15	[arg1] "{x0}" (arg1),
16	16	: "memory", "cc"
17	17	);
18	18	}
19	19
20	20	pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21	21	return asm volatile ("svc #0"
22		: [ret] "={x0}" (-> usize)
	22	: [ret] "={x0}" (-> usize),
23	23	: [number] "{x8}" (@enumToInt(number)),
24	24	[arg1] "{x0}" (arg1),
25		[arg2] "{x1}" (arg2)
	25	[arg2] "{x1}" (arg2),
26	26	: "memory", "cc"
27	27	);
28	28	}
29	29
30	30	pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31	31	return asm volatile ("svc #0"
32		: [ret] "={x0}" (-> usize)
	32	: [ret] "={x0}" (-> usize),
33	33	: [number] "{x8}" (@enumToInt(number)),
34	34	[arg1] "{x0}" (arg1),
35	35	[arg2] "{x1}" (arg2),
36		[arg3] "{x2}" (arg3)
	36	[arg3] "{x2}" (arg3),
37	37	: "memory", "cc"
38	38	);
39	39	}
40	40
41	41	pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42	42	return asm volatile ("svc #0"
43		: [ret] "={x0}" (-> usize)
	43	: [ret] "={x0}" (-> usize),
44	44	: [number] "{x8}" (@enumToInt(number)),
45	45	[arg1] "{x0}" (arg1),
46	46	[arg2] "{x1}" (arg2),
47	47	[arg3] "{x2}" (arg3),
48		[arg4] "{x3}" (arg4)
	48	[arg4] "{x3}" (arg4),
49	49	: "memory", "cc"
50	50	);
51	51	}
52	52
53	53	pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54	54	return asm volatile ("svc #0"
55		: [ret] "={x0}" (-> usize)
	55	: [ret] "={x0}" (-> usize),
56	56	: [number] "{x8}" (@enumToInt(number)),
57	57	[arg1] "{x0}" (arg1),
58	58	[arg2] "{x1}" (arg2),
59	59	[arg3] "{x2}" (arg3),
60	60	[arg4] "{x3}" (arg4),
61		[arg5] "{x4}" (arg5)
	61	[arg5] "{x4}" (arg5),
62	62	: "memory", "cc"
63	63	);
64	64	}
...	...	@@ -73,14 +73,14 @@ pub fn syscall6(
73	73	arg6: usize,
74	74	) usize {
75	75	return asm volatile ("svc #0"
76		: [ret] "={x0}" (-> usize)
	76	: [ret] "={x0}" (-> usize),
77	77	: [number] "{x8}" (@enumToInt(number)),
78	78	[arg1] "{x0}" (arg1),
79	79	[arg2] "{x1}" (arg2),
80	80	[arg3] "{x2}" (arg3),
81	81	[arg4] "{x3}" (arg4),
82	82	[arg5] "{x4}" (arg5),
83		[arg6] "{x5}" (arg6)
	83	[arg6] "{x5}" (arg6),
84	84	: "memory", "cc"
85	85	);
86	86	}
...	...	@@ -93,7 +93,7 @@ pub const restore = restore_rt;
93	93	pub fn restore_rt() callconv(.Naked) void {
94	94	return asm volatile ("svc #0"
95	95	:
96		: [number] "{x8}" (@enumToInt(SYS.rt_sigreturn))
	96	: [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)),
97	97	: "memory", "cc"
98	98	);
99	99	}

lib/std/os/linux/i386.zig+18-18

...	...	@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
2	2
3	3	pub fn syscall0(number: SYS) usize {
4	4	return asm volatile ("int $0x80"
5		: [ret] "={eax}" (-> usize)
6		: [number] "{eax}" (@enumToInt(number))
	5	: [ret] "={eax}" (-> usize),
	6	: [number] "{eax}" (@enumToInt(number)),
7	7	: "memory"
8	8	);
9	9	}
10	10
11	11	pub fn syscall1(number: SYS, arg1: usize) usize {
12	12	return asm volatile ("int $0x80"
13		: [ret] "={eax}" (-> usize)
	13	: [ret] "={eax}" (-> usize),
14	14	: [number] "{eax}" (@enumToInt(number)),
15		[arg1] "{ebx}" (arg1)
	15	[arg1] "{ebx}" (arg1),
16	16	: "memory"
17	17	);
18	18	}
19	19
20	20	pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21	21	return asm volatile ("int $0x80"
22		: [ret] "={eax}" (-> usize)
	22	: [ret] "={eax}" (-> usize),
23	23	: [number] "{eax}" (@enumToInt(number)),
24	24	[arg1] "{ebx}" (arg1),
25		[arg2] "{ecx}" (arg2)
	25	[arg2] "{ecx}" (arg2),
26	26	: "memory"
27	27	);
28	28	}
29	29
30	30	pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31	31	return asm volatile ("int $0x80"
32		: [ret] "={eax}" (-> usize)
	32	: [ret] "={eax}" (-> usize),
33	33	: [number] "{eax}" (@enumToInt(number)),
34	34	[arg1] "{ebx}" (arg1),
35	35	[arg2] "{ecx}" (arg2),
36		[arg3] "{edx}" (arg3)
	36	[arg3] "{edx}" (arg3),
37	37	: "memory"
38	38	);
39	39	}
40	40
41	41	pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42	42	return asm volatile ("int $0x80"
43		: [ret] "={eax}" (-> usize)
	43	: [ret] "={eax}" (-> usize),
44	44	: [number] "{eax}" (@enumToInt(number)),
45	45	[arg1] "{ebx}" (arg1),
46	46	[arg2] "{ecx}" (arg2),
47	47	[arg3] "{edx}" (arg3),
48		[arg4] "{esi}" (arg4)
	48	[arg4] "{esi}" (arg4),
49	49	: "memory"
50	50	);
51	51	}
52	52
53	53	pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54	54	return asm volatile ("int $0x80"
55		: [ret] "={eax}" (-> usize)
	55	: [ret] "={eax}" (-> usize),
56	56	: [number] "{eax}" (@enumToInt(number)),
57	57	[arg1] "{ebx}" (arg1),
58	58	[arg2] "{ecx}" (arg2),
59	59	[arg3] "{edx}" (arg3),
60	60	[arg4] "{esi}" (arg4),
61		[arg5] "{edi}" (arg5)
	61	[arg5] "{edi}" (arg5),
62	62	: "memory"
63	63	);
64	64	}
...	...	@@ -83,24 +83,24 @@ pub fn syscall6(
83	83	\\ int $0x80
84	84	\\ pop %%ebp
85	85	\\ add $4, %%esp
86		: [ret] "={eax}" (-> usize)
	86	: [ret] "={eax}" (-> usize),
87	87	: [number] "{eax}" (@enumToInt(number)),
88	88	[arg1] "{ebx}" (arg1),
89	89	[arg2] "{ecx}" (arg2),
90	90	[arg3] "{edx}" (arg3),
91	91	[arg4] "{esi}" (arg4),
92	92	[arg5] "{edi}" (arg5),
93		[arg6] "rm" (arg6)
	93	[arg6] "rm" (arg6),
94	94	: "memory"
95	95	);
96	96	}
97	97
98	98	pub fn socketcall(call: usize, args: [*]usize) usize {
99	99	return asm volatile ("int $0x80"
100		: [ret] "={eax}" (-> usize)
	100	: [ret] "={eax}" (-> usize),
101	101	: [number] "{eax}" (@enumToInt(SYS.socketcall)),
102	102	[arg1] "{ebx}" (call),
103		[arg2] "{ecx}" (@ptrToInt(args))
	103	[arg2] "{ecx}" (@ptrToInt(args)),
104	104	: "memory"
105	105	);
106	106	}
...	...	@@ -111,7 +111,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
111	111	pub fn restore() callconv(.Naked) void {
112	112	return asm volatile ("int $0x80"
113	113	:
114		: [number] "{eax}" (@enumToInt(SYS.sigreturn))
	114	: [number] "{eax}" (@enumToInt(SYS.sigreturn)),
115	115	: "memory"
116	116	);
117	117	}
...	...	@@ -119,7 +119,7 @@ pub fn restore() callconv(.Naked) void {
119	119	pub fn restore_rt() callconv(.Naked) void {
120	120	return asm volatile ("int $0x80"
121	121	:
122		: [number] "{eax}" (@enumToInt(SYS.rt_sigreturn))
	122	: [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)),
123	123	: "memory"
124	124	);
125	125	}

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

...	...	@@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6	6	\\ blez $7, 1f
7	7	\\ subu $2, $0, $2
8	8	\\ 1:
9		: [ret] "={$2}" (-> usize)
10		: [number] "{$2}" (@enumToInt(number))
	9	: [ret] "={$2}" (-> usize),
	10	: [number] "{$2}" (@enumToInt(number)),
11	11	: "memory", "cc", "$7"
12	12	);
13	13	}
...	...	@@ -25,9 +25,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
25	25	\\ sw $2, 0($4)
26	26	\\ sw $3, 4($4)
27	27	\\ 2:
28		: [ret] "={$2}" (-> usize)
	28	: [ret] "={$2}" (-> usize),
29	29	: [number] "{$2}" (@enumToInt(SYS.pipe)),
30		[fd] "{$4}" (fd)
	30	[fd] "{$4}" (fd),
31	31	: "memory", "cc", "$7"
32	32	);
33	33	}
...	...	@@ -38,9 +38,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
38	38	\\ blez $7, 1f
39	39	\\ subu $2, $0, $2
40	40	\\ 1:
41		: [ret] "={$2}" (-> usize)
	41	: [ret] "={$2}" (-> usize),
42	42	: [number] "{$2}" (@enumToInt(number)),
43		[arg1] "{$4}" (arg1)
	43	[arg1] "{$4}" (arg1),
44	44	: "memory", "cc", "$7"
45	45	);
46	46	}
...	...	@@ -51,10 +51,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
51	51	\\ blez $7, 1f
52	52	\\ subu $2, $0, $2
53	53	\\ 1:
54		: [ret] "={$2}" (-> usize)
	54	: [ret] "={$2}" (-> usize),
55	55	: [number] "{$2}" (@enumToInt(number)),
56	56	[arg1] "{$4}" (arg1),
57		[arg2] "{$5}" (arg2)
	57	[arg2] "{$5}" (arg2),
58	58	: "memory", "cc", "$7"
59	59	);
60	60	}
...	...	@@ -65,11 +65,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
65	65	\\ blez $7, 1f
66	66	\\ subu $2, $0, $2
67	67	\\ 1:
68		: [ret] "={$2}" (-> usize)
	68	: [ret] "={$2}" (-> usize),
69	69	: [number] "{$2}" (@enumToInt(number)),
70	70	[arg1] "{$4}" (arg1),
71	71	[arg2] "{$5}" (arg2),
72		[arg3] "{$6}" (arg3)
	72	[arg3] "{$6}" (arg3),
73	73	: "memory", "cc", "$7"
74	74	);
75	75	}
...	...	@@ -80,12 +80,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
80	80	\\ blez $7, 1f
81	81	\\ subu $2, $0, $2
82	82	\\ 1:
83		: [ret] "={$2}" (-> usize)
	83	: [ret] "={$2}" (-> usize),
84	84	: [number] "{$2}" (@enumToInt(number)),
85	85	[arg1] "{$4}" (arg1),
86	86	[arg2] "{$5}" (arg2),
87	87	[arg3] "{$6}" (arg3),
88		[arg4] "{$7}" (arg4)
	88	[arg4] "{$7}" (arg4),
89	89	: "memory", "cc", "$7"
90	90	);
91	91	}
...	...	@@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
100	100	\\ blez $7, 1f
101	101	\\ subu $2, $0, $2
102	102	\\ 1:
103		: [ret] "={$2}" (-> usize)
	103	: [ret] "={$2}" (-> usize),
104	104	: [number] "{$2}" (@enumToInt(number)),
105	105	[arg1] "{$4}" (arg1),
106	106	[arg2] "{$5}" (arg2),
107	107	[arg3] "{$6}" (arg3),
108	108	[arg4] "{$7}" (arg4),
109		[arg5] "r" (arg5)
	109	[arg5] "r" (arg5),
110	110	: "memory", "cc", "$7"
111	111	);
112	112	}
...	...	@@ -133,14 +133,14 @@ pub fn syscall6(
133	133	\\ blez $7, 1f
134	134	\\ subu $2, $0, $2
135	135	\\ 1:
136		: [ret] "={$2}" (-> usize)
	136	: [ret] "={$2}" (-> usize),
137	137	: [number] "{$2}" (@enumToInt(number)),
138	138	[arg1] "{$4}" (arg1),
139	139	[arg2] "{$5}" (arg2),
140	140	[arg3] "{$6}" (arg3),
141	141	[arg4] "{$7}" (arg4),
142	142	[arg5] "r" (arg5),
143		[arg6] "r" (arg6)
	143	[arg6] "r" (arg6),
144	144	: "memory", "cc", "$7"
145	145	);
146	146	}
...	...	@@ -166,7 +166,7 @@ pub fn syscall7(
166	166	\\ blez $7, 1f
167	167	\\ subu $2, $0, $2
168	168	\\ 1:
169		: [ret] "={$2}" (-> usize)
	169	: [ret] "={$2}" (-> usize),
170	170	: [number] "{$2}" (@enumToInt(number)),
171	171	[arg1] "{$4}" (arg1),
172	172	[arg2] "{$5}" (arg2),
...	...	@@ -174,7 +174,7 @@ pub fn syscall7(
174	174	[arg4] "{$7}" (arg4),
175	175	[arg5] "r" (arg5),
176	176	[arg6] "r" (arg6),
177		[arg7] "r" (arg7)
	177	[arg7] "r" (arg7),
178	178	: "memory", "cc", "$7"
179	179	);
180	180	}
...	...	@@ -185,7 +185,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
185	185	pub fn restore() callconv(.Naked) void {
186	186	return asm volatile ("syscall"
187	187	:
188		: [number] "{$2}" (@enumToInt(SYS.sigreturn))
	188	: [number] "{$2}" (@enumToInt(SYS.sigreturn)),
189	189	: "memory", "cc", "$7"
190	190	);
191	191	}
...	...	@@ -193,7 +193,7 @@ pub fn restore() callconv(.Naked) void {
193	193	pub fn restore_rt() callconv(.Naked) void {
194	194	return asm volatile ("syscall"
195	195	:
196		: [number] "{$2}" (@enumToInt(SYS.rt_sigreturn))
	196	: [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)),
197	197	: "memory", "cc", "$7"
198	198	);
199	199	}

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

...	...	@@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6	6	\\ bns+ 1f
7	7	\\ neg 3, 3
8	8	\\ 1:
9		: [ret] "={r3}" (-> usize)
10		: [number] "{r0}" (@enumToInt(number))
	9	: [ret] "={r3}" (-> usize),
	10	: [number] "{r0}" (@enumToInt(number)),
11	11	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
12	12	);
13	13	}
...	...	@@ -18,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
18	18	\\ bns+ 1f
19	19	\\ neg 3, 3
20	20	\\ 1:
21		: [ret] "={r3}" (-> usize)
	21	: [ret] "={r3}" (-> usize),
22	22	: [number] "{r0}" (@enumToInt(number)),
23		[arg1] "{r3}" (arg1)
	23	[arg1] "{r3}" (arg1),
24	24	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
25	25	);
26	26	}
...	...	@@ -31,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
31	31	\\ bns+ 1f
32	32	\\ neg 3, 3
33	33	\\ 1:
34		: [ret] "={r3}" (-> usize)
	34	: [ret] "={r3}" (-> usize),
35	35	: [number] "{r0}" (@enumToInt(number)),
36	36	[arg1] "{r3}" (arg1),
37		[arg2] "{r4}" (arg2)
	37	[arg2] "{r4}" (arg2),
38	38	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
39	39	);
40	40	}
...	...	@@ -45,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45	45	\\ bns+ 1f
46	46	\\ neg 3, 3
47	47	\\ 1:
48		: [ret] "={r3}" (-> usize)
	48	: [ret] "={r3}" (-> usize),
49	49	: [number] "{r0}" (@enumToInt(number)),
50	50	[arg1] "{r3}" (arg1),
51	51	[arg2] "{r4}" (arg2),
52		[arg3] "{r5}" (arg3)
	52	[arg3] "{r5}" (arg3),
53	53	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
54	54	);
55	55	}
...	...	@@ -60,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
60	60	\\ bns+ 1f
61	61	\\ neg 3, 3
62	62	\\ 1:
63		: [ret] "={r3}" (-> usize)
	63	: [ret] "={r3}" (-> usize),
64	64	: [number] "{r0}" (@enumToInt(number)),
65	65	[arg1] "{r3}" (arg1),
66	66	[arg2] "{r4}" (arg2),
67	67	[arg3] "{r5}" (arg3),
68		[arg4] "{r6}" (arg4)
	68	[arg4] "{r6}" (arg4),
69	69	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
70	70	);
71	71	}
...	...	@@ -76,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
76	76	\\ bns+ 1f
77	77	\\ neg 3, 3
78	78	\\ 1:
79		: [ret] "={r3}" (-> usize)
	79	: [ret] "={r3}" (-> usize),
80	80	: [number] "{r0}" (@enumToInt(number)),
81	81	[arg1] "{r3}" (arg1),
82	82	[arg2] "{r4}" (arg2),
83	83	[arg3] "{r5}" (arg3),
84	84	[arg4] "{r6}" (arg4),
85		[arg5] "{r7}" (arg5)
	85	[arg5] "{r7}" (arg5),
86	86	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
87	87	);
88	88	}
...	...	@@ -101,14 +101,14 @@ pub fn syscall6(
101	101	\\ bns+ 1f
102	102	\\ neg 3, 3
103	103	\\ 1:
104		: [ret] "={r3}" (-> usize)
	104	: [ret] "={r3}" (-> usize),
105	105	: [number] "{r0}" (@enumToInt(number)),
106	106	[arg1] "{r3}" (arg1),
107	107	[arg2] "{r4}" (arg2),
108	108	[arg3] "{r5}" (arg3),
109	109	[arg4] "{r6}" (arg4),
110	110	[arg5] "{r7}" (arg5),
111		[arg6] "{r8}" (arg6)
	111	[arg6] "{r8}" (arg6),
112	112	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
113	113	);
114	114	}
...	...	@@ -121,7 +121,7 @@ pub const restore = restore_rt;
121	121	pub fn restore_rt() callconv(.Naked) void {
122	122	return asm volatile ("sc"
123	123	:
124		: [number] "{r0}" (@enumToInt(SYS.rt_sigreturn))
	124	: [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)),
125	125	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
126	126	);
127	127	}

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

...	...	@@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6	6	\\ bns+ 1f
7	7	\\ neg 3, 3
8	8	\\ 1:
9		: [ret] "={r3}" (-> usize)
10		: [number] "{r0}" (@enumToInt(number))
	9	: [ret] "={r3}" (-> usize),
	10	: [number] "{r0}" (@enumToInt(number)),
11	11	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
12	12	);
13	13	}
...	...	@@ -18,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
18	18	\\ bns+ 1f
19	19	\\ neg 3, 3
20	20	\\ 1:
21		: [ret] "={r3}" (-> usize)
	21	: [ret] "={r3}" (-> usize),
22	22	: [number] "{r0}" (@enumToInt(number)),
23		[arg1] "{r3}" (arg1)
	23	[arg1] "{r3}" (arg1),
24	24	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
25	25	);
26	26	}
...	...	@@ -31,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
31	31	\\ bns+ 1f
32	32	\\ neg 3, 3
33	33	\\ 1:
34		: [ret] "={r3}" (-> usize)
	34	: [ret] "={r3}" (-> usize),
35	35	: [number] "{r0}" (@enumToInt(number)),
36	36	[arg1] "{r3}" (arg1),
37		[arg2] "{r4}" (arg2)
	37	[arg2] "{r4}" (arg2),
38	38	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
39	39	);
40	40	}
...	...	@@ -45,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45	45	\\ bns+ 1f
46	46	\\ neg 3, 3
47	47	\\ 1:
48		: [ret] "={r3}" (-> usize)
	48	: [ret] "={r3}" (-> usize),
49	49	: [number] "{r0}" (@enumToInt(number)),
50	50	[arg1] "{r3}" (arg1),
51	51	[arg2] "{r4}" (arg2),
52		[arg3] "{r5}" (arg3)
	52	[arg3] "{r5}" (arg3),
53	53	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
54	54	);
55	55	}
...	...	@@ -60,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
60	60	\\ bns+ 1f
61	61	\\ neg 3, 3
62	62	\\ 1:
63		: [ret] "={r3}" (-> usize)
	63	: [ret] "={r3}" (-> usize),
64	64	: [number] "{r0}" (@enumToInt(number)),
65	65	[arg1] "{r3}" (arg1),
66	66	[arg2] "{r4}" (arg2),
67	67	[arg3] "{r5}" (arg3),
68		[arg4] "{r6}" (arg4)
	68	[arg4] "{r6}" (arg4),
69	69	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
70	70	);
71	71	}
...	...	@@ -76,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
76	76	\\ bns+ 1f
77	77	\\ neg 3, 3
78	78	\\ 1:
79		: [ret] "={r3}" (-> usize)
	79	: [ret] "={r3}" (-> usize),
80	80	: [number] "{r0}" (@enumToInt(number)),
81	81	[arg1] "{r3}" (arg1),
82	82	[arg2] "{r4}" (arg2),
83	83	[arg3] "{r5}" (arg3),
84	84	[arg4] "{r6}" (arg4),
85		[arg5] "{r7}" (arg5)
	85	[arg5] "{r7}" (arg5),
86	86	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
87	87	);
88	88	}
...	...	@@ -101,14 +101,14 @@ pub fn syscall6(
101	101	\\ bns+ 1f
102	102	\\ neg 3, 3
103	103	\\ 1:
104		: [ret] "={r3}" (-> usize)
	104	: [ret] "={r3}" (-> usize),
105	105	: [number] "{r0}" (@enumToInt(number)),
106	106	[arg1] "{r3}" (arg1),
107	107	[arg2] "{r4}" (arg2),
108	108	[arg3] "{r5}" (arg3),
109	109	[arg4] "{r6}" (arg4),
110	110	[arg5] "{r7}" (arg5),
111		[arg6] "{r8}" (arg6)
	111	[arg6] "{r8}" (arg6),
112	112	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
113	113	);
114	114	}
...	...	@@ -121,7 +121,7 @@ pub const restore = restore_rt;
121	121	pub fn restore_rt() callconv(.Naked) void {
122	122	return asm volatile ("sc"
123	123	:
124		: [number] "{r0}" (@enumToInt(SYS.rt_sigreturn))
	124	: [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)),
125	125	: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
126	126	);
127	127	}

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

...	...	@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
2	2
3	3	pub fn syscall0(number: SYS) usize {
4	4	return asm volatile ("ecall"
5		: [ret] "={x10}" (-> usize)
6		: [number] "{x17}" (@enumToInt(number))
	5	: [ret] "={x10}" (-> usize),
	6	: [number] "{x17}" (@enumToInt(number)),
7	7	: "memory"
8	8	);
9	9	}
10	10
11	11	pub fn syscall1(number: SYS, arg1: usize) usize {
12	12	return asm volatile ("ecall"
13		: [ret] "={x10}" (-> usize)
	13	: [ret] "={x10}" (-> usize),
14	14	: [number] "{x17}" (@enumToInt(number)),
15		[arg1] "{x10}" (arg1)
	15	[arg1] "{x10}" (arg1),
16	16	: "memory"
17	17	);
18	18	}
19	19
20	20	pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21	21	return asm volatile ("ecall"
22		: [ret] "={x10}" (-> usize)
	22	: [ret] "={x10}" (-> usize),
23	23	: [number] "{x17}" (@enumToInt(number)),
24	24	[arg1] "{x10}" (arg1),
25		[arg2] "{x11}" (arg2)
	25	[arg2] "{x11}" (arg2),
26	26	: "memory"
27	27	);
28	28	}
29	29
30	30	pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31	31	return asm volatile ("ecall"
32		: [ret] "={x10}" (-> usize)
	32	: [ret] "={x10}" (-> usize),
33	33	: [number] "{x17}" (@enumToInt(number)),
34	34	[arg1] "{x10}" (arg1),
35	35	[arg2] "{x11}" (arg2),
36		[arg3] "{x12}" (arg3)
	36	[arg3] "{x12}" (arg3),
37	37	: "memory"
38	38	);
39	39	}
40	40
41	41	pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42	42	return asm volatile ("ecall"
43		: [ret] "={x10}" (-> usize)
	43	: [ret] "={x10}" (-> usize),
44	44	: [number] "{x17}" (@enumToInt(number)),
45	45	[arg1] "{x10}" (arg1),
46	46	[arg2] "{x11}" (arg2),
47	47	[arg3] "{x12}" (arg3),
48		[arg4] "{x13}" (arg4)
	48	[arg4] "{x13}" (arg4),
49	49	: "memory"
50	50	);
51	51	}
52	52
53	53	pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54	54	return asm volatile ("ecall"
55		: [ret] "={x10}" (-> usize)
	55	: [ret] "={x10}" (-> usize),
56	56	: [number] "{x17}" (@enumToInt(number)),
57	57	[arg1] "{x10}" (arg1),
58	58	[arg2] "{x11}" (arg2),
59	59	[arg3] "{x12}" (arg3),
60	60	[arg4] "{x13}" (arg4),
61		[arg5] "{x14}" (arg5)
	61	[arg5] "{x14}" (arg5),
62	62	: "memory"
63	63	);
64	64	}
...	...	@@ -73,14 +73,14 @@ pub fn syscall6(
73	73	arg6: usize,
74	74	) usize {
75	75	return asm volatile ("ecall"
76		: [ret] "={x10}" (-> usize)
	76	: [ret] "={x10}" (-> usize),
77	77	: [number] "{x17}" (@enumToInt(number)),
78	78	[arg1] "{x10}" (arg1),
79	79	[arg2] "{x11}" (arg2),
80	80	[arg3] "{x12}" (arg3),
81	81	[arg4] "{x13}" (arg4),
82	82	[arg5] "{x14}" (arg5),
83		[arg6] "{x15}" (arg6)
	83	[arg6] "{x15}" (arg6),
84	84	: "memory"
85	85	);
86	86	}
...	...	@@ -92,7 +92,7 @@ pub const restore = restore_rt;
92	92	pub fn restore_rt() callconv(.Naked) void {
93	93	return asm volatile ("ecall"
94	94	:
95		: [number] "{x17}" (@enumToInt(SYS.rt_sigreturn))
	95	: [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)),
96	96	: "memory"
97	97	);
98	98	}

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

...	...	@@ -14,9 +14,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
14	14	\\ st %%o1, [%%g3+4]
15	15	\\ clr %%o0
16	16	\\2:
17		: [ret] "={o0}" (-> usize)
	17	: [ret] "={o0}" (-> usize),
18	18	: [number] "{g1}" (@enumToInt(SYS.pipe)),
19		[arg] "r" (fd)
	19	[arg] "r" (fd),
20	20	: "memory", "g3"
21	21	);
22	22	}
...	...	@@ -38,8 +38,8 @@ pub fn syscall_fork() usize {
38	38	\\ dec %%o1
39	39	\\ and %%o1, %%o0, %%o0
40	40	\\ 2:
41		: [ret] "={o0}" (-> usize)
42		: [number] "{g1}" (@enumToInt(SYS.fork))
	41	: [ret] "={o0}" (-> usize),
	42	: [number] "{g1}" (@enumToInt(SYS.fork)),
43	43	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
44	44	);
45	45	}
...	...	@@ -51,8 +51,8 @@ pub fn syscall0(number: SYS) usize {
51	51	\\ nop
52	52	\\ neg %%o0
53	53	\\ 1:
54		: [ret] "={o0}" (-> usize)
55		: [number] "{g1}" (@enumToInt(number))
	54	: [ret] "={o0}" (-> usize),
	55	: [number] "{g1}" (@enumToInt(number)),
56	56	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
57	57	);
58	58	}
...	...	@@ -64,9 +64,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
64	64	\\ nop
65	65	\\ neg %%o0
66	66	\\ 1:
67		: [ret] "={o0}" (-> usize)
	67	: [ret] "={o0}" (-> usize),
68	68	: [number] "{g1}" (@enumToInt(number)),
69		[arg1] "{o0}" (arg1)
	69	[arg1] "{o0}" (arg1),
70	70	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
71	71	);
72	72	}
...	...	@@ -78,10 +78,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
78	78	\\ nop
79	79	\\ neg %%o0
80	80	\\ 1:
81		: [ret] "={o0}" (-> usize)
	81	: [ret] "={o0}" (-> usize),
82	82	: [number] "{g1}" (@enumToInt(number)),
83	83	[arg1] "{o0}" (arg1),
84		[arg2] "{o1}" (arg2)
	84	[arg2] "{o1}" (arg2),
85	85	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
86	86	);
87	87	}
...	...	@@ -93,11 +93,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
93	93	\\ nop
94	94	\\ neg %%o0
95	95	\\ 1:
96		: [ret] "={o0}" (-> usize)
	96	: [ret] "={o0}" (-> usize),
97	97	: [number] "{g1}" (@enumToInt(number)),
98	98	[arg1] "{o0}" (arg1),
99	99	[arg2] "{o1}" (arg2),
100		[arg3] "{o2}" (arg3)
	100	[arg3] "{o2}" (arg3),
101	101	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
102	102	);
103	103	}
...	...	@@ -109,12 +109,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109	109	\\ nop
110	110	\\ neg %%o0
111	111	\\ 1:
112		: [ret] "={o0}" (-> usize)
	112	: [ret] "={o0}" (-> usize),
113	113	: [number] "{g1}" (@enumToInt(number)),
114	114	[arg1] "{o0}" (arg1),
115	115	[arg2] "{o1}" (arg2),
116	116	[arg3] "{o2}" (arg3),
117		[arg4] "{o3}" (arg4)
	117	[arg4] "{o3}" (arg4),
118	118	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
119	119	);
120	120	}
...	...	@@ -126,13 +126,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
126	126	\\ nop
127	127	\\ neg %%o0
128	128	\\ 1:
129		: [ret] "={o0}" (-> usize)
	129	: [ret] "={o0}" (-> usize),
130	130	: [number] "{g1}" (@enumToInt(number)),
131	131	[arg1] "{o0}" (arg1),
132	132	[arg2] "{o1}" (arg2),
133	133	[arg3] "{o2}" (arg3),
134	134	[arg4] "{o3}" (arg4),
135		[arg5] "{o4}" (arg5)
	135	[arg5] "{o4}" (arg5),
136	136	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
137	137	);
138	138	}
...	...	@@ -152,14 +152,14 @@ pub fn syscall6(
152	152	\\ nop
153	153	\\ neg %%o0
154	154	\\ 1:
155		: [ret] "={o0}" (-> usize)
	155	: [ret] "={o0}" (-> usize),
156	156	: [number] "{g1}" (@enumToInt(number)),
157	157	[arg1] "{o0}" (arg1),
158	158	[arg2] "{o1}" (arg2),
159	159	[arg3] "{o2}" (arg3),
160	160	[arg4] "{o3}" (arg4),
161	161	[arg5] "{o4}" (arg5),
162		[arg6] "{o5}" (arg6)
	162	[arg6] "{o5}" (arg6),
163	163	: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
164	164	);
165	165	}
...	...	@@ -174,7 +174,7 @@ pub const restore = restore_rt;
174	174	pub fn restore_rt() callconv(.C) void {
175	175	return asm volatile ("t 0x6d"
176	176	:
177		: [number] "{g1}" (@enumToInt(SYS.rt_sigreturn))
	177	: [number] "{g1}" (@enumToInt(SYS.rt_sigreturn)),
178	178	: "memory", "xcc", "o0", "o1", "o2", "o3", "o4", "o5", "o7"
179	179	);
180	180	}

lib/std/os/linux/start_pie.zig+5-5

...	...	@@ -30,13 +30,13 @@ fn getDynamicSymbol() [*]elf.Dyn {
30	30	\\ call 1f
31	31	\\ 1: pop %[ret]
32	32	\\ lea _DYNAMIC-1b(%[ret]), %[ret]
33		: [ret] "=r" (-> [*]elf.Dyn)
	33	: [ret] "=r" (-> [*]elf.Dyn),
34	34	),
35	35	.x86_64 => asm volatile (
36	36	\\ .weak _DYNAMIC
37	37	\\ .hidden _DYNAMIC
38	38	\\ lea _DYNAMIC(%%rip), %[ret]
39		: [ret] "=r" (-> [*]elf.Dyn)
	39	: [ret] "=r" (-> [*]elf.Dyn),
40	40	),
41	41	// Work around the limited offset range of `ldr`
42	42	.arm => asm volatile (
...	...	@@ -47,7 +47,7 @@ fn getDynamicSymbol() [*]elf.Dyn {
47	47	\\ b 2f
48	48	\\ 1: .word _DYNAMIC-1b
49	49	\\ 2:
50		: [ret] "=r" (-> [*]elf.Dyn)
	50	: [ret] "=r" (-> [*]elf.Dyn),
51	51	),
52	52	// A simple `adr` is not enough as it has a limited offset range
53	53	.aarch64 => asm volatile (
...	...	@@ -55,13 +55,13 @@ fn getDynamicSymbol() [*]elf.Dyn {
55	55	\\ .hidden _DYNAMIC
56	56	\\ adrp %[ret], _DYNAMIC
57	57	\\ add %[ret], %[ret], #:lo12:_DYNAMIC
58		: [ret] "=r" (-> [*]elf.Dyn)
	58	: [ret] "=r" (-> [*]elf.Dyn),
59	59	),
60	60	.riscv64 => asm volatile (
61	61	\\ .weak _DYNAMIC
62	62	\\ .hidden _DYNAMIC
63	63	\\ lla %[ret], _DYNAMIC
64		: [ret] "=r" (-> [*]elf.Dyn)
	64	: [ret] "=r" (-> [*]elf.Dyn),
65	65	),
66	66	else => {
67	67	@compileError("PIE startup is not yet supported for this target!");

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

...	...	@@ -15,8 +15,8 @@ pub fn syscall0(number: SYS) usize {
15	15	\\ ldr r7, [%[tmp]]
16	16	\\ svc #0
17	17	\\ ldr r7, [%[tmp], #4]
18		: [ret] "={r0}" (-> usize)
19		: [tmp] "{r1}" (buf)
	18	: [ret] "={r0}" (-> usize),
	19	: [tmp] "{r1}" (buf),
20	20	: "memory"
21	21	);
22	22	}
...	...	@@ -30,9 +30,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
30	30	\\ ldr r7, [%[tmp]]
31	31	\\ svc #0
32	32	\\ ldr r7, [%[tmp], #4]
33		: [ret] "={r0}" (-> usize)
	33	: [ret] "={r0}" (-> usize),
34	34	: [tmp] "{r1}" (buf),
35		[arg1] "{r0}" (arg1)
	35	[arg1] "{r0}" (arg1),
36	36	: "memory"
37	37	);
38	38	}
...	...	@@ -46,10 +46,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
46	46	\\ ldr r7, [%[tmp]]
47	47	\\ svc #0
48	48	\\ ldr r7, [%[tmp], #4]
49		: [ret] "={r0}" (-> usize)
	49	: [ret] "={r0}" (-> usize),
50	50	: [tmp] "{r2}" (buf),
51	51	[arg1] "{r0}" (arg1),
52		[arg2] "{r1}" (arg2)
	52	[arg2] "{r1}" (arg2),
53	53	: "memory"
54	54	);
55	55	}
...	...	@@ -63,11 +63,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
63	63	\\ ldr r7, [%[tmp]]
64	64	\\ svc #0
65	65	\\ ldr r7, [%[tmp], #4]
66		: [ret] "={r0}" (-> usize)
	66	: [ret] "={r0}" (-> usize),
67	67	: [tmp] "{r3}" (buf),
68	68	[arg1] "{r0}" (arg1),
69	69	[arg2] "{r1}" (arg2),
70		[arg3] "{r2}" (arg3)
	70	[arg3] "{r2}" (arg3),
71	71	: "memory"
72	72	);
73	73	}
...	...	@@ -81,12 +81,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
81	81	\\ ldr r7, [%[tmp]]
82	82	\\ svc #0
83	83	\\ ldr r7, [%[tmp], #4]
84		: [ret] "={r0}" (-> usize)
	84	: [ret] "={r0}" (-> usize),
85	85	: [tmp] "{r4}" (buf),
86	86	[arg1] "{r0}" (arg1),
87	87	[arg2] "{r1}" (arg2),
88	88	[arg3] "{r2}" (arg3),
89		[arg4] "{r3}" (arg4)
	89	[arg4] "{r3}" (arg4),
90	90	: "memory"
91	91	);
92	92	}
...	...	@@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
100	100	\\ ldr r7, [%[tmp]]
101	101	\\ svc #0
102	102	\\ ldr r7, [%[tmp], #4]
103		: [ret] "={r0}" (-> usize)
	103	: [ret] "={r0}" (-> usize),
104	104	: [tmp] "{r5}" (buf),
105	105	[arg1] "{r0}" (arg1),
106	106	[arg2] "{r1}" (arg2),
107	107	[arg3] "{r2}" (arg3),
108	108	[arg4] "{r3}" (arg4),
109		[arg5] "{r4}" (arg5)
	109	[arg5] "{r4}" (arg5),
110	110	: "memory"
111	111	);
112	112	}
...	...	@@ -128,14 +128,14 @@ pub fn syscall6(
128	128	\\ ldr r7, [%[tmp]]
129	129	\\ svc #0
130	130	\\ ldr r7, [%[tmp], #4]
131		: [ret] "={r0}" (-> usize)
	131	: [ret] "={r0}" (-> usize),
132	132	: [tmp] "{r6}" (buf),
133	133	[arg1] "{r0}" (arg1),
134	134	[arg2] "{r1}" (arg2),
135	135	[arg3] "{r2}" (arg3),
136	136	[arg4] "{r3}" (arg4),
137	137	[arg5] "{r4}" (arg5),
138		[arg6] "{r5}" (arg6)
	138	[arg6] "{r5}" (arg6),
139	139	: "memory"
140	140	);
141	141	}
...	...	@@ -148,7 +148,7 @@ pub fn restore() callconv(.Naked) void {
148	148	\\ mov r7, %[number]
149	149	\\ svc #0
150	150	:
151		: [number] "I" (@enumToInt(SYS.sigreturn))
	151	: [number] "I" (@enumToInt(SYS.sigreturn)),
152	152	);
153	153	}
154	154
...	...	@@ -157,7 +157,7 @@ pub fn restore_rt() callconv(.Naked) void {
157	157	\\ mov r7, %[number]
158	158	\\ svc #0
159	159	:
160		: [number] "I" (@enumToInt(SYS.rt_sigreturn))
	160	: [number] "I" (@enumToInt(SYS.rt_sigreturn)),
161	161	: "memory"
162	162	);
163	163	}

lib/std/os/linux/tls.zig+6-6

...	...	@@ -131,7 +131,7 @@ pub fn setThreadPointer(addr: usize) void {
131	131	// Update the %gs selector
132	132	asm volatile ("movl %[gs_val], %%gs"
133	133	:
134		: [gs_val] "r" (gdt_entry_number << 3 \| 3)
	134	: [gs_val] "r" (gdt_entry_number << 3 \| 3),
135	135	);
136	136	},
137	137	.x86_64 => {
...	...	@@ -142,7 +142,7 @@ pub fn setThreadPointer(addr: usize) void {
142	142	asm volatile (
143	143	\\ msr tpidr_el0, %[addr]
144	144	:
145		: [addr] "r" (addr)
	145	: [addr] "r" (addr),
146	146	);
147	147	},
148	148	.arm, .thumb => {
...	...	@@ -153,7 +153,7 @@ pub fn setThreadPointer(addr: usize) void {
153	153	asm volatile (
154	154	\\ mv tp, %[addr]
155	155	:
156		: [addr] "r" (addr)
	156	: [addr] "r" (addr),
157	157	);
158	158	},
159	159	.mips, .mipsel => {
...	...	@@ -164,21 +164,21 @@ pub fn setThreadPointer(addr: usize) void {
164	164	asm volatile (
165	165	\\ mr 2, %[addr]
166	166	:
167		: [addr] "r" (addr)
	167	: [addr] "r" (addr),
168	168	);
169	169	},
170	170	.powerpc64, .powerpc64le => {
171	171	asm volatile (
172	172	\\ mr 13, %[addr]
173	173	:
174		: [addr] "r" (addr)
	174	: [addr] "r" (addr),
175	175	);
176	176	},
177	177	.sparcv9 => {
178	178	asm volatile (
179	179	\\ mov %[addr], %%g7
180	180	:
181		: [addr] "r" (addr)
	181	: [addr] "r" (addr),
182	182	);
183	183	},
184	184	else => @compileError("Unsupported architecture"),

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

...	...	@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
2	2
3	3	pub fn syscall0(number: SYS) usize {
4	4	return asm volatile ("syscall"
5		: [ret] "={rax}" (-> usize)
6		: [number] "{rax}" (@enumToInt(number))
	5	: [ret] "={rax}" (-> usize),
	6	: [number] "{rax}" (@enumToInt(number)),
7	7	: "rcx", "r11", "memory"
8	8	);
9	9	}
10	10
11	11	pub fn syscall1(number: SYS, arg1: usize) usize {
12	12	return asm volatile ("syscall"
13		: [ret] "={rax}" (-> usize)
	13	: [ret] "={rax}" (-> usize),
14	14	: [number] "{rax}" (@enumToInt(number)),
15		[arg1] "{rdi}" (arg1)
	15	[arg1] "{rdi}" (arg1),
16	16	: "rcx", "r11", "memory"
17	17	);
18	18	}
19	19
20	20	pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21	21	return asm volatile ("syscall"
22		: [ret] "={rax}" (-> usize)
	22	: [ret] "={rax}" (-> usize),
23	23	: [number] "{rax}" (@enumToInt(number)),
24	24	[arg1] "{rdi}" (arg1),
25		[arg2] "{rsi}" (arg2)
	25	[arg2] "{rsi}" (arg2),
26	26	: "rcx", "r11", "memory"
27	27	);
28	28	}
29	29
30	30	pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31	31	return asm volatile ("syscall"
32		: [ret] "={rax}" (-> usize)
	32	: [ret] "={rax}" (-> usize),
33	33	: [number] "{rax}" (@enumToInt(number)),
34	34	[arg1] "{rdi}" (arg1),
35	35	[arg2] "{rsi}" (arg2),
36		[arg3] "{rdx}" (arg3)
	36	[arg3] "{rdx}" (arg3),
37	37	: "rcx", "r11", "memory"
38	38	);
39	39	}
40	40
41	41	pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42	42	return asm volatile ("syscall"
43		: [ret] "={rax}" (-> usize)
	43	: [ret] "={rax}" (-> usize),
44	44	: [number] "{rax}" (@enumToInt(number)),
45	45	[arg1] "{rdi}" (arg1),
46	46	[arg2] "{rsi}" (arg2),
47	47	[arg3] "{rdx}" (arg3),
48		[arg4] "{r10}" (arg4)
	48	[arg4] "{r10}" (arg4),
49	49	: "rcx", "r11", "memory"
50	50	);
51	51	}
52	52
53	53	pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54	54	return asm volatile ("syscall"
55		: [ret] "={rax}" (-> usize)
	55	: [ret] "={rax}" (-> usize),
56	56	: [number] "{rax}" (@enumToInt(number)),
57	57	[arg1] "{rdi}" (arg1),
58	58	[arg2] "{rsi}" (arg2),
59	59	[arg3] "{rdx}" (arg3),
60	60	[arg4] "{r10}" (arg4),
61		[arg5] "{r8}" (arg5)
	61	[arg5] "{r8}" (arg5),
62	62	: "rcx", "r11", "memory"
63	63	);
64	64	}
...	...	@@ -73,14 +73,14 @@ pub fn syscall6(
73	73	arg6: usize,
74	74	) usize {
75	75	return asm volatile ("syscall"
76		: [ret] "={rax}" (-> usize)
	76	: [ret] "={rax}" (-> usize),
77	77	: [number] "{rax}" (@enumToInt(number)),
78	78	[arg1] "{rdi}" (arg1),
79	79	[arg2] "{rsi}" (arg2),
80	80	[arg3] "{rdx}" (arg3),
81	81	[arg4] "{r10}" (arg4),
82	82	[arg5] "{r8}" (arg5),
83		[arg6] "{r9}" (arg6)
	83	[arg6] "{r9}" (arg6),
84	84	: "rcx", "r11", "memory"
85	85	);
86	86	}
...	...	@@ -93,7 +93,7 @@ pub const restore = restore_rt;
93	93	pub fn restore_rt() callconv(.Naked) void {
94	94	return asm volatile ("syscall"
95	95	:
96		: [number] "{rax}" (@enumToInt(SYS.rt_sigreturn))
	96	: [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)),
97	97	: "rcx", "r11", "memory"
98	98	);
99	99	}

lib/std/os/windows.zig+3-3

...	...	@@ -1723,15 +1723,15 @@ pub fn teb() *TEB {
1723	1723	return switch (builtin.target.cpu.arch) {
1724	1724	.i386 => asm volatile (
1725	1725	\\ movl %%fs:0x18, %[ptr]
1726		: [ptr] "=r" (-> *TEB)
	1726	: [ptr] "=r" (-> *TEB),
1727	1727	),
1728	1728	.x86_64 => asm volatile (
1729	1729	\\ movq %%gs:0x30, %[ptr]
1730		: [ptr] "=r" (-> *TEB)
	1730	: [ptr] "=r" (-> *TEB),
1731	1731	),
1732	1732	.aarch64 => asm volatile (
1733	1733	\\ mov %[ptr], x18
1734		: [ptr] "=r" (-> *TEB)
	1734	: [ptr] "=r" (-> *TEB),
1735	1735	),
1736	1736	else => @compileError("unsupported arch"),
1737	1737	};

lib/std/special/compiler_rt/clear_cache.zig+3-3

...	...	@@ -88,7 +88,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
88	88	asm volatile (
89	89	\\mrs %[x], ctr_el0
90	90	\\
91		: [x] "=r" (ctr_el0)
	91	: [x] "=r" (ctr_el0),
92	92	);
93	93	// The DC and IC instructions must use 64-bit registers so we don't use
94	94	// uintptr_t in case this runs in an IPL32 environment.
...	...	@@ -101,7 +101,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
101	101	while (addr < end) : (addr += dcache_line_size) {
102	102	asm volatile ("dc cvau, %[addr]"
103	103	:
104		: [addr] "r" (addr)
	104	: [addr] "r" (addr),
105	105	);
106	106	}
107	107	}
...	...	@@ -114,7 +114,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
114	114	while (addr < end) : (addr += icache_line_size) {
115	115	asm volatile ("ic ivau, %[addr]"
116	116	:
117		: [addr] "r" (addr)
	117	: [addr] "r" (addr),
118	118	);
119	119	}
120	120	}

lib/std/start.zig+13-13

...	...	@@ -98,7 +98,7 @@ fn exit2(code: usize) noreturn {
98	98	asm volatile ("syscall"
99	99	:
100	100	: [number] "{rax}" (231),
101		[arg1] "{rdi}" (code)
	101	[arg1] "{rdi}" (code),
102	102	: "rcx", "r11", "memory"
103	103	);
104	104	},
...	...	@@ -106,7 +106,7 @@ fn exit2(code: usize) noreturn {
106	106	asm volatile ("svc #0"
107	107	:
108	108	: [number] "{r7}" (1),
109		[arg1] "{r0}" (code)
	109	[arg1] "{r0}" (code),
110	110	: "memory"
111	111	);
112	112	},
...	...	@@ -114,7 +114,7 @@ fn exit2(code: usize) noreturn {
114	114	asm volatile ("svc #0"
115	115	:
116	116	: [number] "{x8}" (93),
117		[arg1] "{x0}" (code)
	117	[arg1] "{x0}" (code),
118	118	: "memory", "cc"
119	119	);
120	120	},
...	...	@@ -128,7 +128,7 @@ fn exit2(code: usize) noreturn {
128	128	\\push $0
129	129	\\syscall
130	130	:
131		: [syscall_number] "{rbp}" (8)
	131	: [syscall_number] "{rbp}" (8),
132	132	: "rcx", "r11", "memory"
133	133	);
134	134	},
...	...	@@ -137,7 +137,7 @@ fn exit2(code: usize) noreturn {
137	137	.aarch64 => {
138	138	asm volatile ("svc #0"
139	139	:
140		: [exit] "{x0}" (0x08)
	140	: [exit] "{x0}" (0x08),
141	141	: "memory", "cc"
142	142	);
143	143	},
...	...	@@ -208,34 +208,34 @@ fn _start() callconv(.Naked) noreturn {
208	208	.x86_64 => {
209	209	argc_argv_ptr = asm volatile (
210	210	\\ xor %%rbp, %%rbp
211		: [argc] "={rsp}" (-> [*]usize)
	211	: [argc] "={rsp}" (-> [*]usize),
212	212	);
213	213	},
214	214	.i386 => {
215	215	argc_argv_ptr = asm volatile (
216	216	\\ xor %%ebp, %%ebp
217		: [argc] "={esp}" (-> [*]usize)
	217	: [argc] "={esp}" (-> [*]usize),
218	218	);
219	219	},
220	220	.aarch64, .aarch64_be, .arm, .armeb, .thumb => {
221	221	argc_argv_ptr = asm volatile (
222	222	\\ mov fp, #0
223	223	\\ mov lr, #0
224		: [argc] "={sp}" (-> [*]usize)
	224	: [argc] "={sp}" (-> [*]usize),
225	225	);
226	226	},
227	227	.riscv64 => {
228	228	argc_argv_ptr = asm volatile (
229	229	\\ li s0, 0
230	230	\\ li ra, 0
231		: [argc] "={sp}" (-> [*]usize)
	231	: [argc] "={sp}" (-> [*]usize),
232	232	);
233	233	},
234	234	.mips, .mipsel => {
235	235	// The lr is already zeroed on entry, as specified by the ABI.
236	236	argc_argv_ptr = asm volatile (
237	237	\\ move $fp, $0
238		: [argc] "={sp}" (-> [*]usize)
	238	: [argc] "={sp}" (-> [*]usize),
239	239	);
240	240	},
241	241	.powerpc => {
...	...	@@ -246,7 +246,7 @@ fn _start() callconv(.Naked) noreturn {
246	246	\\ stwu 1,-16(1)
247	247	\\ stw 0, 0(1)
248	248	\\ mtlr 0
249		: [argc] "={r4}" (-> [*]usize)
	249	: [argc] "={r4}" (-> [*]usize),
250	250	:
251	251	: "r0"
252	252	);
...	...	@@ -259,7 +259,7 @@ fn _start() callconv(.Naked) noreturn {
259	259	\\ li 0, 0
260	260	\\ stdu 0, -32(1)
261	261	\\ mtlr 0
262		: [argc] "={r4}" (-> [*]usize)
	262	: [argc] "={r4}" (-> [*]usize),
263	263	:
264	264	: "r0"
265	265	);
...	...	@@ -269,7 +269,7 @@ fn _start() callconv(.Naked) noreturn {
269	269	argc_argv_ptr = asm (
270	270	\\ mov %%g0, %%i6
271	271	\\ add %%o6, 2175, %[argc]
272		: [argc] "=r" (-> [*]usize)
	272	: [argc] "=r" (-> [*]usize),
273	273	);
274	274	},
275	275	else => @compileError("unsupported arch"),

lib/std/valgrind.zig+4-4

...	...	@@ -13,9 +13,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:
13	13	\\ roll $3, %%edi ; roll $13, %%edi
14	14	\\ roll $29, %%edi ; roll $19, %%edi
15	15	\\ xchgl %%ebx,%%ebx
16		: [_] "={edx}" (-> usize)
	16	: [_] "={edx}" (-> usize),
17	17	: [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
18		[_] "0" (default)
	18	[_] "0" (default),
19	19	: "cc", "memory"
20	20	);
21	21	},
...	...	@@ -24,9 +24,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:
24	24	\\ rolq $3, %%rdi ; rolq $13, %%rdi
25	25	\\ rolq $61, %%rdi ; rolq $51, %%rdi
26	26	\\ xchgq %%rbx,%%rbx
27		: [_] "={rdx}" (-> usize)
	27	: [_] "={rdx}" (-> usize),
28	28	: [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
29		[_] "0" (default)
	29	[_] "0" (default),
30	30	: "cc", "memory"
31	31	);
32	32	},

lib/std/zig/parser_test.zig+15-29

...	...	@@ -1,5 +1,5 @@
1	1	test "zig fmt: preserves clobbers in inline asm with stray comma" {
2		try testTransform(
	2	try testCanonical(
3	3	\\fn foo() void {
4	4	\\ asm volatile (""
5	5	\\ : [_] "" (-> type),
...	...	@@ -13,20 +13,6 @@ test "zig fmt: preserves clobbers in inline asm with stray comma" {
13	13	\\ );
14	14	\\}
15	15	\\
16		,
17		\\fn foo() void {
18		\\ asm volatile (""
19		\\ : [_] "" (-> type)
20		\\ :
21		\\ : "clobber"
22		\\ );
23		\\ asm volatile (""
24		\\ :
25		\\ : [_] "" (type)
26		\\ : "clobber"
27		\\ );
28		\\}
29		\\
30	16	);
31	17	}
32	18
...	...	@@ -508,15 +494,15 @@ test "zig fmt: asm expression with comptime content" {
508	494	\\pub fn main() void {
509	495	\\ asm volatile ("foo" ++ "bar");
510	496	\\ asm volatile ("foo" ++ "bar"
511		\\ : [_] "" (x)
	497	\\ : [_] "" (x),
512	498	\\ );
513	499	\\ asm volatile ("foo" ++ "bar"
514		\\ : [_] "" (x)
515		\\ : [_] "" (y)
	500	\\ : [_] "" (x),
	501	\\ : [_] "" (y),
516	502	\\ );
517	503	\\ asm volatile ("foo" ++ "bar"
518		\\ : [_] "" (x)
519		\\ : [_] "" (y)
	504	\\ : [_] "" (x),
	505	\\ : [_] "" (y),
520	506	\\ : "h", "e", "l", "l", "o"
521	507	\\ );
522	508	\\}
...	...	@@ -2058,11 +2044,11 @@ test "zig fmt: simple asm" {
2058	2044	\\ );
2059	2045	\\
2060	2046	\\ asm ("not real assembly"
2061		\\ : [a] "x" (x)
	2047	\\ : [a] "x" (x),
2062	2048	\\ );
2063	2049	\\ asm ("not real assembly"
2064		\\ : [a] "x" (-> i32)
2065		\\ : [a] "x" (1)
	2050	\\ : [a] "x" (-> i32),
	2051	\\ : [a] "x" (1),
2066	2052	\\ );
2067	2053	\\ asm ("still not real assembly" ::: "a", "b");
2068	2054	\\}
...	...	@@ -3712,9 +3698,9 @@ test "zig fmt: inline asm" {
3712	3698	try testCanonical(
3713	3699	\\pub fn syscall1(number: usize, arg1: usize) usize {
3714	3700	\\ return asm volatile ("syscall"
3715		\\ : [ret] "={rax}" (-> usize)
	3701	\\ : [ret] "={rax}" (-> usize),
3716	3702	\\ : [number] "{rax}" (number),
3717		\\ [arg1] "{rdi}" (arg1)
	3703	\\ [arg1] "{rdi}" (arg1),
3718	3704	\\ : "rcx", "r11"
3719	3705	\\ );
3720	3706	\\}
...	...	@@ -3817,14 +3803,14 @@ test "zig fmt: inline asm parameter alignment" {
3817	3803	\\ \\ foo
3818	3804	\\ \\ bar
3819	3805	\\ : [_] "" (-> usize),
3820		\\ [_] "" (-> usize)
	3806	\\ [_] "" (-> usize),
3821	3807	\\ );
3822	3808	\\ asm volatile (
3823	3809	\\ \\ foo
3824	3810	\\ \\ bar
3825	3811	\\ :
3826	3812	\\ : [_] "" (0),
3827		\\ [_] "" (0)
	3813	\\ [_] "" (0),
3828	3814	\\ );
3829	3815	\\ asm volatile (
3830	3816	\\ \\ foo
...	...	@@ -3834,9 +3820,9 @@ test "zig fmt: inline asm parameter alignment" {
3834	3820	\\ \\ foo
3835	3821	\\ \\ bar
3836	3822	\\ : [_] "" (-> usize),
3837		\\ [_] "" (-> usize)
	3823	\\ [_] "" (-> usize),
3838	3824	\\ : [_] "" (0),
3839		\\ [_] "" (0)
	3825	\\ [_] "" (0),
3840	3826	\\ : "", ""
3841	3827	\\ );
3842	3828	\\}

lib/std/zig/render.zig+4-4

...	...	@@ -1944,13 +1944,13 @@ fn renderAsm(
1944	1944	try renderToken(ais, tree, comma, .newline); // ,
1945	1945	try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));
1946	1946	} else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) {
1947		try renderAsmOutput(gpa, ais, tree, asm_output, .newline);
	1947	try renderAsmOutput(gpa, ais, tree, asm_output, .comma);
1948	1948	ais.popIndent();
1949	1949	ais.setIndentDelta(indent_delta);
1950	1950	ais.popIndent();
1951	1951	return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
1952	1952	} else {
1953		try renderAsmOutput(gpa, ais, tree, asm_output, .newline);
	1953	try renderAsmOutput(gpa, ais, tree, asm_output, .comma);
1954	1954	const comma_or_colon = tree.lastToken(asm_output) + 1;
1955	1955	ais.popIndent();
1956	1956	break :colon2 switch (token_tags[comma_or_colon]) {
...	...	@@ -1976,13 +1976,13 @@ fn renderAsm(
1976	1976	try renderToken(ais, tree, first_token - 1, .newline); // ,
1977	1977	try renderExtraNewlineToken(ais, tree, first_token);
1978	1978	} else if (asm_node.first_clobber == null) {
1979		try renderAsmInput(gpa, ais, tree, asm_input, .newline);
	1979	try renderAsmInput(gpa, ais, tree, asm_input, .comma);
1980	1980	ais.popIndent();
1981	1981	ais.setIndentDelta(indent_delta);
1982	1982	ais.popIndent();
1983	1983	return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
1984	1984	} else {
1985		try renderAsmInput(gpa, ais, tree, asm_input, .newline);
	1985	try renderAsmInput(gpa, ais, tree, asm_input, .comma);
1986	1986	const comma_or_colon = tree.lastToken(asm_input) + 1;
1987	1987	ais.popIndent();
1988	1988	break :colon3 switch (token_tags[comma_or_colon]) {

lib/std/zig/system/x86.zig+2-2

...	...	@@ -543,7 +543,7 @@ fn cpuid(leaf_id: u32, subid: u32) CpuidLeaf {
543	543	:
544	544	: [leaf_id] "{eax}" (leaf_id),
545	545	[subid] "{ecx}" (subid),
546		[leaf_ptr] "r" (&cpuid_leaf)
	546	[leaf_ptr] "r" (&cpuid_leaf),
547	547	: "eax", "ebx", "ecx", "edx"
548	548	);
549	549
...	...	@@ -555,7 +555,7 @@ fn getXCR0() u32 {
555	555	return asm volatile (
556	556	\\ xor %%ecx, %%ecx
557	557	\\ xgetbv
558		: [ret] "={eax}" (-> u32)
	558	: [ret] "={eax}" (-> u32),
559	559	:
560	560	: "eax", "edx", "ecx"
561	561	);

test/behavior/asm.zig+15-15

...	...	@@ -23,12 +23,12 @@ test "output constraint modifiers" {
23	23	// This is only testing compilation.
24	24	var a: u32 = 3;
25	25	asm volatile (""
26		: [_] "=m,r" (a)
	26	: [_] "=m,r" (a),
27	27	:
28	28	: ""
29	29	);
30	30	asm volatile (""
31		: [_] "=r,m" (a)
	31	: [_] "=r,m" (a),
32	32	:
33	33	: ""
34	34	);
...	...	@@ -38,8 +38,8 @@ test "alternative constraints" {
38	38	// Make sure we allow commas as a separator for alternative constraints.
39	39	var a: u32 = 3;
40	40	asm volatile (""
41		: [_] "=r,m" (a)
42		: [_] "r,m" (a)
	41	: [_] "=r,m" (a),
	42	: [_] "r,m" (a),
43	43	: ""
44	44	);
45	45	}
...	...	@@ -47,42 +47,42 @@ test "alternative constraints" {
47	47	test "sized integer/float in asm input" {
48	48	asm volatile (""
49	49	:
50		: [_] "m" (@as(usize, 3))
	50	: [_] "m" (@as(usize, 3)),
51	51	: ""
52	52	);
53	53	asm volatile (""
54	54	:
55		: [_] "m" (@as(i15, -3))
	55	: [_] "m" (@as(i15, -3)),
56	56	: ""
57	57	);
58	58	asm volatile (""
59	59	:
60		: [_] "m" (@as(u3, 3))
	60	: [_] "m" (@as(u3, 3)),
61	61	: ""
62	62	);
63	63	asm volatile (""
64	64	:
65		: [_] "m" (@as(i3, 3))
	65	: [_] "m" (@as(i3, 3)),
66	66	: ""
67	67	);
68	68	asm volatile (""
69	69	:
70		: [_] "m" (@as(u121, 3))
	70	: [_] "m" (@as(u121, 3)),
71	71	: ""
72	72	);
73	73	asm volatile (""
74	74	:
75		: [_] "m" (@as(i121, 3))
	75	: [_] "m" (@as(i121, 3)),
76	76	: ""
77	77	);
78	78	asm volatile (""
79	79	:
80		: [_] "m" (@as(f32, 3.17))
	80	: [_] "m" (@as(f32, 3.17)),
81	81	: ""
82	82	);
83	83	asm volatile (""
84	84	:
85		: [_] "m" (@as(f64, 3.17))
	85	: [_] "m" (@as(f64, 3.17)),
86	86	: ""
87	87	);
88	88	}
...	...	@@ -90,15 +90,15 @@ test "sized integer/float in asm input" {
90	90	test "struct/array/union types as input values" {
91	91	asm volatile (""
92	92	:
93		: [_] "m" (@as([1]u32, undefined))
	93	: [_] "m" (@as([1]u32, undefined)),
94	94	); // fails
95	95	asm volatile (""
96	96	:
97		: [_] "m" (@as(struct { x: u32, y: u8 }, undefined))
	97	: [_] "m" (@as(struct { x: u32, y: u8 }, undefined)),
98	98	); // fails
99	99	asm volatile (""
100	100	:
101		: [_] "m" (@as(union { x: u32, y: u8 }, undefined))
	101	: [_] "m" (@as(union { x: u32, y: u8 }, undefined)),
102	102	); // fails
103	103	}
104	104

author	jdmichaud <jdmichaud@users.noreply.github.com> 2021-08-29 11:57:32+02:00
committer	GitHub <noreply@github.com> 2021-08-29 11:57:32+02:00
log	49c9975484aeb4c1534626d0f975a938a795ebe2
tree	13884b0f0e4e9e850feecbd6951859822938fe98
parent	7b863aa8ac6d48092c8d5b3c8713d9f8a9cfbdf3
signature	Signed by PGP key 4AEE18F83AFDEB23

zig fmt: respect trailing commas in inline assembly