Commit 49c9975484
Changed files (27)
lib
std
atomic
crypto
os
special
compiler_rt
zig
test
behavior
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"
),
},
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),
),
};
}
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),
),
};
}
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];
}
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"
);
}
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"
);
}
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"
);
}
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"
);
}
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"
);
}
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"
);
}
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"
);
}
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"
);
}
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!");
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"
);
}
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"),
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"
);
}
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"),
};
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),
);
}
}
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"
);
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),
\\ : "", ""
\\ );
\\}
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]) {
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 });
}
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"
);
}
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"),
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)),
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"
);
},
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
}