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

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

Browse Source
This commit is contained in:
Alex Rønne Petersen 2025-10-16 23:39:11 +02:00
parent fc7a5f2ae4
commit cfdc0f0e34
No known key found for this signature in database
16 changed files with 432 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
lib/std/os/linux/aarch64.zig
View File

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

44
lib/std/os/linux/arm.zig
View File

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

42
lib/std/os/linux/hexagon.zig
View File

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

42
lib/std/os/linux/loongarch64.zig
View File

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

42
lib/std/os/linux/m68k.zig
View File

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

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

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

64
lib/std/os/linux/mips64.zig
View File

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

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

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

86
lib/std/os/linux/powerpc64.zig
View File

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

44
lib/std/os/linux/riscv32.zig
View File

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

44
lib/std/os/linux/riscv64.zig
View File

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

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

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

58
lib/std/os/linux/sparc64.zig
View File

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

54
lib/std/os/linux/thumb.zig
View File

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

50
lib/std/os/linux/x86.zig
View File

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

58
lib/std/os/linux/x86_64.zig
View File

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