std.os.linux: replace usize/isize in arch bits with fixed types for clarity

16 files changed, 432 insertions, 432 deletions

diff --git a/lib/std/os/linux/aarch64.zig b/lib/std/os/linux/aarch64.zig
index 771d1126e7..5f3d68549e 100644
--- a/lib/std/os/linux/aarch64.zig
+++ b/lib/std/os/linux/aarch64.zig
@@ -14,33 +14,33 @@ const stack_t = linux.stack_t;
 const sigset_t = linux.sigset_t;
 const timespec = std.os.linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -73,15 +73,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -92,7 +92,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         x0,   x1,    w2,    x3,  x4,   x5,  x6
     //
@@ -192,12 +192,12 @@ pub const Flock = extern struct {
 
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i64;
 pub const mode_t = u32;
-pub const off_t = isize;
-pub const ino_t = usize;
-pub const dev_t = usize;
-pub const blkcnt_t = isize;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+pub const blkcnt_t = i64;
 
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
@@ -208,7 +208,7 @@ pub const Stat = extern struct {
     uid: uid_t,
     gid: gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u64,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
diff --git a/lib/std/os/linux/arm.zig b/lib/std/os/linux/arm.zig
index 4689bf8be2..15c371c53c 100644
--- a/lib/std/os/linux/arm.zig
+++ b/lib/std/os/linux/arm.zig
@@ -13,33 +13,33 @@ const pid_t = linux.pid_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -91,7 +91,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         r0,   r1,    r2,    r3,  +0,   +4,  +8
     //
@@ -228,7 +228,7 @@ pub const Flock = extern struct {
 
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
diff --git a/lib/std/os/linux/hexagon.zig b/lib/std/os/linux/hexagon.zig
index 230b6ad88d..c42de2ac25 100644
--- a/lib/std/os/linux/hexagon.zig
+++ b/lib/std/os/linux/hexagon.zig
@@ -13,33 +13,33 @@ const stack_t = linux.stack_t;
 const sigset_t = linux.sigset_t;
 const timespec = std.os.linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -91,7 +91,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         r0,   r1,    r2,    r3,  r4,   r5,  +0
     //
diff --git a/lib/std/os/linux/loongarch64.zig b/lib/std/os/linux/loongarch64.zig
index 7fc226bb90..da2caa3d06 100644
--- a/lib/std/os/linux/loongarch64.zig
+++ b/lib/std/os/linux/loongarch64.zig
@@ -12,37 +12,37 @@ const sockaddr = linux.sockaddr;
 const socklen_t = linux.socklen_t;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -50,10 +50,10 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -62,10 +62,10 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -77,16 +77,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -97,7 +97,7 @@ pub fn syscall6(
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //           a0,    a1,    a2,  a3,   a4,  a5,   a6
     // sys_clone(flags, stack, ptid, ctid, tls)
diff --git a/lib/std/os/linux/m68k.zig b/lib/std/os/linux/m68k.zig
index 16008053e1..9febdc3087 100644
--- a/lib/std/os/linux/m68k.zig
+++ b/lib/std/os/linux/m68k.zig
@@ -11,33 +11,33 @@ const sockaddr = linux.sockaddr;
 const socklen_t = linux.socklen_t;
 const timespec = std.os.linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -45,9 +45,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -56,9 +56,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -70,15 +70,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -89,7 +89,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         +4,   +8,    +12,   +16, +20,  +24, +28
     //
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index dd67a853f2..3e16042ea0 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -14,19 +14,19 @@ const sigset_t = linux.sigset_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
         : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u32 {
     return asm volatile (
         \\ .set noat
         \\ .set noreorder
@@ -39,47 +39,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ sw $2, 0($4)
         \\ sw $3, 4($4)
         \\ 2:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
         : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -87,14 +87,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -103,7 +103,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 24
@@ -114,7 +114,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -129,13 +129,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 24
@@ -147,7 +147,7 @@ pub fn syscall6(
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -160,14 +160,14 @@ pub fn syscall6(
 
 pub fn syscall7(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-    arg7: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+    arg7: u32,
+) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 32
@@ -180,7 +180,7 @@ pub fn syscall7(
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -192,7 +192,7 @@ pub fn syscall7(
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
diff --git a/lib/std/os/linux/mips64.zig b/lib/std/os/linux/mips64.zig
index 4fc77d0fe1..477fb32c61 100644
--- a/lib/std/os/linux/mips64.zig
+++ b/lib/std/os/linux/mips64.zig
@@ -14,19 +14,19 @@ const sigset_t = linux.sigset_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
         : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u64 {
     return asm volatile (
         \\ .set noat
         \\ .set noreorder
@@ -39,13 +39,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ sw $2, 0($4)
         \\ sw $3, 4($4)
         \\ 2:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
@@ -53,34 +53,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         \\ nop
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
         : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -88,14 +88,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -104,14 +104,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -123,20 +123,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -149,21 +149,21 @@ pub fn syscall6(
 
 pub fn syscall7(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-    arg7: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+    arg7: u64,
+) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -175,7 +175,7 @@ pub fn syscall7(
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig
index 7ebfe3d69e..d79bcf5e94 100644
--- a/lib/std/os/linux/powerpc.zig
+++ b/lib/std/os/linux/powerpc.zig
@@ -14,48 +14,48 @@ const sigset_t = linux.sigset_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     // r0 is both an input register and a clobber. musl and glibc achieve this with
     // a "+" constraint, which isn't supported in Zig, so instead we separately list
     // r0 as both an input and an output. (Listing it as an input and a clobber would
     // cause the C backend to emit invalid code; see #25209.)
-    var r0_out: usize = undefined;
+    var r0_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     // r0 is both an input and a clobber.
-    var r0_out: usize = undefined;
+    var r0_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
         : [number] "{r0}" (@intFromEnum(number)),
@@ -64,17 +64,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -85,18 +85,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -109,19 +109,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
+    var r7_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -138,26 +138,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
-    var r8_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
+    var r7_out: u32 = undefined;
+    var r8_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -174,7 +174,7 @@ pub fn syscall6(
         : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
@@ -303,7 +303,7 @@ pub const Flock = extern struct {
 
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig
index fa8ab5e238..14c2f47bc7 100644
--- a/lib/std/os/linux/powerpc64.zig
+++ b/lib/std/os/linux/powerpc64.zig
@@ -14,48 +14,48 @@ const sigset_t = linux.sigset_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     // r0 is both an input register and a clobber. musl and glibc achieve this with
     // a "+" constraint, which isn't supported in Zig, so instead we separately list
     // r0 as both an input and an output. (Listing it as an input and a clobber would
     // cause the C backend to emit invalid code; see #25209.)
-    var r0_out: usize = undefined;
+    var r0_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     // r0 is both an input and a clobber.
-    var r0_out: usize = undefined;
+    var r0_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
         : [number] "{r0}" (@intFromEnum(number)),
@@ -64,17 +64,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -85,18 +85,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -109,19 +109,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
+    var r7_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -138,26 +138,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
-    var r8_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
+    var r7_out: u64 = undefined;
+    var r8_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -174,7 +174,7 @@ pub fn syscall6(
         : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
diff --git a/lib/std/os/linux/riscv32.zig b/lib/std/os/linux/riscv32.zig
index 760af2c489..896dbb456b 100644
--- a/lib/std/os/linux/riscv32.zig
+++ b/lib/std/os/linux/riscv32.zig
@@ -13,33 +13,33 @@ const sockaddr = linux.sockaddr;
 const socklen_t = linux.socklen_t;
 const timespec = std.os.linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -91,7 +91,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         a0,   a1,    a2,    a3,  a4,   a5,  a6
     //
@@ -186,7 +186,7 @@ pub const Stat = extern struct {
     uid: uid_t,
     gid: gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u32,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index 05b8adca68..6091c386ff 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -13,33 +13,33 @@ const sockaddr = linux.sockaddr;
 const socklen_t = linux.socklen_t;
 const timespec = std.os.linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -91,7 +91,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         a0,   a1,    a2,    a3,  a4,   a5,  a6
     //
@@ -186,7 +186,7 @@ pub const Stat = extern struct {
     uid: uid_t,
     gid: gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u64,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
diff --git a/lib/std/os/linux/s390x.zig b/lib/std/os/linux/s390x.zig
index aade6d9d2f..fc1e79db85 100644
--- a/lib/std/os/linux/s390x.zig
+++ b/lib/std/os/linux/s390x.zig
@@ -13,33 +13,33 @@ const timespec = std.os.linux.timespec;
 const stack_t = std.os.linux.stack_t;
 const sigset_t = std.os.linux.sigset_t;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -70,9 +70,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         : .{ .memory = true });
 }
 
-pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
+pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -83,7 +83,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     asm volatile (
         \\# int clone(
         \\#    fn,      a = r2
diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig
index bb8c748960..7365d85c76 100644
--- a/lib/std/os/linux/sparc64.zig
+++ b/lib/std/os/linux/sparc64.zig
@@ -15,7 +15,7 @@ const iovec = std.posix.iovec;
 const iovec_const = std.posix.iovec_const;
 const timespec = linux.timespec;
 
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u64 {
     return asm volatile (
         \\ mov %[arg], %%g3
         \\ t 0x6d
@@ -29,13 +29,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ st %%o1, [%%g3+4]
         \\ clr %%o0
         \\2:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(SYS.pipe)),
           [arg] "r" (fd),
         : .{ .memory = true, .g3 = true });
 }
 
-pub fn syscall_fork() usize {
+pub fn syscall_fork() u64 {
     // Linux/sparc64 fork() returns two values in %o0 and %o1:
     // - On the parent's side, %o0 is the child's PID and %o1 is 0.
     // - On the child's side, %o0 is the parent's PID and %o1 is 1.
@@ -52,58 +52,58 @@ pub fn syscall_fork() usize {
         \\ dec %%o1
         \\ and %%o1, %%o0, %%o0
         \\ 2:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(SYS.fork)),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
         : .{ .memory = true, .icc = 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 {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -111,14 +111,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .icc = 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 {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -127,14 +127,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .icc = 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 {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -146,20 +146,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -170,7 +170,7 @@ pub fn syscall6(
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         i0,   i1,    i2,    i3,  i4,   i5,  sp
     //
@@ -274,12 +274,12 @@ pub const Flock = extern struct {
 
 pub const off_t = i64;
 pub const ino_t = u64;
-pub const time_t = isize;
+pub const time_t = i64;
 pub const mode_t = u32;
-pub const dev_t = usize;
+pub const dev_t = u64;
 pub const nlink_t = u32;
-pub const blksize_t = isize;
-pub const blkcnt_t = isize;
+pub const blksize_t = i64;
+pub const blkcnt_t = i64;
 
 // The `stat64` definition used by the kernel.
 pub const Stat = extern struct {
diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig
index 4f5566acf4..cd0daec4d9 100644
--- a/lib/std/os/linux/thumb.zig
+++ b/lib/std/os/linux/thumb.zig
@@ -7,53 +7,53 @@ const std = @import("../../std.zig");
 const linux = std.os.linux;
 const SYS = linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall0(number: SYS) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r1}" (&buf),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r1}" (&buf),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r2}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r3}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -61,14 +61,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r4}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -77,14 +77,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r5}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -96,20 +96,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r6}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig
index aa94ad6a63..4f72c3cc63 100644
--- a/lib/std/os/linux/x86.zig
+++ b/lib/std/os/linux/x86.zig
@@ -14,33 +14,33 @@ const sigset_t = linux.sigset_t;
 const sockaddr = linux.sockaddr;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -73,20 +73,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     // arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer
     // and there are no more GPRs available; so we'll need a memory operand for it. Adding that
     // memory operand means that on PIC we might need a reference to the GOT, which in turn needs
     // *its* own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get
     // right, because we can't touch esp or ebp until we're done with the memory input (as that
     // input could be relative to esp or ebp).
-    const args56: [2]usize = .{ arg5, arg6 };
+    const args56: [2]u32 = .{ arg5, arg6 };
     return asm volatile (
         \\ push %[args56]
         \\ push %%ebp
@@ -99,7 +99,7 @@ pub fn syscall6(
         \\ int  $0x80
         \\ pop  %%ebp
         \\ pop  %%edi
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -109,16 +109,16 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn socketcall(call: usize, args: [*]const usize) usize {
+pub fn socketcall(call: u32, args: [*]const u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(SYS.socketcall)),
           [arg1] "{ebx}" (call),
           [arg2] "{ecx}" (@intFromPtr(args)),
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         +8,   +12,   +16,   +20, +24,  +28, +32
     //
@@ -239,7 +239,7 @@ pub const Flock = extern struct {
 
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index 8d27983f29..79381c8b58 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -16,33 +16,33 @@ const sockaddr = linux.sockaddr;
 const socklen_t = linux.socklen_t;
 const timespec = linux.timespec;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -50,9 +50,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -61,9 +61,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -75,15 +75,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -94,7 +94,7 @@ pub fn syscall6(
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     asm volatile (
         \\      movl $56,%%eax // SYS_clone
         \\      movq %%rdi,%%r11
@@ -146,11 +146,11 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const mode_t = usize;
-pub const time_t = isize;
-pub const nlink_t = usize;
-pub const blksize_t = isize;
-pub const blkcnt_t = isize;
+pub const mode_t = u64;
+pub const time_t = i64;
+pub const nlink_t = u64;
+pub const blksize_t = i64;
+pub const blkcnt_t = i64;
 
 pub const F = struct {
     pub const DUPFD = 0;
@@ -206,7 +206,7 @@ pub const dev_t = u64;
 pub const Stat = extern struct {
     dev: dev_t,
     ino: ino_t,
-    nlink: usize,
+    nlink: u64,
 
     mode: u32,
     uid: uid_t,
@@ -214,13 +214,13 @@ pub const Stat = extern struct {
     __pad0: u32,
     rdev: dev_t,
     size: off_t,
-    blksize: isize,
+    blksize: i64,
     blocks: i64,
 
     atim: timespec,
     mtim: timespec,
     ctim: timespec,
-    __unused: [3]isize,
+    __unused: [3]i64,
 
     pub fn atime(self: @This()) timespec {
         return self.atim;