authorgravatar for jdmichaud@users.noreply.github.comjdmichaud <jdmichaud@users.noreply.github.com> 2021-08-29 11:57:32+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2021-08-29 11:57:32+02:00
log49c9975484aeb4c1534626d0f975a938a795ebe2
tree13884b0f0e4e9e850feecbd6951859822938fe98
parent7b863aa8ac6d48092c8d5b3c8713d9f8a9cfbdf3
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

zig fmt: respect trailing commas in inline assembly

27 files changed, 293 insertions(+), 307 deletions(-)

lib/std/Thread.zig+9-9
...@@ -700,7 +700,7 @@ const LinuxThreadImpl = struct {...@@ -700,7 +700,7 @@ const LinuxThreadImpl = struct {
700 \\ int $128700 \\ int $128
701 :701 :
702 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),702 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
703 [len] "r" (self.mapped.len)703 [len] "r" (self.mapped.len),
704 : "memory"704 : "memory"
705 ),705 ),
706 .x86_64 => asm volatile (706 .x86_64 => asm volatile (
...@@ -713,7 +713,7 @@ const LinuxThreadImpl = struct {...@@ -713,7 +713,7 @@ const LinuxThreadImpl = struct {
713 \\ syscall713 \\ syscall
714 :714 :
715 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),715 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
716 [len] "r" (self.mapped.len)716 [len] "r" (self.mapped.len),
717 : "memory"717 : "memory"
718 ),718 ),
719 .arm, .armeb, .thumb, .thumbeb => asm volatile (719 .arm, .armeb, .thumb, .thumbeb => asm volatile (
...@@ -726,7 +726,7 @@ const LinuxThreadImpl = struct {...@@ -726,7 +726,7 @@ const LinuxThreadImpl = struct {
726 \\ svc 0726 \\ svc 0
727 :727 :
728 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),728 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
729 [len] "r" (self.mapped.len)729 [len] "r" (self.mapped.len),
730 : "memory"730 : "memory"
731 ),731 ),
732 .aarch64, .aarch64_be, .aarch64_32 => asm volatile (732 .aarch64, .aarch64_be, .aarch64_32 => asm volatile (
...@@ -739,7 +739,7 @@ const LinuxThreadImpl = struct {...@@ -739,7 +739,7 @@ const LinuxThreadImpl = struct {
739 \\ svc 0739 \\ svc 0
740 :740 :
741 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),741 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
742 [len] "r" (self.mapped.len)742 [len] "r" (self.mapped.len),
743 : "memory"743 : "memory"
744 ),744 ),
745 .mips, .mipsel => asm volatile (745 .mips, .mipsel => asm volatile (
...@@ -753,7 +753,7 @@ const LinuxThreadImpl = struct {...@@ -753,7 +753,7 @@ const LinuxThreadImpl = struct {
753 \\ syscall753 \\ syscall
754 :754 :
755 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),755 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
756 [len] "r" (self.mapped.len)756 [len] "r" (self.mapped.len),
757 : "memory"757 : "memory"
758 ),758 ),
759 .mips64, .mips64el => asm volatile (759 .mips64, .mips64el => asm volatile (
...@@ -766,7 +766,7 @@ const LinuxThreadImpl = struct {...@@ -766,7 +766,7 @@ const LinuxThreadImpl = struct {
766 \\ syscall766 \\ syscall
767 :767 :
768 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),768 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
769 [len] "r" (self.mapped.len)769 [len] "r" (self.mapped.len),
770 : "memory"770 : "memory"
771 ),771 ),
772 .powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile (772 .powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile (
...@@ -780,7 +780,7 @@ const LinuxThreadImpl = struct {...@@ -780,7 +780,7 @@ const LinuxThreadImpl = struct {
780 \\ blr780 \\ blr
781 :781 :
782 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),782 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
783 [len] "r" (self.mapped.len)783 [len] "r" (self.mapped.len),
784 : "memory"784 : "memory"
785 ),785 ),
786 .riscv64 => asm volatile (786 .riscv64 => asm volatile (
...@@ -793,7 +793,7 @@ const LinuxThreadImpl = struct {...@@ -793,7 +793,7 @@ const LinuxThreadImpl = struct {
793 \\ ecall793 \\ ecall
794 :794 :
795 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),795 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
796 [len] "r" (self.mapped.len)796 [len] "r" (self.mapped.len),
797 : "memory"797 : "memory"
798 ),798 ),
799 .sparcv9 => asm volatile (799 .sparcv9 => asm volatile (
...@@ -821,7 +821,7 @@ const LinuxThreadImpl = struct {...@@ -821,7 +821,7 @@ const LinuxThreadImpl = struct {
821 \\ t 0x6d821 \\ t 0x6d
822 :822 :
823 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),823 : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
824 [len] "r" (self.mapped.len)824 [len] "r" (self.mapped.len),
825 : "memory"825 : "memory"
826 ),826 ),
827 else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)),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,69 +176,69 @@ pub fn Atomic(comptime T: type) type {
176 2 => switch (op) {176 2 => switch (op) {
177 .Set => asm volatile ("lock btsw %[bit], %[ptr]"177 .Set => asm volatile ("lock btsw %[bit], %[ptr]"
178 // LLVM doesn't support u1 flag register return values178 // LLVM doesn't support u1 flag register return values
179 : [result] "={@ccc}" (-> u8)179 : [result] "={@ccc}" (-> u8),
180 : [ptr] "*p" (&self.value),180 : [ptr] "*p" (&self.value),
181 [bit] "X" (@as(T, bit))181 [bit] "X" (@as(T, bit)),
182 : "cc", "memory"182 : "cc", "memory"
183 ),183 ),
184 .Reset => asm volatile ("lock btrw %[bit], %[ptr]"184 .Reset => asm volatile ("lock btrw %[bit], %[ptr]"
185 // LLVM doesn't support u1 flag register return values185 // LLVM doesn't support u1 flag register return values
186 : [result] "={@ccc}" (-> u8)186 : [result] "={@ccc}" (-> u8),
187 : [ptr] "*p" (&self.value),187 : [ptr] "*p" (&self.value),
188 [bit] "X" (@as(T, bit))188 [bit] "X" (@as(T, bit)),
189 : "cc", "memory"189 : "cc", "memory"
190 ),190 ),
191 .Toggle => asm volatile ("lock btcw %[bit], %[ptr]"191 .Toggle => asm volatile ("lock btcw %[bit], %[ptr]"
192 // LLVM doesn't support u1 flag register return values192 // LLVM doesn't support u1 flag register return values
193 : [result] "={@ccc}" (-> u8)193 : [result] "={@ccc}" (-> u8),
194 : [ptr] "*p" (&self.value),194 : [ptr] "*p" (&self.value),
195 [bit] "X" (@as(T, bit))195 [bit] "X" (@as(T, bit)),
196 : "cc", "memory"196 : "cc", "memory"
197 ),197 ),
198 },198 },
199 4 => switch (op) {199 4 => switch (op) {
200 .Set => asm volatile ("lock btsl %[bit], %[ptr]"200 .Set => asm volatile ("lock btsl %[bit], %[ptr]"
201 // LLVM doesn't support u1 flag register return values201 // LLVM doesn't support u1 flag register return values
202 : [result] "={@ccc}" (-> u8)202 : [result] "={@ccc}" (-> u8),
203 : [ptr] "*p" (&self.value),203 : [ptr] "*p" (&self.value),
204 [bit] "X" (@as(T, bit))204 [bit] "X" (@as(T, bit)),
205 : "cc", "memory"205 : "cc", "memory"
206 ),206 ),
207 .Reset => asm volatile ("lock btrl %[bit], %[ptr]"207 .Reset => asm volatile ("lock btrl %[bit], %[ptr]"
208 // LLVM doesn't support u1 flag register return values208 // LLVM doesn't support u1 flag register return values
209 : [result] "={@ccc}" (-> u8)209 : [result] "={@ccc}" (-> u8),
210 : [ptr] "*p" (&self.value),210 : [ptr] "*p" (&self.value),
211 [bit] "X" (@as(T, bit))211 [bit] "X" (@as(T, bit)),
212 : "cc", "memory"212 : "cc", "memory"
213 ),213 ),
214 .Toggle => asm volatile ("lock btcl %[bit], %[ptr]"214 .Toggle => asm volatile ("lock btcl %[bit], %[ptr]"
215 // LLVM doesn't support u1 flag register return values215 // LLVM doesn't support u1 flag register return values
216 : [result] "={@ccc}" (-> u8)216 : [result] "={@ccc}" (-> u8),
217 : [ptr] "*p" (&self.value),217 : [ptr] "*p" (&self.value),
218 [bit] "X" (@as(T, bit))218 [bit] "X" (@as(T, bit)),
219 : "cc", "memory"219 : "cc", "memory"
220 ),220 ),
221 },221 },
222 8 => switch (op) {222 8 => switch (op) {
223 .Set => asm volatile ("lock btsq %[bit], %[ptr]"223 .Set => asm volatile ("lock btsq %[bit], %[ptr]"
224 // LLVM doesn't support u1 flag register return values224 // LLVM doesn't support u1 flag register return values
225 : [result] "={@ccc}" (-> u8)225 : [result] "={@ccc}" (-> u8),
226 : [ptr] "*p" (&self.value),226 : [ptr] "*p" (&self.value),
227 [bit] "X" (@as(T, bit))227 [bit] "X" (@as(T, bit)),
228 : "cc", "memory"228 : "cc", "memory"
229 ),229 ),
230 .Reset => asm volatile ("lock btrq %[bit], %[ptr]"230 .Reset => asm volatile ("lock btrq %[bit], %[ptr]"
231 // LLVM doesn't support u1 flag register return values231 // LLVM doesn't support u1 flag register return values
232 : [result] "={@ccc}" (-> u8)232 : [result] "={@ccc}" (-> u8),
233 : [ptr] "*p" (&self.value),233 : [ptr] "*p" (&self.value),
234 [bit] "X" (@as(T, bit))234 [bit] "X" (@as(T, bit)),
235 : "cc", "memory"235 : "cc", "memory"
236 ),236 ),
237 .Toggle => asm volatile ("lock btcq %[bit], %[ptr]"237 .Toggle => asm volatile ("lock btcq %[bit], %[ptr]"
238 // LLVM doesn't support u1 flag register return values238 // LLVM doesn't support u1 flag register return values
239 : [result] "={@ccc}" (-> u8)239 : [result] "={@ccc}" (-> u8),
240 : [ptr] "*p" (&self.value),240 : [ptr] "*p" (&self.value),
241 [bit] "X" (@as(T, bit))241 [bit] "X" (@as(T, bit)),
242 : "cc", "memory"242 : "cc", "memory"
243 ),243 ),
244 },244 },
lib/std/crypto/aes/aesni.zig+12-12
...@@ -34,9 +34,9 @@ pub const Block = struct {...@@ -34,9 +34,9 @@ pub const Block = struct {
34 return Block{34 return Block{
35 .repr = asm (35 .repr = asm (
36 \\ vaesenc %[rk], %[in], %[out]36 \\ vaesenc %[rk], %[in], %[out]
37 : [out] "=x" (-> BlockVec)37 : [out] "=x" (-> BlockVec),
38 : [in] "x" (block.repr),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,9 +46,9 @@ pub const Block = struct {
46 return Block{46 return Block{
47 .repr = asm (47 .repr = asm (
48 \\ vaesenclast %[rk], %[in], %[out]48 \\ vaesenclast %[rk], %[in], %[out]
49 : [out] "=x" (-> BlockVec)49 : [out] "=x" (-> BlockVec),
50 : [in] "x" (block.repr),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,9 +58,9 @@ pub const Block = struct {
58 return Block{58 return Block{
59 .repr = asm (59 .repr = asm (
60 \\ vaesdec %[rk], %[in], %[out]60 \\ vaesdec %[rk], %[in], %[out]
61 : [out] "=x" (-> BlockVec)61 : [out] "=x" (-> BlockVec),
62 : [in] "x" (block.repr),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,9 +70,9 @@ pub const Block = struct {
70 return Block{70 return Block{
71 .repr = asm (71 .repr = asm (
72 \\ vaesdeclast %[rk], %[in], %[out]72 \\ vaesdeclast %[rk], %[in], %[out]
73 : [out] "=x" (-> BlockVec)73 : [out] "=x" (-> BlockVec),
74 : [in] "x" (block.repr),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,11 +190,11 @@ fn KeySchedule(comptime Aes: type) type {
190 \\ vpxor %[ts], %[r], %[r]190 \\ vpxor %[ts], %[r], %[r]
191 : [r] "=&x" (-> BlockVec),191 : [r] "=&x" (-> BlockVec),
192 [s] "=&x" (s),192 [s] "=&x" (s),
193 [ts] "=&x" (ts)193 [ts] "=&x" (ts),
194 : [rc] "n" (rc),194 : [rc] "n" (rc),
195 [t] "x" (t),195 [t] "x" (t),
196 [tx] "x" (tx),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 }
200200
...@@ -235,8 +235,8 @@ fn KeySchedule(comptime Aes: type) type {...@@ -235,8 +235,8 @@ fn KeySchedule(comptime Aes: type) type {
235 inv_round_keys[i] = Block{235 inv_round_keys[i] = Block{
236 .repr = asm (236 .repr = asm (
237 \\ vaesimc %[rk], %[inv_rk]237 \\ vaesimc %[rk], %[inv_rk]
238 : [inv_rk] "=x" (-> BlockVec)238 : [inv_rk] "=x" (-> BlockVec),
239 : [rk] "x" (round_keys[rounds - i].repr)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,10 +39,10 @@ pub const Block = struct {
39 \\ aese %[out].16b, %[zero].16b39 \\ aese %[out].16b, %[zero].16b
40 \\ aesmc %[out].16b, %[out].16b40 \\ aesmc %[out].16b, %[out].16b
41 \\ eor %[out].16b, %[out].16b, %[rk].16b41 \\ eor %[out].16b, %[out].16b, %[rk].16b
42 : [out] "=&x" (-> BlockVec)42 : [out] "=&x" (-> BlockVec),
43 : [in] "x" (block.repr),43 : [in] "x" (block.repr),
44 [rk] "x" (round_key.repr),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,10 +54,10 @@ pub const Block = struct {
54 \\ mov %[out].16b, %[in].16b54 \\ mov %[out].16b, %[in].16b
55 \\ aese %[out].16b, %[zero].16b55 \\ aese %[out].16b, %[zero].16b
56 \\ eor %[out].16b, %[out].16b, %[rk].16b56 \\ eor %[out].16b, %[out].16b, %[rk].16b
57 : [out] "=&x" (-> BlockVec)57 : [out] "=&x" (-> BlockVec),
58 : [in] "x" (block.repr),58 : [in] "x" (block.repr),
59 [rk] "x" (round_key.repr),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,10 +70,10 @@ pub const Block = struct {
70 \\ aesd %[out].16b, %[zero].16b70 \\ aesd %[out].16b, %[zero].16b
71 \\ aesimc %[out].16b, %[out].16b71 \\ aesimc %[out].16b, %[out].16b
72 \\ eor %[out].16b, %[out].16b, %[rk].16b72 \\ eor %[out].16b, %[out].16b, %[rk].16b
73 : [out] "=&x" (-> BlockVec)73 : [out] "=&x" (-> BlockVec),
74 : [in] "x" (block.repr),74 : [in] "x" (block.repr),
75 [rk] "x" (inv_round_key.repr),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,10 +85,10 @@ pub const Block = struct {
85 \\ mov %[out].16b, %[in].16b85 \\ mov %[out].16b, %[in].16b
86 \\ aesd %[out].16b, %[zero].16b86 \\ aesd %[out].16b, %[zero].16b
87 \\ eor %[out].16b, %[out].16b, %[rk].16b87 \\ eor %[out].16b, %[out].16b, %[rk].16b
88 : [out] "=&x" (-> BlockVec)88 : [out] "=&x" (-> BlockVec),
89 : [in] "x" (block.repr),89 : [in] "x" (block.repr),
90 [rk] "x" (inv_round_key.repr),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,11 +210,11 @@ fn KeySchedule(comptime Aes: type) type {
210 [v1] "=&x" (v1),210 [v1] "=&x" (v1),
211 [v2] "=&x" (v2),211 [v2] "=&x" (v2),
212 [v3] "=&x" (v3),212 [v3] "=&x" (v3),
213 [v4] "=&x" (v4)213 [v4] "=&x" (v4),
214 : [rc] "N" (rc),214 : [rc] "N" (rc),
215 [t] "x" (t),215 [t] "x" (t),
216 [zero] "x" (zero),216 [zero] "x" (zero),
217 [mask] "x" (mask1)217 [mask] "x" (mask1),
218 );218 );
219 }219 }
220220
...@@ -240,12 +240,12 @@ fn KeySchedule(comptime Aes: type) type {...@@ -240,12 +240,12 @@ fn KeySchedule(comptime Aes: type) type {
240 [v1] "=&x" (v1),240 [v1] "=&x" (v1),
241 [v2] "=&x" (v2),241 [v2] "=&x" (v2),
242 [v3] "=&x" (v3),242 [v3] "=&x" (v3),
243 [v4] "=&x" (v4)243 [v4] "=&x" (v4),
244 : [rc] "N" (if (second) @as(u8, 0) else rc),244 : [rc] "N" (if (second) @as(u8, 0) else rc),
245 [t] "x" (t),245 [t] "x" (t),
246 [tx] "x" (tx),246 [tx] "x" (tx),
247 [zero] "x" (zero),247 [zero] "x" (zero),
248 [mask] "x" (if (second) mask2 else mask1)248 [mask] "x" (if (second) mask2 else mask1),
249 );249 );
250 }250 }
251251
...@@ -286,8 +286,8 @@ fn KeySchedule(comptime Aes: type) type {...@@ -286,8 +286,8 @@ fn KeySchedule(comptime Aes: type) type {
286 inv_round_keys[i] = Block{286 inv_round_keys[i] = Block{
287 .repr = asm (287 .repr = asm (
288 \\ aesimc %[inv_rk].16b, %[rk].16b288 \\ aesimc %[inv_rk].16b, %[rk].16b
289 : [inv_rk] "=x" (-> BlockVec)289 : [inv_rk] "=x" (-> BlockVec),
290 : [rk] "x" (round_keys[rounds - i].repr)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,9 +94,9 @@ pub const Ghash = struct {
94 const Vector = std.meta.Vector;94 const Vector = std.meta.Vector;
95 const product = asm (95 const product = asm (
96 \\ vpclmulqdq $0x00, %[x], %[y], %[out]96 \\ vpclmulqdq $0x00, %[x], %[y], %[out]
97 : [out] "=x" (-> Vector(2, u64))97 : [out] "=x" (-> Vector(2, u64)),
98 : [x] "x" (@bitCast(Vector(2, u64), @as(u128, x))),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 return product[0];101 return product[0];
102 }102 }
...@@ -105,9 +105,9 @@ pub const Ghash = struct {...@@ -105,9 +105,9 @@ pub const Ghash = struct {
105 const Vector = std.meta.Vector;105 const Vector = std.meta.Vector;
106 const product = asm (106 const product = asm (
107 \\ pmull %[out].1q, %[x].1d, %[y].1d107 \\ pmull %[out].1q, %[x].1d, %[y].1d
108 : [out] "=w" (-> Vector(2, u64))108 : [out] "=w" (-> Vector(2, u64)),
109 : [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))),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 return product[0];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,7 +1634,7 @@ fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, comptime msg: u
16341634
1635pub fn dumpStackPointerAddr(prefix: []const u8) void {1635pub fn dumpStackPointerAddr(prefix: []const u8) void {
1636 const sp = asm (""1636 const sp = asm (""
1637 : [argc] "={rsp}" (-> usize)1637 : [argc] "={rsp}" (-> usize),
1638 );1638 );
1639 std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp });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,7 +2860,7 @@ pub fn alignForwardGeneric(comptime T: type, addr: T, alignment: T) T {
2860pub fn doNotOptimizeAway(val: anytype) void {2860pub fn doNotOptimizeAway(val: anytype) void {
2861 asm volatile (""2861 asm volatile (""
2862 :2862 :
2863 : [val] "rm" (val)2863 : [val] "rm" (val),
2864 : "memory"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,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
22
3pub fn syscall0(number: SYS) usize {3pub fn syscall0(number: SYS) usize {
4 return asm volatile ("svc #0"4 return asm volatile ("svc #0"
5 : [ret] "={r0}" (-> usize)5 : [ret] "={r0}" (-> usize),
6 : [number] "{r7}" (@enumToInt(number))6 : [number] "{r7}" (@enumToInt(number)),
7 : "memory"7 : "memory"
8 );8 );
9}9}
1010
11pub fn syscall1(number: SYS, arg1: usize) usize {11pub fn syscall1(number: SYS, arg1: usize) usize {
12 return asm volatile ("svc #0"12 return asm volatile ("svc #0"
13 : [ret] "={r0}" (-> usize)13 : [ret] "={r0}" (-> usize),
14 : [number] "{r7}" (@enumToInt(number)),14 : [number] "{r7}" (@enumToInt(number)),
15 [arg1] "{r0}" (arg1)15 [arg1] "{r0}" (arg1),
16 : "memory"16 : "memory"
17 );17 );
18}18}
1919
20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21 return asm volatile ("svc #0"21 return asm volatile ("svc #0"
22 : [ret] "={r0}" (-> usize)22 : [ret] "={r0}" (-> usize),
23 : [number] "{r7}" (@enumToInt(number)),23 : [number] "{r7}" (@enumToInt(number)),
24 [arg1] "{r0}" (arg1),24 [arg1] "{r0}" (arg1),
25 [arg2] "{r1}" (arg2)25 [arg2] "{r1}" (arg2),
26 : "memory"26 : "memory"
27 );27 );
28}28}
2929
30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31 return asm volatile ("svc #0"31 return asm volatile ("svc #0"
32 : [ret] "={r0}" (-> usize)32 : [ret] "={r0}" (-> usize),
33 : [number] "{r7}" (@enumToInt(number)),33 : [number] "{r7}" (@enumToInt(number)),
34 [arg1] "{r0}" (arg1),34 [arg1] "{r0}" (arg1),
35 [arg2] "{r1}" (arg2),35 [arg2] "{r1}" (arg2),
36 [arg3] "{r2}" (arg3)36 [arg3] "{r2}" (arg3),
37 : "memory"37 : "memory"
38 );38 );
39}39}
4040
41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42 return asm volatile ("svc #0"42 return asm volatile ("svc #0"
43 : [ret] "={r0}" (-> usize)43 : [ret] "={r0}" (-> usize),
44 : [number] "{r7}" (@enumToInt(number)),44 : [number] "{r7}" (@enumToInt(number)),
45 [arg1] "{r0}" (arg1),45 [arg1] "{r0}" (arg1),
46 [arg2] "{r1}" (arg2),46 [arg2] "{r1}" (arg2),
47 [arg3] "{r2}" (arg3),47 [arg3] "{r2}" (arg3),
48 [arg4] "{r3}" (arg4)48 [arg4] "{r3}" (arg4),
49 : "memory"49 : "memory"
50 );50 );
51}51}
5252
53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54 return asm volatile ("svc #0"54 return asm volatile ("svc #0"
55 : [ret] "={r0}" (-> usize)55 : [ret] "={r0}" (-> usize),
56 : [number] "{r7}" (@enumToInt(number)),56 : [number] "{r7}" (@enumToInt(number)),
57 [arg1] "{r0}" (arg1),57 [arg1] "{r0}" (arg1),
58 [arg2] "{r1}" (arg2),58 [arg2] "{r1}" (arg2),
59 [arg3] "{r2}" (arg3),59 [arg3] "{r2}" (arg3),
60 [arg4] "{r3}" (arg4),60 [arg4] "{r3}" (arg4),
61 [arg5] "{r4}" (arg5)61 [arg5] "{r4}" (arg5),
62 : "memory"62 : "memory"
63 );63 );
64}64}
...@@ -73,14 +73,14 @@ pub fn syscall6(...@@ -73,14 +73,14 @@ pub fn syscall6(
73 arg6: usize,73 arg6: usize,
74) usize {74) usize {
75 return asm volatile ("svc #0"75 return asm volatile ("svc #0"
76 : [ret] "={r0}" (-> usize)76 : [ret] "={r0}" (-> usize),
77 : [number] "{r7}" (@enumToInt(number)),77 : [number] "{r7}" (@enumToInt(number)),
78 [arg1] "{r0}" (arg1),78 [arg1] "{r0}" (arg1),
79 [arg2] "{r1}" (arg2),79 [arg2] "{r1}" (arg2),
80 [arg3] "{r2}" (arg3),80 [arg3] "{r2}" (arg3),
81 [arg4] "{r3}" (arg4),81 [arg4] "{r3}" (arg4),
82 [arg5] "{r4}" (arg5),82 [arg5] "{r4}" (arg5),
83 [arg6] "{r5}" (arg6)83 [arg6] "{r5}" (arg6),
84 : "memory"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,7 +91,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
91pub fn restore() callconv(.Naked) void {91pub fn restore() callconv(.Naked) void {
92 return asm volatile ("svc #0"92 return asm volatile ("svc #0"
93 :93 :
94 : [number] "{r7}" (@enumToInt(SYS.sigreturn))94 : [number] "{r7}" (@enumToInt(SYS.sigreturn)),
95 : "memory"95 : "memory"
96 );96 );
97}97}
...@@ -99,7 +99,7 @@ pub fn restore() callconv(.Naked) void {...@@ -99,7 +99,7 @@ pub fn restore() callconv(.Naked) void {
99pub fn restore_rt() callconv(.Naked) void {99pub fn restore_rt() callconv(.Naked) void {
100 return asm volatile ("svc #0"100 return asm volatile ("svc #0"
101 :101 :
102 : [number] "{r7}" (@enumToInt(SYS.rt_sigreturn))102 : [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)),
103 : "memory"103 : "memory"
104 );104 );
105}105}
lib/std/os/linux/arm64.zig+15-15
...@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");...@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
22
3pub fn syscall0(number: SYS) usize {3pub fn syscall0(number: SYS) usize {
4 return asm volatile ("svc #0"4 return asm volatile ("svc #0"
5 : [ret] "={x0}" (-> usize)5 : [ret] "={x0}" (-> usize),
6 : [number] "{x8}" (@enumToInt(number))6 : [number] "{x8}" (@enumToInt(number)),
7 : "memory", "cc"7 : "memory", "cc"
8 );8 );
9}9}
1010
11pub fn syscall1(number: SYS, arg1: usize) usize {11pub fn syscall1(number: SYS, arg1: usize) usize {
12 return asm volatile ("svc #0"12 return asm volatile ("svc #0"
13 : [ret] "={x0}" (-> usize)13 : [ret] "={x0}" (-> usize),
14 : [number] "{x8}" (@enumToInt(number)),14 : [number] "{x8}" (@enumToInt(number)),
15 [arg1] "{x0}" (arg1)15 [arg1] "{x0}" (arg1),
16 : "memory", "cc"16 : "memory", "cc"
17 );17 );
18}18}
1919
20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21 return asm volatile ("svc #0"21 return asm volatile ("svc #0"
22 : [ret] "={x0}" (-> usize)22 : [ret] "={x0}" (-> usize),
23 : [number] "{x8}" (@enumToInt(number)),23 : [number] "{x8}" (@enumToInt(number)),
24 [arg1] "{x0}" (arg1),24 [arg1] "{x0}" (arg1),
25 [arg2] "{x1}" (arg2)25 [arg2] "{x1}" (arg2),
26 : "memory", "cc"26 : "memory", "cc"
27 );27 );
28}28}
2929
30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31 return asm volatile ("svc #0"31 return asm volatile ("svc #0"
32 : [ret] "={x0}" (-> usize)32 : [ret] "={x0}" (-> usize),
33 : [number] "{x8}" (@enumToInt(number)),33 : [number] "{x8}" (@enumToInt(number)),
34 [arg1] "{x0}" (arg1),34 [arg1] "{x0}" (arg1),
35 [arg2] "{x1}" (arg2),35 [arg2] "{x1}" (arg2),
36 [arg3] "{x2}" (arg3)36 [arg3] "{x2}" (arg3),
37 : "memory", "cc"37 : "memory", "cc"
38 );38 );
39}39}
4040
41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42 return asm volatile ("svc #0"42 return asm volatile ("svc #0"
43 : [ret] "={x0}" (-> usize)43 : [ret] "={x0}" (-> usize),
44 : [number] "{x8}" (@enumToInt(number)),44 : [number] "{x8}" (@enumToInt(number)),
45 [arg1] "{x0}" (arg1),45 [arg1] "{x0}" (arg1),
46 [arg2] "{x1}" (arg2),46 [arg2] "{x1}" (arg2),
47 [arg3] "{x2}" (arg3),47 [arg3] "{x2}" (arg3),
48 [arg4] "{x3}" (arg4)48 [arg4] "{x3}" (arg4),
49 : "memory", "cc"49 : "memory", "cc"
50 );50 );
51}51}
5252
53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54 return asm volatile ("svc #0"54 return asm volatile ("svc #0"
55 : [ret] "={x0}" (-> usize)55 : [ret] "={x0}" (-> usize),
56 : [number] "{x8}" (@enumToInt(number)),56 : [number] "{x8}" (@enumToInt(number)),
57 [arg1] "{x0}" (arg1),57 [arg1] "{x0}" (arg1),
58 [arg2] "{x1}" (arg2),58 [arg2] "{x1}" (arg2),
59 [arg3] "{x2}" (arg3),59 [arg3] "{x2}" (arg3),
60 [arg4] "{x3}" (arg4),60 [arg4] "{x3}" (arg4),
61 [arg5] "{x4}" (arg5)61 [arg5] "{x4}" (arg5),
62 : "memory", "cc"62 : "memory", "cc"
63 );63 );
64}64}
...@@ -73,14 +73,14 @@ pub fn syscall6(...@@ -73,14 +73,14 @@ pub fn syscall6(
73 arg6: usize,73 arg6: usize,
74) usize {74) usize {
75 return asm volatile ("svc #0"75 return asm volatile ("svc #0"
76 : [ret] "={x0}" (-> usize)76 : [ret] "={x0}" (-> usize),
77 : [number] "{x8}" (@enumToInt(number)),77 : [number] "{x8}" (@enumToInt(number)),
78 [arg1] "{x0}" (arg1),78 [arg1] "{x0}" (arg1),
79 [arg2] "{x1}" (arg2),79 [arg2] "{x1}" (arg2),
80 [arg3] "{x2}" (arg3),80 [arg3] "{x2}" (arg3),
81 [arg4] "{x3}" (arg4),81 [arg4] "{x3}" (arg4),
82 [arg5] "{x4}" (arg5),82 [arg5] "{x4}" (arg5),
83 [arg6] "{x5}" (arg6)83 [arg6] "{x5}" (arg6),
84 : "memory", "cc"84 : "memory", "cc"
85 );85 );
86}86}
...@@ -93,7 +93,7 @@ pub const restore = restore_rt;...@@ -93,7 +93,7 @@ pub const restore = restore_rt;
93pub fn restore_rt() callconv(.Naked) void {93pub fn restore_rt() callconv(.Naked) void {
94 return asm volatile ("svc #0"94 return asm volatile ("svc #0"
95 :95 :
96 : [number] "{x8}" (@enumToInt(SYS.rt_sigreturn))96 : [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)),
97 : "memory", "cc"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,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
22
3pub fn syscall0(number: SYS) usize {3pub fn syscall0(number: SYS) usize {
4 return asm volatile ("int $0x80"4 return asm volatile ("int $0x80"
5 : [ret] "={eax}" (-> usize)5 : [ret] "={eax}" (-> usize),
6 : [number] "{eax}" (@enumToInt(number))6 : [number] "{eax}" (@enumToInt(number)),
7 : "memory"7 : "memory"
8 );8 );
9}9}
1010
11pub fn syscall1(number: SYS, arg1: usize) usize {11pub fn syscall1(number: SYS, arg1: usize) usize {
12 return asm volatile ("int $0x80"12 return asm volatile ("int $0x80"
13 : [ret] "={eax}" (-> usize)13 : [ret] "={eax}" (-> usize),
14 : [number] "{eax}" (@enumToInt(number)),14 : [number] "{eax}" (@enumToInt(number)),
15 [arg1] "{ebx}" (arg1)15 [arg1] "{ebx}" (arg1),
16 : "memory"16 : "memory"
17 );17 );
18}18}
1919
20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21 return asm volatile ("int $0x80"21 return asm volatile ("int $0x80"
22 : [ret] "={eax}" (-> usize)22 : [ret] "={eax}" (-> usize),
23 : [number] "{eax}" (@enumToInt(number)),23 : [number] "{eax}" (@enumToInt(number)),
24 [arg1] "{ebx}" (arg1),24 [arg1] "{ebx}" (arg1),
25 [arg2] "{ecx}" (arg2)25 [arg2] "{ecx}" (arg2),
26 : "memory"26 : "memory"
27 );27 );
28}28}
2929
30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31 return asm volatile ("int $0x80"31 return asm volatile ("int $0x80"
32 : [ret] "={eax}" (-> usize)32 : [ret] "={eax}" (-> usize),
33 : [number] "{eax}" (@enumToInt(number)),33 : [number] "{eax}" (@enumToInt(number)),
34 [arg1] "{ebx}" (arg1),34 [arg1] "{ebx}" (arg1),
35 [arg2] "{ecx}" (arg2),35 [arg2] "{ecx}" (arg2),
36 [arg3] "{edx}" (arg3)36 [arg3] "{edx}" (arg3),
37 : "memory"37 : "memory"
38 );38 );
39}39}
4040
41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42 return asm volatile ("int $0x80"42 return asm volatile ("int $0x80"
43 : [ret] "={eax}" (-> usize)43 : [ret] "={eax}" (-> usize),
44 : [number] "{eax}" (@enumToInt(number)),44 : [number] "{eax}" (@enumToInt(number)),
45 [arg1] "{ebx}" (arg1),45 [arg1] "{ebx}" (arg1),
46 [arg2] "{ecx}" (arg2),46 [arg2] "{ecx}" (arg2),
47 [arg3] "{edx}" (arg3),47 [arg3] "{edx}" (arg3),
48 [arg4] "{esi}" (arg4)48 [arg4] "{esi}" (arg4),
49 : "memory"49 : "memory"
50 );50 );
51}51}
5252
53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54 return asm volatile ("int $0x80"54 return asm volatile ("int $0x80"
55 : [ret] "={eax}" (-> usize)55 : [ret] "={eax}" (-> usize),
56 : [number] "{eax}" (@enumToInt(number)),56 : [number] "{eax}" (@enumToInt(number)),
57 [arg1] "{ebx}" (arg1),57 [arg1] "{ebx}" (arg1),
58 [arg2] "{ecx}" (arg2),58 [arg2] "{ecx}" (arg2),
59 [arg3] "{edx}" (arg3),59 [arg3] "{edx}" (arg3),
60 [arg4] "{esi}" (arg4),60 [arg4] "{esi}" (arg4),
61 [arg5] "{edi}" (arg5)61 [arg5] "{edi}" (arg5),
62 : "memory"62 : "memory"
63 );63 );
64}64}
...@@ -83,24 +83,24 @@ pub fn syscall6(...@@ -83,24 +83,24 @@ pub fn syscall6(
83 \\ int $0x8083 \\ int $0x80
84 \\ pop %%ebp84 \\ pop %%ebp
85 \\ add $4, %%esp85 \\ add $4, %%esp
86 : [ret] "={eax}" (-> usize)86 : [ret] "={eax}" (-> usize),
87 : [number] "{eax}" (@enumToInt(number)),87 : [number] "{eax}" (@enumToInt(number)),
88 [arg1] "{ebx}" (arg1),88 [arg1] "{ebx}" (arg1),
89 [arg2] "{ecx}" (arg2),89 [arg2] "{ecx}" (arg2),
90 [arg3] "{edx}" (arg3),90 [arg3] "{edx}" (arg3),
91 [arg4] "{esi}" (arg4),91 [arg4] "{esi}" (arg4),
92 [arg5] "{edi}" (arg5),92 [arg5] "{edi}" (arg5),
93 [arg6] "rm" (arg6)93 [arg6] "rm" (arg6),
94 : "memory"94 : "memory"
95 );95 );
96}96}
9797
98pub fn socketcall(call: usize, args: [*]usize) usize {98pub fn socketcall(call: usize, args: [*]usize) usize {
99 return asm volatile ("int $0x80"99 return asm volatile ("int $0x80"
100 : [ret] "={eax}" (-> usize)100 : [ret] "={eax}" (-> usize),
101 : [number] "{eax}" (@enumToInt(SYS.socketcall)),101 : [number] "{eax}" (@enumToInt(SYS.socketcall)),
102 [arg1] "{ebx}" (call),102 [arg1] "{ebx}" (call),
103 [arg2] "{ecx}" (@ptrToInt(args))103 [arg2] "{ecx}" (@ptrToInt(args)),
104 : "memory"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,7 +111,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
111pub fn restore() callconv(.Naked) void {111pub fn restore() callconv(.Naked) void {
112 return asm volatile ("int $0x80"112 return asm volatile ("int $0x80"
113 :113 :
114 : [number] "{eax}" (@enumToInt(SYS.sigreturn))114 : [number] "{eax}" (@enumToInt(SYS.sigreturn)),
115 : "memory"115 : "memory"
116 );116 );
117}117}
...@@ -119,7 +119,7 @@ pub fn restore() callconv(.Naked) void {...@@ -119,7 +119,7 @@ pub fn restore() callconv(.Naked) void {
119pub fn restore_rt() callconv(.Naked) void {119pub fn restore_rt() callconv(.Naked) void {
120 return asm volatile ("int $0x80"120 return asm volatile ("int $0x80"
121 :121 :
122 : [number] "{eax}" (@enumToInt(SYS.rt_sigreturn))122 : [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)),
123 : "memory"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,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6 \\ blez $7, 1f6 \\ blez $7, 1f
7 \\ subu $2, $0, $27 \\ subu $2, $0, $2
8 \\ 1:8 \\ 1:
9 : [ret] "={$2}" (-> usize)9 : [ret] "={$2}" (-> usize),
10 : [number] "{$2}" (@enumToInt(number))10 : [number] "{$2}" (@enumToInt(number)),
11 : "memory", "cc", "$7"11 : "memory", "cc", "$7"
12 );12 );
13}13}
...@@ -25,9 +25,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {...@@ -25,9 +25,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
25 \\ sw $2, 0($4)25 \\ sw $2, 0($4)
26 \\ sw $3, 4($4)26 \\ sw $3, 4($4)
27 \\ 2:27 \\ 2:
28 : [ret] "={$2}" (-> usize)28 : [ret] "={$2}" (-> usize),
29 : [number] "{$2}" (@enumToInt(SYS.pipe)),29 : [number] "{$2}" (@enumToInt(SYS.pipe)),
30 [fd] "{$4}" (fd)30 [fd] "{$4}" (fd),
31 : "memory", "cc", "$7"31 : "memory", "cc", "$7"
32 );32 );
33}33}
...@@ -38,9 +38,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {...@@ -38,9 +38,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
38 \\ blez $7, 1f38 \\ blez $7, 1f
39 \\ subu $2, $0, $239 \\ subu $2, $0, $2
40 \\ 1:40 \\ 1:
41 : [ret] "={$2}" (-> usize)41 : [ret] "={$2}" (-> usize),
42 : [number] "{$2}" (@enumToInt(number)),42 : [number] "{$2}" (@enumToInt(number)),
43 [arg1] "{$4}" (arg1)43 [arg1] "{$4}" (arg1),
44 : "memory", "cc", "$7"44 : "memory", "cc", "$7"
45 );45 );
46}46}
...@@ -51,10 +51,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {...@@ -51,10 +51,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
51 \\ blez $7, 1f51 \\ blez $7, 1f
52 \\ subu $2, $0, $252 \\ subu $2, $0, $2
53 \\ 1:53 \\ 1:
54 : [ret] "={$2}" (-> usize)54 : [ret] "={$2}" (-> usize),
55 : [number] "{$2}" (@enumToInt(number)),55 : [number] "{$2}" (@enumToInt(number)),
56 [arg1] "{$4}" (arg1),56 [arg1] "{$4}" (arg1),
57 [arg2] "{$5}" (arg2)57 [arg2] "{$5}" (arg2),
58 : "memory", "cc", "$7"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,11 +65,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
65 \\ blez $7, 1f65 \\ blez $7, 1f
66 \\ subu $2, $0, $266 \\ subu $2, $0, $2
67 \\ 1:67 \\ 1:
68 : [ret] "={$2}" (-> usize)68 : [ret] "={$2}" (-> usize),
69 : [number] "{$2}" (@enumToInt(number)),69 : [number] "{$2}" (@enumToInt(number)),
70 [arg1] "{$4}" (arg1),70 [arg1] "{$4}" (arg1),
71 [arg2] "{$5}" (arg2),71 [arg2] "{$5}" (arg2),
72 [arg3] "{$6}" (arg3)72 [arg3] "{$6}" (arg3),
73 : "memory", "cc", "$7"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,12 +80,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
80 \\ blez $7, 1f80 \\ blez $7, 1f
81 \\ subu $2, $0, $281 \\ subu $2, $0, $2
82 \\ 1:82 \\ 1:
83 : [ret] "={$2}" (-> usize)83 : [ret] "={$2}" (-> usize),
84 : [number] "{$2}" (@enumToInt(number)),84 : [number] "{$2}" (@enumToInt(number)),
85 [arg1] "{$4}" (arg1),85 [arg1] "{$4}" (arg1),
86 [arg2] "{$5}" (arg2),86 [arg2] "{$5}" (arg2),
87 [arg3] "{$6}" (arg3),87 [arg3] "{$6}" (arg3),
88 [arg4] "{$7}" (arg4)88 [arg4] "{$7}" (arg4),
89 : "memory", "cc", "$7"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,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
100 \\ blez $7, 1f100 \\ blez $7, 1f
101 \\ subu $2, $0, $2101 \\ subu $2, $0, $2
102 \\ 1:102 \\ 1:
103 : [ret] "={$2}" (-> usize)103 : [ret] "={$2}" (-> usize),
104 : [number] "{$2}" (@enumToInt(number)),104 : [number] "{$2}" (@enumToInt(number)),
105 [arg1] "{$4}" (arg1),105 [arg1] "{$4}" (arg1),
106 [arg2] "{$5}" (arg2),106 [arg2] "{$5}" (arg2),
107 [arg3] "{$6}" (arg3),107 [arg3] "{$6}" (arg3),
108 [arg4] "{$7}" (arg4),108 [arg4] "{$7}" (arg4),
109 [arg5] "r" (arg5)109 [arg5] "r" (arg5),
110 : "memory", "cc", "$7"110 : "memory", "cc", "$7"
111 );111 );
112}112}
...@@ -133,14 +133,14 @@ pub fn syscall6(...@@ -133,14 +133,14 @@ pub fn syscall6(
133 \\ blez $7, 1f133 \\ blez $7, 1f
134 \\ subu $2, $0, $2134 \\ subu $2, $0, $2
135 \\ 1:135 \\ 1:
136 : [ret] "={$2}" (-> usize)136 : [ret] "={$2}" (-> usize),
137 : [number] "{$2}" (@enumToInt(number)),137 : [number] "{$2}" (@enumToInt(number)),
138 [arg1] "{$4}" (arg1),138 [arg1] "{$4}" (arg1),
139 [arg2] "{$5}" (arg2),139 [arg2] "{$5}" (arg2),
140 [arg3] "{$6}" (arg3),140 [arg3] "{$6}" (arg3),
141 [arg4] "{$7}" (arg4),141 [arg4] "{$7}" (arg4),
142 [arg5] "r" (arg5),142 [arg5] "r" (arg5),
143 [arg6] "r" (arg6)143 [arg6] "r" (arg6),
144 : "memory", "cc", "$7"144 : "memory", "cc", "$7"
145 );145 );
146}146}
...@@ -166,7 +166,7 @@ pub fn syscall7(...@@ -166,7 +166,7 @@ pub fn syscall7(
166 \\ blez $7, 1f166 \\ blez $7, 1f
167 \\ subu $2, $0, $2167 \\ subu $2, $0, $2
168 \\ 1:168 \\ 1:
169 : [ret] "={$2}" (-> usize)169 : [ret] "={$2}" (-> usize),
170 : [number] "{$2}" (@enumToInt(number)),170 : [number] "{$2}" (@enumToInt(number)),
171 [arg1] "{$4}" (arg1),171 [arg1] "{$4}" (arg1),
172 [arg2] "{$5}" (arg2),172 [arg2] "{$5}" (arg2),
...@@ -174,7 +174,7 @@ pub fn syscall7(...@@ -174,7 +174,7 @@ pub fn syscall7(
174 [arg4] "{$7}" (arg4),174 [arg4] "{$7}" (arg4),
175 [arg5] "r" (arg5),175 [arg5] "r" (arg5),
176 [arg6] "r" (arg6),176 [arg6] "r" (arg6),
177 [arg7] "r" (arg7)177 [arg7] "r" (arg7),
178 : "memory", "cc", "$7"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,7 +185,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags:
185pub fn restore() callconv(.Naked) void {185pub fn restore() callconv(.Naked) void {
186 return asm volatile ("syscall"186 return asm volatile ("syscall"
187 :187 :
188 : [number] "{$2}" (@enumToInt(SYS.sigreturn))188 : [number] "{$2}" (@enumToInt(SYS.sigreturn)),
189 : "memory", "cc", "$7"189 : "memory", "cc", "$7"
190 );190 );
191}191}
...@@ -193,7 +193,7 @@ pub fn restore() callconv(.Naked) void {...@@ -193,7 +193,7 @@ pub fn restore() callconv(.Naked) void {
193pub fn restore_rt() callconv(.Naked) void {193pub fn restore_rt() callconv(.Naked) void {
194 return asm volatile ("syscall"194 return asm volatile ("syscall"
195 :195 :
196 : [number] "{$2}" (@enumToInt(SYS.rt_sigreturn))196 : [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)),
197 : "memory", "cc", "$7"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,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6 \\ bns+ 1f6 \\ bns+ 1f
7 \\ neg 3, 37 \\ neg 3, 3
8 \\ 1:8 \\ 1:
9 : [ret] "={r3}" (-> usize)9 : [ret] "={r3}" (-> usize),
10 : [number] "{r0}" (@enumToInt(number))10 : [number] "{r0}" (@enumToInt(number)),
11 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
18 \\ bns+ 1f18 \\ bns+ 1f
19 \\ neg 3, 319 \\ neg 3, 3
20 \\ 1:20 \\ 1:
21 : [ret] "={r3}" (-> usize)21 : [ret] "={r3}" (-> usize),
22 : [number] "{r0}" (@enumToInt(number)),22 : [number] "{r0}" (@enumToInt(number)),
23 [arg1] "{r3}" (arg1)23 [arg1] "{r3}" (arg1),
24 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
31 \\ bns+ 1f31 \\ bns+ 1f
32 \\ neg 3, 332 \\ neg 3, 3
33 \\ 1:33 \\ 1:
34 : [ret] "={r3}" (-> usize)34 : [ret] "={r3}" (-> usize),
35 : [number] "{r0}" (@enumToInt(number)),35 : [number] "{r0}" (@enumToInt(number)),
36 [arg1] "{r3}" (arg1),36 [arg1] "{r3}" (arg1),
37 [arg2] "{r4}" (arg2)37 [arg2] "{r4}" (arg2),
38 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45 \\ bns+ 1f45 \\ bns+ 1f
46 \\ neg 3, 346 \\ neg 3, 3
47 \\ 1:47 \\ 1:
48 : [ret] "={r3}" (-> usize)48 : [ret] "={r3}" (-> usize),
49 : [number] "{r0}" (@enumToInt(number)),49 : [number] "{r0}" (@enumToInt(number)),
50 [arg1] "{r3}" (arg1),50 [arg1] "{r3}" (arg1),
51 [arg2] "{r4}" (arg2),51 [arg2] "{r4}" (arg2),
52 [arg3] "{r5}" (arg3)52 [arg3] "{r5}" (arg3),
53 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
60 \\ bns+ 1f60 \\ bns+ 1f
61 \\ neg 3, 361 \\ neg 3, 3
62 \\ 1:62 \\ 1:
63 : [ret] "={r3}" (-> usize)63 : [ret] "={r3}" (-> usize),
64 : [number] "{r0}" (@enumToInt(number)),64 : [number] "{r0}" (@enumToInt(number)),
65 [arg1] "{r3}" (arg1),65 [arg1] "{r3}" (arg1),
66 [arg2] "{r4}" (arg2),66 [arg2] "{r4}" (arg2),
67 [arg3] "{r5}" (arg3),67 [arg3] "{r5}" (arg3),
68 [arg4] "{r6}" (arg4)68 [arg4] "{r6}" (arg4),
69 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
76 \\ bns+ 1f76 \\ bns+ 1f
77 \\ neg 3, 377 \\ neg 3, 3
78 \\ 1:78 \\ 1:
79 : [ret] "={r3}" (-> usize)79 : [ret] "={r3}" (-> usize),
80 : [number] "{r0}" (@enumToInt(number)),80 : [number] "{r0}" (@enumToInt(number)),
81 [arg1] "{r3}" (arg1),81 [arg1] "{r3}" (arg1),
82 [arg2] "{r4}" (arg2),82 [arg2] "{r4}" (arg2),
83 [arg3] "{r5}" (arg3),83 [arg3] "{r5}" (arg3),
84 [arg4] "{r6}" (arg4),84 [arg4] "{r6}" (arg4),
85 [arg5] "{r7}" (arg5)85 [arg5] "{r7}" (arg5),
86 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"86 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
87 );87 );
88}88}
...@@ -101,14 +101,14 @@ pub fn syscall6(...@@ -101,14 +101,14 @@ pub fn syscall6(
101 \\ bns+ 1f101 \\ bns+ 1f
102 \\ neg 3, 3102 \\ neg 3, 3
103 \\ 1:103 \\ 1:
104 : [ret] "={r3}" (-> usize)104 : [ret] "={r3}" (-> usize),
105 : [number] "{r0}" (@enumToInt(number)),105 : [number] "{r0}" (@enumToInt(number)),
106 [arg1] "{r3}" (arg1),106 [arg1] "{r3}" (arg1),
107 [arg2] "{r4}" (arg2),107 [arg2] "{r4}" (arg2),
108 [arg3] "{r5}" (arg3),108 [arg3] "{r5}" (arg3),
109 [arg4] "{r6}" (arg4),109 [arg4] "{r6}" (arg4),
110 [arg5] "{r7}" (arg5),110 [arg5] "{r7}" (arg5),
111 [arg6] "{r8}" (arg6)111 [arg6] "{r8}" (arg6),
112 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,7 +121,7 @@ pub const restore = restore_rt;
121pub fn restore_rt() callconv(.Naked) void {121pub fn restore_rt() callconv(.Naked) void {
122 return asm volatile ("sc"122 return asm volatile ("sc"
123 :123 :
124 : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn))124 : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)),
125 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
6 \\ bns+ 1f6 \\ bns+ 1f
7 \\ neg 3, 37 \\ neg 3, 3
8 \\ 1:8 \\ 1:
9 : [ret] "={r3}" (-> usize)9 : [ret] "={r3}" (-> usize),
10 : [number] "{r0}" (@enumToInt(number))10 : [number] "{r0}" (@enumToInt(number)),
11 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
18 \\ bns+ 1f18 \\ bns+ 1f
19 \\ neg 3, 319 \\ neg 3, 3
20 \\ 1:20 \\ 1:
21 : [ret] "={r3}" (-> usize)21 : [ret] "={r3}" (-> usize),
22 : [number] "{r0}" (@enumToInt(number)),22 : [number] "{r0}" (@enumToInt(number)),
23 [arg1] "{r3}" (arg1)23 [arg1] "{r3}" (arg1),
24 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
31 \\ bns+ 1f31 \\ bns+ 1f
32 \\ neg 3, 332 \\ neg 3, 3
33 \\ 1:33 \\ 1:
34 : [ret] "={r3}" (-> usize)34 : [ret] "={r3}" (-> usize),
35 : [number] "{r0}" (@enumToInt(number)),35 : [number] "{r0}" (@enumToInt(number)),
36 [arg1] "{r3}" (arg1),36 [arg1] "{r3}" (arg1),
37 [arg2] "{r4}" (arg2)37 [arg2] "{r4}" (arg2),
38 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45 \\ bns+ 1f45 \\ bns+ 1f
46 \\ neg 3, 346 \\ neg 3, 3
47 \\ 1:47 \\ 1:
48 : [ret] "={r3}" (-> usize)48 : [ret] "={r3}" (-> usize),
49 : [number] "{r0}" (@enumToInt(number)),49 : [number] "{r0}" (@enumToInt(number)),
50 [arg1] "{r3}" (arg1),50 [arg1] "{r3}" (arg1),
51 [arg2] "{r4}" (arg2),51 [arg2] "{r4}" (arg2),
52 [arg3] "{r5}" (arg3)52 [arg3] "{r5}" (arg3),
53 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
60 \\ bns+ 1f60 \\ bns+ 1f
61 \\ neg 3, 361 \\ neg 3, 3
62 \\ 1:62 \\ 1:
63 : [ret] "={r3}" (-> usize)63 : [ret] "={r3}" (-> usize),
64 : [number] "{r0}" (@enumToInt(number)),64 : [number] "{r0}" (@enumToInt(number)),
65 [arg1] "{r3}" (arg1),65 [arg1] "{r3}" (arg1),
66 [arg2] "{r4}" (arg2),66 [arg2] "{r4}" (arg2),
67 [arg3] "{r5}" (arg3),67 [arg3] "{r5}" (arg3),
68 [arg4] "{r6}" (arg4)68 [arg4] "{r6}" (arg4),
69 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
76 \\ bns+ 1f76 \\ bns+ 1f
77 \\ neg 3, 377 \\ neg 3, 3
78 \\ 1:78 \\ 1:
79 : [ret] "={r3}" (-> usize)79 : [ret] "={r3}" (-> usize),
80 : [number] "{r0}" (@enumToInt(number)),80 : [number] "{r0}" (@enumToInt(number)),
81 [arg1] "{r3}" (arg1),81 [arg1] "{r3}" (arg1),
82 [arg2] "{r4}" (arg2),82 [arg2] "{r4}" (arg2),
83 [arg3] "{r5}" (arg3),83 [arg3] "{r5}" (arg3),
84 [arg4] "{r6}" (arg4),84 [arg4] "{r6}" (arg4),
85 [arg5] "{r7}" (arg5)85 [arg5] "{r7}" (arg5),
86 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"86 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
87 );87 );
88}88}
...@@ -101,14 +101,14 @@ pub fn syscall6(...@@ -101,14 +101,14 @@ pub fn syscall6(
101 \\ bns+ 1f101 \\ bns+ 1f
102 \\ neg 3, 3102 \\ neg 3, 3
103 \\ 1:103 \\ 1:
104 : [ret] "={r3}" (-> usize)104 : [ret] "={r3}" (-> usize),
105 : [number] "{r0}" (@enumToInt(number)),105 : [number] "{r0}" (@enumToInt(number)),
106 [arg1] "{r3}" (arg1),106 [arg1] "{r3}" (arg1),
107 [arg2] "{r4}" (arg2),107 [arg2] "{r4}" (arg2),
108 [arg3] "{r5}" (arg3),108 [arg3] "{r5}" (arg3),
109 [arg4] "{r6}" (arg4),109 [arg4] "{r6}" (arg4),
110 [arg5] "{r7}" (arg5),110 [arg5] "{r7}" (arg5),
111 [arg6] "{r8}" (arg6)111 [arg6] "{r8}" (arg6),
112 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,7 +121,7 @@ pub const restore = restore_rt;
121pub fn restore_rt() callconv(.Naked) void {121pub fn restore_rt() callconv(.Naked) void {
122 return asm volatile ("sc"122 return asm volatile ("sc"
123 :123 :
124 : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn))124 : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)),
125 : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"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,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
22
3pub fn syscall0(number: SYS) usize {3pub fn syscall0(number: SYS) usize {
4 return asm volatile ("ecall"4 return asm volatile ("ecall"
5 : [ret] "={x10}" (-> usize)5 : [ret] "={x10}" (-> usize),
6 : [number] "{x17}" (@enumToInt(number))6 : [number] "{x17}" (@enumToInt(number)),
7 : "memory"7 : "memory"
8 );8 );
9}9}
1010
11pub fn syscall1(number: SYS, arg1: usize) usize {11pub fn syscall1(number: SYS, arg1: usize) usize {
12 return asm volatile ("ecall"12 return asm volatile ("ecall"
13 : [ret] "={x10}" (-> usize)13 : [ret] "={x10}" (-> usize),
14 : [number] "{x17}" (@enumToInt(number)),14 : [number] "{x17}" (@enumToInt(number)),
15 [arg1] "{x10}" (arg1)15 [arg1] "{x10}" (arg1),
16 : "memory"16 : "memory"
17 );17 );
18}18}
1919
20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21 return asm volatile ("ecall"21 return asm volatile ("ecall"
22 : [ret] "={x10}" (-> usize)22 : [ret] "={x10}" (-> usize),
23 : [number] "{x17}" (@enumToInt(number)),23 : [number] "{x17}" (@enumToInt(number)),
24 [arg1] "{x10}" (arg1),24 [arg1] "{x10}" (arg1),
25 [arg2] "{x11}" (arg2)25 [arg2] "{x11}" (arg2),
26 : "memory"26 : "memory"
27 );27 );
28}28}
2929
30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31 return asm volatile ("ecall"31 return asm volatile ("ecall"
32 : [ret] "={x10}" (-> usize)32 : [ret] "={x10}" (-> usize),
33 : [number] "{x17}" (@enumToInt(number)),33 : [number] "{x17}" (@enumToInt(number)),
34 [arg1] "{x10}" (arg1),34 [arg1] "{x10}" (arg1),
35 [arg2] "{x11}" (arg2),35 [arg2] "{x11}" (arg2),
36 [arg3] "{x12}" (arg3)36 [arg3] "{x12}" (arg3),
37 : "memory"37 : "memory"
38 );38 );
39}39}
4040
41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42 return asm volatile ("ecall"42 return asm volatile ("ecall"
43 : [ret] "={x10}" (-> usize)43 : [ret] "={x10}" (-> usize),
44 : [number] "{x17}" (@enumToInt(number)),44 : [number] "{x17}" (@enumToInt(number)),
45 [arg1] "{x10}" (arg1),45 [arg1] "{x10}" (arg1),
46 [arg2] "{x11}" (arg2),46 [arg2] "{x11}" (arg2),
47 [arg3] "{x12}" (arg3),47 [arg3] "{x12}" (arg3),
48 [arg4] "{x13}" (arg4)48 [arg4] "{x13}" (arg4),
49 : "memory"49 : "memory"
50 );50 );
51}51}
5252
53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54 return asm volatile ("ecall"54 return asm volatile ("ecall"
55 : [ret] "={x10}" (-> usize)55 : [ret] "={x10}" (-> usize),
56 : [number] "{x17}" (@enumToInt(number)),56 : [number] "{x17}" (@enumToInt(number)),
57 [arg1] "{x10}" (arg1),57 [arg1] "{x10}" (arg1),
58 [arg2] "{x11}" (arg2),58 [arg2] "{x11}" (arg2),
59 [arg3] "{x12}" (arg3),59 [arg3] "{x12}" (arg3),
60 [arg4] "{x13}" (arg4),60 [arg4] "{x13}" (arg4),
61 [arg5] "{x14}" (arg5)61 [arg5] "{x14}" (arg5),
62 : "memory"62 : "memory"
63 );63 );
64}64}
...@@ -73,14 +73,14 @@ pub fn syscall6(...@@ -73,14 +73,14 @@ pub fn syscall6(
73 arg6: usize,73 arg6: usize,
74) usize {74) usize {
75 return asm volatile ("ecall"75 return asm volatile ("ecall"
76 : [ret] "={x10}" (-> usize)76 : [ret] "={x10}" (-> usize),
77 : [number] "{x17}" (@enumToInt(number)),77 : [number] "{x17}" (@enumToInt(number)),
78 [arg1] "{x10}" (arg1),78 [arg1] "{x10}" (arg1),
79 [arg2] "{x11}" (arg2),79 [arg2] "{x11}" (arg2),
80 [arg3] "{x12}" (arg3),80 [arg3] "{x12}" (arg3),
81 [arg4] "{x13}" (arg4),81 [arg4] "{x13}" (arg4),
82 [arg5] "{x14}" (arg5),82 [arg5] "{x14}" (arg5),
83 [arg6] "{x15}" (arg6)83 [arg6] "{x15}" (arg6),
84 : "memory"84 : "memory"
85 );85 );
86}86}
...@@ -92,7 +92,7 @@ pub const restore = restore_rt;...@@ -92,7 +92,7 @@ pub const restore = restore_rt;
92pub fn restore_rt() callconv(.Naked) void {92pub fn restore_rt() callconv(.Naked) void {
93 return asm volatile ("ecall"93 return asm volatile ("ecall"
94 :94 :
95 : [number] "{x17}" (@enumToInt(SYS.rt_sigreturn))95 : [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)),
96 : "memory"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,9 +14,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
14 \\ st %%o1, [%%g3+4]14 \\ st %%o1, [%%g3+4]
15 \\ clr %%o015 \\ clr %%o0
16 \\2:16 \\2:
17 : [ret] "={o0}" (-> usize)17 : [ret] "={o0}" (-> usize),
18 : [number] "{g1}" (@enumToInt(SYS.pipe)),18 : [number] "{g1}" (@enumToInt(SYS.pipe)),
19 [arg] "r" (fd)19 [arg] "r" (fd),
20 : "memory", "g3"20 : "memory", "g3"
21 );21 );
22}22}
...@@ -38,8 +38,8 @@ pub fn syscall_fork() usize {...@@ -38,8 +38,8 @@ pub fn syscall_fork() usize {
38 \\ dec %%o138 \\ dec %%o1
39 \\ and %%o1, %%o0, %%o039 \\ and %%o1, %%o0, %%o0
40 \\ 2:40 \\ 2:
41 : [ret] "={o0}" (-> usize)41 : [ret] "={o0}" (-> usize),
42 : [number] "{g1}" (@enumToInt(SYS.fork))42 : [number] "{g1}" (@enumToInt(SYS.fork)),
43 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"43 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
44 );44 );
45}45}
...@@ -51,8 +51,8 @@ pub fn syscall0(number: SYS) usize {...@@ -51,8 +51,8 @@ pub fn syscall0(number: SYS) usize {
51 \\ nop51 \\ nop
52 \\ neg %%o052 \\ neg %%o0
53 \\ 1:53 \\ 1:
54 : [ret] "={o0}" (-> usize)54 : [ret] "={o0}" (-> usize),
55 : [number] "{g1}" (@enumToInt(number))55 : [number] "{g1}" (@enumToInt(number)),
56 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"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,9 +64,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
64 \\ nop64 \\ nop
65 \\ neg %%o065 \\ neg %%o0
66 \\ 1:66 \\ 1:
67 : [ret] "={o0}" (-> usize)67 : [ret] "={o0}" (-> usize),
68 : [number] "{g1}" (@enumToInt(number)),68 : [number] "{g1}" (@enumToInt(number)),
69 [arg1] "{o0}" (arg1)69 [arg1] "{o0}" (arg1),
70 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"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,10 +78,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
78 \\ nop78 \\ nop
79 \\ neg %%o079 \\ neg %%o0
80 \\ 1:80 \\ 1:
81 : [ret] "={o0}" (-> usize)81 : [ret] "={o0}" (-> usize),
82 : [number] "{g1}" (@enumToInt(number)),82 : [number] "{g1}" (@enumToInt(number)),
83 [arg1] "{o0}" (arg1),83 [arg1] "{o0}" (arg1),
84 [arg2] "{o1}" (arg2)84 [arg2] "{o1}" (arg2),
85 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"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,11 +93,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
93 \\ nop93 \\ nop
94 \\ neg %%o094 \\ neg %%o0
95 \\ 1:95 \\ 1:
96 : [ret] "={o0}" (-> usize)96 : [ret] "={o0}" (-> usize),
97 : [number] "{g1}" (@enumToInt(number)),97 : [number] "{g1}" (@enumToInt(number)),
98 [arg1] "{o0}" (arg1),98 [arg1] "{o0}" (arg1),
99 [arg2] "{o1}" (arg2),99 [arg2] "{o1}" (arg2),
100 [arg3] "{o2}" (arg3)100 [arg3] "{o2}" (arg3),
101 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"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,12 +109,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109 \\ nop109 \\ nop
110 \\ neg %%o0110 \\ neg %%o0
111 \\ 1:111 \\ 1:
112 : [ret] "={o0}" (-> usize)112 : [ret] "={o0}" (-> usize),
113 : [number] "{g1}" (@enumToInt(number)),113 : [number] "{g1}" (@enumToInt(number)),
114 [arg1] "{o0}" (arg1),114 [arg1] "{o0}" (arg1),
115 [arg2] "{o1}" (arg2),115 [arg2] "{o1}" (arg2),
116 [arg3] "{o2}" (arg3),116 [arg3] "{o2}" (arg3),
117 [arg4] "{o3}" (arg4)117 [arg4] "{o3}" (arg4),
118 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"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,13 +126,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
126 \\ nop126 \\ nop
127 \\ neg %%o0127 \\ neg %%o0
128 \\ 1:128 \\ 1:
129 : [ret] "={o0}" (-> usize)129 : [ret] "={o0}" (-> usize),
130 : [number] "{g1}" (@enumToInt(number)),130 : [number] "{g1}" (@enumToInt(number)),
131 [arg1] "{o0}" (arg1),131 [arg1] "{o0}" (arg1),
132 [arg2] "{o1}" (arg2),132 [arg2] "{o1}" (arg2),
133 [arg3] "{o2}" (arg3),133 [arg3] "{o2}" (arg3),
134 [arg4] "{o3}" (arg4),134 [arg4] "{o3}" (arg4),
135 [arg5] "{o4}" (arg5)135 [arg5] "{o4}" (arg5),
136 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"136 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
137 );137 );
138}138}
...@@ -152,14 +152,14 @@ pub fn syscall6(...@@ -152,14 +152,14 @@ pub fn syscall6(
152 \\ nop152 \\ nop
153 \\ neg %%o0153 \\ neg %%o0
154 \\ 1:154 \\ 1:
155 : [ret] "={o0}" (-> usize)155 : [ret] "={o0}" (-> usize),
156 : [number] "{g1}" (@enumToInt(number)),156 : [number] "{g1}" (@enumToInt(number)),
157 [arg1] "{o0}" (arg1),157 [arg1] "{o0}" (arg1),
158 [arg2] "{o1}" (arg2),158 [arg2] "{o1}" (arg2),
159 [arg3] "{o2}" (arg3),159 [arg3] "{o2}" (arg3),
160 [arg4] "{o3}" (arg4),160 [arg4] "{o3}" (arg4),
161 [arg5] "{o4}" (arg5),161 [arg5] "{o4}" (arg5),
162 [arg6] "{o5}" (arg6)162 [arg6] "{o5}" (arg6),
163 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"163 : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
164 );164 );
165}165}
...@@ -174,7 +174,7 @@ pub const restore = restore_rt;...@@ -174,7 +174,7 @@ pub const restore = restore_rt;
174pub fn restore_rt() callconv(.C) void {174pub fn restore_rt() callconv(.C) void {
175 return asm volatile ("t 0x6d"175 return asm volatile ("t 0x6d"
176 :176 :
177 : [number] "{g1}" (@enumToInt(SYS.rt_sigreturn))177 : [number] "{g1}" (@enumToInt(SYS.rt_sigreturn)),
178 : "memory", "xcc", "o0", "o1", "o2", "o3", "o4", "o5", "o7"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,13 +30,13 @@ fn getDynamicSymbol() [*]elf.Dyn {
30 \\ call 1f30 \\ call 1f
31 \\ 1: pop %[ret]31 \\ 1: pop %[ret]
32 \\ lea _DYNAMIC-1b(%[ret]), %[ret]32 \\ lea _DYNAMIC-1b(%[ret]), %[ret]
33 : [ret] "=r" (-> [*]elf.Dyn)33 : [ret] "=r" (-> [*]elf.Dyn),
34 ),34 ),
35 .x86_64 => asm volatile (35 .x86_64 => asm volatile (
36 \\ .weak _DYNAMIC36 \\ .weak _DYNAMIC
37 \\ .hidden _DYNAMIC37 \\ .hidden _DYNAMIC
38 \\ lea _DYNAMIC(%%rip), %[ret]38 \\ lea _DYNAMIC(%%rip), %[ret]
39 : [ret] "=r" (-> [*]elf.Dyn)39 : [ret] "=r" (-> [*]elf.Dyn),
40 ),40 ),
41 // Work around the limited offset range of `ldr`41 // Work around the limited offset range of `ldr`
42 .arm => asm volatile (42 .arm => asm volatile (
...@@ -47,7 +47,7 @@ fn getDynamicSymbol() [*]elf.Dyn {...@@ -47,7 +47,7 @@ fn getDynamicSymbol() [*]elf.Dyn {
47 \\ b 2f47 \\ b 2f
48 \\ 1: .word _DYNAMIC-1b48 \\ 1: .word _DYNAMIC-1b
49 \\ 2:49 \\ 2:
50 : [ret] "=r" (-> [*]elf.Dyn)50 : [ret] "=r" (-> [*]elf.Dyn),
51 ),51 ),
52 // A simple `adr` is not enough as it has a limited offset range52 // A simple `adr` is not enough as it has a limited offset range
53 .aarch64 => asm volatile (53 .aarch64 => asm volatile (
...@@ -55,13 +55,13 @@ fn getDynamicSymbol() [*]elf.Dyn {...@@ -55,13 +55,13 @@ fn getDynamicSymbol() [*]elf.Dyn {
55 \\ .hidden _DYNAMIC55 \\ .hidden _DYNAMIC
56 \\ adrp %[ret], _DYNAMIC56 \\ adrp %[ret], _DYNAMIC
57 \\ add %[ret], %[ret], #:lo12:_DYNAMIC57 \\ add %[ret], %[ret], #:lo12:_DYNAMIC
58 : [ret] "=r" (-> [*]elf.Dyn)58 : [ret] "=r" (-> [*]elf.Dyn),
59 ),59 ),
60 .riscv64 => asm volatile (60 .riscv64 => asm volatile (
61 \\ .weak _DYNAMIC61 \\ .weak _DYNAMIC
62 \\ .hidden _DYNAMIC62 \\ .hidden _DYNAMIC
63 \\ lla %[ret], _DYNAMIC63 \\ lla %[ret], _DYNAMIC
64 : [ret] "=r" (-> [*]elf.Dyn)64 : [ret] "=r" (-> [*]elf.Dyn),
65 ),65 ),
66 else => {66 else => {
67 @compileError("PIE startup is not yet supported for this target!");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,8 +15,8 @@ pub fn syscall0(number: SYS) usize {
15 \\ ldr r7, [%[tmp]]15 \\ ldr r7, [%[tmp]]
16 \\ svc #016 \\ svc #0
17 \\ ldr r7, [%[tmp], #4]17 \\ ldr r7, [%[tmp], #4]
18 : [ret] "={r0}" (-> usize)18 : [ret] "={r0}" (-> usize),
19 : [tmp] "{r1}" (buf)19 : [tmp] "{r1}" (buf),
20 : "memory"20 : "memory"
21 );21 );
22}22}
...@@ -30,9 +30,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {...@@ -30,9 +30,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
30 \\ ldr r7, [%[tmp]]30 \\ ldr r7, [%[tmp]]
31 \\ svc #031 \\ svc #0
32 \\ ldr r7, [%[tmp], #4]32 \\ ldr r7, [%[tmp], #4]
33 : [ret] "={r0}" (-> usize)33 : [ret] "={r0}" (-> usize),
34 : [tmp] "{r1}" (buf),34 : [tmp] "{r1}" (buf),
35 [arg1] "{r0}" (arg1)35 [arg1] "{r0}" (arg1),
36 : "memory"36 : "memory"
37 );37 );
38}38}
...@@ -46,10 +46,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {...@@ -46,10 +46,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
46 \\ ldr r7, [%[tmp]]46 \\ ldr r7, [%[tmp]]
47 \\ svc #047 \\ svc #0
48 \\ ldr r7, [%[tmp], #4]48 \\ ldr r7, [%[tmp], #4]
49 : [ret] "={r0}" (-> usize)49 : [ret] "={r0}" (-> usize),
50 : [tmp] "{r2}" (buf),50 : [tmp] "{r2}" (buf),
51 [arg1] "{r0}" (arg1),51 [arg1] "{r0}" (arg1),
52 [arg2] "{r1}" (arg2)52 [arg2] "{r1}" (arg2),
53 : "memory"53 : "memory"
54 );54 );
55}55}
...@@ -63,11 +63,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -63,11 +63,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
63 \\ ldr r7, [%[tmp]]63 \\ ldr r7, [%[tmp]]
64 \\ svc #064 \\ svc #0
65 \\ ldr r7, [%[tmp], #4]65 \\ ldr r7, [%[tmp], #4]
66 : [ret] "={r0}" (-> usize)66 : [ret] "={r0}" (-> usize),
67 : [tmp] "{r3}" (buf),67 : [tmp] "{r3}" (buf),
68 [arg1] "{r0}" (arg1),68 [arg1] "{r0}" (arg1),
69 [arg2] "{r1}" (arg2),69 [arg2] "{r1}" (arg2),
70 [arg3] "{r2}" (arg3)70 [arg3] "{r2}" (arg3),
71 : "memory"71 : "memory"
72 );72 );
73}73}
...@@ -81,12 +81,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -81,12 +81,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
81 \\ ldr r7, [%[tmp]]81 \\ ldr r7, [%[tmp]]
82 \\ svc #082 \\ svc #0
83 \\ ldr r7, [%[tmp], #4]83 \\ ldr r7, [%[tmp], #4]
84 : [ret] "={r0}" (-> usize)84 : [ret] "={r0}" (-> usize),
85 : [tmp] "{r4}" (buf),85 : [tmp] "{r4}" (buf),
86 [arg1] "{r0}" (arg1),86 [arg1] "{r0}" (arg1),
87 [arg2] "{r1}" (arg2),87 [arg2] "{r1}" (arg2),
88 [arg3] "{r2}" (arg3),88 [arg3] "{r2}" (arg3),
89 [arg4] "{r3}" (arg4)89 [arg4] "{r3}" (arg4),
90 : "memory"90 : "memory"
91 );91 );
92}92}
...@@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
100 \\ ldr r7, [%[tmp]]100 \\ ldr r7, [%[tmp]]
101 \\ svc #0101 \\ svc #0
102 \\ ldr r7, [%[tmp], #4]102 \\ ldr r7, [%[tmp], #4]
103 : [ret] "={r0}" (-> usize)103 : [ret] "={r0}" (-> usize),
104 : [tmp] "{r5}" (buf),104 : [tmp] "{r5}" (buf),
105 [arg1] "{r0}" (arg1),105 [arg1] "{r0}" (arg1),
106 [arg2] "{r1}" (arg2),106 [arg2] "{r1}" (arg2),
107 [arg3] "{r2}" (arg3),107 [arg3] "{r2}" (arg3),
108 [arg4] "{r3}" (arg4),108 [arg4] "{r3}" (arg4),
109 [arg5] "{r4}" (arg5)109 [arg5] "{r4}" (arg5),
110 : "memory"110 : "memory"
111 );111 );
112}112}
...@@ -128,14 +128,14 @@ pub fn syscall6(...@@ -128,14 +128,14 @@ pub fn syscall6(
128 \\ ldr r7, [%[tmp]]128 \\ ldr r7, [%[tmp]]
129 \\ svc #0129 \\ svc #0
130 \\ ldr r7, [%[tmp], #4]130 \\ ldr r7, [%[tmp], #4]
131 : [ret] "={r0}" (-> usize)131 : [ret] "={r0}" (-> usize),
132 : [tmp] "{r6}" (buf),132 : [tmp] "{r6}" (buf),
133 [arg1] "{r0}" (arg1),133 [arg1] "{r0}" (arg1),
134 [arg2] "{r1}" (arg2),134 [arg2] "{r1}" (arg2),
135 [arg3] "{r2}" (arg3),135 [arg3] "{r2}" (arg3),
136 [arg4] "{r3}" (arg4),136 [arg4] "{r3}" (arg4),
137 [arg5] "{r4}" (arg5),137 [arg5] "{r4}" (arg5),
138 [arg6] "{r5}" (arg6)138 [arg6] "{r5}" (arg6),
139 : "memory"139 : "memory"
140 );140 );
141}141}
...@@ -148,7 +148,7 @@ pub fn restore() callconv(.Naked) void {...@@ -148,7 +148,7 @@ pub fn restore() callconv(.Naked) void {
148 \\ mov r7, %[number]148 \\ mov r7, %[number]
149 \\ svc #0149 \\ svc #0
150 :150 :
151 : [number] "I" (@enumToInt(SYS.sigreturn))151 : [number] "I" (@enumToInt(SYS.sigreturn)),
152 );152 );
153}153}
154154
...@@ -157,7 +157,7 @@ pub fn restore_rt() callconv(.Naked) void {...@@ -157,7 +157,7 @@ pub fn restore_rt() callconv(.Naked) void {
157 \\ mov r7, %[number]157 \\ mov r7, %[number]
158 \\ svc #0158 \\ svc #0
159 :159 :
160 : [number] "I" (@enumToInt(SYS.rt_sigreturn))160 : [number] "I" (@enumToInt(SYS.rt_sigreturn)),
161 : "memory"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,7 +131,7 @@ pub fn setThreadPointer(addr: usize) void {
131 // Update the %gs selector131 // Update the %gs selector
132 asm volatile ("movl %[gs_val], %%gs"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 .x86_64 => {137 .x86_64 => {
...@@ -142,7 +142,7 @@ pub fn setThreadPointer(addr: usize) void {...@@ -142,7 +142,7 @@ pub fn setThreadPointer(addr: usize) void {
142 asm volatile (142 asm volatile (
143 \\ msr tpidr_el0, %[addr]143 \\ msr tpidr_el0, %[addr]
144 :144 :
145 : [addr] "r" (addr)145 : [addr] "r" (addr),
146 );146 );
147 },147 },
148 .arm, .thumb => {148 .arm, .thumb => {
...@@ -153,7 +153,7 @@ pub fn setThreadPointer(addr: usize) void {...@@ -153,7 +153,7 @@ pub fn setThreadPointer(addr: usize) void {
153 asm volatile (153 asm volatile (
154 \\ mv tp, %[addr]154 \\ mv tp, %[addr]
155 :155 :
156 : [addr] "r" (addr)156 : [addr] "r" (addr),
157 );157 );
158 },158 },
159 .mips, .mipsel => {159 .mips, .mipsel => {
...@@ -164,21 +164,21 @@ pub fn setThreadPointer(addr: usize) void {...@@ -164,21 +164,21 @@ pub fn setThreadPointer(addr: usize) void {
164 asm volatile (164 asm volatile (
165 \\ mr 2, %[addr]165 \\ mr 2, %[addr]
166 :166 :
167 : [addr] "r" (addr)167 : [addr] "r" (addr),
168 );168 );
169 },169 },
170 .powerpc64, .powerpc64le => {170 .powerpc64, .powerpc64le => {
171 asm volatile (171 asm volatile (
172 \\ mr 13, %[addr]172 \\ mr 13, %[addr]
173 :173 :
174 : [addr] "r" (addr)174 : [addr] "r" (addr),
175 );175 );
176 },176 },
177 .sparcv9 => {177 .sparcv9 => {
178 asm volatile (178 asm volatile (
179 \\ mov %[addr], %%g7179 \\ mov %[addr], %%g7
180 :180 :
181 : [addr] "r" (addr)181 : [addr] "r" (addr),
182 );182 );
183 },183 },
184 else => @compileError("Unsupported architecture"),184 else => @compileError("Unsupported architecture"),
lib/std/os/linux/x86_64.zig+15-15
...@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");...@@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig");
22
3pub fn syscall0(number: SYS) usize {3pub fn syscall0(number: SYS) usize {
4 return asm volatile ("syscall"4 return asm volatile ("syscall"
5 : [ret] "={rax}" (-> usize)5 : [ret] "={rax}" (-> usize),
6 : [number] "{rax}" (@enumToInt(number))6 : [number] "{rax}" (@enumToInt(number)),
7 : "rcx", "r11", "memory"7 : "rcx", "r11", "memory"
8 );8 );
9}9}
1010
11pub fn syscall1(number: SYS, arg1: usize) usize {11pub fn syscall1(number: SYS, arg1: usize) usize {
12 return asm volatile ("syscall"12 return asm volatile ("syscall"
13 : [ret] "={rax}" (-> usize)13 : [ret] "={rax}" (-> usize),
14 : [number] "{rax}" (@enumToInt(number)),14 : [number] "{rax}" (@enumToInt(number)),
15 [arg1] "{rdi}" (arg1)15 [arg1] "{rdi}" (arg1),
16 : "rcx", "r11", "memory"16 : "rcx", "r11", "memory"
17 );17 );
18}18}
1919
20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
21 return asm volatile ("syscall"21 return asm volatile ("syscall"
22 : [ret] "={rax}" (-> usize)22 : [ret] "={rax}" (-> usize),
23 : [number] "{rax}" (@enumToInt(number)),23 : [number] "{rax}" (@enumToInt(number)),
24 [arg1] "{rdi}" (arg1),24 [arg1] "{rdi}" (arg1),
25 [arg2] "{rsi}" (arg2)25 [arg2] "{rsi}" (arg2),
26 : "rcx", "r11", "memory"26 : "rcx", "r11", "memory"
27 );27 );
28}28}
2929
30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {30pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
31 return asm volatile ("syscall"31 return asm volatile ("syscall"
32 : [ret] "={rax}" (-> usize)32 : [ret] "={rax}" (-> usize),
33 : [number] "{rax}" (@enumToInt(number)),33 : [number] "{rax}" (@enumToInt(number)),
34 [arg1] "{rdi}" (arg1),34 [arg1] "{rdi}" (arg1),
35 [arg2] "{rsi}" (arg2),35 [arg2] "{rsi}" (arg2),
36 [arg3] "{rdx}" (arg3)36 [arg3] "{rdx}" (arg3),
37 : "rcx", "r11", "memory"37 : "rcx", "r11", "memory"
38 );38 );
39}39}
4040
41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {41pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
42 return asm volatile ("syscall"42 return asm volatile ("syscall"
43 : [ret] "={rax}" (-> usize)43 : [ret] "={rax}" (-> usize),
44 : [number] "{rax}" (@enumToInt(number)),44 : [number] "{rax}" (@enumToInt(number)),
45 [arg1] "{rdi}" (arg1),45 [arg1] "{rdi}" (arg1),
46 [arg2] "{rsi}" (arg2),46 [arg2] "{rsi}" (arg2),
47 [arg3] "{rdx}" (arg3),47 [arg3] "{rdx}" (arg3),
48 [arg4] "{r10}" (arg4)48 [arg4] "{r10}" (arg4),
49 : "rcx", "r11", "memory"49 : "rcx", "r11", "memory"
50 );50 );
51}51}
5252
53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {53pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
54 return asm volatile ("syscall"54 return asm volatile ("syscall"
55 : [ret] "={rax}" (-> usize)55 : [ret] "={rax}" (-> usize),
56 : [number] "{rax}" (@enumToInt(number)),56 : [number] "{rax}" (@enumToInt(number)),
57 [arg1] "{rdi}" (arg1),57 [arg1] "{rdi}" (arg1),
58 [arg2] "{rsi}" (arg2),58 [arg2] "{rsi}" (arg2),
59 [arg3] "{rdx}" (arg3),59 [arg3] "{rdx}" (arg3),
60 [arg4] "{r10}" (arg4),60 [arg4] "{r10}" (arg4),
61 [arg5] "{r8}" (arg5)61 [arg5] "{r8}" (arg5),
62 : "rcx", "r11", "memory"62 : "rcx", "r11", "memory"
63 );63 );
64}64}
...@@ -73,14 +73,14 @@ pub fn syscall6(...@@ -73,14 +73,14 @@ pub fn syscall6(
73 arg6: usize,73 arg6: usize,
74) usize {74) usize {
75 return asm volatile ("syscall"75 return asm volatile ("syscall"
76 : [ret] "={rax}" (-> usize)76 : [ret] "={rax}" (-> usize),
77 : [number] "{rax}" (@enumToInt(number)),77 : [number] "{rax}" (@enumToInt(number)),
78 [arg1] "{rdi}" (arg1),78 [arg1] "{rdi}" (arg1),
79 [arg2] "{rsi}" (arg2),79 [arg2] "{rsi}" (arg2),
80 [arg3] "{rdx}" (arg3),80 [arg3] "{rdx}" (arg3),
81 [arg4] "{r10}" (arg4),81 [arg4] "{r10}" (arg4),
82 [arg5] "{r8}" (arg5),82 [arg5] "{r8}" (arg5),
83 [arg6] "{r9}" (arg6)83 [arg6] "{r9}" (arg6),
84 : "rcx", "r11", "memory"84 : "rcx", "r11", "memory"
85 );85 );
86}86}
...@@ -93,7 +93,7 @@ pub const restore = restore_rt;...@@ -93,7 +93,7 @@ pub const restore = restore_rt;
93pub fn restore_rt() callconv(.Naked) void {93pub fn restore_rt() callconv(.Naked) void {
94 return asm volatile ("syscall"94 return asm volatile ("syscall"
95 :95 :
96 : [number] "{rax}" (@enumToInt(SYS.rt_sigreturn))96 : [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)),
97 : "rcx", "r11", "memory"97 : "rcx", "r11", "memory"
98 );98 );
99}99}
lib/std/os/windows.zig+3-3
...@@ -1723,15 +1723,15 @@ pub fn teb() *TEB {...@@ -1723,15 +1723,15 @@ pub fn teb() *TEB {
1723 return switch (builtin.target.cpu.arch) {1723 return switch (builtin.target.cpu.arch) {
1724 .i386 => asm volatile (1724 .i386 => asm volatile (
1725 \\ movl %%fs:0x18, %[ptr]1725 \\ movl %%fs:0x18, %[ptr]
1726 : [ptr] "=r" (-> *TEB)1726 : [ptr] "=r" (-> *TEB),
1727 ),1727 ),
1728 .x86_64 => asm volatile (1728 .x86_64 => asm volatile (
1729 \\ movq %%gs:0x30, %[ptr]1729 \\ movq %%gs:0x30, %[ptr]
1730 : [ptr] "=r" (-> *TEB)1730 : [ptr] "=r" (-> *TEB),
1731 ),1731 ),
1732 .aarch64 => asm volatile (1732 .aarch64 => asm volatile (
1733 \\ mov %[ptr], x181733 \\ mov %[ptr], x18
1734 : [ptr] "=r" (-> *TEB)1734 : [ptr] "=r" (-> *TEB),
1735 ),1735 ),
1736 else => @compileError("unsupported arch"),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,7 +88,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
88 asm volatile (88 asm volatile (
89 \\mrs %[x], ctr_el089 \\mrs %[x], ctr_el0
90 \\90 \\
91 : [x] "=r" (ctr_el0)91 : [x] "=r" (ctr_el0),
92 );92 );
93 // The DC and IC instructions must use 64-bit registers so we don't use93 // The DC and IC instructions must use 64-bit registers so we don't use
94 // uintptr_t in case this runs in an IPL32 environment.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,7 +101,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
101 while (addr < end) : (addr += dcache_line_size) {101 while (addr < end) : (addr += dcache_line_size) {
102 asm volatile ("dc cvau, %[addr]"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,7 +114,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
114 while (addr < end) : (addr += icache_line_size) {114 while (addr < end) : (addr += icache_line_size) {
115 asm volatile ("ic ivau, %[addr]"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,7 +98,7 @@ fn exit2(code: usize) noreturn {
98 asm volatile ("syscall"98 asm volatile ("syscall"
99 :99 :
100 : [number] "{rax}" (231),100 : [number] "{rax}" (231),
101 [arg1] "{rdi}" (code)101 [arg1] "{rdi}" (code),
102 : "rcx", "r11", "memory"102 : "rcx", "r11", "memory"
103 );103 );
104 },104 },
...@@ -106,7 +106,7 @@ fn exit2(code: usize) noreturn {...@@ -106,7 +106,7 @@ fn exit2(code: usize) noreturn {
106 asm volatile ("svc #0"106 asm volatile ("svc #0"
107 :107 :
108 : [number] "{r7}" (1),108 : [number] "{r7}" (1),
109 [arg1] "{r0}" (code)109 [arg1] "{r0}" (code),
110 : "memory"110 : "memory"
111 );111 );
112 },112 },
...@@ -114,7 +114,7 @@ fn exit2(code: usize) noreturn {...@@ -114,7 +114,7 @@ fn exit2(code: usize) noreturn {
114 asm volatile ("svc #0"114 asm volatile ("svc #0"
115 :115 :
116 : [number] "{x8}" (93),116 : [number] "{x8}" (93),
117 [arg1] "{x0}" (code)117 [arg1] "{x0}" (code),
118 : "memory", "cc"118 : "memory", "cc"
119 );119 );
120 },120 },
...@@ -128,7 +128,7 @@ fn exit2(code: usize) noreturn {...@@ -128,7 +128,7 @@ fn exit2(code: usize) noreturn {
128 \\push $0128 \\push $0
129 \\syscall129 \\syscall
130 :130 :
131 : [syscall_number] "{rbp}" (8)131 : [syscall_number] "{rbp}" (8),
132 : "rcx", "r11", "memory"132 : "rcx", "r11", "memory"
133 );133 );
134 },134 },
...@@ -137,7 +137,7 @@ fn exit2(code: usize) noreturn {...@@ -137,7 +137,7 @@ fn exit2(code: usize) noreturn {
137 .aarch64 => {137 .aarch64 => {
138 asm volatile ("svc #0"138 asm volatile ("svc #0"
139 :139 :
140 : [exit] "{x0}" (0x08)140 : [exit] "{x0}" (0x08),
141 : "memory", "cc"141 : "memory", "cc"
142 );142 );
143 },143 },
...@@ -208,34 +208,34 @@ fn _start() callconv(.Naked) noreturn {...@@ -208,34 +208,34 @@ fn _start() callconv(.Naked) noreturn {
208 .x86_64 => {208 .x86_64 => {
209 argc_argv_ptr = asm volatile (209 argc_argv_ptr = asm volatile (
210 \\ xor %%rbp, %%rbp210 \\ xor %%rbp, %%rbp
211 : [argc] "={rsp}" (-> [*]usize)211 : [argc] "={rsp}" (-> [*]usize),
212 );212 );
213 },213 },
214 .i386 => {214 .i386 => {
215 argc_argv_ptr = asm volatile (215 argc_argv_ptr = asm volatile (
216 \\ xor %%ebp, %%ebp216 \\ xor %%ebp, %%ebp
217 : [argc] "={esp}" (-> [*]usize)217 : [argc] "={esp}" (-> [*]usize),
218 );218 );
219 },219 },
220 .aarch64, .aarch64_be, .arm, .armeb, .thumb => {220 .aarch64, .aarch64_be, .arm, .armeb, .thumb => {
221 argc_argv_ptr = asm volatile (221 argc_argv_ptr = asm volatile (
222 \\ mov fp, #0222 \\ mov fp, #0
223 \\ mov lr, #0223 \\ mov lr, #0
224 : [argc] "={sp}" (-> [*]usize)224 : [argc] "={sp}" (-> [*]usize),
225 );225 );
226 },226 },
227 .riscv64 => {227 .riscv64 => {
228 argc_argv_ptr = asm volatile (228 argc_argv_ptr = asm volatile (
229 \\ li s0, 0229 \\ li s0, 0
230 \\ li ra, 0230 \\ li ra, 0
231 : [argc] "={sp}" (-> [*]usize)231 : [argc] "={sp}" (-> [*]usize),
232 );232 );
233 },233 },
234 .mips, .mipsel => {234 .mips, .mipsel => {
235 // The lr is already zeroed on entry, as specified by the ABI.235 // The lr is already zeroed on entry, as specified by the ABI.
236 argc_argv_ptr = asm volatile (236 argc_argv_ptr = asm volatile (
237 \\ move $fp, $0237 \\ move $fp, $0
238 : [argc] "={sp}" (-> [*]usize)238 : [argc] "={sp}" (-> [*]usize),
239 );239 );
240 },240 },
241 .powerpc => {241 .powerpc => {
...@@ -246,7 +246,7 @@ fn _start() callconv(.Naked) noreturn {...@@ -246,7 +246,7 @@ fn _start() callconv(.Naked) noreturn {
246 \\ stwu 1,-16(1)246 \\ stwu 1,-16(1)
247 \\ stw 0, 0(1)247 \\ stw 0, 0(1)
248 \\ mtlr 0248 \\ mtlr 0
249 : [argc] "={r4}" (-> [*]usize)249 : [argc] "={r4}" (-> [*]usize),
250 :250 :
251 : "r0"251 : "r0"
252 );252 );
...@@ -259,7 +259,7 @@ fn _start() callconv(.Naked) noreturn {...@@ -259,7 +259,7 @@ fn _start() callconv(.Naked) noreturn {
259 \\ li 0, 0259 \\ li 0, 0
260 \\ stdu 0, -32(1)260 \\ stdu 0, -32(1)
261 \\ mtlr 0261 \\ mtlr 0
262 : [argc] "={r4}" (-> [*]usize)262 : [argc] "={r4}" (-> [*]usize),
263 :263 :
264 : "r0"264 : "r0"
265 );265 );
...@@ -269,7 +269,7 @@ fn _start() callconv(.Naked) noreturn {...@@ -269,7 +269,7 @@ fn _start() callconv(.Naked) noreturn {
269 argc_argv_ptr = asm (269 argc_argv_ptr = asm (
270 \\ mov %%g0, %%i6270 \\ mov %%g0, %%i6
271 \\ add %%o6, 2175, %[argc]271 \\ add %%o6, 2175, %[argc]
272 : [argc] "=r" (-> [*]usize)272 : [argc] "=r" (-> [*]usize),
273 );273 );
274 },274 },
275 else => @compileError("unsupported arch"),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,9 +13,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:
13 \\ roll $3, %%edi ; roll $13, %%edi13 \\ roll $3, %%edi ; roll $13, %%edi
14 \\ roll $29, %%edi ; roll $19, %%edi14 \\ roll $29, %%edi ; roll $19, %%edi
15 \\ xchgl %%ebx,%%ebx15 \\ xchgl %%ebx,%%ebx
16 : [_] "={edx}" (-> usize)16 : [_] "={edx}" (-> usize),
17 : [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),17 : [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
18 [_] "0" (default)18 [_] "0" (default),
19 : "cc", "memory"19 : "cc", "memory"
20 );20 );
21 },21 },
...@@ -24,9 +24,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:...@@ -24,9 +24,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:
24 \\ rolq $3, %%rdi ; rolq $13, %%rdi24 \\ rolq $3, %%rdi ; rolq $13, %%rdi
25 \\ rolq $61, %%rdi ; rolq $51, %%rdi25 \\ rolq $61, %%rdi ; rolq $51, %%rdi
26 \\ xchgq %%rbx,%%rbx26 \\ xchgq %%rbx,%%rbx
27 : [_] "={rdx}" (-> usize)27 : [_] "={rdx}" (-> usize),
28 : [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),28 : [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
29 [_] "0" (default)29 [_] "0" (default),
30 : "cc", "memory"30 : "cc", "memory"
31 );31 );
32 },32 },
lib/std/zig/parser_test.zig+15-29
...@@ -1,5 +1,5 @@...@@ -1,5 +1,5 @@
1test "zig fmt: preserves clobbers in inline asm with stray comma" {1test "zig fmt: preserves clobbers in inline asm with stray comma" {
2 try testTransform(2 try testCanonical(
3 \\fn foo() void {3 \\fn foo() void {
4 \\ asm volatile (""4 \\ asm volatile (""
5 \\ : [_] "" (-> type),5 \\ : [_] "" (-> type),
...@@ -13,20 +13,6 @@ test "zig fmt: preserves clobbers in inline asm with stray comma" {...@@ -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}
3218
...@@ -508,15 +494,15 @@ test "zig fmt: asm expression with comptime content" {...@@ -508,15 +494,15 @@ test "zig fmt: asm expression with comptime content" {
508 \\pub fn main() void {494 \\pub fn main() void {
509 \\ asm volatile ("foo" ++ "bar");495 \\ asm volatile ("foo" ++ "bar");
510 \\ asm volatile ("foo" ++ "bar"496 \\ asm volatile ("foo" ++ "bar"
511 \\ : [_] "" (x)497 \\ : [_] "" (x),
512 \\ );498 \\ );
513 \\ asm volatile ("foo" ++ "bar"499 \\ asm volatile ("foo" ++ "bar"
514 \\ : [_] "" (x)500 \\ : [_] "" (x),
515 \\ : [_] "" (y)501 \\ : [_] "" (y),
516 \\ );502 \\ );
517 \\ asm volatile ("foo" ++ "bar"503 \\ asm volatile ("foo" ++ "bar"
518 \\ : [_] "" (x)504 \\ : [_] "" (x),
519 \\ : [_] "" (y)505 \\ : [_] "" (y),
520 \\ : "h", "e", "l", "l", "o"506 \\ : "h", "e", "l", "l", "o"
521 \\ );507 \\ );
522 \\}508 \\}
...@@ -2058,11 +2044,11 @@ test "zig fmt: simple asm" {...@@ -2058,11 +2044,11 @@ test "zig fmt: simple asm" {
2058 \\ );2044 \\ );
2059 \\2045 \\
2060 \\ asm ("not real assembly"2046 \\ asm ("not real assembly"
2061 \\ : [a] "x" (x)2047 \\ : [a] "x" (x),
2062 \\ );2048 \\ );
2063 \\ asm ("not real assembly"2049 \\ asm ("not real assembly"
2064 \\ : [a] "x" (-> i32)2050 \\ : [a] "x" (-> i32),
2065 \\ : [a] "x" (1)2051 \\ : [a] "x" (1),
2066 \\ );2052 \\ );
2067 \\ asm ("still not real assembly" ::: "a", "b");2053 \\ asm ("still not real assembly" ::: "a", "b");
2068 \\}2054 \\}
...@@ -3712,9 +3698,9 @@ test "zig fmt: inline asm" {...@@ -3712,9 +3698,9 @@ test "zig fmt: inline asm" {
3712 try testCanonical(3698 try testCanonical(
3713 \\pub fn syscall1(number: usize, arg1: usize) usize {3699 \\pub fn syscall1(number: usize, arg1: usize) usize {
3714 \\ return asm volatile ("syscall"3700 \\ return asm volatile ("syscall"
3715 \\ : [ret] "={rax}" (-> usize)3701 \\ : [ret] "={rax}" (-> usize),
3716 \\ : [number] "{rax}" (number),3702 \\ : [number] "{rax}" (number),
3717 \\ [arg1] "{rdi}" (arg1)3703 \\ [arg1] "{rdi}" (arg1),
3718 \\ : "rcx", "r11"3704 \\ : "rcx", "r11"
3719 \\ );3705 \\ );
3720 \\}3706 \\}
...@@ -3817,14 +3803,14 @@ test "zig fmt: inline asm parameter alignment" {...@@ -3817,14 +3803,14 @@ test "zig fmt: inline asm parameter alignment" {
3817 \\ \\ foo3803 \\ \\ foo
3818 \\ \\ bar3804 \\ \\ bar
3819 \\ : [_] "" (-> usize),3805 \\ : [_] "" (-> usize),
3820 \\ [_] "" (-> usize)3806 \\ [_] "" (-> usize),
3821 \\ );3807 \\ );
3822 \\ asm volatile (3808 \\ asm volatile (
3823 \\ \\ foo3809 \\ \\ foo
3824 \\ \\ bar3810 \\ \\ bar
3825 \\ :3811 \\ :
3826 \\ : [_] "" (0),3812 \\ : [_] "" (0),
3827 \\ [_] "" (0)3813 \\ [_] "" (0),
3828 \\ );3814 \\ );
3829 \\ asm volatile (3815 \\ asm volatile (
3830 \\ \\ foo3816 \\ \\ foo
...@@ -3834,9 +3820,9 @@ test "zig fmt: inline asm parameter alignment" {...@@ -3834,9 +3820,9 @@ test "zig fmt: inline asm parameter alignment" {
3834 \\ \\ foo3820 \\ \\ foo
3835 \\ \\ bar3821 \\ \\ bar
3836 \\ : [_] "" (-> usize),3822 \\ : [_] "" (-> usize),
3837 \\ [_] "" (-> usize)3823 \\ [_] "" (-> usize),
3838 \\ : [_] "" (0),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,13 +1944,13 @@ fn renderAsm(
1944 try renderToken(ais, tree, comma, .newline); // ,1944 try renderToken(ais, tree, comma, .newline); // ,
1945 try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));1945 try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));
1946 } else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) {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 ais.popIndent();1948 ais.popIndent();
1949 ais.setIndentDelta(indent_delta);1949 ais.setIndentDelta(indent_delta);
1950 ais.popIndent();1950 ais.popIndent();
1951 return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen1951 return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
1952 } else {1952 } else {
1953 try renderAsmOutput(gpa, ais, tree, asm_output, .newline);1953 try renderAsmOutput(gpa, ais, tree, asm_output, .comma);
1954 const comma_or_colon = tree.lastToken(asm_output) + 1;1954 const comma_or_colon = tree.lastToken(asm_output) + 1;
1955 ais.popIndent();1955 ais.popIndent();
1956 break :colon2 switch (token_tags[comma_or_colon]) {1956 break :colon2 switch (token_tags[comma_or_colon]) {
...@@ -1976,13 +1976,13 @@ fn renderAsm(...@@ -1976,13 +1976,13 @@ fn renderAsm(
1976 try renderToken(ais, tree, first_token - 1, .newline); // ,1976 try renderToken(ais, tree, first_token - 1, .newline); // ,
1977 try renderExtraNewlineToken(ais, tree, first_token);1977 try renderExtraNewlineToken(ais, tree, first_token);
1978 } else if (asm_node.first_clobber == null) {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 ais.popIndent();1980 ais.popIndent();
1981 ais.setIndentDelta(indent_delta);1981 ais.setIndentDelta(indent_delta);
1982 ais.popIndent();1982 ais.popIndent();
1983 return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen1983 return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
1984 } else {1984 } else {
1985 try renderAsmInput(gpa, ais, tree, asm_input, .newline);1985 try renderAsmInput(gpa, ais, tree, asm_input, .comma);
1986 const comma_or_colon = tree.lastToken(asm_input) + 1;1986 const comma_or_colon = tree.lastToken(asm_input) + 1;
1987 ais.popIndent();1987 ais.popIndent();
1988 break :colon3 switch (token_tags[comma_or_colon]) {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,7 +543,7 @@ fn cpuid(leaf_id: u32, subid: u32) CpuidLeaf {
543 :543 :
544 : [leaf_id] "{eax}" (leaf_id),544 : [leaf_id] "{eax}" (leaf_id),
545 [subid] "{ecx}" (subid),545 [subid] "{ecx}" (subid),
546 [leaf_ptr] "r" (&cpuid_leaf)546 [leaf_ptr] "r" (&cpuid_leaf),
547 : "eax", "ebx", "ecx", "edx"547 : "eax", "ebx", "ecx", "edx"
548 );548 );
549549
...@@ -555,7 +555,7 @@ fn getXCR0() u32 {...@@ -555,7 +555,7 @@ fn getXCR0() u32 {
555 return asm volatile (555 return asm volatile (
556 \\ xor %%ecx, %%ecx556 \\ xor %%ecx, %%ecx
557 \\ xgetbv557 \\ xgetbv
558 : [ret] "={eax}" (-> u32)558 : [ret] "={eax}" (-> u32),
559 :559 :
560 : "eax", "edx", "ecx"560 : "eax", "edx", "ecx"
561 );561 );
test/behavior/asm.zig+15-15
...@@ -23,12 +23,12 @@ test "output constraint modifiers" {...@@ -23,12 +23,12 @@ test "output constraint modifiers" {
23 // This is only testing compilation.23 // This is only testing compilation.
24 var a: u32 = 3;24 var a: u32 = 3;
25 asm volatile (""25 asm volatile (""
26 : [_] "=m,r" (a)26 : [_] "=m,r" (a),
27 :27 :
28 : ""28 : ""
29 );29 );
30 asm volatile (""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,8 +38,8 @@ test "alternative constraints" {
38 // Make sure we allow commas as a separator for alternative constraints.38 // Make sure we allow commas as a separator for alternative constraints.
39 var a: u32 = 3;39 var a: u32 = 3;
40 asm volatile (""40 asm volatile (""
41 : [_] "=r,m" (a)41 : [_] "=r,m" (a),
42 : [_] "r,m" (a)42 : [_] "r,m" (a),
43 : ""43 : ""
44 );44 );
45}45}
...@@ -47,42 +47,42 @@ test "alternative constraints" {...@@ -47,42 +47,42 @@ test "alternative constraints" {
47test "sized integer/float in asm input" {47test "sized integer/float in asm input" {
48 asm volatile (""48 asm volatile (""
49 :49 :
50 : [_] "m" (@as(usize, 3))50 : [_] "m" (@as(usize, 3)),
51 : ""51 : ""
52 );52 );
53 asm volatile (""53 asm volatile (""
54 :54 :
55 : [_] "m" (@as(i15, -3))55 : [_] "m" (@as(i15, -3)),
56 : ""56 : ""
57 );57 );
58 asm volatile (""58 asm volatile (""
59 :59 :
60 : [_] "m" (@as(u3, 3))60 : [_] "m" (@as(u3, 3)),
61 : ""61 : ""
62 );62 );
63 asm volatile (""63 asm volatile (""
64 :64 :
65 : [_] "m" (@as(i3, 3))65 : [_] "m" (@as(i3, 3)),
66 : ""66 : ""
67 );67 );
68 asm volatile (""68 asm volatile (""
69 :69 :
70 : [_] "m" (@as(u121, 3))70 : [_] "m" (@as(u121, 3)),
71 : ""71 : ""
72 );72 );
73 asm volatile (""73 asm volatile (""
74 :74 :
75 : [_] "m" (@as(i121, 3))75 : [_] "m" (@as(i121, 3)),
76 : ""76 : ""
77 );77 );
78 asm volatile (""78 asm volatile (""
79 :79 :
80 : [_] "m" (@as(f32, 3.17))80 : [_] "m" (@as(f32, 3.17)),
81 : ""81 : ""
82 );82 );
83 asm volatile (""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,15 +90,15 @@ test "sized integer/float in asm input" {
90test "struct/array/union types as input values" {90test "struct/array/union types as input values" {
91 asm volatile (""91 asm volatile (""
92 :92 :
93 : [_] "m" (@as([1]u32, undefined))93 : [_] "m" (@as([1]u32, undefined)),
94 ); // fails94 ); // fails
95 asm volatile (""95 asm volatile (""
96 :96 :
97 : [_] "m" (@as(struct { x: u32, y: u8 }, undefined))97 : [_] "m" (@as(struct { x: u32, y: u8 }, undefined)),
98 ); // fails98 ); // fails
99 asm volatile (""99 asm volatile (""
100 :100 :
101 : [_] "m" (@as(union { x: u32, y: u8 }, undefined))101 : [_] "m" (@as(union { x: u32, y: u8 }, undefined)),
102 ); // fails102 ); // fails
103}103}
104104