mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 14:23:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

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 \\ int $128
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.x86_64 => asm volatile ( .x86_64 => asm volatile (
@ -713,7 +713,7 @@ const LinuxThreadImpl = struct {
\\ syscall \\ syscall
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.arm, .armeb, .thumb, .thumbeb => asm volatile ( .arm, .armeb, .thumb, .thumbeb => asm volatile (
@ -726,7 +726,7 @@ const LinuxThreadImpl = struct {
\\ svc 0 \\ svc 0
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.aarch64, .aarch64_be, .aarch64_32 => asm volatile ( .aarch64, .aarch64_be, .aarch64_32 => asm volatile (
@ -739,7 +739,7 @@ const LinuxThreadImpl = struct {
\\ svc 0 \\ svc 0
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.mips, .mipsel => asm volatile ( .mips, .mipsel => asm volatile (
@ -753,7 +753,7 @@ const LinuxThreadImpl = struct {
\\ syscall \\ syscall
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.mips64, .mips64el => asm volatile ( .mips64, .mips64el => asm volatile (
@ -766,7 +766,7 @@ const LinuxThreadImpl = struct {
\\ syscall \\ syscall
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile ( .powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile (
@ -780,7 +780,7 @@ const LinuxThreadImpl = struct {
\\ blr \\ blr
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.riscv64 => asm volatile ( .riscv64 => asm volatile (
@ -793,7 +793,7 @@ const LinuxThreadImpl = struct {
\\ ecall \\ ecall
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
.sparcv9 => asm volatile ( .sparcv9 => asm volatile (
@ -821,7 +821,7 @@ const LinuxThreadImpl = struct {
\\ t 0x6d \\ t 0x6d
: :
: [ptr] "r" (@ptrToInt(self.mapped.ptr)), : [ptr] "r" (@ptrToInt(self.mapped.ptr)),
[len] "r" (self.mapped.len) [len] "r" (self.mapped.len),
: "memory" : "memory"
), ),
else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)), 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) { 2 => switch (op) {
.Set => asm volatile ("lock btsw %[bit], %[ptr]" .Set => asm volatile ("lock btsw %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Reset => asm volatile ("lock btrw %[bit], %[ptr]" .Reset => asm volatile ("lock btrw %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Toggle => asm volatile ("lock btcw %[bit], %[ptr]" .Toggle => asm volatile ("lock btcw %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
}, },
4 => switch (op) { 4 => switch (op) {
.Set => asm volatile ("lock btsl %[bit], %[ptr]" .Set => asm volatile ("lock btsl %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Reset => asm volatile ("lock btrl %[bit], %[ptr]" .Reset => asm volatile ("lock btrl %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Toggle => asm volatile ("lock btcl %[bit], %[ptr]" .Toggle => asm volatile ("lock btcl %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
}, },
8 => switch (op) { 8 => switch (op) {
.Set => asm volatile ("lock btsq %[bit], %[ptr]" .Set => asm volatile ("lock btsq %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Reset => asm volatile ("lock btrq %[bit], %[ptr]" .Reset => asm volatile ("lock btrq %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
.Toggle => asm volatile ("lock btcq %[bit], %[ptr]" .Toggle => asm volatile ("lock btcq %[bit], %[ptr]"
// LLVM doesn't support u1 flag register return values // LLVM doesn't support u1 flag register return values
: [result] "={@ccc}" (-> u8) : [result] "={@ccc}" (-> u8),
: [ptr] "*p" (&self.value), : [ptr] "*p" (&self.value),
[bit] "X" (@as(T, bit)) [bit] "X" (@as(T, bit)),
: "cc", "memory" : "cc", "memory"
), ),
}, },

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

@ -34,9 +34,9 @@ pub const Block = struct {
return Block{ return Block{
.repr = asm ( .repr = asm (
\\ vaesenc %[rk], %[in], %[out] \\ vaesenc %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec) : [out] "=x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (round_key.repr) [rk] "x" (round_key.repr),
), ),
}; };
} }
@ -46,9 +46,9 @@ pub const Block = struct {
return Block{ return Block{
.repr = asm ( .repr = asm (
\\ vaesenclast %[rk], %[in], %[out] \\ vaesenclast %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec) : [out] "=x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (round_key.repr) [rk] "x" (round_key.repr),
), ),
}; };
} }
@ -58,9 +58,9 @@ pub const Block = struct {
return Block{ return Block{
.repr = asm ( .repr = asm (
\\ vaesdec %[rk], %[in], %[out] \\ vaesdec %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec) : [out] "=x" (-> BlockVec),
: [in] "x" (block.repr), : [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{ return Block{
.repr = asm ( .repr = asm (
\\ vaesdeclast %[rk], %[in], %[out] \\ vaesdeclast %[rk], %[in], %[out]
: [out] "=x" (-> BlockVec) : [out] "=x" (-> BlockVec),
: [in] "x" (block.repr), : [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] \\ vpxor %[ts], %[r], %[r]
: [r] "=&x" (-> BlockVec), : [r] "=&x" (-> BlockVec),
[s] "=&x" (s), [s] "=&x" (s),
[ts] "=&x" (ts) [ts] "=&x" (ts),
: [rc] "n" (rc), : [rc] "n" (rc),
[t] "x" (t), [t] "x" (t),
[tx] "x" (tx), [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{ inv_round_keys[i] = Block{
.repr = asm ( .repr = asm (
\\ vaesimc %[rk], %[inv_rk] \\ vaesimc %[rk], %[inv_rk]
: [inv_rk] "=x" (-> BlockVec) : [inv_rk] "=x" (-> BlockVec),
: [rk] "x" (round_keys[rounds - i].repr) : [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 \\ aese %[out].16b, %[zero].16b
\\ aesmc %[out].16b, %[out].16b \\ aesmc %[out].16b, %[out].16b
\\ eor %[out].16b, %[out].16b, %[rk].16b \\ eor %[out].16b, %[out].16b, %[rk].16b
: [out] "=&x" (-> BlockVec) : [out] "=&x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (round_key.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 \\ mov %[out].16b, %[in].16b
\\ aese %[out].16b, %[zero].16b \\ aese %[out].16b, %[zero].16b
\\ eor %[out].16b, %[out].16b, %[rk].16b \\ eor %[out].16b, %[out].16b, %[rk].16b
: [out] "=&x" (-> BlockVec) : [out] "=&x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (round_key.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 \\ aesd %[out].16b, %[zero].16b
\\ aesimc %[out].16b, %[out].16b \\ aesimc %[out].16b, %[out].16b
\\ eor %[out].16b, %[out].16b, %[rk].16b \\ eor %[out].16b, %[out].16b, %[rk].16b
: [out] "=&x" (-> BlockVec) : [out] "=&x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (inv_round_key.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 \\ mov %[out].16b, %[in].16b
\\ aesd %[out].16b, %[zero].16b \\ aesd %[out].16b, %[zero].16b
\\ eor %[out].16b, %[out].16b, %[rk].16b \\ eor %[out].16b, %[out].16b, %[rk].16b
: [out] "=&x" (-> BlockVec) : [out] "=&x" (-> BlockVec),
: [in] "x" (block.repr), : [in] "x" (block.repr),
[rk] "x" (inv_round_key.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), [v1] "=&x" (v1),
[v2] "=&x" (v2), [v2] "=&x" (v2),
[v3] "=&x" (v3), [v3] "=&x" (v3),
[v4] "=&x" (v4) [v4] "=&x" (v4),
: [rc] "N" (rc), : [rc] "N" (rc),
[t] "x" (t), [t] "x" (t),
[zero] "x" (zero), [zero] "x" (zero),
[mask] "x" (mask1) [mask] "x" (mask1),
); );
} }
@ -240,12 +240,12 @@ fn KeySchedule(comptime Aes: type) type {
[v1] "=&x" (v1), [v1] "=&x" (v1),
[v2] "=&x" (v2), [v2] "=&x" (v2),
[v3] "=&x" (v3), [v3] "=&x" (v3),
[v4] "=&x" (v4) [v4] "=&x" (v4),
: [rc] "N" (if (second) @as(u8, 0) else rc), : [rc] "N" (if (second) @as(u8, 0) else rc),
[t] "x" (t), [t] "x" (t),
[tx] "x" (tx), [tx] "x" (tx),
[zero] "x" (zero), [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{ inv_round_keys[i] = Block{
.repr = asm ( .repr = asm (
\\ aesimc %[inv_rk].16b, %[rk].16b \\ aesimc %[inv_rk].16b, %[rk].16b
: [inv_rk] "=x" (-> BlockVec) : [inv_rk] "=x" (-> BlockVec),
: [rk] "x" (round_keys[rounds - i].repr) : [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 Vector = std.meta.Vector;
const product = asm ( const product = asm (
\\ vpclmulqdq $0x00, %[x], %[y], %[out] \\ vpclmulqdq $0x00, %[x], %[y], %[out]
: [out] "=x" (-> Vector(2, u64)) : [out] "=x" (-> Vector(2, u64)),
: [x] "x" (@bitCast(Vector(2, u64), @as(u128, x))), : [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]; return product[0];
} }
@ -105,9 +105,9 @@ pub const Ghash = struct {
const Vector = std.meta.Vector; const Vector = std.meta.Vector;
const product = asm ( const product = asm (
\\ pmull %[out].1q, %[x].1d, %[y].1d \\ 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))), : [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]; 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 { pub fn dumpStackPointerAddr(prefix: []const u8) void {
const sp = asm ("" const sp = asm (""
: [argc] "={rsp}" (-> usize) : [argc] "={rsp}" (-> usize),
); );
std.debug.warn("{} sp = 0x{x}\n", .{ prefix, sp }); 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 { pub fn doNotOptimizeAway(val: anytype) void {
asm volatile ("" asm volatile (""
: :
: [val] "rm" (val) : [val] "rm" (val),
: "memory" : "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 { pub fn syscall0(number: SYS) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)) : [number] "{r7}" (@enumToInt(number)),
: "memory" : "memory"
); );
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1) [arg1] "{r0}" (arg1),
: "memory" : "memory"
); );
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2) [arg2] "{r1}" (arg2),
: "memory" : "memory"
); );
} }
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3) [arg3] "{r2}" (arg3),
: "memory" : "memory"
); );
} }
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4) [arg4] "{r3}" (arg4),
: "memory" : "memory"
); );
} }
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4), [arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5) [arg5] "{r4}" (arg5),
: "memory" : "memory"
); );
} }
@ -73,14 +73,14 @@ pub fn syscall6(
arg6: usize, arg6: usize,
) usize { ) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [number] "{r7}" (@enumToInt(number)), : [number] "{r7}" (@enumToInt(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4), [arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5), [arg5] "{r4}" (arg5),
[arg6] "{r5}" (arg6) [arg6] "{r5}" (arg6),
: "memory" : "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 { pub fn restore() callconv(.Naked) void {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: :
: [number] "{r7}" (@enumToInt(SYS.sigreturn)) : [number] "{r7}" (@enumToInt(SYS.sigreturn)),
: "memory" : "memory"
); );
} }
@ -99,7 +99,7 @@ pub fn restore() callconv(.Naked) void {
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: :
: [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{r7}" (@enumToInt(SYS.rt_sigreturn)),
: "memory" : "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 { pub fn syscall0(number: SYS) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)) : [number] "{x8}" (@enumToInt(number)),
: "memory", "cc" : "memory", "cc"
); );
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1) [arg1] "{x0}" (arg1),
: "memory", "cc" : "memory", "cc"
); );
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2) [arg2] "{x1}" (arg2),
: "memory", "cc" : "memory", "cc"
); );
} }
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
[arg3] "{x2}" (arg3) [arg3] "{x2}" (arg3),
: "memory", "cc" : "memory", "cc"
); );
} }
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
[arg3] "{x2}" (arg3), [arg3] "{x2}" (arg3),
[arg4] "{x3}" (arg4) [arg4] "{x3}" (arg4),
: "memory", "cc" : "memory", "cc"
); );
} }
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
[arg3] "{x2}" (arg3), [arg3] "{x2}" (arg3),
[arg4] "{x3}" (arg4), [arg4] "{x3}" (arg4),
[arg5] "{x4}" (arg5) [arg5] "{x4}" (arg5),
: "memory", "cc" : "memory", "cc"
); );
} }
@ -73,14 +73,14 @@ pub fn syscall6(
arg6: usize, arg6: usize,
) usize { ) usize {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize) : [ret] "={x0}" (-> usize),
: [number] "{x8}" (@enumToInt(number)), : [number] "{x8}" (@enumToInt(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
[arg3] "{x2}" (arg3), [arg3] "{x2}" (arg3),
[arg4] "{x3}" (arg4), [arg4] "{x3}" (arg4),
[arg5] "{x4}" (arg5), [arg5] "{x4}" (arg5),
[arg6] "{x5}" (arg6) [arg6] "{x5}" (arg6),
: "memory", "cc" : "memory", "cc"
); );
} }
@ -93,7 +93,7 @@ pub const restore = restore_rt;
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: :
: [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{x8}" (@enumToInt(SYS.rt_sigreturn)),
: "memory", "cc" : "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 { pub fn syscall0(number: SYS) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)) : [number] "{eax}" (@enumToInt(number)),
: "memory" : "memory"
); );
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1) [arg1] "{ebx}" (arg1),
: "memory" : "memory"
); );
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2) [arg2] "{ecx}" (arg2),
: "memory" : "memory"
); );
} }
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
[arg3] "{edx}" (arg3) [arg3] "{edx}" (arg3),
: "memory" : "memory"
); );
} }
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
[arg3] "{edx}" (arg3), [arg3] "{edx}" (arg3),
[arg4] "{esi}" (arg4) [arg4] "{esi}" (arg4),
: "memory" : "memory"
); );
} }
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
[arg3] "{edx}" (arg3), [arg3] "{edx}" (arg3),
[arg4] "{esi}" (arg4), [arg4] "{esi}" (arg4),
[arg5] "{edi}" (arg5) [arg5] "{edi}" (arg5),
: "memory" : "memory"
); );
} }
@ -83,24 +83,24 @@ pub fn syscall6(
\\ int $0x80 \\ int $0x80
\\ pop %%ebp \\ pop %%ebp
\\ add $4, %%esp \\ add $4, %%esp
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(number)), : [number] "{eax}" (@enumToInt(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
[arg3] "{edx}" (arg3), [arg3] "{edx}" (arg3),
[arg4] "{esi}" (arg4), [arg4] "{esi}" (arg4),
[arg5] "{edi}" (arg5), [arg5] "{edi}" (arg5),
[arg6] "rm" (arg6) [arg6] "rm" (arg6),
: "memory" : "memory"
); );
} }
pub fn socketcall(call: usize, args: [*]usize) usize { pub fn socketcall(call: usize, args: [*]usize) usize {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize) : [ret] "={eax}" (-> usize),
: [number] "{eax}" (@enumToInt(SYS.socketcall)), : [number] "{eax}" (@enumToInt(SYS.socketcall)),
[arg1] "{ebx}" (call), [arg1] "{ebx}" (call),
[arg2] "{ecx}" (@ptrToInt(args)) [arg2] "{ecx}" (@ptrToInt(args)),
: "memory" : "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 { pub fn restore() callconv(.Naked) void {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: :
: [number] "{eax}" (@enumToInt(SYS.sigreturn)) : [number] "{eax}" (@enumToInt(SYS.sigreturn)),
: "memory" : "memory"
); );
} }
@ -119,7 +119,7 @@ pub fn restore() callconv(.Naked) void {
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: :
: [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{eax}" (@enumToInt(SYS.rt_sigreturn)),
: "memory" : "memory"
); );
} }

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

@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)) : [number] "{$2}" (@enumToInt(number)),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -25,9 +25,9 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
\\ sw $2, 0($4) \\ sw $2, 0($4)
\\ sw $3, 4($4) \\ sw $3, 4($4)
\\ 2: \\ 2:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(SYS.pipe)), : [number] "{$2}" (@enumToInt(SYS.pipe)),
[fd] "{$4}" (fd) [fd] "{$4}" (fd),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -38,9 +38,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1) [arg1] "{$4}" (arg1),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -51,10 +51,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2) [arg2] "{$5}" (arg2),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -65,11 +65,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
[arg3] "{$6}" (arg3) [arg3] "{$6}" (arg3),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -80,12 +80,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
[arg3] "{$6}" (arg3), [arg3] "{$6}" (arg3),
[arg4] "{$7}" (arg4) [arg4] "{$7}" (arg4),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
[arg3] "{$6}" (arg3), [arg3] "{$6}" (arg3),
[arg4] "{$7}" (arg4), [arg4] "{$7}" (arg4),
[arg5] "r" (arg5) [arg5] "r" (arg5),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -133,14 +133,14 @@ pub fn syscall6(
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
[arg3] "{$6}" (arg3), [arg3] "{$6}" (arg3),
[arg4] "{$7}" (arg4), [arg4] "{$7}" (arg4),
[arg5] "r" (arg5), [arg5] "r" (arg5),
[arg6] "r" (arg6) [arg6] "r" (arg6),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -166,7 +166,7 @@ pub fn syscall7(
\\ blez $7, 1f \\ blez $7, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize) : [ret] "={$2}" (-> usize),
: [number] "{$2}" (@enumToInt(number)), : [number] "{$2}" (@enumToInt(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
@ -174,7 +174,7 @@ pub fn syscall7(
[arg4] "{$7}" (arg4), [arg4] "{$7}" (arg4),
[arg5] "r" (arg5), [arg5] "r" (arg5),
[arg6] "r" (arg6), [arg6] "r" (arg6),
[arg7] "r" (arg7) [arg7] "r" (arg7),
: "memory", "cc", "$7" : "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 { pub fn restore() callconv(.Naked) void {
return asm volatile ("syscall" return asm volatile ("syscall"
: :
: [number] "{$2}" (@enumToInt(SYS.sigreturn)) : [number] "{$2}" (@enumToInt(SYS.sigreturn)),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }
@ -193,7 +193,7 @@ pub fn restore() callconv(.Naked) void {
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("syscall" return asm volatile ("syscall"
: :
: [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{$2}" (@enumToInt(SYS.rt_sigreturn)),
: "memory", "cc", "$7" : "memory", "cc", "$7"
); );
} }

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

@ -6,8 +6,8 @@ pub fn syscall0(number: SYS) usize {
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)) : [number] "{r0}" (@enumToInt(number)),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1) [arg1] "{r3}" (arg1),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2) [arg2] "{r4}" (arg2),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3) [arg3] "{r5}" (arg3),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4) [arg4] "{r6}" (arg4),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4), [arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5) [arg5] "{r7}" (arg5),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
); );
} }
@ -101,14 +101,14 @@ pub fn syscall6(
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4), [arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5), [arg5] "{r7}" (arg5),
[arg6] "{r8}" (arg6) [arg6] "{r8}" (arg6),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("sc" 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" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)) : [number] "{r0}" (@enumToInt(number)),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1) [arg1] "{r3}" (arg1),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2) [arg2] "{r4}" (arg2),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3) [arg3] "{r5}" (arg3),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4) [arg4] "{r6}" (arg4),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4), [arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5) [arg5] "{r7}" (arg5),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
); );
} }
@ -101,14 +101,14 @@ pub fn syscall6(
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize) : [ret] "={r3}" (-> usize),
: [number] "{r0}" (@enumToInt(number)), : [number] "{r0}" (@enumToInt(number)),
[arg1] "{r3}" (arg1), [arg1] "{r3}" (arg1),
[arg2] "{r4}" (arg2), [arg2] "{r4}" (arg2),
[arg3] "{r5}" (arg3), [arg3] "{r5}" (arg3),
[arg4] "{r6}" (arg4), [arg4] "{r6}" (arg4),
[arg5] "{r7}" (arg5), [arg5] "{r7}" (arg5),
[arg6] "{r8}" (arg6) [arg6] "{r8}" (arg6),
: "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" : "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 { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("sc" 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" : "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 { pub fn syscall0(number: SYS) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)) : [number] "{x17}" (@enumToInt(number)),
: "memory" : "memory"
); );
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1) [arg1] "{x10}" (arg1),
: "memory" : "memory"
); );
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2) [arg2] "{x11}" (arg2),
: "memory" : "memory"
); );
} }
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
[arg3] "{x12}" (arg3) [arg3] "{x12}" (arg3),
: "memory" : "memory"
); );
} }
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
[arg3] "{x12}" (arg3), [arg3] "{x12}" (arg3),
[arg4] "{x13}" (arg4) [arg4] "{x13}" (arg4),
: "memory" : "memory"
); );
} }
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
[arg3] "{x12}" (arg3), [arg3] "{x12}" (arg3),
[arg4] "{x13}" (arg4), [arg4] "{x13}" (arg4),
[arg5] "{x14}" (arg5) [arg5] "{x14}" (arg5),
: "memory" : "memory"
); );
} }
@ -73,14 +73,14 @@ pub fn syscall6(
arg6: usize, arg6: usize,
) usize { ) usize {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize) : [ret] "={x10}" (-> usize),
: [number] "{x17}" (@enumToInt(number)), : [number] "{x17}" (@enumToInt(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
[arg3] "{x12}" (arg3), [arg3] "{x12}" (arg3),
[arg4] "{x13}" (arg4), [arg4] "{x13}" (arg4),
[arg5] "{x14}" (arg5), [arg5] "{x14}" (arg5),
[arg6] "{x15}" (arg6) [arg6] "{x15}" (arg6),
: "memory" : "memory"
); );
} }
@ -92,7 +92,7 @@ pub const restore = restore_rt;
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("ecall" return asm volatile ("ecall"
: :
: [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{x17}" (@enumToInt(SYS.rt_sigreturn)),
: "memory" : "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] \\ st %%o1, [%%g3+4]
\\ clr %%o0 \\ clr %%o0
\\2: \\2:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(SYS.pipe)), : [number] "{g1}" (@enumToInt(SYS.pipe)),
[arg] "r" (fd) [arg] "r" (fd),
: "memory", "g3" : "memory", "g3"
); );
} }
@ -38,8 +38,8 @@ pub fn syscall_fork() usize {
\\ dec %%o1 \\ dec %%o1
\\ and %%o1, %%o0, %%o0 \\ and %%o1, %%o0, %%o0
\\ 2: \\ 2:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(SYS.fork)) : [number] "{g1}" (@enumToInt(SYS.fork)),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
); );
} }
@ -51,8 +51,8 @@ pub fn syscall0(number: SYS) usize {
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)) : [number] "{g1}" (@enumToInt(number)),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
); );
} }
@ -64,9 +64,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1) [arg1] "{o0}" (arg1),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
); );
} }
@ -78,10 +78,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2) [arg2] "{o1}" (arg2),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "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 \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
[arg3] "{o2}" (arg3) [arg3] "{o2}" (arg3),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "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 \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
[arg3] "{o2}" (arg3), [arg3] "{o2}" (arg3),
[arg4] "{o3}" (arg4) [arg4] "{o3}" (arg4),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "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 \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
[arg3] "{o2}" (arg3), [arg3] "{o2}" (arg3),
[arg4] "{o3}" (arg4), [arg4] "{o3}" (arg4),
[arg5] "{o4}" (arg5) [arg5] "{o4}" (arg5),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
); );
} }
@ -152,14 +152,14 @@ pub fn syscall6(
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize) : [ret] "={o0}" (-> usize),
: [number] "{g1}" (@enumToInt(number)), : [number] "{g1}" (@enumToInt(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
[arg3] "{o2}" (arg3), [arg3] "{o2}" (arg3),
[arg4] "{o3}" (arg4), [arg4] "{o3}" (arg4),
[arg5] "{o4}" (arg5), [arg5] "{o4}" (arg5),
[arg6] "{o5}" (arg6) [arg6] "{o5}" (arg6),
: "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7" : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
); );
} }
@ -174,7 +174,7 @@ pub const restore = restore_rt;
pub fn restore_rt() callconv(.C) void { pub fn restore_rt() callconv(.C) void {
return asm volatile ("t 0x6d" 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" : "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 \\ call 1f
\\ 1: pop %[ret] \\ 1: pop %[ret]
\\ lea _DYNAMIC-1b(%[ret]), %[ret] \\ lea _DYNAMIC-1b(%[ret]), %[ret]
: [ret] "=r" (-> [*]elf.Dyn) : [ret] "=r" (-> [*]elf.Dyn),
), ),
.x86_64 => asm volatile ( .x86_64 => asm volatile (
\\ .weak _DYNAMIC \\ .weak _DYNAMIC
\\ .hidden _DYNAMIC \\ .hidden _DYNAMIC
\\ lea _DYNAMIC(%%rip), %[ret] \\ lea _DYNAMIC(%%rip), %[ret]
: [ret] "=r" (-> [*]elf.Dyn) : [ret] "=r" (-> [*]elf.Dyn),
), ),
// Work around the limited offset range of `ldr` // Work around the limited offset range of `ldr`
.arm => asm volatile ( .arm => asm volatile (
@ -47,7 +47,7 @@ fn getDynamicSymbol() [*]elf.Dyn {
\\ b 2f \\ b 2f
\\ 1: .word _DYNAMIC-1b \\ 1: .word _DYNAMIC-1b
\\ 2: \\ 2:
: [ret] "=r" (-> [*]elf.Dyn) : [ret] "=r" (-> [*]elf.Dyn),
), ),
// A simple `adr` is not enough as it has a limited offset range // A simple `adr` is not enough as it has a limited offset range
.aarch64 => asm volatile ( .aarch64 => asm volatile (
@ -55,13 +55,13 @@ fn getDynamicSymbol() [*]elf.Dyn {
\\ .hidden _DYNAMIC \\ .hidden _DYNAMIC
\\ adrp %[ret], _DYNAMIC \\ adrp %[ret], _DYNAMIC
\\ add %[ret], %[ret], #:lo12:_DYNAMIC \\ add %[ret], %[ret], #:lo12:_DYNAMIC
: [ret] "=r" (-> [*]elf.Dyn) : [ret] "=r" (-> [*]elf.Dyn),
), ),
.riscv64 => asm volatile ( .riscv64 => asm volatile (
\\ .weak _DYNAMIC \\ .weak _DYNAMIC
\\ .hidden _DYNAMIC \\ .hidden _DYNAMIC
\\ lla %[ret], _DYNAMIC \\ lla %[ret], _DYNAMIC
: [ret] "=r" (-> [*]elf.Dyn) : [ret] "=r" (-> [*]elf.Dyn),
), ),
else => { else => {
@compileError("PIE startup is not yet supported for this target!"); @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]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r1}" (buf) : [tmp] "{r1}" (buf),
: "memory" : "memory"
); );
} }
@ -30,9 +30,9 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r1}" (buf), : [tmp] "{r1}" (buf),
[arg1] "{r0}" (arg1) [arg1] "{r0}" (arg1),
: "memory" : "memory"
); );
} }
@ -46,10 +46,10 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r2}" (buf), : [tmp] "{r2}" (buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2) [arg2] "{r1}" (arg2),
: "memory" : "memory"
); );
} }
@ -63,11 +63,11 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r3}" (buf), : [tmp] "{r3}" (buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3) [arg3] "{r2}" (arg3),
: "memory" : "memory"
); );
} }
@ -81,12 +81,12 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r4}" (buf), : [tmp] "{r4}" (buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4) [arg4] "{r3}" (arg4),
: "memory" : "memory"
); );
} }
@ -100,13 +100,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r5}" (buf), : [tmp] "{r5}" (buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4), [arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5) [arg5] "{r4}" (arg5),
: "memory" : "memory"
); );
} }
@ -128,14 +128,14 @@ pub fn syscall6(
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize) : [ret] "={r0}" (-> usize),
: [tmp] "{r6}" (buf), : [tmp] "{r6}" (buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
[arg3] "{r2}" (arg3), [arg3] "{r2}" (arg3),
[arg4] "{r3}" (arg4), [arg4] "{r3}" (arg4),
[arg5] "{r4}" (arg5), [arg5] "{r4}" (arg5),
[arg6] "{r5}" (arg6) [arg6] "{r5}" (arg6),
: "memory" : "memory"
); );
} }
@ -148,7 +148,7 @@ pub fn restore() callconv(.Naked) void {
\\ mov r7, %[number] \\ mov r7, %[number]
\\ svc #0 \\ 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] \\ mov r7, %[number]
\\ svc #0 \\ svc #0
: :
: [number] "I" (@enumToInt(SYS.rt_sigreturn)) : [number] "I" (@enumToInt(SYS.rt_sigreturn)),
: "memory" : "memory"
); );
} }

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

@ -131,7 +131,7 @@ pub fn setThreadPointer(addr: usize) void {
// Update the %gs selector // Update the %gs selector
asm volatile ("movl %[gs_val], %%gs" asm volatile ("movl %[gs_val], %%gs"
: :
: [gs_val] "r" (gdt_entry_number << 3 | 3) : [gs_val] "r" (gdt_entry_number << 3 | 3),
); );
}, },
.x86_64 => { .x86_64 => {
@ -142,7 +142,7 @@ pub fn setThreadPointer(addr: usize) void {
asm volatile ( asm volatile (
\\ msr tpidr_el0, %[addr] \\ msr tpidr_el0, %[addr]
: :
: [addr] "r" (addr) : [addr] "r" (addr),
); );
}, },
.arm, .thumb => { .arm, .thumb => {
@ -153,7 +153,7 @@ pub fn setThreadPointer(addr: usize) void {
asm volatile ( asm volatile (
\\ mv tp, %[addr] \\ mv tp, %[addr]
: :
: [addr] "r" (addr) : [addr] "r" (addr),
); );
}, },
.mips, .mipsel => { .mips, .mipsel => {
@ -164,21 +164,21 @@ pub fn setThreadPointer(addr: usize) void {
asm volatile ( asm volatile (
\\ mr 2, %[addr] \\ mr 2, %[addr]
: :
: [addr] "r" (addr) : [addr] "r" (addr),
); );
}, },
.powerpc64, .powerpc64le => { .powerpc64, .powerpc64le => {
asm volatile ( asm volatile (
\\ mr 13, %[addr] \\ mr 13, %[addr]
: :
: [addr] "r" (addr) : [addr] "r" (addr),
); );
}, },
.sparcv9 => { .sparcv9 => {
asm volatile ( asm volatile (
\\ mov %[addr], %%g7 \\ mov %[addr], %%g7
: :
: [addr] "r" (addr) : [addr] "r" (addr),
); );
}, },
else => @compileError("Unsupported architecture"), 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 { pub fn syscall0(number: SYS) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)) : [number] "{rax}" (@enumToInt(number)),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: usize) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1) [arg1] "{rdi}" (arg1),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2) [arg2] "{rsi}" (arg2),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize { pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
[arg3] "{rdx}" (arg3) [arg3] "{rdx}" (arg3),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize { pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
[arg3] "{rdx}" (arg3), [arg3] "{rdx}" (arg3),
[arg4] "{r10}" (arg4) [arg4] "{r10}" (arg4),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize { pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
[arg3] "{rdx}" (arg3), [arg3] "{rdx}" (arg3),
[arg4] "{r10}" (arg4), [arg4] "{r10}" (arg4),
[arg5] "{r8}" (arg5) [arg5] "{r8}" (arg5),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
@ -73,14 +73,14 @@ pub fn syscall6(
arg6: usize, arg6: usize,
) usize { ) usize {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize) : [ret] "={rax}" (-> usize),
: [number] "{rax}" (@enumToInt(number)), : [number] "{rax}" (@enumToInt(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
[arg3] "{rdx}" (arg3), [arg3] "{rdx}" (arg3),
[arg4] "{r10}" (arg4), [arg4] "{r10}" (arg4),
[arg5] "{r8}" (arg5), [arg5] "{r8}" (arg5),
[arg6] "{r9}" (arg6) [arg6] "{r9}" (arg6),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
} }
@ -93,7 +93,7 @@ pub const restore = restore_rt;
pub fn restore_rt() callconv(.Naked) void { pub fn restore_rt() callconv(.Naked) void {
return asm volatile ("syscall" return asm volatile ("syscall"
: :
: [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)) : [number] "{rax}" (@enumToInt(SYS.rt_sigreturn)),
: "rcx", "r11", "memory" : "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) { return switch (builtin.target.cpu.arch) {
.i386 => asm volatile ( .i386 => asm volatile (
\\ movl %%fs:0x18, %[ptr] \\ movl %%fs:0x18, %[ptr]
: [ptr] "=r" (-> *TEB) : [ptr] "=r" (-> *TEB),
), ),
.x86_64 => asm volatile ( .x86_64 => asm volatile (
\\ movq %%gs:0x30, %[ptr] \\ movq %%gs:0x30, %[ptr]
: [ptr] "=r" (-> *TEB) : [ptr] "=r" (-> *TEB),
), ),
.aarch64 => asm volatile ( .aarch64 => asm volatile (
\\ mov %[ptr], x18 \\ mov %[ptr], x18
: [ptr] "=r" (-> *TEB) : [ptr] "=r" (-> *TEB),
), ),
else => @compileError("unsupported arch"), 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 ( asm volatile (
\\mrs %[x], ctr_el0 \\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 // 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. // 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) { while (addr < end) : (addr += dcache_line_size) {
asm volatile ("dc cvau, %[addr]" 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) { while (addr < end) : (addr += icache_line_size) {
asm volatile ("ic ivau, %[addr]" 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" asm volatile ("syscall"
: :
: [number] "{rax}" (231), : [number] "{rax}" (231),
[arg1] "{rdi}" (code) [arg1] "{rdi}" (code),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
}, },
@ -106,7 +106,7 @@ fn exit2(code: usize) noreturn {
asm volatile ("svc #0" asm volatile ("svc #0"
: :
: [number] "{r7}" (1), : [number] "{r7}" (1),
[arg1] "{r0}" (code) [arg1] "{r0}" (code),
: "memory" : "memory"
); );
}, },
@ -114,7 +114,7 @@ fn exit2(code: usize) noreturn {
asm volatile ("svc #0" asm volatile ("svc #0"
: :
: [number] "{x8}" (93), : [number] "{x8}" (93),
[arg1] "{x0}" (code) [arg1] "{x0}" (code),
: "memory", "cc" : "memory", "cc"
); );
}, },
@ -128,7 +128,7 @@ fn exit2(code: usize) noreturn {
\\push $0 \\push $0
\\syscall \\syscall
: :
: [syscall_number] "{rbp}" (8) : [syscall_number] "{rbp}" (8),
: "rcx", "r11", "memory" : "rcx", "r11", "memory"
); );
}, },
@ -137,7 +137,7 @@ fn exit2(code: usize) noreturn {
.aarch64 => { .aarch64 => {
asm volatile ("svc #0" asm volatile ("svc #0"
: :
: [exit] "{x0}" (0x08) : [exit] "{x0}" (0x08),
: "memory", "cc" : "memory", "cc"
); );
}, },
@ -208,34 +208,34 @@ fn _start() callconv(.Naked) noreturn {
.x86_64 => { .x86_64 => {
argc_argv_ptr = asm volatile ( argc_argv_ptr = asm volatile (
\\ xor %%rbp, %%rbp \\ xor %%rbp, %%rbp
: [argc] "={rsp}" (-> [*]usize) : [argc] "={rsp}" (-> [*]usize),
); );
}, },
.i386 => { .i386 => {
argc_argv_ptr = asm volatile ( argc_argv_ptr = asm volatile (
\\ xor %%ebp, %%ebp \\ xor %%ebp, %%ebp
: [argc] "={esp}" (-> [*]usize) : [argc] "={esp}" (-> [*]usize),
); );
}, },
.aarch64, .aarch64_be, .arm, .armeb, .thumb => { .aarch64, .aarch64_be, .arm, .armeb, .thumb => {
argc_argv_ptr = asm volatile ( argc_argv_ptr = asm volatile (
\\ mov fp, #0 \\ mov fp, #0
\\ mov lr, #0 \\ mov lr, #0
: [argc] "={sp}" (-> [*]usize) : [argc] "={sp}" (-> [*]usize),
); );
}, },
.riscv64 => { .riscv64 => {
argc_argv_ptr = asm volatile ( argc_argv_ptr = asm volatile (
\\ li s0, 0 \\ li s0, 0
\\ li ra, 0 \\ li ra, 0
: [argc] "={sp}" (-> [*]usize) : [argc] "={sp}" (-> [*]usize),
); );
}, },
.mips, .mipsel => { .mips, .mipsel => {
// The lr is already zeroed on entry, as specified by the ABI. // The lr is already zeroed on entry, as specified by the ABI.
argc_argv_ptr = asm volatile ( argc_argv_ptr = asm volatile (
\\ move $fp, $0 \\ move $fp, $0
: [argc] "={sp}" (-> [*]usize) : [argc] "={sp}" (-> [*]usize),
); );
}, },
.powerpc => { .powerpc => {
@ -246,7 +246,7 @@ fn _start() callconv(.Naked) noreturn {
\\ stwu 1,-16(1) \\ stwu 1,-16(1)
\\ stw 0, 0(1) \\ stw 0, 0(1)
\\ mtlr 0 \\ mtlr 0
: [argc] "={r4}" (-> [*]usize) : [argc] "={r4}" (-> [*]usize),
: :
: "r0" : "r0"
); );
@ -259,7 +259,7 @@ fn _start() callconv(.Naked) noreturn {
\\ li 0, 0 \\ li 0, 0
\\ stdu 0, -32(1) \\ stdu 0, -32(1)
\\ mtlr 0 \\ mtlr 0
: [argc] "={r4}" (-> [*]usize) : [argc] "={r4}" (-> [*]usize),
: :
: "r0" : "r0"
); );
@ -269,7 +269,7 @@ fn _start() callconv(.Naked) noreturn {
argc_argv_ptr = asm ( argc_argv_ptr = asm (
\\ mov %%g0, %%i6 \\ mov %%g0, %%i6
\\ add %%o6, 2175, %[argc] \\ add %%o6, 2175, %[argc]
: [argc] "=r" (-> [*]usize) : [argc] "=r" (-> [*]usize),
); );
}, },
else => @compileError("unsupported arch"), 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 $3, %%edi ; roll $13, %%edi
\\ roll $29, %%edi ; roll $19, %%edi \\ roll $29, %%edi ; roll $19, %%edi
\\ xchgl %%ebx,%%ebx \\ xchgl %%ebx,%%ebx
: [_] "={edx}" (-> usize) : [_] "={edx}" (-> usize),
: [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }), : [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
[_] "0" (default) [_] "0" (default),
: "cc", "memory" : "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 $3, %%rdi ; rolq $13, %%rdi
\\ rolq $61, %%rdi ; rolq $51, %%rdi \\ rolq $61, %%rdi ; rolq $51, %%rdi
\\ xchgq %%rbx,%%rbx \\ xchgq %%rbx,%%rbx
: [_] "={rdx}" (-> usize) : [_] "={rdx}" (-> usize),
: [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }), : [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
[_] "0" (default) [_] "0" (default),
: "cc", "memory" : "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" { test "zig fmt: preserves clobbers in inline asm with stray comma" {
try testTransform( try testCanonical(
\\fn foo() void { \\fn foo() void {
\\ asm volatile ("" \\ asm volatile (""
\\ : [_] "" (-> type), \\ : [_] "" (-> 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 { \\pub fn main() void {
\\ asm volatile ("foo" ++ "bar"); \\ asm volatile ("foo" ++ "bar");
\\ asm volatile ("foo" ++ "bar" \\ asm volatile ("foo" ++ "bar"
\\ : [_] "" (x) \\ : [_] "" (x),
\\ ); \\ );
\\ asm volatile ("foo" ++ "bar" \\ asm volatile ("foo" ++ "bar"
\\ : [_] "" (x) \\ : [_] "" (x),
\\ : [_] "" (y) \\ : [_] "" (y),
\\ ); \\ );
\\ asm volatile ("foo" ++ "bar" \\ asm volatile ("foo" ++ "bar"
\\ : [_] "" (x) \\ : [_] "" (x),
\\ : [_] "" (y) \\ : [_] "" (y),
\\ : "h", "e", "l", "l", "o" \\ : "h", "e", "l", "l", "o"
\\ ); \\ );
\\} \\}
@ -2058,11 +2044,11 @@ test "zig fmt: simple asm" {
\\ ); \\ );
\\ \\
\\ asm ("not real assembly" \\ asm ("not real assembly"
\\ : [a] "x" (x) \\ : [a] "x" (x),
\\ ); \\ );
\\ asm ("not real assembly" \\ asm ("not real assembly"
\\ : [a] "x" (-> i32) \\ : [a] "x" (-> i32),
\\ : [a] "x" (1) \\ : [a] "x" (1),
\\ ); \\ );
\\ asm ("still not real assembly" ::: "a", "b"); \\ asm ("still not real assembly" ::: "a", "b");
\\} \\}
@ -3712,9 +3698,9 @@ test "zig fmt: inline asm" {
try testCanonical( try testCanonical(
\\pub fn syscall1(number: usize, arg1: usize) usize { \\pub fn syscall1(number: usize, arg1: usize) usize {
\\ return asm volatile ("syscall" \\ return asm volatile ("syscall"
\\ : [ret] "={rax}" (-> usize) \\ : [ret] "={rax}" (-> usize),
\\ : [number] "{rax}" (number), \\ : [number] "{rax}" (number),
\\ [arg1] "{rdi}" (arg1) \\ [arg1] "{rdi}" (arg1),
\\ : "rcx", "r11" \\ : "rcx", "r11"
\\ ); \\ );
\\} \\}
@ -3817,14 +3803,14 @@ test "zig fmt: inline asm parameter alignment" {
\\ \\ foo \\ \\ foo
\\ \\ bar \\ \\ bar
\\ : [_] "" (-> usize), \\ : [_] "" (-> usize),
\\ [_] "" (-> usize) \\ [_] "" (-> usize),
\\ ); \\ );
\\ asm volatile ( \\ asm volatile (
\\ \\ foo \\ \\ foo
\\ \\ bar \\ \\ bar
\\ : \\ :
\\ : [_] "" (0), \\ : [_] "" (0),
\\ [_] "" (0) \\ [_] "" (0),
\\ ); \\ );
\\ asm volatile ( \\ asm volatile (
\\ \\ foo \\ \\ foo
@ -3834,9 +3820,9 @@ test "zig fmt: inline asm parameter alignment" {
\\ \\ foo \\ \\ foo
\\ \\ bar \\ \\ bar
\\ : [_] "" (-> usize), \\ : [_] "" (-> usize),
\\ [_] "" (-> usize) \\ [_] "" (-> usize),
\\ : [_] "" (0), \\ : [_] "" (0),
\\ [_] "" (0) \\ [_] "" (0),
\\ : "", "" \\ : "", ""
\\ ); \\ );
\\} \\}

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

@ -1944,13 +1944,13 @@ fn renderAsm(
try renderToken(ais, tree, comma, .newline); // , try renderToken(ais, tree, comma, .newline); // ,
try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output)); try renderExtraNewlineToken(ais, tree, tree.firstToken(next_asm_output));
} else if (asm_node.inputs.len == 0 and asm_node.first_clobber == null) { } 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.popIndent();
ais.setIndentDelta(indent_delta); ais.setIndentDelta(indent_delta);
ais.popIndent(); ais.popIndent();
return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
} else { } 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; const comma_or_colon = tree.lastToken(asm_output) + 1;
ais.popIndent(); ais.popIndent();
break :colon2 switch (token_tags[comma_or_colon]) { break :colon2 switch (token_tags[comma_or_colon]) {
@ -1976,13 +1976,13 @@ fn renderAsm(
try renderToken(ais, tree, first_token - 1, .newline); // , try renderToken(ais, tree, first_token - 1, .newline); // ,
try renderExtraNewlineToken(ais, tree, first_token); try renderExtraNewlineToken(ais, tree, first_token);
} else if (asm_node.first_clobber == null) { } 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.popIndent();
ais.setIndentDelta(indent_delta); ais.setIndentDelta(indent_delta);
ais.popIndent(); ais.popIndent();
return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen return renderToken(ais, tree, asm_node.ast.rparen, space); // rparen
} else { } 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; const comma_or_colon = tree.lastToken(asm_input) + 1;
ais.popIndent(); ais.popIndent();
break :colon3 switch (token_tags[comma_or_colon]) { 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), : [leaf_id] "{eax}" (leaf_id),
[subid] "{ecx}" (subid), [subid] "{ecx}" (subid),
[leaf_ptr] "r" (&cpuid_leaf) [leaf_ptr] "r" (&cpuid_leaf),
: "eax", "ebx", "ecx", "edx" : "eax", "ebx", "ecx", "edx"
); );
@ -555,7 +555,7 @@ fn getXCR0() u32 {
return asm volatile ( return asm volatile (
\\ xor %%ecx, %%ecx \\ xor %%ecx, %%ecx
\\ xgetbv \\ xgetbv
: [ret] "={eax}" (-> u32) : [ret] "={eax}" (-> u32),
: :
: "eax", "edx", "ecx" : "eax", "edx", "ecx"
); );

30
test/behavior/asm.zig
View File

@ -23,12 +23,12 @@ test "output constraint modifiers" {
// This is only testing compilation. // This is only testing compilation.
var a: u32 = 3; var a: u32 = 3;
asm volatile ("" asm volatile (""
: [_] "=m,r" (a) : [_] "=m,r" (a),
: :
: "" : ""
); );
asm volatile ("" 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. // Make sure we allow commas as a separator for alternative constraints.
var a: u32 = 3; var a: u32 = 3;
asm volatile ("" 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" { test "sized integer/float in asm input" {
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(usize, 3)) : [_] "m" (@as(usize, 3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(i15, -3)) : [_] "m" (@as(i15, -3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(u3, 3)) : [_] "m" (@as(u3, 3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(i3, 3)) : [_] "m" (@as(i3, 3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(u121, 3)) : [_] "m" (@as(u121, 3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(i121, 3)) : [_] "m" (@as(i121, 3)),
: "" : ""
); );
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(f32, 3.17)) : [_] "m" (@as(f32, 3.17)),
: "" : ""
); );
asm volatile ("" 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" { test "struct/array/union types as input values" {
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as([1]u32, undefined)) : [_] "m" (@as([1]u32, undefined)),
); // fails ); // fails
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(struct { x: u32, y: u8 }, undefined)) : [_] "m" (@as(struct { x: u32, y: u8 }, undefined)),
); // fails ); // fails
asm volatile ("" asm volatile (""
: :
: [_] "m" (@as(union { x: u32, y: u8 }, undefined)) : [_] "m" (@as(union { x: u32, y: u8 }, undefined)),
); // fails ); // fails
} }