mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-12 17: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 sigset_t = linux.sigset_t;
const timespec = std.os.linux.timespec; const timespec = std.os.linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u64 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u64) u64 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
@ -73,15 +73,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={x0}" (-> usize), : [ret] "={x0}" (-> u64),
: [number] "{x8}" (@intFromEnum(number)), : [number] "{x8}" (@intFromEnum(number)),
[arg1] "{x0}" (arg1), [arg1] "{x0}" (arg1),
[arg2] "{x1}" (arg2), [arg2] "{x1}" (arg2),
@ -92,7 +92,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u64 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// x0, x1, w2, x3, x4, x5, x6 // x0, x1, w2, x3, x4, x5, x6
// //
@ -192,12 +192,12 @@ pub const Flock = extern struct {
pub const blksize_t = i32; pub const blksize_t = i32;
pub const nlink_t = u32; pub const nlink_t = u32;
pub const time_t = isize; pub const time_t = i64;
pub const mode_t = u32; pub const mode_t = u32;
pub const off_t = isize; pub const off_t = i64;
pub const ino_t = usize; pub const ino_t = u64;
pub const dev_t = usize; pub const dev_t = u64;
pub const blkcnt_t = isize; pub const blkcnt_t = i64;
// The `stat` definition used by the Linux kernel. // The `stat` definition used by the Linux kernel.
pub const Stat = extern struct { pub const Stat = extern struct {
@ -208,7 +208,7 @@ pub const Stat = extern struct {
uid: uid_t, uid: uid_t,
gid: gid_t, gid: gid_t,
rdev: dev_t, rdev: dev_t,
__pad: usize, __pad: u64,
size: off_t, size: off_t,
blksize: blksize_t, blksize: blksize_t,
__pad2: i32, __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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
return asm volatile ("svc #0" return asm volatile ("svc #0"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r7}" (@intFromEnum(number)), : [number] "{r7}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -91,7 +91,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u32 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// r0, r1, r2, r3, +0, +4, +8 // r0, r1, r2, r3, +0, +4, +8
// //
@ -228,7 +228,7 @@ pub const Flock = extern struct {
pub const blksize_t = i32; pub const blksize_t = i32;
pub const nlink_t = u32; pub const nlink_t = u32;
pub const time_t = isize; pub const time_t = i32;
pub const mode_t = u32; pub const mode_t = u32;
pub const off_t = i64; pub const off_t = i64;
pub const ino_t = u64; 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 sigset_t = linux.sigset_t;
const timespec = std.os.linux.timespec; const timespec = std.os.linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
return asm volatile ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
: .{ .memory = 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 ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
: .{ .memory = 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 ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
return asm volatile ("trap0(#1)" return asm volatile ("trap0(#1)"
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [number] "{r6}" (@intFromEnum(number)), : [number] "{r6}" (@intFromEnum(number)),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -91,7 +91,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u32 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// r0, r1, r2, r3, r4, r5, +0 // 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 socklen_t = linux.socklen_t;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u64 {
return asm volatile ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); : .{ .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 ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); : .{ .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 ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
[arg2] "{$r5}" (arg2), [arg2] "{$r5}" (arg2),
: .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); : .{ .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 ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
[arg2] "{$r5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
[arg2] "{$r5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
[arg2] "{$r5}" (arg2), [arg2] "{$r5}" (arg2),
@ -77,16 +77,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ( return asm volatile (
\\ syscall 0 \\ syscall 0
: [ret] "={$r4}" (-> usize), : [ret] "={$r4}" (-> u64),
: [number] "{$r11}" (@intFromEnum(number)), : [number] "{$r11}" (@intFromEnum(number)),
[arg1] "{$r4}" (arg1), [arg1] "{$r4}" (arg1),
[arg2] "{$r5}" (arg2), [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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// a0, a1, a2, a3, a4, a5, a6 // a0, a1, a2, a3, a4, a5, a6
// sys_clone(flags, stack, ptid, ctid, tls) // 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 socklen_t = linux.socklen_t;
const timespec = std.os.linux.timespec; const timespec = std.os.linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
return asm volatile ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
: .{ .memory = 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 ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
[arg2] "{d2}" (arg2), [arg2] "{d2}" (arg2),
: .{ .memory = 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 ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
[arg2] "{d2}" (arg2), [arg2] "{d2}" (arg2),
@ -45,9 +45,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
[arg2] "{d2}" (arg2), [arg2] "{d2}" (arg2),
@ -56,9 +56,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
[arg2] "{d2}" (arg2), [arg2] "{d2}" (arg2),
@ -70,15 +70,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
return asm volatile ("trap #0" return asm volatile ("trap #0"
: [ret] "={d0}" (-> usize), : [ret] "={d0}" (-> u32),
: [number] "{d0}" (@intFromEnum(number)), : [number] "{d0}" (@intFromEnum(number)),
[arg1] "{d1}" (arg1), [arg1] "{d1}" (arg1),
[arg2] "{d2}" (arg2), [arg2] "{d2}" (arg2),
@ -89,7 +89,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u32 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// +4, +8, +12, +16, +20, +24, +28 // +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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [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 }); : .{ .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 ( return asm volatile (
\\ .set noat \\ .set noat
\\ .set noreorder \\ .set noreorder
@ -39,47 +39,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
\\ sw $2, 0($4) \\ sw $2, 0($4)
\\ sw $3, 4($4) \\ sw $3, 4($4)
\\ 2: \\ 2:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(SYS.pipe)), : [number] "{$2}" (@intFromEnum(SYS.pipe)),
[fd] "{$4}" (fd), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ .set noat \\ .set noat
\\ subu $sp, $sp, 24 \\ subu $sp, $sp, 24
@ -114,7 +114,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
@ -129,13 +129,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
return asm volatile ( return asm volatile (
\\ .set noat \\ .set noat
\\ subu $sp, $sp, 24 \\ subu $sp, $sp, 24
@ -147,7 +147,7 @@ pub fn syscall6(
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
@ -160,14 +160,14 @@ pub fn syscall6(
pub fn syscall7( pub fn syscall7(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
arg7: usize, arg7: u32,
) usize { ) u32 {
return asm volatile ( return asm volatile (
\\ .set noat \\ .set noat
\\ subu $sp, $sp, 32 \\ subu $sp, $sp, 32
@ -180,7 +180,7 @@ pub fn syscall7(
\\ blez $2, 1f \\ blez $2, 1f
\\ subu $2, $0, $2 \\ subu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u32),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// 3, 4, 5, 6, 7, 8, 9 // 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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u64 {
return asm volatile ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [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 }); : .{ .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 ( return asm volatile (
\\ .set noat \\ .set noat
\\ .set noreorder \\ .set noreorder
@ -39,13 +39,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
\\ sw $2, 0($4) \\ sw $2, 0($4)
\\ sw $3, 4($4) \\ sw $3, 4($4)
\\ 2: \\ 2:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(SYS.pipe)), : [number] "{$2}" (@intFromEnum(SYS.pipe)),
[fd] "{$4}" (fd), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
@ -53,34 +53,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
\\ nop \\ nop
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
@ -123,20 +123,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [arg2] "{$5}" (arg2),
@ -149,21 +149,21 @@ pub fn syscall6(
pub fn syscall7( pub fn syscall7(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
arg7: usize, arg7: u64,
) usize { ) u64 {
return asm volatile ( return asm volatile (
\\ syscall \\ syscall
\\ beq $7, $zero, 1f \\ beq $7, $zero, 1f
\\ blez $2, 1f \\ blez $2, 1f
\\ dsubu $2, $0, $2 \\ dsubu $2, $0, $2
\\ 1: \\ 1:
: [ret] "={$2}" (-> usize), : [ret] "={$2}" (-> u64),
: [number] "{$2}" (@intFromEnum(number)), : [number] "{$2}" (@intFromEnum(number)),
[arg1] "{$4}" (arg1), [arg1] "{$4}" (arg1),
[arg2] "{$5}" (arg2), [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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// 3, 4, 5, 6, 7, 8, 9 // 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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; 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 // 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 // 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 // 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.) // cause the C backend to emit invalid code; see #25209.)
var r0_out: usize = undefined; var r0_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
: [number] "{r0}" (@intFromEnum(number)), : [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 }); : .{ .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. // r0 is both an input and a clobber.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
: [number] "{r0}" (@intFromEnum(number)), : [number] "{r0}" (@intFromEnum(number)),
[arg1] "{r3}" (arg1), [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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
var r4_out: usize = undefined; var r4_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
: [number] "{r0}" (@intFromEnum(number)), : [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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
var r4_out: usize = undefined; var r4_out: u32 = undefined;
var r5_out: usize = undefined; var r5_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
var r4_out: usize = undefined; var r4_out: u32 = undefined;
var r5_out: usize = undefined; var r5_out: u32 = undefined;
var r6_out: usize = undefined; var r6_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
var r4_out: usize = undefined; var r4_out: u32 = undefined;
var r5_out: usize = undefined; var r5_out: u32 = undefined;
var r6_out: usize = undefined; var r6_out: u32 = undefined;
var r7_out: usize = undefined; var r7_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
// These registers are both inputs and clobbers. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u32 = undefined;
var r4_out: usize = undefined; var r4_out: u32 = undefined;
var r5_out: usize = undefined; var r5_out: u32 = undefined;
var r6_out: usize = undefined; var r6_out: u32 = undefined;
var r7_out: usize = undefined; var r7_out: u32 = undefined;
var r8_out: usize = undefined; var r8_out: u32 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u32),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// 3, 4, 5, 6, 7, 8, 9 // 3, 4, 5, 6, 7, 8, 9
// //
@ -303,7 +303,7 @@ pub const Flock = extern struct {
pub const blksize_t = i32; pub const blksize_t = i32;
pub const nlink_t = u32; pub const nlink_t = u32;
pub const time_t = isize; pub const time_t = i32;
pub const mode_t = u32; pub const mode_t = u32;
pub const off_t = i64; pub const off_t = i64;
pub const ino_t = u64; 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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; 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 // 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 // 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 // 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.) // cause the C backend to emit invalid code; see #25209.)
var r0_out: usize = undefined; var r0_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
: [number] "{r0}" (@intFromEnum(number)), : [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 }); : .{ .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. // r0 is both an input and a clobber.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
: [number] "{r0}" (@intFromEnum(number)), : [number] "{r0}" (@intFromEnum(number)),
[arg1] "{r3}" (arg1), [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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
var r4_out: usize = undefined; var r4_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
: [number] "{r0}" (@intFromEnum(number)), : [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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
var r4_out: usize = undefined; var r4_out: u64 = undefined;
var r5_out: usize = undefined; var r5_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
var r4_out: usize = undefined; var r4_out: u64 = undefined;
var r5_out: usize = undefined; var r5_out: u64 = undefined;
var r6_out: usize = undefined; var r6_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
var r4_out: usize = undefined; var r4_out: u64 = undefined;
var r5_out: usize = undefined; var r5_out: u64 = undefined;
var r6_out: usize = undefined; var r6_out: u64 = undefined;
var r7_out: usize = undefined; var r7_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
// These registers are both inputs and clobbers. // These registers are both inputs and clobbers.
var r0_out: usize = undefined; var r0_out: u64 = undefined;
var r4_out: usize = undefined; var r4_out: u64 = undefined;
var r5_out: usize = undefined; var r5_out: u64 = undefined;
var r6_out: usize = undefined; var r6_out: u64 = undefined;
var r7_out: usize = undefined; var r7_out: u64 = undefined;
var r8_out: usize = undefined; var r8_out: u64 = undefined;
return asm volatile ( return asm volatile (
\\ sc \\ sc
\\ bns+ 1f \\ bns+ 1f
\\ neg 3, 3 \\ neg 3, 3
\\ 1: \\ 1:
: [ret] "={r3}" (-> usize), : [ret] "={r3}" (-> u64),
[r0_out] "={r0}" (r0_out), [r0_out] "={r0}" (r0_out),
[r4_out] "={r4}" (r4_out), [r4_out] "={r4}" (r4_out),
[r5_out] "={r5}" (r5_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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// 3, 4, 5, 6, 7, 8, 9 // 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 socklen_t = linux.socklen_t;
const timespec = std.os.linux.timespec; const timespec = std.os.linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u32),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -91,7 +91,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u32 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// a0, a1, a2, a3, a4, a5, a6 // a0, a1, a2, a3, a4, a5, a6
// //
@ -186,7 +186,7 @@ pub const Stat = extern struct {
uid: uid_t, uid: uid_t,
gid: gid_t, gid: gid_t,
rdev: dev_t, rdev: dev_t,
__pad: usize, __pad: u32,
size: off_t, size: off_t,
blksize: blksize_t, blksize: blksize_t,
__pad2: i32, __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 socklen_t = linux.socklen_t;
const timespec = std.os.linux.timespec; const timespec = std.os.linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u64 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u64) u64 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -72,15 +72,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ("ecall" return asm volatile ("ecall"
: [ret] "={x10}" (-> usize), : [ret] "={x10}" (-> u64),
: [number] "{x17}" (@intFromEnum(number)), : [number] "{x17}" (@intFromEnum(number)),
[arg1] "{x10}" (arg1), [arg1] "{x10}" (arg1),
[arg2] "{x11}" (arg2), [arg2] "{x11}" (arg2),
@ -91,7 +91,7 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u64 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// a0, a1, a2, a3, a4, a5, a6 // a0, a1, a2, a3, a4, a5, a6
// //
@ -186,7 +186,7 @@ pub const Stat = extern struct {
uid: uid_t, uid: uid_t,
gid: gid_t, gid: gid_t,
rdev: dev_t, rdev: dev_t,
__pad: usize, __pad: u64,
size: off_t, size: off_t,
blksize: blksize_t, blksize: blksize_t,
__pad2: i32, __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 stack_t = std.os.linux.stack_t;
const sigset_t = std.os.linux.sigset_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" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u64) u64 {
return asm volatile ("svc 0" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
: .{ .memory = 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 ("svc 0" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
[arg2] "{r3}" (arg2), [arg2] "{r3}" (arg2),
: .{ .memory = 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 ("svc 0" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
[arg2] "{r3}" (arg2), [arg2] "{r3}" (arg2),
@ -47,9 +47,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("svc 0" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
[arg2] "{r3}" (arg2), [arg2] "{r3}" (arg2),
@ -58,9 +58,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("svc 0" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
[arg2] "{r3}" (arg2), [arg2] "{r3}" (arg2),
@ -70,9 +70,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
: .{ .memory = true }); : .{ .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" return asm volatile ("svc 0"
: [ret] "={r2}" (-> usize), : [ret] "={r2}" (-> u64),
: [number] "{r1}" (@intFromEnum(number)), : [number] "{r1}" (@intFromEnum(number)),
[arg1] "{r2}" (arg1), [arg1] "{r2}" (arg1),
[arg2] "{r3}" (arg2), [arg2] "{r3}" (arg2),
@ -83,7 +83,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u64 {
asm volatile ( asm volatile (
\\# int clone( \\# int clone(
\\# fn, a = r2 \\# 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 iovec_const = std.posix.iovec_const;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall_pipe(fd: *[2]i32) usize { pub fn syscall_pipe(fd: *[2]i32) u64 {
return asm volatile ( return asm volatile (
\\ mov %[arg], %%g3 \\ mov %[arg], %%g3
\\ t 0x6d \\ t 0x6d
@ -29,13 +29,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
\\ st %%o1, [%%g3+4] \\ st %%o1, [%%g3+4]
\\ clr %%o0 \\ clr %%o0
\\2: \\2:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(SYS.pipe)), : [number] "{g1}" (@intFromEnum(SYS.pipe)),
[arg] "r" (fd), [arg] "r" (fd),
: .{ .memory = true, .g3 = true }); : .{ .memory = true, .g3 = true });
} }
pub fn syscall_fork() usize { pub fn syscall_fork() u64 {
// Linux/sparc64 fork() returns two values in %o0 and %o1: // 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 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. // - 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 \\ dec %%o1
\\ and %%o1, %%o0, %%o0 \\ and %%o1, %%o0, %%o0
\\ 2: \\ 2:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(SYS.fork)), : [number] "{g1}" (@intFromEnum(SYS.fork)),
: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
: .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [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 }); : .{ .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 ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [arg2] "{o1}" (arg2),
@ -146,20 +146,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ( return asm volatile (
\\ t 0x6d \\ t 0x6d
\\ bcc,pt %%xcc, 1f \\ bcc,pt %%xcc, 1f
\\ nop \\ nop
\\ neg %%o0 \\ neg %%o0
\\ 1: \\ 1:
: [ret] "={o0}" (-> usize), : [ret] "={o0}" (-> u64),
: [number] "{g1}" (@intFromEnum(number)), : [number] "{g1}" (@intFromEnum(number)),
[arg1] "{o0}" (arg1), [arg1] "{o0}" (arg1),
[arg2] "{o1}" (arg2), [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 }); : .{ .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) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// i0, i1, i2, i3, i4, i5, sp // i0, i1, i2, i3, i4, i5, sp
// //
@ -274,12 +274,12 @@ pub const Flock = extern struct {
pub const off_t = i64; pub const off_t = i64;
pub const ino_t = u64; pub const ino_t = u64;
pub const time_t = isize; pub const time_t = i64;
pub const mode_t = u32; pub const mode_t = u32;
pub const dev_t = usize; pub const dev_t = u64;
pub const nlink_t = u32; pub const nlink_t = u32;
pub const blksize_t = isize; pub const blksize_t = i64;
pub const blkcnt_t = isize; pub const blkcnt_t = i64;
// The `stat64` definition used by the kernel. // The `stat64` definition used by the kernel.
pub const Stat = extern struct { 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 linux = std.os.linux;
const SYS = linux.SYS; const SYS = linux.SYS;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r1}" (&buf), : [tmp] "{r1}" (&buf),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r1}" (&buf), : [tmp] "{r1}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize { pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r2}" (&buf), : [tmp] "{r2}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
: .{ .memory = 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 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r3}" (&buf), : [tmp] "{r3}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -61,14 +61,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r4}" (&buf), : [tmp] "{r4}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -77,14 +77,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r5}" (&buf), : [tmp] "{r5}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [arg2] "{r1}" (arg2),
@ -96,20 +96,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
var buf: [2]usize = .{ @intFromEnum(number), undefined }; var buf: [2]u32 = .{ @intFromEnum(number), undefined };
return asm volatile ( return asm volatile (
\\ str r7, [%[tmp], #4] \\ str r7, [%[tmp], #4]
\\ ldr r7, [%[tmp]] \\ ldr r7, [%[tmp]]
\\ svc #0 \\ svc #0
\\ ldr r7, [%[tmp], #4] \\ ldr r7, [%[tmp], #4]
: [ret] "={r0}" (-> usize), : [ret] "={r0}" (-> u32),
: [tmp] "{r6}" (&buf), : [tmp] "{r6}" (&buf),
[arg1] "{r0}" (arg1), [arg1] "{r0}" (arg1),
[arg2] "{r1}" (arg2), [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 sockaddr = linux.sockaddr;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u32 {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn syscall1(number: SYS, arg1: usize) usize { pub fn syscall1(number: SYS, arg1: u32) u32 {
return asm volatile ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
: .{ .memory = 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 ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
: .{ .memory = 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 ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
@ -48,9 +48,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
: .{ .memory = 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 ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
@ -59,9 +59,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
: .{ .memory = 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 ("int $0x80" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
@ -73,20 +73,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u32,
arg2: usize, arg2: u32,
arg3: usize, arg3: u32,
arg4: usize, arg4: u32,
arg5: usize, arg5: u32,
arg6: usize, arg6: u32,
) usize { ) u32 {
// arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer // 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 // 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 // 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 // *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 // 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). // input could be relative to esp or ebp).
const args56: [2]usize = .{ arg5, arg6 }; const args56: [2]u32 = .{ arg5, arg6 };
return asm volatile ( return asm volatile (
\\ push %[args56] \\ push %[args56]
\\ push %%ebp \\ push %%ebp
@ -99,7 +99,7 @@ pub fn syscall6(
\\ int $0x80 \\ int $0x80
\\ pop %%ebp \\ pop %%ebp
\\ pop %%edi \\ pop %%edi
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(number)), : [number] "{eax}" (@intFromEnum(number)),
[arg1] "{ebx}" (arg1), [arg1] "{ebx}" (arg1),
[arg2] "{ecx}" (arg2), [arg2] "{ecx}" (arg2),
@ -109,16 +109,16 @@ pub fn syscall6(
: .{ .memory = true }); : .{ .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" return asm volatile ("int $0x80"
: [ret] "={eax}" (-> usize), : [ret] "={eax}" (-> u32),
: [number] "{eax}" (@intFromEnum(SYS.socketcall)), : [number] "{eax}" (@intFromEnum(SYS.socketcall)),
[arg1] "{ebx}" (call), [arg1] "{ebx}" (call),
[arg2] "{ecx}" (@intFromPtr(args)), [arg2] "{ecx}" (@intFromPtr(args)),
: .{ .memory = true }); : .{ .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u32 {
// __clone(func, stack, flags, arg, ptid, tls, ctid) // __clone(func, stack, flags, arg, ptid, tls, ctid)
// +8, +12, +16, +20, +24, +28, +32 // +8, +12, +16, +20, +24, +28, +32
// //
@ -239,7 +239,7 @@ pub const Flock = extern struct {
pub const blksize_t = i32; pub const blksize_t = i32;
pub const nlink_t = u32; pub const nlink_t = u32;
pub const time_t = isize; pub const time_t = i32;
pub const mode_t = u32; pub const mode_t = u32;
pub const off_t = i64; pub const off_t = i64;
pub const ino_t = u64; 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 socklen_t = linux.socklen_t;
const timespec = linux.timespec; const timespec = linux.timespec;
pub fn syscall0(number: SYS) usize { pub fn syscall0(number: SYS) u64 {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
: .{ .rcx = true, .r11 = true, .memory = true }); : .{ .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" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
: .{ .rcx = true, .r11 = true, .memory = true }); : .{ .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" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
: .{ .rcx = true, .r11 = true, .memory = true }); : .{ .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" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [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 }); : .{ .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" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [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 }); : .{ .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" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
@ -75,15 +75,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
pub fn syscall6( pub fn syscall6(
number: SYS, number: SYS,
arg1: usize, arg1: u64,
arg2: usize, arg2: u64,
arg3: usize, arg3: u64,
arg4: usize, arg4: u64,
arg5: usize, arg5: u64,
arg6: usize, arg6: u64,
) usize { ) u64 {
return asm volatile ("syscall" return asm volatile ("syscall"
: [ret] "={rax}" (-> usize), : [ret] "={rax}" (-> u64),
: [number] "{rax}" (@intFromEnum(number)), : [number] "{rax}" (@intFromEnum(number)),
[arg1] "{rdi}" (arg1), [arg1] "{rdi}" (arg1),
[arg2] "{rsi}" (arg2), [arg2] "{rsi}" (arg2),
@ -94,7 +94,7 @@ pub fn syscall6(
: .{ .rcx = true, .r11 = true, .memory = true }); : .{ .rcx = true, .r11 = true, .memory = true });
} }
pub fn clone() callconv(.naked) usize { pub fn clone() callconv(.naked) u64 {
asm volatile ( asm volatile (
\\ movl $56,%%eax // SYS_clone \\ movl $56,%%eax // SYS_clone
\\ movq %%rdi,%%r11 \\ movq %%rdi,%%r11
@ -146,11 +146,11 @@ pub fn restore_rt() callconv(.naked) noreturn {
} }
} }
pub const mode_t = usize; pub const mode_t = u64;
pub const time_t = isize; pub const time_t = i64;
pub const nlink_t = usize; pub const nlink_t = u64;
pub const blksize_t = isize; pub const blksize_t = i64;
pub const blkcnt_t = isize; pub const blkcnt_t = i64;
pub const F = struct { pub const F = struct {
pub const DUPFD = 0; pub const DUPFD = 0;
@ -206,7 +206,7 @@ pub const dev_t = u64;
pub const Stat = extern struct { pub const Stat = extern struct {
dev: dev_t, dev: dev_t,
ino: ino_t, ino: ino_t,
nlink: usize, nlink: u64,
mode: u32, mode: u32,
uid: uid_t, uid: uid_t,
@ -214,13 +214,13 @@ pub const Stat = extern struct {
__pad0: u32, __pad0: u32,
rdev: dev_t, rdev: dev_t,
size: off_t, size: off_t,
blksize: isize, blksize: i64,
blocks: i64, blocks: i64,
atim: timespec, atim: timespec,
mtim: timespec, mtim: timespec,
ctim: timespec, ctim: timespec,
__unused: [3]isize, __unused: [3]i64,
pub fn atime(self: @This()) timespec { pub fn atime(self: @This()) timespec {
return self.atim; return self.atim;