diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig index 3c0a53612c..e322485037 100644 --- a/lib/std/Thread.zig +++ b/lib/std/Thread.zig @@ -700,7 +700,7 @@ const LinuxThreadImpl = struct { \\ int $128 : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .x86_64 => asm volatile ( @@ -713,7 +713,7 @@ const LinuxThreadImpl = struct { \\ syscall : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .arm, .armeb, .thumb, .thumbeb => asm volatile ( @@ -726,7 +726,7 @@ const LinuxThreadImpl = struct { \\ svc 0 : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .aarch64, .aarch64_be, .aarch64_32 => asm volatile ( @@ -739,7 +739,7 @@ const LinuxThreadImpl = struct { \\ svc 0 : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .mips, .mipsel => asm volatile ( @@ -753,7 +753,7 @@ const LinuxThreadImpl = struct { \\ syscall : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .mips64, .mips64el => asm volatile ( @@ -766,7 +766,7 @@ const LinuxThreadImpl = struct { \\ syscall : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile ( @@ -780,7 +780,7 @@ const LinuxThreadImpl = struct { \\ blr : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .riscv64 => asm volatile ( @@ -793,7 +793,7 @@ const LinuxThreadImpl = struct { \\ ecall : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), .sparcv9 => asm volatile ( @@ -821,7 +821,7 @@ const LinuxThreadImpl = struct { \\ t 0x6d : : [ptr] "r" (@ptrToInt(self.mapped.ptr)), - [len] "r" (self.mapped.len) + [len] "r" (self.mapped.len), : "memory" ), else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)), diff --git a/lib/std/atomic/Atomic.zig b/lib/std/atomic/Atomic.zig index deb364b7d3..98c4cb95f7 100644 --- a/lib/std/atomic/Atomic.zig +++ b/lib/std/atomic/Atomic.zig @@ -176,69 +176,69 @@ pub fn Atomic(comptime T: type) type { 2 => switch (op) { .Set => asm volatile ("lock btsw %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Reset => asm volatile ("lock btrw %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Toggle => asm volatile ("lock btcw %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), }, 4 => switch (op) { .Set => asm volatile ("lock btsl %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Reset => asm volatile ("lock btrl %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Toggle => asm volatile ("lock btcl %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), }, 8 => switch (op) { .Set => asm volatile ("lock btsq %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Reset => asm volatile ("lock btrq %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), .Toggle => asm volatile ("lock btcq %[bit], %[ptr]" // LLVM doesn't support u1 flag register return values - : [result] "={@ccc}" (-> u8) + : [result] "={@ccc}" (-> u8), : [ptr] "*p" (&self.value), - [bit] "X" (@as(T, bit)) + [bit] "X" (@as(T, bit)), : "cc", "memory" ), }, diff --git a/lib/std/crypto/aes/aesni.zig b/lib/std/crypto/aes/aesni.zig index 94c7f5efc6..ab11b5bc8b 100644 --- a/lib/std/crypto/aes/aesni.zig +++ b/lib/std/crypto/aes/aesni.zig @@ -34,9 +34,9 @@ pub const Block = struct { return Block{ .repr = asm ( \\ vaesenc %[rk], %[in], %[out] - : [out] "=x" (-> BlockVec) + : [out] "=x" (-> BlockVec), : [in] "x" (block.repr), - [rk] "x" (round_key.repr) + [rk] "x" (round_key.repr), ), }; } @@ -46,9 +46,9 @@ pub const Block = struct { return Block{ .repr = asm ( \\ vaesenclast %[rk], %[in], %[out] - : [out] "=x" (-> BlockVec) + : [out] "=x" (-> BlockVec), : [in] "x" (block.repr), - [rk] "x" (round_key.repr) + [rk] "x" (round_key.repr), ), }; } @@ -58,9 +58,9 @@ pub const Block = struct { return Block{ .repr = asm ( \\ vaesdec %[rk], %[in], %[out] - : [out] "=x" (-> BlockVec) + : [out] "=x" (-> BlockVec), : [in] "x" (block.repr), - [rk] "x" (inv_round_key.repr) + [rk] "x" (inv_round_key.repr), ), }; } @@ -70,9 +70,9 @@ pub const Block = struct { return Block{ .repr = asm ( \\ vaesdeclast %[rk], %[in], %[out] - : [out] "=x" (-> BlockVec) + : [out] "=x" (-> BlockVec), : [in] "x" (block.repr), - [rk] "x" (inv_round_key.repr) + [rk] "x" (inv_round_key.repr), ), }; } @@ -190,11 +190,11 @@ fn KeySchedule(comptime Aes: type) type { \\ vpxor %[ts], %[r], %[r] : [r] "=&x" (-> BlockVec), [s] "=&x" (s), - [ts] "=&x" (ts) + [ts] "=&x" (ts), : [rc] "n" (rc), [t] "x" (t), [tx] "x" (tx), - [mask] "n" (@as(u8, if (second) 0xaa else 0xff)) + [mask] "n" (@as(u8, if (second) 0xaa else 0xff)), ); } @@ -235,8 +235,8 @@ fn KeySchedule(comptime Aes: type) type { inv_round_keys[i] = Block{ .repr = asm ( \\ vaesimc %[rk], %[inv_rk] - : [inv_rk] "=x" (-> BlockVec) - : [rk] "x" (round_keys[rounds - i].repr) + : [inv_rk] "=x" (-> BlockVec), + : [rk] "x" (round_keys[rounds - i].repr), ), }; } diff --git a/lib/std/crypto/aes/armcrypto.zig b/lib/std/crypto/aes/armcrypto.zig index cee5b9bccb..6d3c1e8ddf 100644 --- a/lib/std/crypto/aes/armcrypto.zig +++ b/lib/std/crypto/aes/armcrypto.zig @@ -39,10 +39,10 @@ pub const Block = struct { \\ aese %[out].16b, %[zero].16b \\ aesmc %[out].16b, %[out].16b \\ eor %[out].16b, %[out].16b, %[rk].16b - : [out] "=&x" (-> BlockVec) + : [out] "=&x" (-> BlockVec), : [in] "x" (block.repr), [rk] "x" (round_key.repr), - [zero] "x" (zero) + [zero] "x" (zero), ), }; } @@ -54,10 +54,10 @@ pub const Block = struct { \\ mov %[out].16b, %[in].16b \\ aese %[out].16b, %[zero].16b \\ eor %[out].16b, %[out].16b, %[rk].16b - : [out] "=&x" (-> BlockVec) + : [out] "=&x" (-> BlockVec), : [in] "x" (block.repr), [rk] "x" (round_key.repr), - [zero] "x" (zero) + [zero] "x" (zero), ), }; } @@ -70,10 +70,10 @@ pub const Block = struct { \\ aesd %[out].16b, %[zero].16b \\ aesimc %[out].16b, %[out].16b \\ eor %[out].16b, %[out].16b, %[rk].16b - : [out] "=&x" (-> BlockVec) + : [out] "=&x" (-> BlockVec), : [in] "x" (block.repr), [rk] "x" (inv_round_key.repr), - [zero] "x" (zero) + [zero] "x" (zero), ), }; } @@ -85,10 +85,10 @@ pub const Block = struct { \\ mov %[out].16b, %[in].16b \\ aesd %[out].16b, %[zero].16b \\ eor %[out].16b, %[out].16b, %[rk].16b - : [out] "=&x" (-> BlockVec) + : [out] "=&x" (-> BlockVec), : [in] "x" (block.repr), [rk] "x" (inv_round_key.repr), - [zero] "x" (zero) + [zero] "x" (zero), ), }; } @@ -210,11 +210,11 @@ fn KeySchedule(comptime Aes: type) type { [v1] "=&x" (v1), [v2] "=&x" (v2), [v3] "=&x" (v3), - [v4] "=&x" (v4) + [v4] "=&x" (v4), : [rc] "N" (rc), [t] "x" (t), [zero] "x" (zero), - [mask] "x" (mask1) + [mask] "x" (mask1), ); } @@ -240,12 +240,12 @@ fn KeySchedule(comptime Aes: type) type { [v1] "=&x" (v1), [v2] "=&x" (v2), [v3] "=&x" (v3), - [v4] "=&x" (v4) + [v4] "=&x" (v4), : [rc] "N" (if (second) @as(u8, 0) else rc), [t] "x" (t), [tx] "x" (tx), [zero] "x" (zero), - [mask] "x" (if (second) mask2 else mask1) + [mask] "x" (if (second) mask2 else mask1), ); } @@ -286,8 +286,8 @@ fn KeySchedule(comptime Aes: type) type { inv_round_keys[i] = Block{ .repr = asm ( \\ aesimc %[inv_rk].16b, %[rk].16b - : [inv_rk] "=x" (-> BlockVec) - : [rk] "x" (round_keys[rounds - i].repr) + : [inv_rk] "=x" (-> BlockVec), + : [rk] "x" (round_keys[rounds - i].repr), ), }; } diff --git a/lib/std/crypto/ghash.zig b/lib/std/crypto/ghash.zig index 704ed367f0..dfbc13993a 100644 --- a/lib/std/crypto/ghash.zig +++ b/lib/std/crypto/ghash.zig @@ -94,9 +94,9 @@ pub const Ghash = struct { const Vector = std.meta.Vector; const product = asm ( \\ vpclmulqdq $0x00, %[x], %[y], %[out] - : [out] "=x" (-> Vector(2, u64)) + : [out] "=x" (-> Vector(2, u64)), : [x] "x" (@bitCast(Vector(2, u64), @as(u128, x))), - [y] "x" (@bitCast(Vector(2, u64), @as(u128, y))) + [y] "x" (@bitCast(Vector(2, u64), @as(u128, y))), ); return product[0]; } @@ -105,9 +105,9 @@ pub const Ghash = struct { const Vector = std.meta.Vector; const product = asm ( \\ pmull %[out].1q, %[x].1d, %[y].1d - : [out] "=w" (-> Vector(2, u64)) + : [out] "=w" (-> Vector(2, u64)), : [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))), - [y] "w" (@bitCast(Vector(2, u64), @as(u128, y))) + [y] "w" (@bitCast(Vector(2, u64), @as(u128, y))), ); return product[0]; } diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 13f8a4a837..4b715f2b14 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -1634,7 +1634,7 @@ fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, comptime msg: u pub fn dumpStackPointerAddr(prefix: []const u8) void { const sp = asm ("" - : [argc] "={rsp}" (-> usize) + : [argc] "={rsp}" (-> usize), ); std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp }); } diff --git a/lib/std/mem.zig b/lib/std/mem.zig index 57d5a38311..9eaf185119 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -2860,7 +2860,7 @@ pub fn alignForwardGeneric(comptime T: type, addr: T, alignment: T) T { pub fn doNotOptimizeAway(val: anytype) void { asm volatile ("" : - : [val] "rm" (val) + : [val] "rm" (val), : "memory" ); } diff --git a/lib/std/os/linux/arm-eabi.zig b/lib/std/os/linux/arm-eabi.zig index ded72fd100..415cfd42f2 100644 --- a/lib/std/os/linux/arm-eabi.zig +++ b/lib/std/os/linux/arm-eabi.zig @@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig"); pub fn syscall0(number: SYS) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) - : [number] "{r7}" (@enumToInt(number)) + : [ret] "={r0}" (-> usize), + : [number] "{r7}" (@enumToInt(number)), : "memory" ); } pub fn syscall1(number: SYS, arg1: usize) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), - [arg1] "{r0}" (arg1) + [arg1] "{r0}" (arg1), : "memory" ); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), [arg1] "{r0}" (arg1), - [arg2] "{r1}" (arg2) + [arg2] "{r1}" (arg2), : "memory" ); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), - [arg3] "{r2}" (arg3) + [arg3] "{r2}" (arg3), : "memory" ); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), - [arg4] "{r3}" (arg4) + [arg4] "{r3}" (arg4), : "memory" ); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), [arg4] "{r3}" (arg4), - [arg5] "{r4}" (arg5) + [arg5] "{r4}" (arg5), : "memory" ); } @@ -73,14 +73,14 @@ pub fn syscall6( arg6: usize, ) usize { return asm volatile ("svc #0" - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [number] "{r7}" (@enumToInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), [arg4] "{r3}" (arg4), [arg5] "{r4}" (arg5), - [arg6] "{r5}" (arg6) + [arg6] "{r5}" (arg6), : "memory" ); } @@ -91,7 +91,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags: pub fn restore() callconv(.Naked) void { return asm volatile ("svc #0" : - : [number] "{r7}" (@enumToInt(SYS.sigreturn)) + : [number] "{r7}" (@enumToInt(SYS.sigreturn)), : "memory" ); } @@ -99,7 +99,7 @@ pub fn restore() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void { return asm volatile ("svc #0" : - : [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)), : "memory" ); } diff --git a/lib/std/os/linux/arm64.zig b/lib/std/os/linux/arm64.zig index 92942a16ce..3a619c5f45 100644 --- a/lib/std/os/linux/arm64.zig +++ b/lib/std/os/linux/arm64.zig @@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig"); pub fn syscall0(number: SYS) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) - : [number] "{x8}" (@enumToInt(number)) + : [ret] "={x0}" (-> usize), + : [number] "{x8}" (@enumToInt(number)), : "memory", "cc" ); } pub fn syscall1(number: SYS, arg1: usize) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), - [arg1] "{x0}" (arg1) + [arg1] "{x0}" (arg1), : "memory", "cc" ); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), [arg1] "{x0}" (arg1), - [arg2] "{x1}" (arg2) + [arg2] "{x1}" (arg2), : "memory", "cc" ); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), - [arg3] "{x2}" (arg3) + [arg3] "{x2}" (arg3), : "memory", "cc" ); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), - [arg4] "{x3}" (arg4) + [arg4] "{x3}" (arg4), : "memory", "cc" ); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), [arg4] "{x3}" (arg4), - [arg5] "{x4}" (arg5) + [arg5] "{x4}" (arg5), : "memory", "cc" ); } @@ -73,14 +73,14 @@ pub fn syscall6( arg6: usize, ) usize { return asm volatile ("svc #0" - : [ret] "={x0}" (-> usize) + : [ret] "={x0}" (-> usize), : [number] "{x8}" (@enumToInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), [arg4] "{x3}" (arg4), [arg5] "{x4}" (arg5), - [arg6] "{x5}" (arg6) + [arg6] "{x5}" (arg6), : "memory", "cc" ); } @@ -93,7 +93,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) void { return asm volatile ("svc #0" : - : [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)), : "memory", "cc" ); } diff --git a/lib/std/os/linux/i386.zig b/lib/std/os/linux/i386.zig index 70178656d5..04a67da762 100644 --- a/lib/std/os/linux/i386.zig +++ b/lib/std/os/linux/i386.zig @@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig"); pub fn syscall0(number: SYS) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) - : [number] "{eax}" (@enumToInt(number)) + : [ret] "={eax}" (-> usize), + : [number] "{eax}" (@enumToInt(number)), : "memory" ); } pub fn syscall1(number: SYS, arg1: usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), - [arg1] "{ebx}" (arg1) + [arg1] "{ebx}" (arg1), : "memory" ); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), [arg1] "{ebx}" (arg1), - [arg2] "{ecx}" (arg2) + [arg2] "{ecx}" (arg2), : "memory" ); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), - [arg3] "{edx}" (arg3) + [arg3] "{edx}" (arg3), : "memory" ); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), - [arg4] "{esi}" (arg4) + [arg4] "{esi}" (arg4), : "memory" ); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), [arg4] "{esi}" (arg4), - [arg5] "{edi}" (arg5) + [arg5] "{edi}" (arg5), : "memory" ); } @@ -83,24 +83,24 @@ pub fn syscall6( \\ int $0x80 \\ pop %%ebp \\ add $4, %%esp - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), [arg4] "{esi}" (arg4), [arg5] "{edi}" (arg5), - [arg6] "rm" (arg6) + [arg6] "rm" (arg6), : "memory" ); } pub fn socketcall(call: usize, args: [*]usize) usize { return asm volatile ("int $0x80" - : [ret] "={eax}" (-> usize) + : [ret] "={eax}" (-> usize), : [number] "{eax}" (@enumToInt(SYS.socketcall)), [arg1] "{ebx}" (call), - [arg2] "{ecx}" (@ptrToInt(args)) + [arg2] "{ecx}" (@ptrToInt(args)), : "memory" ); } @@ -111,7 +111,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags: pub fn restore() callconv(.Naked) void { return asm volatile ("int $0x80" : - : [number] "{eax}" (@enumToInt(SYS.sigreturn)) + : [number] "{eax}" (@enumToInt(SYS.sigreturn)), : "memory" ); } @@ -119,7 +119,7 @@ pub fn restore() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void { return asm volatile ("int $0x80" : - : [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)), : "memory" ); } diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig index 5cff1e9265..f59f04b130 100644 --- a/lib/std/os/linux/mips.zig +++ b/lib/std/os/linux/mips.zig @@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize { \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) - : [number] "{$2}" (@enumToInt(number)) + : [ret] "={$2}" (-> usize), + : [number] "{$2}" (@enumToInt(number)), : "memory", "cc", "$7" ); } @@ -25,9 +25,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize { \\ sw $2, 0($4) \\ sw $3, 4($4) \\ 2: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(SYS.pipe)), - [fd] "{$4}" (fd) + [fd] "{$4}" (fd), : "memory", "cc", "$7" ); } @@ -38,9 +38,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize { \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), - [arg1] "{$4}" (arg1) + [arg1] "{$4}" (arg1), : "memory", "cc", "$7" ); } @@ -51,10 +51,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), - [arg2] "{$5}" (arg2) + [arg2] "{$5}" (arg2), : "memory", "cc", "$7" ); } @@ -65,11 +65,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), - [arg3] "{$6}" (arg3) + [arg3] "{$6}" (arg3), : "memory", "cc", "$7" ); } @@ -80,12 +80,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), - [arg4] "{$7}" (arg4) + [arg4] "{$7}" (arg4), : "memory", "cc", "$7" ); } @@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), [arg4] "{$7}" (arg4), - [arg5] "r" (arg5) + [arg5] "r" (arg5), : "memory", "cc", "$7" ); } @@ -133,14 +133,14 @@ pub fn syscall6( \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), [arg4] "{$7}" (arg4), [arg5] "r" (arg5), - [arg6] "r" (arg6) + [arg6] "r" (arg6), : "memory", "cc", "$7" ); } @@ -166,7 +166,7 @@ pub fn syscall7( \\ blez $7, 1f \\ subu $2, $0, $2 \\ 1: - : [ret] "={$2}" (-> usize) + : [ret] "={$2}" (-> usize), : [number] "{$2}" (@enumToInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), @@ -174,7 +174,7 @@ pub fn syscall7( [arg4] "{$7}" (arg4), [arg5] "r" (arg5), [arg6] "r" (arg6), - [arg7] "r" (arg7) + [arg7] "r" (arg7), : "memory", "cc", "$7" ); } @@ -185,7 +185,7 @@ pub extern fn clone(func: fn (arg: usize) callconv(.C) u8, stack: usize, flags: pub fn restore() callconv(.Naked) void { return asm volatile ("syscall" : - : [number] "{$2}" (@enumToInt(SYS.sigreturn)) + : [number] "{$2}" (@enumToInt(SYS.sigreturn)), : "memory", "cc", "$7" ); } @@ -193,7 +193,7 @@ pub fn restore() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void { return asm volatile ("syscall" : - : [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)), : "memory", "cc", "$7" ); } diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig index c48d86a155..760655b5fa 100644 --- a/lib/std/os/linux/powerpc.zig +++ b/lib/std/os/linux/powerpc.zig @@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) - : [number] "{r0}" (@enumToInt(number)) + : [ret] "={r3}" (-> usize), + : [number] "{r0}" (@enumToInt(number)), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -18,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), - [arg1] "{r3}" (arg1) + [arg1] "{r3}" (arg1), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -31,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), - [arg2] "{r4}" (arg2) + [arg2] "{r4}" (arg2), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -45,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), - [arg3] "{r5}" (arg3) + [arg3] "{r5}" (arg3), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -60,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), - [arg4] "{r6}" (arg4) + [arg4] "{r6}" (arg4), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -76,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), - [arg5] "{r7}" (arg5) + [arg5] "{r7}" (arg5), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -101,14 +101,14 @@ pub fn syscall6( \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), - [arg6] "{r8}" (arg6) + [arg6] "{r8}" (arg6), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -121,7 +121,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) void { return asm volatile ("sc" : - : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig index c48d86a155..760655b5fa 100644 --- a/lib/std/os/linux/powerpc64.zig +++ b/lib/std/os/linux/powerpc64.zig @@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) - : [number] "{r0}" (@enumToInt(number)) + : [ret] "={r3}" (-> usize), + : [number] "{r0}" (@enumToInt(number)), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -18,9 +18,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), - [arg1] "{r3}" (arg1) + [arg1] "{r3}" (arg1), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -31,10 +31,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), - [arg2] "{r4}" (arg2) + [arg2] "{r4}" (arg2), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -45,11 +45,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), - [arg3] "{r5}" (arg3) + [arg3] "{r5}" (arg3), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -60,12 +60,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), - [arg4] "{r6}" (arg4) + [arg4] "{r6}" (arg4), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -76,13 +76,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), - [arg5] "{r7}" (arg5) + [arg5] "{r7}" (arg5), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -101,14 +101,14 @@ pub fn syscall6( \\ bns+ 1f \\ neg 3, 3 \\ 1: - : [ret] "={r3}" (-> usize) + : [ret] "={r3}" (-> usize), : [number] "{r0}" (@enumToInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), [arg4] "{r6}" (arg4), [arg5] "{r7}" (arg5), - [arg6] "{r8}" (arg6) + [arg6] "{r8}" (arg6), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } @@ -121,7 +121,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) void { return asm volatile ("sc" : - : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{r0}" (@enumToInt(SYS.rt_sigreturn)), : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); } diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig index dfc7e164e8..1448bfe3d3 100644 --- a/lib/std/os/linux/riscv64.zig +++ b/lib/std/os/linux/riscv64.zig @@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig"); pub fn syscall0(number: SYS) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) - : [number] "{x17}" (@enumToInt(number)) + : [ret] "={x10}" (-> usize), + : [number] "{x17}" (@enumToInt(number)), : "memory" ); } pub fn syscall1(number: SYS, arg1: usize) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), - [arg1] "{x10}" (arg1) + [arg1] "{x10}" (arg1), : "memory" ); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), [arg1] "{x10}" (arg1), - [arg2] "{x11}" (arg2) + [arg2] "{x11}" (arg2), : "memory" ); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), - [arg3] "{x12}" (arg3) + [arg3] "{x12}" (arg3), : "memory" ); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), - [arg4] "{x13}" (arg4) + [arg4] "{x13}" (arg4), : "memory" ); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), [arg4] "{x13}" (arg4), - [arg5] "{x14}" (arg5) + [arg5] "{x14}" (arg5), : "memory" ); } @@ -73,14 +73,14 @@ pub fn syscall6( arg6: usize, ) usize { return asm volatile ("ecall" - : [ret] "={x10}" (-> usize) + : [ret] "={x10}" (-> usize), : [number] "{x17}" (@enumToInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), [arg4] "{x13}" (arg4), [arg5] "{x14}" (arg5), - [arg6] "{x15}" (arg6) + [arg6] "{x15}" (arg6), : "memory" ); } @@ -92,7 +92,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) void { return asm volatile ("ecall" : - : [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)), : "memory" ); } diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig index 1c08d39c05..ce41af40d6 100644 --- a/lib/std/os/linux/sparc64.zig +++ b/lib/std/os/linux/sparc64.zig @@ -14,9 +14,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize { \\ st %%o1, [%%g3+4] \\ clr %%o0 \\2: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(SYS.pipe)), - [arg] "r" (fd) + [arg] "r" (fd), : "memory", "g3" ); } @@ -38,8 +38,8 @@ pub fn syscall_fork() usize { \\ dec %%o1 \\ and %%o1, %%o0, %%o0 \\ 2: - : [ret] "={o0}" (-> usize) - : [number] "{g1}" (@enumToInt(SYS.fork)) + : [ret] "={o0}" (-> usize), + : [number] "{g1}" (@enumToInt(SYS.fork)), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -51,8 +51,8 @@ pub fn syscall0(number: SYS) usize { \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) - : [number] "{g1}" (@enumToInt(number)) + : [ret] "={o0}" (-> usize), + : [number] "{g1}" (@enumToInt(number)), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -64,9 +64,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize { \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), - [arg1] "{o0}" (arg1) + [arg1] "{o0}" (arg1), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -78,10 +78,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), [arg1] "{o0}" (arg1), - [arg2] "{o1}" (arg2) + [arg2] "{o1}" (arg2), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -93,11 +93,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), - [arg3] "{o2}" (arg3) + [arg3] "{o2}" (arg3), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -109,12 +109,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), - [arg4] "{o3}" (arg4) + [arg4] "{o3}" (arg4), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -126,13 +126,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), [arg4] "{o3}" (arg4), - [arg5] "{o4}" (arg5) + [arg5] "{o4}" (arg5), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -152,14 +152,14 @@ pub fn syscall6( \\ nop \\ neg %%o0 \\ 1: - : [ret] "={o0}" (-> usize) + : [ret] "={o0}" (-> usize), : [number] "{g1}" (@enumToInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), [arg4] "{o3}" (arg4), [arg5] "{o4}" (arg5), - [arg6] "{o5}" (arg6) + [arg6] "{o5}" (arg6), : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" ); } @@ -174,7 +174,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.C) void { return asm volatile ("t 0x6d" : - : [number] "{g1}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{g1}" (@enumToInt(SYS.rt_sigreturn)), : "memory", "xcc", "o0", "o1", "o2", "o3", "o4", "o5", "o7" ); } diff --git a/lib/std/os/linux/start_pie.zig b/lib/std/os/linux/start_pie.zig index 19e1a29bc5..89dbeaf212 100644 --- a/lib/std/os/linux/start_pie.zig +++ b/lib/std/os/linux/start_pie.zig @@ -30,13 +30,13 @@ fn getDynamicSymbol() [*]elf.Dyn { \\ call 1f \\ 1: pop %[ret] \\ lea _DYNAMIC-1b(%[ret]), %[ret] - : [ret] "=r" (-> [*]elf.Dyn) + : [ret] "=r" (-> [*]elf.Dyn), ), .x86_64 => asm volatile ( \\ .weak _DYNAMIC \\ .hidden _DYNAMIC \\ lea _DYNAMIC(%%rip), %[ret] - : [ret] "=r" (-> [*]elf.Dyn) + : [ret] "=r" (-> [*]elf.Dyn), ), // Work around the limited offset range of `ldr` .arm => asm volatile ( @@ -47,7 +47,7 @@ fn getDynamicSymbol() [*]elf.Dyn { \\ b 2f \\ 1: .word _DYNAMIC-1b \\ 2: - : [ret] "=r" (-> [*]elf.Dyn) + : [ret] "=r" (-> [*]elf.Dyn), ), // A simple `adr` is not enough as it has a limited offset range .aarch64 => asm volatile ( @@ -55,13 +55,13 @@ fn getDynamicSymbol() [*]elf.Dyn { \\ .hidden _DYNAMIC \\ adrp %[ret], _DYNAMIC \\ add %[ret], %[ret], #:lo12:_DYNAMIC - : [ret] "=r" (-> [*]elf.Dyn) + : [ret] "=r" (-> [*]elf.Dyn), ), .riscv64 => asm volatile ( \\ .weak _DYNAMIC \\ .hidden _DYNAMIC \\ lla %[ret], _DYNAMIC - : [ret] "=r" (-> [*]elf.Dyn) + : [ret] "=r" (-> [*]elf.Dyn), ), else => { @compileError("PIE startup is not yet supported for this target!"); diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig index d965e4430e..e5d185b8c1 100644 --- a/lib/std/os/linux/thumb.zig +++ b/lib/std/os/linux/thumb.zig @@ -15,8 +15,8 @@ pub fn syscall0(number: SYS) usize { \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) - : [tmp] "{r1}" (buf) + : [ret] "={r0}" (-> usize), + : [tmp] "{r1}" (buf), : "memory" ); } @@ -30,9 +30,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize { \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r1}" (buf), - [arg1] "{r0}" (arg1) + [arg1] "{r0}" (arg1), : "memory" ); } @@ -46,10 +46,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r2}" (buf), [arg1] "{r0}" (arg1), - [arg2] "{r1}" (arg2) + [arg2] "{r1}" (arg2), : "memory" ); } @@ -63,11 +63,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r3}" (buf), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), - [arg3] "{r2}" (arg3) + [arg3] "{r2}" (arg3), : "memory" ); } @@ -81,12 +81,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r4}" (buf), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), - [arg4] "{r3}" (arg4) + [arg4] "{r3}" (arg4), : "memory" ); } @@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r5}" (buf), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), [arg4] "{r3}" (arg4), - [arg5] "{r4}" (arg5) + [arg5] "{r4}" (arg5), : "memory" ); } @@ -128,14 +128,14 @@ pub fn syscall6( \\ ldr r7, [%[tmp]] \\ svc #0 \\ ldr r7, [%[tmp], #4] - : [ret] "={r0}" (-> usize) + : [ret] "={r0}" (-> usize), : [tmp] "{r6}" (buf), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), [arg4] "{r3}" (arg4), [arg5] "{r4}" (arg5), - [arg6] "{r5}" (arg6) + [arg6] "{r5}" (arg6), : "memory" ); } @@ -148,7 +148,7 @@ pub fn restore() callconv(.Naked) void { \\ mov r7, %[number] \\ svc #0 : - : [number] "I" (@enumToInt(SYS.sigreturn)) + : [number] "I" (@enumToInt(SYS.sigreturn)), ); } @@ -157,7 +157,7 @@ pub fn restore_rt() callconv(.Naked) void { \\ mov r7, %[number] \\ svc #0 : - : [number] "I" (@enumToInt(SYS.rt_sigreturn)) + : [number] "I" (@enumToInt(SYS.rt_sigreturn)), : "memory" ); } diff --git a/lib/std/os/linux/tls.zig b/lib/std/os/linux/tls.zig index 47230cf786..d04bf24b5f 100644 --- a/lib/std/os/linux/tls.zig +++ b/lib/std/os/linux/tls.zig @@ -131,7 +131,7 @@ pub fn setThreadPointer(addr: usize) void { // Update the %gs selector asm volatile ("movl %[gs_val], %%gs" : - : [gs_val] "r" (gdt_entry_number << 3 | 3) + : [gs_val] "r" (gdt_entry_number << 3 | 3), ); }, .x86_64 => { @@ -142,7 +142,7 @@ pub fn setThreadPointer(addr: usize) void { asm volatile ( \\ msr tpidr_el0, %[addr] : - : [addr] "r" (addr) + : [addr] "r" (addr), ); }, .arm, .thumb => { @@ -153,7 +153,7 @@ pub fn setThreadPointer(addr: usize) void { asm volatile ( \\ mv tp, %[addr] : - : [addr] "r" (addr) + : [addr] "r" (addr), ); }, .mips, .mipsel => { @@ -164,21 +164,21 @@ pub fn setThreadPointer(addr: usize) void { asm volatile ( \\ mr 2, %[addr] : - : [addr] "r" (addr) + : [addr] "r" (addr), ); }, .powerpc64, .powerpc64le => { asm volatile ( \\ mr 13, %[addr] : - : [addr] "r" (addr) + : [addr] "r" (addr), ); }, .sparcv9 => { asm volatile ( \\ mov %[addr], %%g7 : - : [addr] "r" (addr) + : [addr] "r" (addr), ); }, else => @compileError("Unsupported architecture"), diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig index c403742d3d..7398c3afb6 100644 --- a/lib/std/os/linux/x86_64.zig +++ b/lib/std/os/linux/x86_64.zig @@ -2,63 +2,63 @@ usingnamespace @import("../bits/linux.zig"); pub fn syscall0(number: SYS) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) - : [number] "{rax}" (@enumToInt(number)) + : [ret] "={rax}" (-> usize), + : [number] "{rax}" (@enumToInt(number)), : "rcx", "r11", "memory" ); } pub fn syscall1(number: SYS, arg1: usize) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), - [arg1] "{rdi}" (arg1) + [arg1] "{rdi}" (arg1), : "rcx", "r11", "memory" ); } pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), [arg1] "{rdi}" (arg1), - [arg2] "{rsi}" (arg2) + [arg2] "{rsi}" (arg2), : "rcx", "r11", "memory" ); } pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), - [arg3] "{rdx}" (arg3) + [arg3] "{rdx}" (arg3), : "rcx", "r11", "memory" ); } pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), - [arg4] "{r10}" (arg4) + [arg4] "{r10}" (arg4), : "rcx", "r11", "memory" ); } pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), [arg4] "{r10}" (arg4), - [arg5] "{r8}" (arg5) + [arg5] "{r8}" (arg5), : "rcx", "r11", "memory" ); } @@ -73,14 +73,14 @@ pub fn syscall6( arg6: usize, ) usize { return asm volatile ("syscall" - : [ret] "={rax}" (-> usize) + : [ret] "={rax}" (-> usize), : [number] "{rax}" (@enumToInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), [arg4] "{r10}" (arg4), [arg5] "{r8}" (arg5), - [arg6] "{r9}" (arg6) + [arg6] "{r9}" (arg6), : "rcx", "r11", "memory" ); } @@ -93,7 +93,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.Naked) void { return asm volatile ("syscall" : - : [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)) + : [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)), : "rcx", "r11", "memory" ); } diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig index 6972de597c..cef4628edd 100644 --- a/lib/std/os/windows.zig +++ b/lib/std/os/windows.zig @@ -1723,15 +1723,15 @@ pub fn teb() *TEB { return switch (builtin.target.cpu.arch) { .i386 => asm volatile ( \\ movl %%fs:0x18, %[ptr] - : [ptr] "=r" (-> *TEB) + : [ptr] "=r" (-> *TEB), ), .x86_64 => asm volatile ( \\ movq %%gs:0x30, %[ptr] - : [ptr] "=r" (-> *TEB) + : [ptr] "=r" (-> *TEB), ), .aarch64 => asm volatile ( \\ mov %[ptr], x18 - : [ptr] "=r" (-> *TEB) + : [ptr] "=r" (-> *TEB), ), else => @compileError("unsupported arch"), }; diff --git a/lib/std/special/compiler_rt/clear_cache.zig b/lib/std/special/compiler_rt/clear_cache.zig index 033441acdb..fdc847e439 100644 --- a/lib/std/special/compiler_rt/clear_cache.zig +++ b/lib/std/special/compiler_rt/clear_cache.zig @@ -88,7 +88,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void { asm volatile ( \\mrs %[x], ctr_el0 \\ - : [x] "=r" (ctr_el0) + : [x] "=r" (ctr_el0), ); // The DC and IC instructions must use 64-bit registers so we don't use // 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 { while (addr < end) : (addr += dcache_line_size) { asm volatile ("dc cvau, %[addr]" : - : [addr] "r" (addr) + : [addr] "r" (addr), ); } } @@ -114,7 +114,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void { while (addr < end) : (addr += icache_line_size) { asm volatile ("ic ivau, %[addr]" : - : [addr] "r" (addr) + : [addr] "r" (addr), ); } } diff --git a/lib/std/start.zig b/lib/std/start.zig index a3035231df..f16a5aba1e 100644 --- a/lib/std/start.zig +++ b/lib/std/start.zig @@ -98,7 +98,7 @@ fn exit2(code: usize) noreturn { asm volatile ("syscall" : : [number] "{rax}" (231), - [arg1] "{rdi}" (code) + [arg1] "{rdi}" (code), : "rcx", "r11", "memory" ); }, @@ -106,7 +106,7 @@ fn exit2(code: usize) noreturn { asm volatile ("svc #0" : : [number] "{r7}" (1), - [arg1] "{r0}" (code) + [arg1] "{r0}" (code), : "memory" ); }, @@ -114,7 +114,7 @@ fn exit2(code: usize) noreturn { asm volatile ("svc #0" : : [number] "{x8}" (93), - [arg1] "{x0}" (code) + [arg1] "{x0}" (code), : "memory", "cc" ); }, @@ -128,7 +128,7 @@ fn exit2(code: usize) noreturn { \\push $0 \\syscall : - : [syscall_number] "{rbp}" (8) + : [syscall_number] "{rbp}" (8), : "rcx", "r11", "memory" ); }, @@ -137,7 +137,7 @@ fn exit2(code: usize) noreturn { .aarch64 => { asm volatile ("svc #0" : - : [exit] "{x0}" (0x08) + : [exit] "{x0}" (0x08), : "memory", "cc" ); }, @@ -208,34 +208,34 @@ fn _start() callconv(.Naked) noreturn { .x86_64 => { argc_argv_ptr = asm volatile ( \\ xor %%rbp, %%rbp - : [argc] "={rsp}" (-> [*]usize) + : [argc] "={rsp}" (-> [*]usize), ); }, .i386 => { argc_argv_ptr = asm volatile ( \\ xor %%ebp, %%ebp - : [argc] "={esp}" (-> [*]usize) + : [argc] "={esp}" (-> [*]usize), ); }, .aarch64, .aarch64_be, .arm, .armeb, .thumb => { argc_argv_ptr = asm volatile ( \\ mov fp, #0 \\ mov lr, #0 - : [argc] "={sp}" (-> [*]usize) + : [argc] "={sp}" (-> [*]usize), ); }, .riscv64 => { argc_argv_ptr = asm volatile ( \\ li s0, 0 \\ li ra, 0 - : [argc] "={sp}" (-> [*]usize) + : [argc] "={sp}" (-> [*]usize), ); }, .mips, .mipsel => { // The lr is already zeroed on entry, as specified by the ABI. argc_argv_ptr = asm volatile ( \\ move $fp, $0 - : [argc] "={sp}" (-> [*]usize) + : [argc] "={sp}" (-> [*]usize), ); }, .powerpc => { @@ -246,7 +246,7 @@ fn _start() callconv(.Naked) noreturn { \\ stwu 1,-16(1) \\ stw 0, 0(1) \\ mtlr 0 - : [argc] "={r4}" (-> [*]usize) + : [argc] "={r4}" (-> [*]usize), : : "r0" ); @@ -259,7 +259,7 @@ fn _start() callconv(.Naked) noreturn { \\ li 0, 0 \\ stdu 0, -32(1) \\ mtlr 0 - : [argc] "={r4}" (-> [*]usize) + : [argc] "={r4}" (-> [*]usize), : : "r0" ); @@ -269,7 +269,7 @@ fn _start() callconv(.Naked) noreturn { argc_argv_ptr = asm ( \\ mov %%g0, %%i6 \\ add %%o6, 2175, %[argc] - : [argc] "=r" (-> [*]usize) + : [argc] "=r" (-> [*]usize), ); }, else => @compileError("unsupported arch"), diff --git a/lib/std/valgrind.zig b/lib/std/valgrind.zig index b8ca05a4c7..91034fa03e 100644 --- a/lib/std/valgrind.zig +++ b/lib/std/valgrind.zig @@ -13,9 +13,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3: \\ roll $3, %%edi ; roll $13, %%edi \\ roll $29, %%edi ; roll $19, %%edi \\ xchgl %%ebx,%%ebx - : [_] "={edx}" (-> usize) + : [_] "={edx}" (-> usize), : [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }), - [_] "0" (default) + [_] "0" (default), : "cc", "memory" ); }, @@ -24,9 +24,9 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3: \\ rolq $3, %%rdi ; rolq $13, %%rdi \\ rolq $61, %%rdi ; rolq $51, %%rdi \\ xchgq %%rbx,%%rbx - : [_] "={rdx}" (-> usize) + : [_] "={rdx}" (-> usize), : [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }), - [_] "0" (default) + [_] "0" (default), : "cc", "memory" ); }, diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig index fed63ba21f..ff6ba8b63a 100644 --- a/lib/std/zig/parser_test.zig +++ b/lib/std/zig/parser_test.zig @@ -1,5 +1,5 @@ test "zig fmt: preserves clobbers in inline asm with stray comma" { - try testTransform( + try testCanonical( \\fn foo() void { \\ asm volatile ("" \\ : [_] "" (-> type), @@ -13,20 +13,6 @@ test "zig fmt: preserves clobbers in inline asm with stray comma" { \\ ); \\} \\ - , - \\fn foo() void { - \\ asm volatile ("" - \\ : [_] "" (-> type) - \\ : - \\ : "clobber" - \\ ); - \\ asm volatile ("" - \\ : - \\ : [_] "" (type) - \\ : "clobber" - \\ ); - \\} - \\ ); } @@ -508,15 +494,15 @@ test "zig fmt: asm expression with comptime content" { \\pub fn main() void { \\ asm volatile ("foo" ++ "bar"); \\ asm volatile ("foo" ++ "bar" - \\ : [_] "" (x) + \\ : [_] "" (x), \\ ); \\ asm volatile ("foo" ++ "bar" - \\ : [_] "" (x) - \\ : [_] "" (y) + \\ : [_] "" (x), + \\ : [_] "" (y), \\ ); \\ asm volatile ("foo" ++ "bar" - \\ : [_] "" (x) - \\ : [_] "" (y) + \\ : [_] "" (x), + \\ : [_] "" (y), \\ : "h", "e", "l", "l", "o" \\ ); \\} @@ -2058,11 +2044,11 @@ test "zig fmt: simple asm" { \\ ); \\ \\ asm ("not real assembly" - \\ : [a] "x" (x) + \\ : [a] "x" (x), \\ ); \\ asm ("not real assembly" - \\ : [a] "x" (-> i32) - \\ : [a] "x" (1) + \\ : [a] "x" (-> i32), + \\ : [a] "x" (1), \\ ); \\ asm ("still not real assembly" ::: "a", "b"); \\} @@ -3712,9 +3698,9 @@ test "zig fmt: inline asm" { try testCanonical( \\pub fn syscall1(number: usize, arg1: usize) usize { \\ return asm volatile ("syscall" - \\ : [ret] "={rax}" (-> usize) + \\ : [ret] "={rax}" (-> usize), \\ : [number] "{rax}" (number), - \\ [arg1] "{rdi}" (arg1) + \\ [arg1] "{rdi}" (arg1), \\ : "rcx", "r11" \\ ); \\} @@ -3817,14 +3803,14 @@ test "zig fmt: inline asm parameter alignment" { \\ \\ foo \\ \\ bar \\ : [_] "" (-> usize), - \\ [_] "" (-> usize) + \\ [_] "" (-> usize), \\ ); \\ asm volatile ( \\ \\ foo \\ \\ bar \\ : \\ : [_] "" (0), - \\ [_] "" (0) + \\ [_] "" (0), \\ ); \\ asm volatile ( \\ \\ foo @@ -3834,9 +3820,9 @@ test "zig fmt: inline asm parameter alignment" { \\ \\ foo \\ \\ bar \\ : [_] "" (-> usize), - \\ [_] "" (-> usize) + \\ [_] "" (-> usize), \\ : [_] "" (0), - \\ [_] "" (0) + \\ [_] "" (0), \\ : "", "" \\ ); \\} diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig index 71b071d6fb..eecb04b35c 100644 --- a/lib/std/zig/render.zig +++ b/lib/std/zig/render.zig @@ -1944,13 +1944,13 @@ fn renderAsm( try renderToken(ais, tree, comma, .newline); // , try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output)); } else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) { - try renderAsmOutput(gpa, ais, tree, asm_output, .newline); + try renderAsmOutput(gpa, ais, tree, asm_output, .comma); ais.popIndent(); ais.setIndentDelta(indent_delta); ais.popIndent(); return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen } else { - try renderAsmOutput(gpa, ais, tree, asm_output, .newline); + try renderAsmOutput(gpa, ais, tree, asm_output, .comma); const comma_or_colon = tree.lastToken(asm_output) + 1; ais.popIndent(); break :colon2 switch (token_tags[comma_or_colon]) { @@ -1976,13 +1976,13 @@ fn renderAsm( try renderToken(ais, tree, first_token - 1, .newline); // , try renderExtraNewlineToken(ais, tree, first_token); } else if (asm_node.first_clobber == null) { - try renderAsmInput(gpa, ais, tree, asm_input, .newline); + try renderAsmInput(gpa, ais, tree, asm_input, .comma); ais.popIndent(); ais.setIndentDelta(indent_delta); ais.popIndent(); return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen } else { - try renderAsmInput(gpa, ais, tree, asm_input, .newline); + try renderAsmInput(gpa, ais, tree, asm_input, .comma); const comma_or_colon = tree.lastToken(asm_input) + 1; ais.popIndent(); break :colon3 switch (token_tags[comma_or_colon]) { diff --git a/lib/std/zig/system/x86.zig b/lib/std/zig/system/x86.zig index 06a11c81ae..e9d1f0fcbc 100644 --- a/lib/std/zig/system/x86.zig +++ b/lib/std/zig/system/x86.zig @@ -543,7 +543,7 @@ fn cpuid(leaf_id: u32, subid: u32) CpuidLeaf { : : [leaf_id] "{eax}" (leaf_id), [subid] "{ecx}" (subid), - [leaf_ptr] "r" (&cpuid_leaf) + [leaf_ptr] "r" (&cpuid_leaf), : "eax", "ebx", "ecx", "edx" ); @@ -555,7 +555,7 @@ fn getXCR0() u32 { return asm volatile ( \\ xor %%ecx, %%ecx \\ xgetbv - : [ret] "={eax}" (-> u32) + : [ret] "={eax}" (-> u32), : : "eax", "edx", "ecx" ); diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig index c9bffa806d..4b52aff92b 100644 --- a/test/behavior/asm.zig +++ b/test/behavior/asm.zig @@ -23,12 +23,12 @@ test "output constraint modifiers" { // This is only testing compilation. var a: u32 = 3; asm volatile ("" - : [_] "=m,r" (a) + : [_] "=m,r" (a), : : "" ); asm volatile ("" - : [_] "=r,m" (a) + : [_] "=r,m" (a), : : "" ); @@ -38,8 +38,8 @@ test "alternative constraints" { // Make sure we allow commas as a separator for alternative constraints. var a: u32 = 3; asm volatile ("" - : [_] "=r,m" (a) - : [_] "r,m" (a) + : [_] "=r,m" (a), + : [_] "r,m" (a), : "" ); } @@ -47,42 +47,42 @@ test "alternative constraints" { test "sized integer/float in asm input" { asm volatile ("" : - : [_] "m" (@as(usize, 3)) + : [_] "m" (@as(usize, 3)), : "" ); asm volatile ("" : - : [_] "m" (@as(i15, -3)) + : [_] "m" (@as(i15, -3)), : "" ); asm volatile ("" : - : [_] "m" (@as(u3, 3)) + : [_] "m" (@as(u3, 3)), : "" ); asm volatile ("" : - : [_] "m" (@as(i3, 3)) + : [_] "m" (@as(i3, 3)), : "" ); asm volatile ("" : - : [_] "m" (@as(u121, 3)) + : [_] "m" (@as(u121, 3)), : "" ); asm volatile ("" : - : [_] "m" (@as(i121, 3)) + : [_] "m" (@as(i121, 3)), : "" ); asm volatile ("" : - : [_] "m" (@as(f32, 3.17)) + : [_] "m" (@as(f32, 3.17)), : "" ); asm volatile ("" : - : [_] "m" (@as(f64, 3.17)) + : [_] "m" (@as(f64, 3.17)), : "" ); } @@ -90,15 +90,15 @@ test "sized integer/float in asm input" { test "struct/array/union types as input values" { asm volatile ("" : - : [_] "m" (@as([1]u32, undefined)) + : [_] "m" (@as([1]u32, undefined)), ); // fails asm volatile ("" : - : [_] "m" (@as(struct { x: u32, y: u8 }, undefined)) + : [_] "m" (@as(struct { x: u32, y: u8 }, undefined)), ); // fails asm volatile ("" : - : [_] "m" (@as(union { x: u32, y: u8 }, undefined)) + : [_] "m" (@as(union { x: u32, y: u8 }, undefined)), ); // fails }