zig fmt

17 files changed, 150 insertions, 300 deletions

diff --git a/lib/std/os/linux/aarch64.zig b/lib/std/os/linux/aarch64.zig
index cd3d1ab027..c0d1aabd08 100644
--- a/lib/std/os/linux/aarch64.zig
+++ b/lib/std/os/linux/aarch64.zig
@@ -18,8 +18,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("svc #0"
         : [ret] "={x0}" (-> usize),
         : [number] "{x8}" (@intFromEnum(number)),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -27,8 +26,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={x0}" (-> usize),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -37,8 +35,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -48,8 +45,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
           [arg3] "{x2}" (arg3),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -60,8 +56,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{x1}" (arg2),
           [arg3] "{x2}" (arg3),
           [arg4] "{x3}" (arg4),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -73,8 +68,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{x2}" (arg3),
           [arg4] "{x3}" (arg4),
           [arg5] "{x4}" (arg5),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn syscall6(
@@ -95,8 +89,7 @@ pub fn syscall6(
           [arg4] "{x3}" (arg4),
           [arg5] "{x4}" (arg5),
           [arg6] "{x5}" (arg6),
-        : "memory", "cc"
-    );
+        : .{ .memory = true, .cc = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -148,14 +141,12 @@ pub fn restore_rt() callconv(.naked) noreturn {
             \\ svc #0
             :
             : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory", "cc"
-        ),
+            : .{ .memory = true, .cc = true }),
         else => asm volatile (
             \\ svc #0
             :
             : [number] "{x8}" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory", "cc"
-        ),
+            : .{ .memory = true, .cc = true }),
     }
 }
 
diff --git a/lib/std/os/linux/arm.zig b/lib/std/os/linux/arm.zig
index ec7616fe82..1b9bc913f8 100644
--- a/lib/std/os/linux/arm.zig
+++ b/lib/std/os/linux/arm.zig
@@ -17,8 +17,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("svc #0"
         : [ret] "={r0}" (-> usize),
         : [number] "{r7}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -26,8 +25,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r0}" (-> usize),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -36,8 +34,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -47,8 +44,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -59,8 +55,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -72,8 +67,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -94,8 +88,7 @@ pub fn syscall6(
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
           [arg6] "{r5}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -141,14 +134,12 @@ pub fn restore() callconv(.naked) noreturn {
             \\ svc #0
             :
             : [number] "I" (@intFromEnum(SYS.sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
         else => asm volatile (
             \\ svc #0
             :
             : [number] "{r7}" (@intFromEnum(SYS.sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
     }
 }
 
@@ -159,14 +150,12 @@ pub fn restore_rt() callconv(.naked) noreturn {
             \\ svc #0
             :
             : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
         else => asm volatile (
             \\ svc #0
             :
             : [number] "{r7}" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
     }
 }
 
diff --git a/lib/std/os/linux/hexagon.zig b/lib/std/os/linux/hexagon.zig
index dcc19cd96b..a3acbee50b 100644
--- a/lib/std/os/linux/hexagon.zig
+++ b/lib/std/os/linux/hexagon.zig
@@ -15,8 +15,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("trap0(#1)"
         : [ret] "={r0}" (-> usize),
         : [number] "{r6}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -24,8 +23,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r0}" (-> usize),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -34,8 +32,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -45,8 +42,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -57,8 +53,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -70,8 +65,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -92,8 +86,7 @@ pub fn syscall6(
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
           [arg6] "{r5}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -142,8 +135,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ trap0(#0)
         :
         : [number] "{r6}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/loongarch64.zig b/lib/std/os/linux/loongarch64.zig
index 50c4664ac8..89863dda1c 100644
--- a/lib/std/os/linux/loongarch64.zig
+++ b/lib/std/os/linux/loongarch64.zig
@@ -17,8 +17,7 @@ pub fn syscall0(number: SYS) usize {
         \\ syscall 0
         : [ret] "={$r4}" (-> usize),
         : [number] "{$r11}" (@intFromEnum(number)),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -27,8 +26,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={$r4}" (-> usize),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -38,8 +36,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -50,8 +47,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
           [arg3] "{$r6}" (arg3),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -63,8 +59,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{$r5}" (arg2),
           [arg3] "{$r6}" (arg3),
           [arg4] "{$r7}" (arg4),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -77,8 +72,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{$r6}" (arg3),
           [arg4] "{$r7}" (arg4),
           [arg5] "{$r8}" (arg5),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn syscall6(
@@ -100,8 +94,7 @@ pub fn syscall6(
           [arg4] "{$r7}" (arg4),
           [arg5] "{$r8}" (arg5),
           [arg6] "{$r9}" (arg6),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -150,8 +143,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ syscall 0
         :
         : [number] "r" (@intFromEnum(SYS.rt_sigreturn)),
-        : "$t0", "$t1", "$t2", "$t3", "$t4", "$t5", "$t6", "$t7", "$t8", "memory"
-    );
+        : .{ .@"$t0" = true, .@"$t1" = true, .@"$t2" = true, .@"$t3" = true, .@"$t4" = true, .@"$t5" = true, .@"$t6" = true, .@"$t7" = true, .@"$t8" = true, .memory = true });
 }
 
 pub const msghdr = extern struct {
diff --git a/lib/std/os/linux/m68k.zig b/lib/std/os/linux/m68k.zig
index 0b89c329a8..fde03e3fa9 100644
--- a/lib/std/os/linux/m68k.zig
+++ b/lib/std/os/linux/m68k.zig
@@ -15,8 +15,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("trap #0"
         : [ret] "={d0}" (-> usize),
         : [number] "{d0}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -24,8 +23,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={d0}" (-> usize),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -34,8 +32,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -45,8 +42,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
           [arg3] "{d3}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -57,8 +53,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{d2}" (arg2),
           [arg3] "{d3}" (arg3),
           [arg4] "{d4}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -70,8 +65,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{d3}" (arg3),
           [arg4] "{d4}" (arg4),
           [arg5] "{d5}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -92,8 +86,7 @@ pub fn syscall6(
           [arg4] "{d4}" (arg4),
           [arg5] "{d5}" (arg5),
           [arg6] "{a0}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -155,8 +148,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
     asm volatile ("trap #0"
         :
         : [number] "{d0}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index b12854ea17..c720a03fac 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -21,8 +21,7 @@ pub fn syscall0(number: SYS) usize {
         \\ 1:
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(number)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall_pipe(fd: *[2]i32) usize {
@@ -41,8 +40,7 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
-        : "$1", "$3", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -55,8 +53,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
-        : "$1", "$3", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -70,8 +67,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
-        : "$1", "$3", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -86,8 +82,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
           [arg3] "{$6}" (arg3),
-        : "$1", "$3", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -103,8 +98,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{$5}" (arg2),
           [arg3] "{$6}" (arg3),
           [arg4] "{$7}" (arg4),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -125,8 +119,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{$6}" (arg3),
           [arg4] "{$7}" (arg4),
           [arg5] "r" (arg5),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 // NOTE: The o32 calling convention requires the callee to reserve 16 bytes for
@@ -160,8 +153,7 @@ pub fn syscall6(
           [arg4] "{$7}" (arg4),
           [arg5] "r" (arg5),
           [arg6] "r" (arg6),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall7(
@@ -195,8 +187,7 @@ pub fn syscall7(
           [arg5] "r" (arg5),
           [arg6] "r" (arg6),
           [arg7] "r" (arg7),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -255,8 +246,7 @@ pub fn restore() callconv(.naked) noreturn {
         \\ syscall
         :
         : [number] "{$2}" (@intFromEnum(SYS.sigreturn)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn restore_rt() callconv(.naked) noreturn {
@@ -264,8 +254,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ syscall
         :
         : [number] "{$2}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/mips64.zig b/lib/std/os/linux/mips64.zig
index 6e47f203a6..d2929d5d28 100644
--- a/lib/std/os/linux/mips64.zig
+++ b/lib/std/os/linux/mips64.zig
@@ -21,8 +21,7 @@ pub fn syscall0(number: SYS) usize {
         \\ 1:
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(number)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall_pipe(fd: *[2]i32) usize {
@@ -41,8 +40,7 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
-        : "$1", "$3", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -56,8 +54,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={$2}" (-> usize),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
-        : "$1", "$3", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -71,8 +68,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
-        : "$1", "$3", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -87,8 +83,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
           [arg3] "{$6}" (arg3),
-        : "$1", "$3", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -104,8 +99,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{$5}" (arg2),
           [arg3] "{$6}" (arg3),
           [arg4] "{$7}" (arg4),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -122,8 +116,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{$6}" (arg3),
           [arg4] "{$7}" (arg4),
           [arg5] "{$8}" (arg5),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall6(
@@ -149,8 +142,7 @@ pub fn syscall6(
           [arg4] "{$7}" (arg4),
           [arg5] "{$8}" (arg5),
           [arg6] "{$9}" (arg6),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn syscall7(
@@ -178,8 +170,7 @@ pub fn syscall7(
           [arg5] "{$8}" (arg5),
           [arg6] "{$9}" (arg6),
           [arg7] "{$10}" (arg7),
-        : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -234,8 +225,7 @@ pub fn restore() callconv(.naked) noreturn {
         \\ syscall
         :
         : [number] "{$2}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub fn restore_rt() callconv(.naked) noreturn {
@@ -243,8 +233,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ syscall
         :
         : [number] "{$2}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "$1", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24", "$25", "hi", "lo", "memory"
-    );
+        : .{ .@"$1" = true, .@"$3" = true, .@"$4" = true, .@"$5" = true, .@"$6" = true, .@"$7" = true, .@"$8" = true, .@"$9" = true, .@"$10" = true, .@"$11" = true, .@"$12" = true, .@"$13" = true, .@"$14" = true, .@"$15" = true, .@"$24" = true, .@"$25" = true, .hi = true, .lo = true, .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig
index 1fe4c8349f..018ea2309c 100644
--- a/lib/std/os/linux/powerpc.zig
+++ b/lib/std/os/linux/powerpc.zig
@@ -22,8 +22,7 @@ pub fn syscall0(number: SYS) usize {
         \\ 1:
         : [ret] "={r3}" (-> usize),
         : [number] "{r0}" (@intFromEnum(number)),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -35,8 +34,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r3}" (-> usize),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -49,8 +47,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -64,8 +61,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -80,8 +76,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -97,8 +92,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall6(
@@ -123,8 +117,7 @@ pub fn syscall6(
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
           [arg6] "{r8}" (arg6),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -204,8 +197,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ sc
         :
         : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig
index 88414b7207..d737738c4c 100644
--- a/lib/std/os/linux/powerpc64.zig
+++ b/lib/std/os/linux/powerpc64.zig
@@ -22,8 +22,7 @@ pub fn syscall0(number: SYS) usize {
         \\ 1:
         : [ret] "={r3}" (-> usize),
         : [number] "{r0}" (@intFromEnum(number)),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -35,8 +34,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r3}" (-> usize),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -49,8 +47,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -64,8 +61,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r3}" (arg1),
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -80,8 +76,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r4}" (arg2),
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -97,8 +92,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r5}" (arg3),
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn syscall6(
@@ -123,8 +117,7 @@ pub fn syscall6(
           [arg4] "{r6}" (arg4),
           [arg5] "{r7}" (arg5),
           [arg6] "{r8}" (arg6),
-        : "memory", "cr0", "r0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -189,8 +182,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ sc
         :
         : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory", "cr0", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
-    );
+        : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/riscv32.zig b/lib/std/os/linux/riscv32.zig
index bbe9fab8f0..31e97743dc 100644
--- a/lib/std/os/linux/riscv32.zig
+++ b/lib/std/os/linux/riscv32.zig
@@ -17,8 +17,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("ecall"
         : [ret] "={x10}" (-> usize),
         : [number] "{x17}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -26,8 +25,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={x10}" (-> usize),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -36,8 +34,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -47,8 +44,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
           [arg3] "{x12}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -59,8 +55,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{x11}" (arg2),
           [arg3] "{x12}" (arg3),
           [arg4] "{x13}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -72,8 +67,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{x12}" (arg3),
           [arg4] "{x13}" (arg4),
           [arg5] "{x14}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -94,8 +88,7 @@ pub fn syscall6(
           [arg4] "{x13}" (arg4),
           [arg5] "{x14}" (arg5),
           [arg6] "{x15}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -149,8 +142,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ ecall
         :
         : [number] "{x17}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index 5fea49b8e2..3498fb8fba 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -17,8 +17,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("ecall"
         : [ret] "={x10}" (-> usize),
         : [number] "{x17}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -26,8 +25,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={x10}" (-> usize),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -36,8 +34,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -47,8 +44,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
           [arg3] "{x12}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -59,8 +55,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{x11}" (arg2),
           [arg3] "{x12}" (arg3),
           [arg4] "{x13}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -72,8 +67,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{x12}" (arg3),
           [arg4] "{x13}" (arg4),
           [arg5] "{x14}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -94,8 +88,7 @@ pub fn syscall6(
           [arg4] "{x13}" (arg4),
           [arg5] "{x14}" (arg5),
           [arg6] "{x15}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -149,8 +142,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ ecall
         :
         : [number] "{x17}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/s390x.zig b/lib/std/os/linux/s390x.zig
index 614c33d076..50109aa35f 100644
--- a/lib/std/os/linux/s390x.zig
+++ b/lib/std/os/linux/s390x.zig
@@ -17,8 +17,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("svc 0"
         : [ret] "={r2}" (-> usize),
         : [number] "{r1}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -26,8 +25,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r2}" (-> usize),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -36,8 +34,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -47,8 +44,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
           [arg3] "{r4}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -59,8 +55,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r3}" (arg2),
           [arg3] "{r4}" (arg3),
           [arg4] "{r5}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -72,8 +67,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r4}" (arg3),
           [arg4] "{r5}" (arg4),
           [arg5] "{r6}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
@@ -86,8 +80,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg4] "{r5}" (arg4),
           [arg5] "{r6}" (arg5),
           [arg6] "{r7}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -161,8 +154,7 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\svc 0
         :
         : [number] "{r1}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig
index d34ca92368..1377343888 100644
--- a/lib/std/os/linux/sparc64.zig
+++ b/lib/std/os/linux/sparc64.zig
@@ -32,8 +32,7 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         : [ret] "={o0}" (-> usize),
         : [number] "{g1}" (@intFromEnum(SYS.pipe)),
           [arg] "r" (fd),
-        : "memory", "g3"
-    );
+        : .{ .memory = true, .g3 = true });
 }
 
 pub fn syscall_fork() usize {
@@ -55,8 +54,7 @@ pub fn syscall_fork() usize {
         \\ 2:
         : [ret] "={o0}" (-> usize),
         : [number] "{g1}" (@intFromEnum(SYS.fork)),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall0(number: SYS) usize {
@@ -68,8 +66,7 @@ pub fn syscall0(number: SYS) usize {
         \\ 1:
         : [ret] "={o0}" (-> usize),
         : [number] "{g1}" (@intFromEnum(number)),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -82,8 +79,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={o0}" (-> usize),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -97,8 +93,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -113,8 +108,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
           [arg3] "{o2}" (arg3),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -130,8 +124,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{o1}" (arg2),
           [arg3] "{o2}" (arg3),
           [arg4] "{o3}" (arg4),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -148,8 +141,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{o2}" (arg3),
           [arg4] "{o3}" (arg4),
           [arg5] "{o4}" (arg5),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn syscall6(
@@ -175,8 +167,7 @@ pub fn syscall6(
           [arg4] "{o3}" (arg4),
           [arg5] "{o4}" (arg5),
           [arg6] "{o5}" (arg6),
-        : "memory", "xcc", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -242,8 +233,7 @@ pub fn restore_rt() callconv(.c) void {
     return asm volatile ("t 0x6d"
         :
         : [number] "{g1}" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory", "xcc", "o0", "o1", "o2", "o3", "o4", "o5", "o7"
-    );
+        : .{ .memory = true, .xcc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
 pub const F = struct {
diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig
index 6816b47c26..5146355d77 100644
--- a/lib/std/os/linux/thumb.zig
+++ b/lib/std/os/linux/thumb.zig
@@ -18,8 +18,7 @@ pub fn syscall0(number: SYS) usize {
         \\ ldr r7, [%[tmp], #4]
         : [ret] "={r0}" (-> usize),
         : [tmp] "{r1}" (&buf),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -34,8 +33,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={r0}" (-> usize),
         : [tmp] "{r1}" (&buf),
           [arg1] "{r0}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -51,8 +49,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [tmp] "{r2}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -69,8 +66,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -88,8 +84,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{r1}" (arg2),
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -108,8 +103,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{r2}" (arg3),
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -137,8 +131,7 @@ pub fn syscall6(
           [arg4] "{r3}" (arg4),
           [arg5] "{r4}" (arg5),
           [arg6] "{r5}" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub const clone = @import("arm.zig").clone;
@@ -158,6 +151,5 @@ pub fn restore_rt() callconv(.naked) noreturn {
         \\ svc #0
         :
         : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
diff --git a/lib/std/os/linux/tls.zig b/lib/std/os/linux/tls.zig
index 3587512e65..4433727d9a 100644
--- a/lib/std/os/linux/tls.zig
+++ b/lib/std/os/linux/tls.zig
@@ -308,8 +308,7 @@ pub fn setThreadPointer(addr: usize) void {
                 \\ sar %%a0, %%r0
                 :
                 : [addr] "r" (addr),
-                : "r0"
-            );
+                : .{ .r0 = true });
         },
         .sparc, .sparc64 => {
             asm volatile (
diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig
index cc3932c899..8a2310ebed 100644
--- a/lib/std/os/linux/x86.zig
+++ b/lib/std/os/linux/x86.zig
@@ -18,8 +18,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("int $0x80"
         : [ret] "={eax}" (-> usize),
         : [number] "{eax}" (@intFromEnum(number)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -27,8 +26,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={eax}" (-> usize),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -37,8 +35,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -48,8 +45,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
           [arg3] "{edx}" (arg3),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -60,8 +56,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{ecx}" (arg2),
           [arg3] "{edx}" (arg3),
           [arg4] "{esi}" (arg4),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -73,8 +68,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{edx}" (arg3),
           [arg4] "{esi}" (arg4),
           [arg5] "{edi}" (arg5),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn syscall6(
@@ -108,8 +102,7 @@ pub fn syscall6(
           [arg4] "{esi}" (arg4),
           [arg5] "rm" (arg5),
           [arg6] "rm" (arg6),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn socketcall(call: usize, args: [*]const usize) usize {
@@ -118,8 +111,7 @@ pub fn socketcall(call: usize, args: [*]const usize) usize {
         : [number] "{eax}" (@intFromEnum(SYS.socketcall)),
           [arg1] "{ebx}" (call),
           [arg2] "{ecx}" (@intFromPtr(args)),
-        : "memory"
-    );
+        : .{ .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -179,14 +171,12 @@ pub fn restore() callconv(.naked) noreturn {
             \\ int $0x80
             :
             : [number] "i" (@intFromEnum(SYS.sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
         else => asm volatile (
             \\ int $0x80
             :
             : [number] "{eax}" (@intFromEnum(SYS.sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
     }
 }
 
@@ -197,14 +187,12 @@ pub fn restore_rt() callconv(.naked) noreturn {
             \\ int $0x80
             :
             : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
         else => asm volatile (
             \\ int $0x80
             :
             : [number] "{eax}" (@intFromEnum(SYS.rt_sigreturn)),
-            : "memory"
-        ),
+            : .{ .memory = true }),
     }
 }
 
@@ -442,8 +430,7 @@ pub fn getContextInternal() callconv(.naked) usize {
           [sigprocmask] "i" (@intFromEnum(linux.SYS.rt_sigprocmask)),
           [sigmask_offset] "i" (@offsetOf(ucontext_t, "sigmask")),
           [sigset_size] "i" (linux.NSIG / 8),
-        : "cc", "memory", "eax", "ecx", "edx"
-    );
+        : .{ .cc = true, .memory = true, .eax = true, .ecx = true, .edx = true });
 }
 
 pub inline fn getcontext(context: *ucontext_t) usize {
@@ -457,6 +444,5 @@ pub inline fn getcontext(context: *ucontext_t) usize {
           [_] "={edx}" (clobber_edx),
         : [_] "{edx}" (context),
           [getContextInternal] "X" (&getContextInternal),
-        : "cc", "memory", "ecx"
-    );
+        : .{ .cc = true, .memory = true, .ecx = true });
 }
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index bd08c3f147..cf9714dd13 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -20,8 +20,7 @@ pub fn syscall0(number: SYS) usize {
     return asm volatile ("syscall"
         : [ret] "={rax}" (-> usize),
         : [number] "{rax}" (@intFromEnum(number)),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall1(number: SYS, arg1: usize) usize {
@@ -29,8 +28,7 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         : [ret] "={rax}" (-> usize),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
@@ -39,8 +37,7 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
@@ -50,8 +47,7 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
           [arg3] "{rdx}" (arg3),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
@@ -62,8 +58,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
           [arg2] "{rsi}" (arg2),
           [arg3] "{rdx}" (arg3),
           [arg4] "{r10}" (arg4),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
@@ -75,8 +70,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
           [arg3] "{rdx}" (arg3),
           [arg4] "{r10}" (arg4),
           [arg5] "{r8}" (arg5),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn syscall6(
@@ -97,8 +91,7 @@ pub fn syscall6(
           [arg4] "{r10}" (arg4),
           [arg5] "{r8}" (arg5),
           [arg6] "{r9}" (arg6),
-        : "rcx", "r11", "memory"
-    );
+        : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
 pub fn clone() callconv(.naked) usize {
@@ -144,14 +137,12 @@ pub fn restore_rt() callconv(.naked) noreturn {
             \\ syscall
             :
             : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
-            : "rcx", "r11", "memory"
-        ),
+            : .{ .rcx = true, .r11 = true, .memory = true }),
         else => asm volatile (
             \\ syscall
             :
             : [number] "{rax}" (@intFromEnum(SYS.rt_sigreturn)),
-            : "rcx", "r11", "memory"
-        ),
+            : .{ .rcx = true, .r11 = true, .memory = true }),
     }
 }
 
@@ -440,8 +431,7 @@ fn getContextInternal() callconv(.naked) usize {
           [sigprocmask] "i" (@intFromEnum(linux.SYS.rt_sigprocmask)),
           [sigmask_offset] "i" (@offsetOf(ucontext_t, "sigmask")),
           [sigset_size] "i" (@sizeOf(sigset_t)),
-        : "cc", "memory", "rax", "rcx", "rdx", "rdi", "rsi", "r8", "r10", "r11"
-    );
+        : .{ .cc = true, .memory = true, .rax = true, .rcx = true, .rdx = true, .rdi = true, .rsi = true, .r8 = true, .r10 = true, .r11 = true });
 }
 
 pub inline fn getcontext(context: *ucontext_t) usize {
@@ -455,6 +445,5 @@ pub inline fn getcontext(context: *ucontext_t) usize {
           [_] "={rdi}" (clobber_rdi),
         : [_] "{rdi}" (context),
           [getContextInternal] "X" (&getContextInternal),
-        : "cc", "memory", "rcx", "rdx", "rsi", "r8", "r10", "r11"
-    );
+        : .{ .cc = true, .memory = true, .rcx = true, .rdx = true, .rsi = true, .r8 = true, .r10 = true, .r11 = true });
 }