mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2025-12-06 13:54:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

zig fmt: respect trailing commas in inline assembly

Browse source
This commit is contained in:
jdmichaud 2021-08-29 11:57:32 +02:00 • committed by GitHub
parent 7b863aa8ac
commit 49c9975484
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
27 changed files with 293 additions and 307 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
lib/std/Thread.zig
View file

@ -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)),

36
lib/std/atomic/Atomic.zig
View file

@ -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"
),
},

24
lib/std/crypto/aes/aesni.zig
View file

@ -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),
),
};
}

28
lib/std/crypto/aes/armcrypto.zig
View file

@ -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),
),
};
}

8
lib/std/crypto/ghash.zig
View file

@ -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];
}

2
lib/std/debug.zig
View file

@ -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 });
}

2
lib/std/mem.zig
View file

@ -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"
);
}

32
lib/std/os/linux/arm-eabi.zig
View file

@ -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"
);
}

30
lib/std/os/linux/arm64.zig
View file

@ -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"
);
}

36
lib/std/os/linux/i386.zig
View file

@ -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"
);
}

40
lib/std/os/linux/mips.zig
View file

@ -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"
);
}

30
lib/std/os/linux/powerpc.zig
View file

@ -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"
);
}

30
lib/std/os/linux/powerpc64.zig
View file

@ -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"
);
}

30
lib/std/os/linux/riscv64.zig
View file

@ -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"
);
}

38
lib/std/os/linux/sparc64.zig
View file

@ -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"
);
}

10
lib/std/os/linux/start_pie.zig
View file

@ -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!");

32
lib/std/os/linux/thumb.zig
View file

@ -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"
);
}

12
lib/std/os/linux/tls.zig
View file

@ -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"),

30
lib/std/os/linux/x86_64.zig
View file

@ -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"
);
}

6
lib/std/os/windows.zig
View file

@ -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"),
};

6
lib/std/special/compiler_rt/clear_cache.zig
View file

@ -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),
);
}
}

26
lib/std/start.zig
View file

@ -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"),

8
lib/std/valgrind.zig
View file

@ -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"
);
},

44
lib/std/zig/parser_test.zig
View file

@ -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),
\\ : "", ""
\\ );
\\}

8
lib/std/zig/render.zig
View file

@ -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]) {

4
lib/std/zig/system/x86.zig
View file

@ -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"
);

30
test/behavior/asm.zig
View file

@ -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
}