authorgravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2025-10-17 12:07:51+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2025-10-17 12:07:51+02:00
log1f8a72175b5352e77b41ed4d165acccad08ffb16
treed573a9ef3ad64fc8e257fe7a736e57e50c2d8e2d
parent3091efaa1845bf049ce1d4aaacb95e3b1e346453
parent29fb9e4da7d60f32f7efe6d280a69e020cd117a7
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #25610 from alexrp/std-os-linux-cleanup

`std.os.linux`: some miscellaneous cleanup in arch bits

20 files changed, 1155 insertions(+), 1457 deletions(-)

lib/std/os/linux.zig+93-16
...@@ -32,21 +32,27 @@ test {...@@ -32,21 +32,27 @@ test {
32}32}
3333
34const arch_bits = switch (native_arch) {34const arch_bits = switch (native_arch) {
35 .x86 => @import("linux/x86.zig"),
36 .x86_64 => @import("linux/x86_64.zig"),
37 .aarch64, .aarch64_be => @import("linux/aarch64.zig"),35 .aarch64, .aarch64_be => @import("linux/aarch64.zig"),
38 .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),36 .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
39 .hexagon => @import("linux/hexagon.zig"),37 .hexagon => @import("linux/hexagon.zig"),
40 .riscv32 => @import("linux/riscv32.zig"),
41 .riscv64 => @import("linux/riscv64.zig"),
42 .sparc64 => @import("linux/sparc64.zig"),
43 .loongarch64 => @import("linux/loongarch64.zig"),38 .loongarch64 => @import("linux/loongarch64.zig"),
44 .m68k => @import("linux/m68k.zig"),39 .m68k => @import("linux/m68k.zig"),
45 .mips, .mipsel => @import("linux/mips.zig"),40 .mips, .mipsel => @import("linux/mips.zig"),
46 .mips64, .mips64el => @import("linux/mips64.zig"),41 .mips64, .mips64el => switch (builtin.abi) {
42 .gnuabin32, .muslabin32 => @import("linux/mipsn32.zig"),
43 else => @import("linux/mips64.zig"),
44 },
47 .powerpc, .powerpcle => @import("linux/powerpc.zig"),45 .powerpc, .powerpcle => @import("linux/powerpc.zig"),
48 .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),46 .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),
47 .riscv32 => @import("linux/riscv32.zig"),
48 .riscv64 => @import("linux/riscv64.zig"),
49 .s390x => @import("linux/s390x.zig"),49 .s390x => @import("linux/s390x.zig"),
50 .sparc64 => @import("linux/sparc64.zig"),
51 .x86 => @import("linux/x86.zig"),
52 .x86_64 => switch (builtin.abi) {
53 .gnux32, .muslx32 => @import("linux/x32.zig"),
54 else => @import("linux/x86_64.zig"),
55 },
50 else => struct {},56 else => struct {},
51};57};
5258
...@@ -88,9 +94,6 @@ pub fn clone(...@@ -88,9 +94,6 @@ pub fn clone(
88}94}
8995
90pub const ARCH = arch_bits.ARCH;96pub const ARCH = arch_bits.ARCH;
91pub const Elf_Symndx = arch_bits.Elf_Symndx;
92pub const F = arch_bits.F;
93pub const Flock = arch_bits.Flock;
94pub const HWCAP = arch_bits.HWCAP;97pub const HWCAP = arch_bits.HWCAP;
95pub const SC = arch_bits.SC;98pub const SC = arch_bits.SC;
96pub const Stat = arch_bits.Stat;99pub const Stat = arch_bits.Stat;
...@@ -103,8 +106,6 @@ pub const mode_t = arch_bits.mode_t;...@@ -103,8 +106,6 @@ pub const mode_t = arch_bits.mode_t;
103pub const nlink_t = arch_bits.nlink_t;106pub const nlink_t = arch_bits.nlink_t;
104pub const off_t = arch_bits.off_t;107pub const off_t = arch_bits.off_t;
105pub const time_t = arch_bits.time_t;108pub const time_t = arch_bits.time_t;
106pub const timeval = arch_bits.timeval;
107pub const timezone = arch_bits.timezone;
108pub const user_desc = arch_bits.user_desc;109pub const user_desc = arch_bits.user_desc;
109110
110pub const tls = @import("linux/tls.zig");111pub const tls = @import("linux/tls.zig");
...@@ -113,10 +114,10 @@ pub const IOCTL = @import("linux/ioctl.zig");...@@ -113,10 +114,10 @@ pub const IOCTL = @import("linux/ioctl.zig");
113pub const SECCOMP = @import("linux/seccomp.zig");114pub const SECCOMP = @import("linux/seccomp.zig");
114115
115pub const syscalls = @import("linux/syscalls.zig");116pub const syscalls = @import("linux/syscalls.zig");
116pub const SYS = switch (@import("builtin").cpu.arch) {117pub const SYS = switch (native_arch) {
117 .arc => syscalls.Arc,118 .arc => syscalls.Arc,
118 .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
119 .aarch64, .aarch64_be => syscalls.Arm64,119 .aarch64, .aarch64_be => syscalls.Arm64,
120 .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
120 .csky => syscalls.CSky,121 .csky => syscalls.CSky,
121 .hexagon => syscalls.Hexagon,122 .hexagon => syscalls.Hexagon,
122 .loongarch64 => syscalls.LoongArch64,123 .loongarch64 => syscalls.LoongArch64,
...@@ -126,20 +127,20 @@ pub const SYS = switch (@import("builtin").cpu.arch) {...@@ -126,20 +127,20 @@ pub const SYS = switch (@import("builtin").cpu.arch) {
126 .gnuabin32, .muslabin32 => syscalls.MipsN32,127 .gnuabin32, .muslabin32 => syscalls.MipsN32,
127 else => syscalls.MipsN64,128 else => syscalls.MipsN64,
128 },129 },
130 .or1k => syscalls.OpenRisc,
131 .powerpc, .powerpcle => syscalls.PowerPC,
132 .powerpc64, .powerpc64le => syscalls.PowerPC64,
129 .riscv32 => syscalls.RiscV32,133 .riscv32 => syscalls.RiscV32,
130 .riscv64 => syscalls.RiscV64,134 .riscv64 => syscalls.RiscV64,
131 .s390x => syscalls.S390x,135 .s390x => syscalls.S390x,
132 .sparc => syscalls.Sparc,136 .sparc => syscalls.Sparc,
133 .sparc64 => syscalls.Sparc64,137 .sparc64 => syscalls.Sparc64,
134 .powerpc, .powerpcle => syscalls.PowerPC,
135 .powerpc64, .powerpc64le => syscalls.PowerPC64,
136 .x86 => syscalls.X86,138 .x86 => syscalls.X86,
137 .x86_64 => switch (builtin.abi) {139 .x86_64 => switch (builtin.abi) {
138 .gnux32, .muslx32 => syscalls.X32,140 .gnux32, .muslx32 => syscalls.X32,
139 else => syscalls.X64,141 else => syscalls.X64,
140 },142 },
141 .xtensa => syscalls.Xtensa,143 .xtensa => syscalls.Xtensa,
142 .or1k => syscalls.OpenRisc,
143 else => @compileError("The Zig Standard Library is missing syscall definitions for the target CPU architecture"),144 else => @compileError("The Zig Standard Library is missing syscall definitions for the target CPU architecture"),
144};145};
145146
...@@ -1600,6 +1601,70 @@ pub fn waitid(id_type: P, id: i32, infop: *siginfo_t, flags: u32) usize {...@@ -1600,6 +1601,70 @@ pub fn waitid(id_type: P, id: i32, infop: *siginfo_t, flags: u32) usize {
1600 return syscall5(.waitid, @intFromEnum(id_type), @as(usize, @bitCast(@as(isize, id))), @intFromPtr(infop), flags, 0);1601 return syscall5(.waitid, @intFromEnum(id_type), @as(usize, @bitCast(@as(isize, id))), @intFromPtr(infop), flags, 0);
1601}1602}
16021603
1604pub const F = struct {
1605 pub const DUPFD = 0;
1606 pub const GETFD = 1;
1607 pub const SETFD = 2;
1608 pub const GETFL = 3;
1609 pub const SETFL = 4;
1610
1611 pub const GETLK = GET_SET_LK.GETLK;
1612 pub const SETLK = GET_SET_LK.SETLK;
1613 pub const SETLKW = GET_SET_LK.SETLKW;
1614
1615 const GET_SET_LK = if (@sizeOf(usize) == 64) extern struct {
1616 pub const GETLK = if (is_mips) 14 else if (is_sparc) 7 else 5;
1617 pub const SETLK = if (is_mips) 6 else if (is_sparc) 8 else 6;
1618 pub const SETLKW = if (is_mips) 7 else if (is_sparc) 9 else 7;
1619 } else extern struct {
1620 // Ensure that 32-bit code uses the large-file variants (GETLK64, etc).
1621
1622 pub const GETLK = if (is_mips) 33 else 12;
1623 pub const SETLK = if (is_mips) 34 else 13;
1624 pub const SETLKW = if (is_mips) 35 else 14;
1625 };
1626
1627 pub const SETOWN = if (is_mips) 24 else if (is_sparc) 6 else 8;
1628 pub const GETOWN = if (is_mips) 23 else if (is_sparc) 5 else 9;
1629
1630 pub const SETSIG = 10;
1631 pub const GETSIG = 11;
1632
1633 pub const SETOWN_EX = 15;
1634 pub const GETOWN_EX = 16;
1635
1636 pub const GETOWNER_UIDS = 17;
1637
1638 pub const OFD_GETLK = 36;
1639 pub const OFD_SETLK = 37;
1640 pub const OFD_SETLKW = 38;
1641
1642 pub const RDLCK = if (is_sparc) 1 else 0;
1643 pub const WRLCK = if (is_sparc) 2 else 1;
1644 pub const UNLCK = if (is_sparc) 3 else 2;
1645};
1646
1647pub const F_OWNER = enum(i32) {
1648 TID = 0,
1649 PID = 1,
1650 PGRP = 2,
1651 _,
1652};
1653
1654pub const f_owner_ex = extern struct {
1655 type: F_OWNER,
1656 pid: pid_t,
1657};
1658
1659pub const Flock = extern struct {
1660 type: i16,
1661 whence: i16,
1662 start: off_t,
1663 len: off_t,
1664 pid: pid_t,
1665 _unused: if (is_sparc) i16 else void,
1666};
1667
1603pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) usize {1668pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) usize {
1604 if (@hasField(SYS, "fcntl64")) {1669 if (@hasField(SYS, "fcntl64")) {
1605 return syscall3(.fcntl64, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg);1670 return syscall3(.fcntl64, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg);
...@@ -1612,6 +1677,8 @@ pub fn flock(fd: fd_t, operation: i32) usize {...@@ -1612,6 +1677,8 @@ pub fn flock(fd: fd_t, operation: i32) usize {
1612 return syscall2(.flock, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, operation))));1677 return syscall2(.flock, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, operation))));
1613}1678}
16141679
1680pub const Elf_Symndx = if (native_arch == .s390x) u64 else u32;
1681
1615// We must follow the C calling convention when we call into the VDSO1682// We must follow the C calling convention when we call into the VDSO
1616const VdsoClockGettime = *align(1) const fn (clockid_t, *timespec) callconv(.c) usize;1683const VdsoClockGettime = *align(1) const fn (clockid_t, *timespec) callconv(.c) usize;
1617var vdso_clock_gettime: ?VdsoClockGettime = &init_vdso_clock_gettime;1684var vdso_clock_gettime: ?VdsoClockGettime = &init_vdso_clock_gettime;
...@@ -8361,6 +8428,16 @@ pub const POSIX_FADV = switch (native_arch) {...@@ -8361,6 +8428,16 @@ pub const POSIX_FADV = switch (native_arch) {
8361 },8428 },
8362};8429};
83638430
8431pub const timeval = extern struct {
8432 tv_sec: isize,
8433 tv_usec: i64,
8434};
8435
8436pub const timezone = extern struct {
8437 minuteswest: i32,
8438 dsttime: i32,
8439};
8440
8364/// The timespec struct used by the kernel.8441/// The timespec struct used by the kernel.
8365pub const kernel_timespec = extern struct {8442pub const kernel_timespec = extern struct {
8366 sec: i64,8443 sec: i64,
lib/std/os/linux/aarch64.zig+38-97
...@@ -1,46 +1,34 @@...@@ -1,46 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;4
5const SYS = linux.SYS;5pub fn syscall0(number: SYS) u64 {
6const socklen_t = linux.socklen_t;
7const sockaddr = linux.sockaddr;
8const iovec = std.posix.iovec;
9const iovec_const = std.posix.iovec_const;
10const uid_t = linux.uid_t;
11const gid_t = linux.gid_t;
12const pid_t = linux.pid_t;
13const stack_t = linux.stack_t;
14const sigset_t = linux.sigset_t;
15const timespec = std.os.linux.timespec;
16
17pub fn syscall0(number: SYS) usize {
18 return asm volatile ("svc #0"6 return asm volatile ("svc #0"
19 : [ret] "={x0}" (-> usize),7 : [ret] "={x0}" (-> u64),
20 : [number] "{x8}" (@intFromEnum(number)),8 : [number] "{x8}" (@intFromEnum(number)),
21 : .{ .memory = true });9 : .{ .memory = true });
22}10}
2311
24pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u64) u64 {
25 return asm volatile ("svc #0"13 return asm volatile ("svc #0"
26 : [ret] "={x0}" (-> usize),14 : [ret] "={x0}" (-> u64),
27 : [number] "{x8}" (@intFromEnum(number)),15 : [number] "{x8}" (@intFromEnum(number)),
28 [arg1] "{x0}" (arg1),16 [arg1] "{x0}" (arg1),
29 : .{ .memory = true });17 : .{ .memory = true });
30}18}
3119
32pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
33 return asm volatile ("svc #0"21 return asm volatile ("svc #0"
34 : [ret] "={x0}" (-> usize),22 : [ret] "={x0}" (-> u64),
35 : [number] "{x8}" (@intFromEnum(number)),23 : [number] "{x8}" (@intFromEnum(number)),
36 [arg1] "{x0}" (arg1),24 [arg1] "{x0}" (arg1),
37 [arg2] "{x1}" (arg2),25 [arg2] "{x1}" (arg2),
38 : .{ .memory = true });26 : .{ .memory = true });
39}27}
4028
41pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
42 return asm volatile ("svc #0"30 return asm volatile ("svc #0"
43 : [ret] "={x0}" (-> usize),31 : [ret] "={x0}" (-> u64),
44 : [number] "{x8}" (@intFromEnum(number)),32 : [number] "{x8}" (@intFromEnum(number)),
45 [arg1] "{x0}" (arg1),33 [arg1] "{x0}" (arg1),
46 [arg2] "{x1}" (arg2),34 [arg2] "{x1}" (arg2),
...@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
48 : .{ .memory = true });36 : .{ .memory = true });
49}37}
5038
51pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
52 return asm volatile ("svc #0"40 return asm volatile ("svc #0"
53 : [ret] "={x0}" (-> usize),41 : [ret] "={x0}" (-> u64),
54 : [number] "{x8}" (@intFromEnum(number)),42 : [number] "{x8}" (@intFromEnum(number)),
55 [arg1] "{x0}" (arg1),43 [arg1] "{x0}" (arg1),
56 [arg2] "{x1}" (arg2),44 [arg2] "{x1}" (arg2),
...@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
59 : .{ .memory = true });47 : .{ .memory = true });
60}48}
6149
62pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
63 return asm volatile ("svc #0"51 return asm volatile ("svc #0"
64 : [ret] "={x0}" (-> usize),52 : [ret] "={x0}" (-> u64),
65 : [number] "{x8}" (@intFromEnum(number)),53 : [number] "{x8}" (@intFromEnum(number)),
66 [arg1] "{x0}" (arg1),54 [arg1] "{x0}" (arg1),
67 [arg2] "{x1}" (arg2),55 [arg2] "{x1}" (arg2),
...@@ -73,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -73,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7361
74pub fn syscall6(62pub fn syscall6(
75 number: SYS,63 number: SYS,
76 arg1: usize,64 arg1: u64,
77 arg2: usize,65 arg2: u64,
78 arg3: usize,66 arg3: u64,
79 arg4: usize,67 arg4: u64,
80 arg5: usize,68 arg5: u64,
81 arg6: usize,69 arg6: u64,
82) usize {70) u64 {
83 return asm volatile ("svc #0"71 return asm volatile ("svc #0"
84 : [ret] "={x0}" (-> usize),72 : [ret] "={x0}" (-> u64),
85 : [number] "{x8}" (@intFromEnum(number)),73 : [number] "{x8}" (@intFromEnum(number)),
86 [arg1] "{x0}" (arg1),74 [arg1] "{x0}" (arg1),
87 [arg2] "{x1}" (arg2),75 [arg2] "{x1}" (arg2),
...@@ -92,7 +80,7 @@ pub fn syscall6(...@@ -92,7 +80,7 @@ pub fn syscall6(
92 : .{ .memory = true });80 : .{ .memory = true });
93}81}
9482
95pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u64 {
96 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
97 // x0, x1, w2, x3, x4, x5, x685 // x0, x1, w2, x3, x4, x5, x6
98 //86 //
...@@ -135,7 +123,7 @@ pub fn clone() callconv(.naked) usize {...@@ -135,7 +123,7 @@ pub fn clone() callconv(.naked) usize {
135pub const restore = restore_rt;123pub const restore = restore_rt;
136124
137pub fn restore_rt() callconv(.naked) noreturn {125pub fn restore_rt() callconv(.naked) noreturn {
138 switch (@import("builtin").zig_backend) {126 switch (builtin.zig_backend) {
139 .stage2_c => asm volatile (127 .stage2_c => asm volatile (
140 \\ mov x8, %[number]128 \\ mov x8, %[number]
141 \\ svc #0129 \\ svc #0
...@@ -150,54 +138,19 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -150,54 +138,19 @@ pub fn restore_rt() callconv(.naked) noreturn {
150 }138 }
151}139}
152140
153pub const F = struct {
154 pub const DUPFD = 0;
155 pub const GETFD = 1;
156 pub const SETFD = 2;
157 pub const GETFL = 3;
158 pub const SETFL = 4;
159
160 pub const SETOWN = 8;
161 pub const GETOWN = 9;
162 pub const SETSIG = 10;
163 pub const GETSIG = 11;
164
165 pub const GETLK = 5;
166 pub const SETLK = 6;
167 pub const SETLKW = 7;
168
169 pub const RDLCK = 0;
170 pub const WRLCK = 1;
171 pub const UNLCK = 2;
172
173 pub const SETOWN_EX = 15;
174 pub const GETOWN_EX = 16;
175
176 pub const GETOWNER_UIDS = 17;
177};
178
179pub const VDSO = struct {141pub const VDSO = struct {
180 pub const CGT_SYM = "__kernel_clock_gettime";142 pub const CGT_SYM = "__kernel_clock_gettime";
181 pub const CGT_VER = "LINUX_2.6.39";143 pub const CGT_VER = "LINUX_2.6.39";
182};144};
183145
184pub const Flock = extern struct {
185 type: i16,
186 whence: i16,
187 start: off_t,
188 len: off_t,
189 pid: pid_t,
190 __unused: [4]u8,
191};
192
193pub const blksize_t = i32;146pub const blksize_t = i32;
194pub const nlink_t = u32;147pub const nlink_t = u32;
195pub const time_t = isize;148pub const time_t = i64;
196pub const mode_t = u32;149pub const mode_t = u32;
197pub const off_t = isize;150pub const off_t = i64;
198pub const ino_t = usize;151pub const ino_t = u64;
199pub const dev_t = usize;152pub const dev_t = u64;
200pub const blkcnt_t = isize;153pub const blkcnt_t = i64;
201154
202// The `stat` definition used by the Linux kernel.155// The `stat` definition used by the Linux kernel.
203pub const Stat = extern struct {156pub const Stat = extern struct {
...@@ -205,40 +158,28 @@ pub const Stat = extern struct {...@@ -205,40 +158,28 @@ pub const Stat = extern struct {
205 ino: ino_t,158 ino: ino_t,
206 mode: mode_t,159 mode: mode_t,
207 nlink: nlink_t,160 nlink: nlink_t,
208 uid: uid_t,161 uid: std.os.linux.uid_t,
209 gid: gid_t,162 gid: std.os.linux.gid_t,
210 rdev: dev_t,163 rdev: dev_t,
211 __pad: usize,164 __pad: u64,
212 size: off_t,165 size: off_t,
213 blksize: blksize_t,166 blksize: blksize_t,
214 __pad2: i32,167 __pad2: i32,
215 blocks: blkcnt_t,168 blocks: blkcnt_t,
216 atim: timespec,169 atim: std.os.linux.timespec,
217 mtim: timespec,170 mtim: std.os.linux.timespec,
218 ctim: timespec,171 ctim: std.os.linux.timespec,
219 __unused: [2]u32,172 __unused: [2]u32,
220173
221 pub fn atime(self: @This()) timespec {174 pub fn atime(self: @This()) std.os.linux.timespec {
222 return self.atim;175 return self.atim;
223 }176 }
224177
225 pub fn mtime(self: @This()) timespec {178 pub fn mtime(self: @This()) std.os.linux.timespec {
226 return self.mtim;179 return self.mtim;
227 }180 }
228181
229 pub fn ctime(self: @This()) timespec {182 pub fn ctime(self: @This()) std.os.linux.timespec {
230 return self.ctim;183 return self.ctim;
231 }184 }
232};185};
233
234pub const timeval = extern struct {
235 sec: isize,
236 usec: isize,
237};
238
239pub const timezone = extern struct {
240 minuteswest: i32,
241 dsttime: i32,
242};
243
244pub const Elf_Symndx = u32;
lib/std/os/linux/arm.zig+36-95
...@@ -1,45 +1,34 @@...@@ -1,45 +1,34 @@
1const builtin = @import("builtin");
1const std = @import("../../std.zig");2const std = @import("../../std.zig");
2const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
3const linux = std.os.linux;
4const SYS = linux.SYS;
5const iovec = std.posix.iovec;
6const iovec_const = std.posix.iovec_const;
7const socklen_t = linux.socklen_t;
8const stack_t = linux.stack_t;
9const sigset_t = linux.sigset_t;
10const uid_t = linux.uid_t;
11const gid_t = linux.gid_t;
12const pid_t = linux.pid_t;
13const sockaddr = linux.sockaddr;
14const timespec = linux.timespec;
154
16pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
17 return asm volatile ("svc #0"6 return asm volatile ("svc #0"
18 : [ret] "={r0}" (-> usize),7 : [ret] "={r0}" (-> u32),
19 : [number] "{r7}" (@intFromEnum(number)),8 : [number] "{r7}" (@intFromEnum(number)),
20 : .{ .memory = true });9 : .{ .memory = true });
21}10}
2211
23pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u32) u32 {
24 return asm volatile ("svc #0"13 return asm volatile ("svc #0"
25 : [ret] "={r0}" (-> usize),14 : [ret] "={r0}" (-> u32),
26 : [number] "{r7}" (@intFromEnum(number)),15 : [number] "{r7}" (@intFromEnum(number)),
27 [arg1] "{r0}" (arg1),16 [arg1] "{r0}" (arg1),
28 : .{ .memory = true });17 : .{ .memory = true });
29}18}
3019
31pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32 return asm volatile ("svc #0"21 return asm volatile ("svc #0"
33 : [ret] "={r0}" (-> usize),22 : [ret] "={r0}" (-> u32),
34 : [number] "{r7}" (@intFromEnum(number)),23 : [number] "{r7}" (@intFromEnum(number)),
35 [arg1] "{r0}" (arg1),24 [arg1] "{r0}" (arg1),
36 [arg2] "{r1}" (arg2),25 [arg2] "{r1}" (arg2),
37 : .{ .memory = true });26 : .{ .memory = true });
38}27}
3928
40pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41 return asm volatile ("svc #0"30 return asm volatile ("svc #0"
42 : [ret] "={r0}" (-> usize),31 : [ret] "={r0}" (-> u32),
43 : [number] "{r7}" (@intFromEnum(number)),32 : [number] "{r7}" (@intFromEnum(number)),
44 [arg1] "{r0}" (arg1),33 [arg1] "{r0}" (arg1),
45 [arg2] "{r1}" (arg2),34 [arg2] "{r1}" (arg2),
...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47 : .{ .memory = true });36 : .{ .memory = true });
48}37}
4938
50pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51 return asm volatile ("svc #0"40 return asm volatile ("svc #0"
52 : [ret] "={r0}" (-> usize),41 : [ret] "={r0}" (-> u32),
53 : [number] "{r7}" (@intFromEnum(number)),42 : [number] "{r7}" (@intFromEnum(number)),
54 [arg1] "{r0}" (arg1),43 [arg1] "{r0}" (arg1),
55 [arg2] "{r1}" (arg2),44 [arg2] "{r1}" (arg2),
...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58 : .{ .memory = true });47 : .{ .memory = true });
59}48}
6049
61pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62 return asm volatile ("svc #0"51 return asm volatile ("svc #0"
63 : [ret] "={r0}" (-> usize),52 : [ret] "={r0}" (-> u32),
64 : [number] "{r7}" (@intFromEnum(number)),53 : [number] "{r7}" (@intFromEnum(number)),
65 [arg1] "{r0}" (arg1),54 [arg1] "{r0}" (arg1),
66 [arg2] "{r1}" (arg2),55 [arg2] "{r1}" (arg2),
...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7261
73pub fn syscall6(62pub fn syscall6(
74 number: SYS,63 number: SYS,
75 arg1: usize,64 arg1: u32,
76 arg2: usize,65 arg2: u32,
77 arg3: usize,66 arg3: u32,
78 arg4: usize,67 arg4: u32,
79 arg5: usize,68 arg5: u32,
80 arg6: usize,69 arg6: u32,
81) usize {70) u32 {
82 return asm volatile ("svc #0"71 return asm volatile ("svc #0"
83 : [ret] "={r0}" (-> usize),72 : [ret] "={r0}" (-> u32),
84 : [number] "{r7}" (@intFromEnum(number)),73 : [number] "{r7}" (@intFromEnum(number)),
85 [arg1] "{r0}" (arg1),74 [arg1] "{r0}" (arg1),
86 [arg2] "{r1}" (arg2),75 [arg2] "{r1}" (arg2),
...@@ -91,7 +80,7 @@ pub fn syscall6(...@@ -91,7 +80,7 @@ pub fn syscall6(
91 : .{ .memory = true });80 : .{ .memory = true });
92}81}
9382
94pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u32 {
95 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
96 // r0, r1, r2, r3, +0, +4, +885 // r0, r1, r2, r3, +0, +4, +8
97 //86 //
...@@ -128,23 +117,23 @@ pub fn clone() callconv(.naked) usize {...@@ -128,23 +117,23 @@ pub fn clone() callconv(.naked) usize {
128}117}
129118
130pub fn restore() callconv(.naked) noreturn {119pub fn restore() callconv(.naked) noreturn {
131 switch (@import("builtin").zig_backend) {120 switch (builtin.zig_backend) {
132 .stage2_c => asm volatile (121 .stage2_c => asm volatile (
133 \\ mov r7, %[number]122 \\ mov r7, %[number]
134 \\ svc #0123 \\ svc #0
135 :124 :
136 : [number] "I" (@intFromEnum(SYS.sigreturn)),125 : [number] "I" (@intFromEnum(SYS.sigreturn)),
137 : .{ .memory = true }),126 ),
138 else => asm volatile (127 else => asm volatile (
139 \\ svc #0128 \\ svc #0
140 :129 :
141 : [number] "{r7}" (@intFromEnum(SYS.sigreturn)),130 : [number] "{r7}" (@intFromEnum(SYS.sigreturn)),
142 : .{ .memory = true }),131 ),
143 }132 }
144}133}
145134
146pub fn restore_rt() callconv(.naked) noreturn {135pub fn restore_rt() callconv(.naked) noreturn {
147 switch (@import("builtin").zig_backend) {136 switch (builtin.zig_backend) {
148 .stage2_c => asm volatile (137 .stage2_c => asm volatile (
149 \\ mov r7, %[number]138 \\ mov r7, %[number]
150 \\ svc #0139 \\ svc #0
...@@ -159,32 +148,6 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -159,32 +148,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
159 }148 }
160}149}
161150
162pub const F = struct {
163 pub const DUPFD = 0;
164 pub const GETFD = 1;
165 pub const SETFD = 2;
166 pub const GETFL = 3;
167 pub const SETFL = 4;
168
169 pub const SETOWN = 8;
170 pub const GETOWN = 9;
171 pub const SETSIG = 10;
172 pub const GETSIG = 11;
173
174 pub const GETLK = 12;
175 pub const SETLK = 13;
176 pub const SETLKW = 14;
177
178 pub const RDLCK = 0;
179 pub const WRLCK = 1;
180 pub const UNLCK = 2;
181
182 pub const SETOWN_EX = 15;
183 pub const GETOWN_EX = 16;
184
185 pub const GETOWNER_UIDS = 17;
186};
187
188pub const VDSO = struct {151pub const VDSO = struct {
189 pub const CGT_SYM = "__vdso_clock_gettime";152 pub const CGT_SYM = "__vdso_clock_gettime";
190 pub const CGT_VER = "LINUX_2.6";153 pub const CGT_VER = "LINUX_2.6";
...@@ -216,19 +179,9 @@ pub const HWCAP = struct {...@@ -216,19 +179,9 @@ pub const HWCAP = struct {
216 pub const EVTSTRM = 1 << 21;179 pub const EVTSTRM = 1 << 21;
217};180};
218181
219pub const Flock = extern struct {
220 type: i16,
221 whence: i16,
222 __pad0: [4]u8,
223 start: off_t,
224 len: off_t,
225 pid: pid_t,
226 __unused: [4]u8,
227};
228
229pub const blksize_t = i32;182pub const blksize_t = i32;
230pub const nlink_t = u32;183pub const nlink_t = u32;
231pub const time_t = isize;184pub const time_t = i32;
232pub const mode_t = u32;185pub const mode_t = u32;
233pub const off_t = i64;186pub const off_t = i64;
234pub const ino_t = u64;187pub const ino_t = u64;
...@@ -242,39 +195,27 @@ pub const Stat = extern struct {...@@ -242,39 +195,27 @@ pub const Stat = extern struct {
242 __ino_truncated: u32,195 __ino_truncated: u32,
243 mode: mode_t,196 mode: mode_t,
244 nlink: nlink_t,197 nlink: nlink_t,
245 uid: uid_t,198 uid: std.os.linux.uid_t,
246 gid: gid_t,199 gid: std.os.linux.gid_t,
247 rdev: dev_t,200 rdev: dev_t,
248 __rdev_padding: u32,201 __rdev_padding: u32,
249 size: off_t,202 size: off_t,
250 blksize: blksize_t,203 blksize: blksize_t,
251 blocks: blkcnt_t,204 blocks: blkcnt_t,
252 atim: timespec,205 atim: std.os.linux.timespec,
253 mtim: timespec,206 mtim: std.os.linux.timespec,
254 ctim: timespec,207 ctim: std.os.linux.timespec,
255 ino: ino_t,208 ino: ino_t,
256209
257 pub fn atime(self: @This()) timespec {210 pub fn atime(self: @This()) std.os.linux.timespec {
258 return self.atim;211 return self.atim;
259 }212 }
260213
261 pub fn mtime(self: @This()) timespec {214 pub fn mtime(self: @This()) std.os.linux.timespec {
262 return self.mtim;215 return self.mtim;
263 }216 }
264217
265 pub fn ctime(self: @This()) timespec {218 pub fn ctime(self: @This()) std.os.linux.timespec {
266 return self.ctim;219 return self.ctim;
267 }220 }
268};221};
269
270pub const timeval = extern struct {
271 sec: i32,
272 usec: i32,
273};
274
275pub const timezone = extern struct {
276 minuteswest: i32,
277 dsttime: i32,
278};
279
280pub const Elf_Symndx = u32;
lib/std/os/linux/hexagon.zig+30-81
...@@ -1,45 +1,34 @@...@@ -1,45 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const iovec = std.posix.iovec;3const SYS = std.os.linux.SYS;
4const iovec_const = std.posix.iovec_const;
5const linux = std.os.linux;
6const SYS = linux.SYS;
7const uid_t = std.os.linux.uid_t;
8const gid_t = std.os.linux.gid_t;
9const pid_t = std.os.linux.pid_t;
10const sockaddr = linux.sockaddr;
11const socklen_t = linux.socklen_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const timespec = std.os.linux.timespec;
154
16pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
17 return asm volatile ("trap0(#1)"6 return asm volatile ("trap0(#1)"
18 : [ret] "={r0}" (-> usize),7 : [ret] "={r0}" (-> u32),
19 : [number] "{r6}" (@intFromEnum(number)),8 : [number] "{r6}" (@intFromEnum(number)),
20 : .{ .memory = true });9 : .{ .memory = true });
21}10}
2211
23pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u32) u32 {
24 return asm volatile ("trap0(#1)"13 return asm volatile ("trap0(#1)"
25 : [ret] "={r0}" (-> usize),14 : [ret] "={r0}" (-> u32),
26 : [number] "{r6}" (@intFromEnum(number)),15 : [number] "{r6}" (@intFromEnum(number)),
27 [arg1] "{r0}" (arg1),16 [arg1] "{r0}" (arg1),
28 : .{ .memory = true });17 : .{ .memory = true });
29}18}
3019
31pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32 return asm volatile ("trap0(#1)"21 return asm volatile ("trap0(#1)"
33 : [ret] "={r0}" (-> usize),22 : [ret] "={r0}" (-> u32),
34 : [number] "{r6}" (@intFromEnum(number)),23 : [number] "{r6}" (@intFromEnum(number)),
35 [arg1] "{r0}" (arg1),24 [arg1] "{r0}" (arg1),
36 [arg2] "{r1}" (arg2),25 [arg2] "{r1}" (arg2),
37 : .{ .memory = true });26 : .{ .memory = true });
38}27}
3928
40pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41 return asm volatile ("trap0(#1)"30 return asm volatile ("trap0(#1)"
42 : [ret] "={r0}" (-> usize),31 : [ret] "={r0}" (-> u32),
43 : [number] "{r6}" (@intFromEnum(number)),32 : [number] "{r6}" (@intFromEnum(number)),
44 [arg1] "{r0}" (arg1),33 [arg1] "{r0}" (arg1),
45 [arg2] "{r1}" (arg2),34 [arg2] "{r1}" (arg2),
...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47 : .{ .memory = true });36 : .{ .memory = true });
48}37}
4938
50pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51 return asm volatile ("trap0(#1)"40 return asm volatile ("trap0(#1)"
52 : [ret] "={r0}" (-> usize),41 : [ret] "={r0}" (-> u32),
53 : [number] "{r6}" (@intFromEnum(number)),42 : [number] "{r6}" (@intFromEnum(number)),
54 [arg1] "{r0}" (arg1),43 [arg1] "{r0}" (arg1),
55 [arg2] "{r1}" (arg2),44 [arg2] "{r1}" (arg2),
...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58 : .{ .memory = true });47 : .{ .memory = true });
59}48}
6049
61pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62 return asm volatile ("trap0(#1)"51 return asm volatile ("trap0(#1)"
63 : [ret] "={r0}" (-> usize),52 : [ret] "={r0}" (-> u32),
64 : [number] "{r6}" (@intFromEnum(number)),53 : [number] "{r6}" (@intFromEnum(number)),
65 [arg1] "{r0}" (arg1),54 [arg1] "{r0}" (arg1),
66 [arg2] "{r1}" (arg2),55 [arg2] "{r1}" (arg2),
...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7261
73pub fn syscall6(62pub fn syscall6(
74 number: SYS,63 number: SYS,
75 arg1: usize,64 arg1: u32,
76 arg2: usize,65 arg2: u32,
77 arg3: usize,66 arg3: u32,
78 arg4: usize,67 arg4: u32,
79 arg5: usize,68 arg5: u32,
80 arg6: usize,69 arg6: u32,
81) usize {70) u32 {
82 return asm volatile ("trap0(#1)"71 return asm volatile ("trap0(#1)"
83 : [ret] "={r0}" (-> usize),72 : [ret] "={r0}" (-> u32),
84 : [number] "{r6}" (@intFromEnum(number)),73 : [number] "{r6}" (@intFromEnum(number)),
85 [arg1] "{r0}" (arg1),74 [arg1] "{r0}" (arg1),
86 [arg2] "{r1}" (arg2),75 [arg2] "{r1}" (arg2),
...@@ -91,7 +80,7 @@ pub fn syscall6(...@@ -91,7 +80,7 @@ pub fn syscall6(
91 : .{ .memory = true });80 : .{ .memory = true });
92}81}
9382
94pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u32 {
95 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
96 // r0, r1, r2, r3, r4, r5, +085 // r0, r1, r2, r3, r4, r5, +0
97 //86 //
...@@ -130,44 +119,6 @@ pub fn clone() callconv(.naked) usize {...@@ -130,44 +119,6 @@ pub fn clone() callconv(.naked) usize {
130 );119 );
131}120}
132121
133pub const F = struct {
134 pub const DUPFD = 0;
135 pub const GETFD = 1;
136 pub const SETFD = 2;
137 pub const GETFL = 3;
138 pub const SETFL = 4;
139 pub const GETLK = 5;
140 pub const SETLK = 6;
141 pub const SETLKW = 7;
142 pub const SETOWN = 8;
143 pub const GETOWN = 9;
144 pub const SETSIG = 10;
145 pub const GETSIG = 11;
146
147 pub const RDLCK = 0;
148 pub const WRLCK = 1;
149 pub const UNLCK = 2;
150
151 pub const SETOWN_EX = 15;
152 pub const GETOWN_EX = 16;
153
154 pub const GETOWNER_UIDS = 17;
155};
156
157pub const timeval = extern struct {
158 sec: time_t,
159 usec: i32,
160};
161
162pub const Flock = extern struct {
163 type: i16,
164 whence: i16,
165 start: off_t,
166 len: off_t,
167 pid: pid_t,
168 __unused: [4]u8,
169};
170
171pub const blksize_t = i32;122pub const blksize_t = i32;
172pub const nlink_t = u32;123pub const nlink_t = u32;
173pub const time_t = i64;124pub const time_t = i64;
...@@ -183,32 +134,30 @@ pub const Stat = extern struct {...@@ -183,32 +134,30 @@ pub const Stat = extern struct {
183 ino: ino_t,134 ino: ino_t,
184 mode: mode_t,135 mode: mode_t,
185 nlink: nlink_t,136 nlink: nlink_t,
186 uid: uid_t,137 uid: std.os.linux.uid_t,
187 gid: gid_t,138 gid: std.os.linux.gid_t,
188 rdev: dev_t,139 rdev: dev_t,
189 __pad: u32,140 __pad: u32,
190 size: off_t,141 size: off_t,
191 blksize: blksize_t,142 blksize: blksize_t,
192 __pad2: i32,143 __pad2: i32,
193 blocks: blkcnt_t,144 blocks: blkcnt_t,
194 atim: timespec,145 atim: std.os.linux.timespec,
195 mtim: timespec,146 mtim: std.os.linux.timespec,
196 ctim: timespec,147 ctim: std.os.linux.timespec,
197 __unused: [2]u32,148 __unused: [2]u32,
198149
199 pub fn atime(self: @This()) timespec {150 pub fn atime(self: @This()) std.os.linux.timespec {
200 return self.atim;151 return self.atim;
201 }152 }
202153
203 pub fn mtime(self: @This()) timespec {154 pub fn mtime(self: @This()) std.os.linux.timespec {
204 return self.mtim;155 return self.mtim;
205 }156 }
206157
207 pub fn ctime(self: @This()) timespec {158 pub fn ctime(self: @This()) std.os.linux.timespec {
208 return self.ctim;159 return self.ctim;
209 }160 }
210};161};
211162
212pub const Elf_Symndx = u32;
213
214pub const VDSO = void;163pub const VDSO = void;
lib/std/os/linux/loongarch64.zig+30-71
...@@ -1,48 +1,38 @@...@@ -1,48 +1,38 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const linux = std.os.linux;3const SYS = std.os.linux.SYS;
4const SYS = linux.SYS;
5const iovec = std.posix.iovec;
6const iovec_const = std.posix.iovec_const;
7const uid_t = linux.uid_t;
8const gid_t = linux.gid_t;
9const stack_t = linux.stack_t;
10const sigset_t = linux.sigset_t;
11const sockaddr = linux.sockaddr;
12const socklen_t = linux.socklen_t;
13const timespec = linux.timespec;
144
15pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u64 {
16 return asm volatile (6 return asm volatile (
17 \\ syscall 07 \\ syscall 0
18 : [ret] "={$r4}" (-> usize),8 : [ret] "={$r4}" (-> u64),
19 : [number] "{$r11}" (@intFromEnum(number)),9 : [number] "{$r11}" (@intFromEnum(number)),
20 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });10 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
21}11}
2212
23pub fn syscall1(number: SYS, arg1: usize) usize {13pub fn syscall1(number: SYS, arg1: u64) u64 {
24 return asm volatile (14 return asm volatile (
25 \\ syscall 015 \\ syscall 0
26 : [ret] "={$r4}" (-> usize),16 : [ret] "={$r4}" (-> u64),
27 : [number] "{$r11}" (@intFromEnum(number)),17 : [number] "{$r11}" (@intFromEnum(number)),
28 [arg1] "{$r4}" (arg1),18 [arg1] "{$r4}" (arg1),
29 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });19 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
30}20}
3121
32pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {22pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
33 return asm volatile (23 return asm volatile (
34 \\ syscall 024 \\ syscall 0
35 : [ret] "={$r4}" (-> usize),25 : [ret] "={$r4}" (-> u64),
36 : [number] "{$r11}" (@intFromEnum(number)),26 : [number] "{$r11}" (@intFromEnum(number)),
37 [arg1] "{$r4}" (arg1),27 [arg1] "{$r4}" (arg1),
38 [arg2] "{$r5}" (arg2),28 [arg2] "{$r5}" (arg2),
39 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });29 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
40}30}
4131
42pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {32pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
43 return asm volatile (33 return asm volatile (
44 \\ syscall 034 \\ syscall 0
45 : [ret] "={$r4}" (-> usize),35 : [ret] "={$r4}" (-> u64),
46 : [number] "{$r11}" (@intFromEnum(number)),36 : [number] "{$r11}" (@intFromEnum(number)),
47 [arg1] "{$r4}" (arg1),37 [arg1] "{$r4}" (arg1),
48 [arg2] "{$r5}" (arg2),38 [arg2] "{$r5}" (arg2),
...@@ -50,10 +40,10 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -50,10 +40,10 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
50 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });40 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
51}41}
5242
53pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {43pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
54 return asm volatile (44 return asm volatile (
55 \\ syscall 045 \\ syscall 0
56 : [ret] "={$r4}" (-> usize),46 : [ret] "={$r4}" (-> u64),
57 : [number] "{$r11}" (@intFromEnum(number)),47 : [number] "{$r11}" (@intFromEnum(number)),
58 [arg1] "{$r4}" (arg1),48 [arg1] "{$r4}" (arg1),
59 [arg2] "{$r5}" (arg2),49 [arg2] "{$r5}" (arg2),
...@@ -62,10 +52,10 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -62,10 +52,10 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
62 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });52 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
63}53}
6454
65pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {55pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
66 return asm volatile (56 return asm volatile (
67 \\ syscall 057 \\ syscall 0
68 : [ret] "={$r4}" (-> usize),58 : [ret] "={$r4}" (-> u64),
69 : [number] "{$r11}" (@intFromEnum(number)),59 : [number] "{$r11}" (@intFromEnum(number)),
70 [arg1] "{$r4}" (arg1),60 [arg1] "{$r4}" (arg1),
71 [arg2] "{$r5}" (arg2),61 [arg2] "{$r5}" (arg2),
...@@ -77,16 +67,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -77,16 +67,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7767
78pub fn syscall6(68pub fn syscall6(
79 number: SYS,69 number: SYS,
80 arg1: usize,70 arg1: u64,
81 arg2: usize,71 arg2: u64,
82 arg3: usize,72 arg3: u64,
83 arg4: usize,73 arg4: u64,
84 arg5: usize,74 arg5: u64,
85 arg6: usize,75 arg6: u64,
86) usize {76) u64 {
87 return asm volatile (77 return asm volatile (
88 \\ syscall 078 \\ syscall 0
89 : [ret] "={$r4}" (-> usize),79 : [ret] "={$r4}" (-> u64),
90 : [number] "{$r11}" (@intFromEnum(number)),80 : [number] "{$r11}" (@intFromEnum(number)),
91 [arg1] "{$r4}" (arg1),81 [arg1] "{$r4}" (arg1),
92 [arg2] "{$r5}" (arg2),82 [arg2] "{$r5}" (arg2),
...@@ -97,7 +87,7 @@ pub fn syscall6(...@@ -97,7 +87,7 @@ pub fn syscall6(
97 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });87 : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
98}88}
9989
100pub fn clone() callconv(.naked) usize {90pub fn clone() callconv(.naked) u64 {
101 // __clone(func, stack, flags, arg, ptid, tls, ctid)91 // __clone(func, stack, flags, arg, ptid, tls, ctid)
102 // a0, a1, a2, a3, a4, a5, a692 // a0, a1, a2, a3, a4, a5, a6
103 // sys_clone(flags, stack, ptid, ctid, tls)93 // sys_clone(flags, stack, ptid, ctid, tls)
...@@ -150,64 +140,33 @@ pub const Stat = extern struct {...@@ -150,64 +140,33 @@ pub const Stat = extern struct {
150 ino: ino_t,140 ino: ino_t,
151 mode: mode_t,141 mode: mode_t,
152 nlink: nlink_t,142 nlink: nlink_t,
153 uid: uid_t,143 uid: std.os.linux.uid_t,
154 gid: gid_t,144 gid: std.os.linux.gid_t,
155 rdev: dev_t,145 rdev: dev_t,
156 _pad1: u64,146 _pad1: u64,
157 size: off_t,147 size: off_t,
158 blksize: blksize_t,148 blksize: blksize_t,
159 _pad2: i32,149 _pad2: i32,
160 blocks: blkcnt_t,150 blocks: blkcnt_t,
161 atim: timespec,151 atim: std.os.linux.timespec,
162 mtim: timespec,152 mtim: std.os.linux.timespec,
163 ctim: timespec,153 ctim: std.os.linux.timespec,
164 _pad3: [2]u32,154 _pad3: [2]u32,
165155
166 pub fn atime(self: @This()) timespec {156 pub fn atime(self: @This()) std.os.linux.timespec {
167 return self.atim;157 return self.atim;
168 }158 }
169159
170 pub fn mtime(self: @This()) timespec {160 pub fn mtime(self: @This()) std.os.linux.timespec {
171 return self.mtim;161 return self.mtim;
172 }162 }
173163
174 pub fn ctime(self: @This()) timespec {164 pub fn ctime(self: @This()) std.os.linux.timespec {
175 return self.ctim;165 return self.ctim;
176 }166 }
177};167};
178168
179pub const timeval = extern struct {
180 tv_sec: time_t,
181 tv_usec: i64,
182};
183
184pub const F = struct {
185 pub const DUPFD = 0;
186 pub const GETFD = 1;
187 pub const SETFD = 2;
188 pub const GETFL = 3;
189 pub const SETFL = 4;
190 pub const GETLK = 5;
191 pub const SETLK = 6;
192 pub const SETLKW = 7;
193 pub const SETOWN = 8;
194 pub const GETOWN = 9;
195 pub const SETSIG = 10;
196 pub const GETSIG = 11;
197
198 pub const RDLCK = 0;
199 pub const WRLCK = 1;
200 pub const UNLCK = 2;
201
202 pub const SETOWN_EX = 15;
203 pub const GETOWN_EX = 16;
204
205 pub const GETOWNER_UIDS = 17;
206};
207
208pub const VDSO = struct {169pub const VDSO = struct {
209 pub const CGT_SYM = "__vdso_clock_gettime";170 pub const CGT_SYM = "__vdso_clock_gettime";
210 pub const CGT_VER = "LINUX_5.10";171 pub const CGT_VER = "LINUX_5.10";
211};172};
212
213pub const Elf_Symndx = u32;
lib/std/os/linux/m68k.zig+31-81
...@@ -1,43 +1,34 @@...@@ -1,43 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const iovec = std.posix.iovec;3const SYS = std.os.linux.SYS;
4const iovec_const = std.posix.iovec_const;4
5const linux = std.os.linux;5pub fn syscall0(number: SYS) u32 {
6const SYS = linux.SYS;
7const uid_t = std.os.linux.uid_t;
8const gid_t = std.os.linux.uid_t;
9const pid_t = std.os.linux.pid_t;
10const sockaddr = linux.sockaddr;
11const socklen_t = linux.socklen_t;
12const timespec = std.os.linux.timespec;
13
14pub fn syscall0(number: SYS) usize {
15 return asm volatile ("trap #0"6 return asm volatile ("trap #0"
16 : [ret] "={d0}" (-> usize),7 : [ret] "={d0}" (-> u32),
17 : [number] "{d0}" (@intFromEnum(number)),8 : [number] "{d0}" (@intFromEnum(number)),
18 : .{ .memory = true });9 : .{ .memory = true });
19}10}
2011
21pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u32) u32 {
22 return asm volatile ("trap #0"13 return asm volatile ("trap #0"
23 : [ret] "={d0}" (-> usize),14 : [ret] "={d0}" (-> u32),
24 : [number] "{d0}" (@intFromEnum(number)),15 : [number] "{d0}" (@intFromEnum(number)),
25 [arg1] "{d1}" (arg1),16 [arg1] "{d1}" (arg1),
26 : .{ .memory = true });17 : .{ .memory = true });
27}18}
2819
29pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
30 return asm volatile ("trap #0"21 return asm volatile ("trap #0"
31 : [ret] "={d0}" (-> usize),22 : [ret] "={d0}" (-> u32),
32 : [number] "{d0}" (@intFromEnum(number)),23 : [number] "{d0}" (@intFromEnum(number)),
33 [arg1] "{d1}" (arg1),24 [arg1] "{d1}" (arg1),
34 [arg2] "{d2}" (arg2),25 [arg2] "{d2}" (arg2),
35 : .{ .memory = true });26 : .{ .memory = true });
36}27}
3728
38pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
39 return asm volatile ("trap #0"30 return asm volatile ("trap #0"
40 : [ret] "={d0}" (-> usize),31 : [ret] "={d0}" (-> u32),
41 : [number] "{d0}" (@intFromEnum(number)),32 : [number] "{d0}" (@intFromEnum(number)),
42 [arg1] "{d1}" (arg1),33 [arg1] "{d1}" (arg1),
43 [arg2] "{d2}" (arg2),34 [arg2] "{d2}" (arg2),
...@@ -45,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -45,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
45 : .{ .memory = true });36 : .{ .memory = true });
46}37}
4738
48pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
49 return asm volatile ("trap #0"40 return asm volatile ("trap #0"
50 : [ret] "={d0}" (-> usize),41 : [ret] "={d0}" (-> u32),
51 : [number] "{d0}" (@intFromEnum(number)),42 : [number] "{d0}" (@intFromEnum(number)),
52 [arg1] "{d1}" (arg1),43 [arg1] "{d1}" (arg1),
53 [arg2] "{d2}" (arg2),44 [arg2] "{d2}" (arg2),
...@@ -56,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -56,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
56 : .{ .memory = true });47 : .{ .memory = true });
57}48}
5849
59pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
60 return asm volatile ("trap #0"51 return asm volatile ("trap #0"
61 : [ret] "={d0}" (-> usize),52 : [ret] "={d0}" (-> u32),
62 : [number] "{d0}" (@intFromEnum(number)),53 : [number] "{d0}" (@intFromEnum(number)),
63 [arg1] "{d1}" (arg1),54 [arg1] "{d1}" (arg1),
64 [arg2] "{d2}" (arg2),55 [arg2] "{d2}" (arg2),
...@@ -70,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -70,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7061
71pub fn syscall6(62pub fn syscall6(
72 number: SYS,63 number: SYS,
73 arg1: usize,64 arg1: u32,
74 arg2: usize,65 arg2: u32,
75 arg3: usize,66 arg3: u32,
76 arg4: usize,67 arg4: u32,
77 arg5: usize,68 arg5: u32,
78 arg6: usize,69 arg6: u32,
79) usize {70) u32 {
80 return asm volatile ("trap #0"71 return asm volatile ("trap #0"
81 : [ret] "={d0}" (-> usize),72 : [ret] "={d0}" (-> u32),
82 : [number] "{d0}" (@intFromEnum(number)),73 : [number] "{d0}" (@intFromEnum(number)),
83 [arg1] "{d1}" (arg1),74 [arg1] "{d1}" (arg1),
84 [arg2] "{d2}" (arg2),75 [arg2] "{d2}" (arg2),
...@@ -89,7 +80,7 @@ pub fn syscall6(...@@ -89,7 +80,7 @@ pub fn syscall6(
89 : .{ .memory = true });80 : .{ .memory = true });
90}81}
9182
92pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u32 {
93 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
94 // +4, +8, +12, +16, +20, +24, +2885 // +4, +8, +12, +16, +20, +24, +28
95 //86 //
...@@ -151,32 +142,6 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -151,32 +142,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
151 );142 );
152}143}
153144
154pub const F = struct {
155 pub const DUPFD = 0;
156 pub const GETFD = 1;
157 pub const SETFD = 2;
158 pub const GETFL = 3;
159 pub const SETFL = 4;
160
161 pub const SETOWN = 8;
162 pub const GETOWN = 9;
163 pub const SETSIG = 10;
164 pub const GETSIG = 11;
165
166 pub const GETLK = 12;
167 pub const SETLK = 13;
168 pub const SETLKW = 14;
169
170 pub const SETOWN_EX = 15;
171 pub const GETOWN_EX = 16;
172
173 pub const GETOWNER_UIDS = 17;
174
175 pub const RDLCK = 0;
176 pub const WRLCK = 1;
177 pub const UNLCK = 2;
178};
179
180pub const blksize_t = i32;145pub const blksize_t = i32;
181pub const nlink_t = u32;146pub const nlink_t = u32;
182pub const time_t = i32;147pub const time_t = i32;
...@@ -186,51 +151,36 @@ pub const ino_t = u64;...@@ -186,51 +151,36 @@ pub const ino_t = u64;
186pub const dev_t = u64;151pub const dev_t = u64;
187pub const blkcnt_t = i64;152pub const blkcnt_t = i64;
188153
189pub const timeval = extern struct {
190 sec: time_t,
191 usec: i32,
192};
193
194pub const Flock = extern struct {
195 type: i16,
196 whence: i16,
197 start: off_t,
198 len: off_t,
199 pid: pid_t,
200};
201
202pub const Stat = extern struct {154pub const Stat = extern struct {
203 dev: dev_t,155 dev: dev_t,
204 __pad: i16,156 __pad: i16,
205 __ino_truncated: i32,157 __ino_truncated: i32,
206 mode: mode_t,158 mode: mode_t,
207 nlink: nlink_t,159 nlink: nlink_t,
208 uid: uid_t,160 uid: std.os.linux.uid_t,
209 gid: gid_t,161 gid: std.os.linux.gid_t,
210 rdev: dev_t,162 rdev: dev_t,
211 __pad2: i16,163 __pad2: i16,
212 size: off_t,164 size: off_t,
213 blksize: blksize_t,165 blksize: blksize_t,
214 blocks: blkcnt_t,166 blocks: blkcnt_t,
215 atim: timespec,167 atim: std.os.linux.timespec,
216 mtim: timespec,168 mtim: std.os.linux.timespec,
217 ctim: timespec,169 ctim: std.os.linux.timespec,
218 ino: ino_t,170 ino: ino_t,
219171
220 pub fn atime(self: @This()) timespec {172 pub fn atime(self: @This()) std.os.linux.timespec {
221 return self.atim;173 return self.atim;
222 }174 }
223175
224 pub fn mtime(self: @This()) timespec {176 pub fn mtime(self: @This()) std.os.linux.timespec {
225 return self.mtim;177 return self.mtim;
226 }178 }
227179
228 pub fn ctime(self: @This()) timespec {180 pub fn ctime(self: @This()) std.os.linux.timespec {
229 return self.ctim;181 return self.ctim;
230 }182 }
231};183};
232184
233pub const Elf_Symndx = u32;
234
235// No VDSO used as of glibc 112a0ae18b831bf31f44d81b82666980312511d6.185// No VDSO used as of glibc 112a0ae18b831bf31f44d81b82666980312511d6.
236pub const VDSO = void;186pub const VDSO = void;
lib/std/os/linux/mips.zig+44-116
...@@ -1,32 +1,20 @@...@@ -1,32 +1,20 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;
5const SYS = linux.SYS;
6const socklen_t = linux.socklen_t;
7const iovec = std.posix.iovec;
8const iovec_const = std.posix.iovec_const;
9const uid_t = linux.uid_t;
10const gid_t = linux.gid_t;
11const pid_t = linux.pid_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const sockaddr = linux.sockaddr;
15const timespec = linux.timespec;
164
17pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
18 return asm volatile (6 return asm volatile (
19 \\ syscall7 \\ syscall
20 \\ beq $7, $zero, 1f8 \\ beq $7, $zero, 1f
21 \\ blez $2, 1f9 \\ blez $2, 1f
22 \\ subu $2, $0, $210 \\ subu $2, $0, $2
23 \\ 1:11 \\ 1:
24 : [ret] "={$2}" (-> usize),12 : [ret] "={$2}" (-> u32),
25 : [number] "{$2}" (@intFromEnum(number)),13 : [number] "{$2}" (@intFromEnum(number)),
26 : .{ .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 });14 : .{ .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 });
27}15}
2816
29pub fn syscall_pipe(fd: *[2]i32) usize {17pub fn syscall_pipe(fd: *[2]i32) u32 {
30 return asm volatile (18 return asm volatile (
31 \\ .set noat19 \\ .set noat
32 \\ .set noreorder20 \\ .set noreorder
...@@ -39,47 +27,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {...@@ -39,47 +27,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
39 \\ sw $2, 0($4)27 \\ sw $2, 0($4)
40 \\ sw $3, 4($4)28 \\ sw $3, 4($4)
41 \\ 2:29 \\ 2:
42 : [ret] "={$2}" (-> usize),30 : [ret] "={$2}" (-> u32),
43 : [number] "{$2}" (@intFromEnum(SYS.pipe)),31 : [number] "{$2}" (@intFromEnum(SYS.pipe)),
44 [fd] "{$4}" (fd),32 [fd] "{$4}" (fd),
45 : .{ .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 });33 : .{ .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 });
46}34}
4735
48pub fn syscall1(number: SYS, arg1: usize) usize {36pub fn syscall1(number: SYS, arg1: u32) u32 {
49 return asm volatile (37 return asm volatile (
50 \\ syscall38 \\ syscall
51 \\ beq $7, $zero, 1f39 \\ beq $7, $zero, 1f
52 \\ blez $2, 1f40 \\ blez $2, 1f
53 \\ subu $2, $0, $241 \\ subu $2, $0, $2
54 \\ 1:42 \\ 1:
55 : [ret] "={$2}" (-> usize),43 : [ret] "={$2}" (-> u32),
56 : [number] "{$2}" (@intFromEnum(number)),44 : [number] "{$2}" (@intFromEnum(number)),
57 [arg1] "{$4}" (arg1),45 [arg1] "{$4}" (arg1),
58 : .{ .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 });46 : .{ .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 });
59}47}
6048
61pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {49pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
62 return asm volatile (50 return asm volatile (
63 \\ syscall51 \\ syscall
64 \\ beq $7, $zero, 1f52 \\ beq $7, $zero, 1f
65 \\ blez $2, 1f53 \\ blez $2, 1f
66 \\ subu $2, $0, $254 \\ subu $2, $0, $2
67 \\ 1:55 \\ 1:
68 : [ret] "={$2}" (-> usize),56 : [ret] "={$2}" (-> u32),
69 : [number] "{$2}" (@intFromEnum(number)),57 : [number] "{$2}" (@intFromEnum(number)),
70 [arg1] "{$4}" (arg1),58 [arg1] "{$4}" (arg1),
71 [arg2] "{$5}" (arg2),59 [arg2] "{$5}" (arg2),
72 : .{ .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 });60 : .{ .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 });
73}61}
7462
75pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {63pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
76 return asm volatile (64 return asm volatile (
77 \\ syscall65 \\ syscall
78 \\ beq $7, $zero, 1f66 \\ beq $7, $zero, 1f
79 \\ blez $2, 1f67 \\ blez $2, 1f
80 \\ subu $2, $0, $268 \\ subu $2, $0, $2
81 \\ 1:69 \\ 1:
82 : [ret] "={$2}" (-> usize),70 : [ret] "={$2}" (-> u32),
83 : [number] "{$2}" (@intFromEnum(number)),71 : [number] "{$2}" (@intFromEnum(number)),
84 [arg1] "{$4}" (arg1),72 [arg1] "{$4}" (arg1),
85 [arg2] "{$5}" (arg2),73 [arg2] "{$5}" (arg2),
...@@ -87,14 +75,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -87,14 +75,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
87 : .{ .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 });75 : .{ .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 });
88}76}
8977
90pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {78pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
91 return asm volatile (79 return asm volatile (
92 \\ syscall80 \\ syscall
93 \\ beq $7, $zero, 1f81 \\ beq $7, $zero, 1f
94 \\ blez $2, 1f82 \\ blez $2, 1f
95 \\ subu $2, $0, $283 \\ subu $2, $0, $2
96 \\ 1:84 \\ 1:
97 : [ret] "={$2}" (-> usize),85 : [ret] "={$2}" (-> u32),
98 : [number] "{$2}" (@intFromEnum(number)),86 : [number] "{$2}" (@intFromEnum(number)),
99 [arg1] "{$4}" (arg1),87 [arg1] "{$4}" (arg1),
100 [arg2] "{$5}" (arg2),88 [arg2] "{$5}" (arg2),
...@@ -103,7 +91,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -103,7 +91,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
103 : .{ .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 });91 : .{ .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 });
104}92}
10593
106pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {94pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
107 return asm volatile (95 return asm volatile (
108 \\ .set noat96 \\ .set noat
109 \\ subu $sp, $sp, 2497 \\ subu $sp, $sp, 24
...@@ -114,7 +102,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -114,7 +102,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
114 \\ blez $2, 1f102 \\ blez $2, 1f
115 \\ subu $2, $0, $2103 \\ subu $2, $0, $2
116 \\ 1:104 \\ 1:
117 : [ret] "={$2}" (-> usize),105 : [ret] "={$2}" (-> u32),
118 : [number] "{$2}" (@intFromEnum(number)),106 : [number] "{$2}" (@intFromEnum(number)),
119 [arg1] "{$4}" (arg1),107 [arg1] "{$4}" (arg1),
120 [arg2] "{$5}" (arg2),108 [arg2] "{$5}" (arg2),
...@@ -129,13 +117,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -129,13 +117,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
129117
130pub fn syscall6(118pub fn syscall6(
131 number: SYS,119 number: SYS,
132 arg1: usize,120 arg1: u32,
133 arg2: usize,121 arg2: u32,
134 arg3: usize,122 arg3: u32,
135 arg4: usize,123 arg4: u32,
136 arg5: usize,124 arg5: u32,
137 arg6: usize,125 arg6: u32,
138) usize {126) u32 {
139 return asm volatile (127 return asm volatile (
140 \\ .set noat128 \\ .set noat
141 \\ subu $sp, $sp, 24129 \\ subu $sp, $sp, 24
...@@ -147,7 +135,7 @@ pub fn syscall6(...@@ -147,7 +135,7 @@ pub fn syscall6(
147 \\ blez $2, 1f135 \\ blez $2, 1f
148 \\ subu $2, $0, $2136 \\ subu $2, $0, $2
149 \\ 1:137 \\ 1:
150 : [ret] "={$2}" (-> usize),138 : [ret] "={$2}" (-> u32),
151 : [number] "{$2}" (@intFromEnum(number)),139 : [number] "{$2}" (@intFromEnum(number)),
152 [arg1] "{$4}" (arg1),140 [arg1] "{$4}" (arg1),
153 [arg2] "{$5}" (arg2),141 [arg2] "{$5}" (arg2),
...@@ -160,14 +148,14 @@ pub fn syscall6(...@@ -160,14 +148,14 @@ pub fn syscall6(
160148
161pub fn syscall7(149pub fn syscall7(
162 number: SYS,150 number: SYS,
163 arg1: usize,151 arg1: u32,
164 arg2: usize,152 arg2: u32,
165 arg3: usize,153 arg3: u32,
166 arg4: usize,154 arg4: u32,
167 arg5: usize,155 arg5: u32,
168 arg6: usize,156 arg6: u32,
169 arg7: usize,157 arg7: u32,
170) usize {158) u32 {
171 return asm volatile (159 return asm volatile (
172 \\ .set noat160 \\ .set noat
173 \\ subu $sp, $sp, 32161 \\ subu $sp, $sp, 32
...@@ -180,7 +168,7 @@ pub fn syscall7(...@@ -180,7 +168,7 @@ pub fn syscall7(
180 \\ blez $2, 1f168 \\ blez $2, 1f
181 \\ subu $2, $0, $2169 \\ subu $2, $0, $2
182 \\ 1:170 \\ 1:
183 : [ret] "={$2}" (-> usize),171 : [ret] "={$2}" (-> u32),
184 : [number] "{$2}" (@intFromEnum(number)),172 : [number] "{$2}" (@intFromEnum(number)),
185 [arg1] "{$4}" (arg1),173 [arg1] "{$4}" (arg1),
186 [arg2] "{$5}" (arg2),174 [arg2] "{$5}" (arg2),
...@@ -192,7 +180,7 @@ pub fn syscall7(...@@ -192,7 +180,7 @@ pub fn syscall7(
192 : .{ .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 });180 : .{ .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 });
193}181}
194182
195pub fn clone() callconv(.naked) usize {183pub fn clone() callconv(.naked) u32 {
196 // __clone(func, stack, flags, arg, ptid, tls, ctid)184 // __clone(func, stack, flags, arg, ptid, tls, ctid)
197 // 3, 4, 5, 6, 7, 8, 9185 // 3, 4, 5, 6, 7, 8, 9
198 //186 //
...@@ -243,47 +231,11 @@ pub fn clone() callconv(.naked) usize {...@@ -243,47 +231,11 @@ pub fn clone() callconv(.naked) usize {
243 );231 );
244}232}
245233
246pub const F = struct {
247 pub const DUPFD = 0;
248 pub const GETFD = 1;
249 pub const SETFD = 2;
250 pub const GETFL = 3;
251 pub const SETFL = 4;
252
253 pub const SETOWN = 24;
254 pub const GETOWN = 23;
255 pub const SETSIG = 10;
256 pub const GETSIG = 11;
257
258 pub const GETLK = 33;
259 pub const SETLK = 34;
260 pub const SETLKW = 35;
261
262 pub const RDLCK = 0;
263 pub const WRLCK = 1;
264 pub const UNLCK = 2;
265
266 pub const SETOWN_EX = 15;
267 pub const GETOWN_EX = 16;
268
269 pub const GETOWNER_UIDS = 17;
270};
271
272pub const VDSO = struct {234pub const VDSO = struct {
273 pub const CGT_SYM = "__vdso_clock_gettime";235 pub const CGT_SYM = "__vdso_clock_gettime";
274 pub const CGT_VER = "LINUX_2.6";236 pub const CGT_VER = "LINUX_2.6";
275};237};
276238
277pub const Flock = extern struct {
278 type: i16,
279 whence: i16,
280 __pad0: [4]u8,
281 start: off_t,
282 len: off_t,
283 pid: pid_t,
284 __unused: [4]u8,
285};
286
287pub const blksize_t = u32;239pub const blksize_t = u32;
288pub const nlink_t = u32;240pub const nlink_t = u32;
289pub const time_t = i32;241pub const time_t = i32;
...@@ -300,51 +252,27 @@ pub const Stat = extern struct {...@@ -300,51 +252,27 @@ pub const Stat = extern struct {
300 ino: ino_t,252 ino: ino_t,
301 mode: mode_t,253 mode: mode_t,
302 nlink: nlink_t,254 nlink: nlink_t,
303 uid: uid_t,255 uid: std.os.linux.uid_t,
304 gid: gid_t,256 gid: std.os.linux.gid_t,
305 rdev: dev_t,257 rdev: dev_t,
306 __pad1: [2]u32,258 __pad1: [2]u32,
307 size: off_t,259 size: off_t,
308 atim: i32,260 atim: std.os.linux.timespec,
309 atim_nsec: i32,261 mtim: std.os.linux.timespec,
310 mtim: i32,262 ctim: std.os.linux.timespec,
311 mtim_nsec: i32,
312 ctim: i32,
313 ctim_nsec: i32,
314 blksize: blksize_t,263 blksize: blksize_t,
315 __pad3: u32,264 __pad3: u32,
316 blocks: blkcnt_t,265 blocks: blkcnt_t,
317266
318 pub fn atime(self: @This()) timespec {267 pub fn atime(self: @This()) std.os.linux.timespec {
319 return .{268 return self.atim;
320 .sec = self.atim,
321 .nsec = self.atim_nsec,
322 };
323 }269 }
324270
325 pub fn mtime(self: @This()) timespec {271 pub fn mtime(self: @This()) std.os.linux.timespec {
326 return .{272 return self.mtim;
327 .sec = self.mtim,
328 .nsec = self.mtim_nsec,
329 };
330 }273 }
331274
332 pub fn ctime(self: @This()) timespec {275 pub fn ctime(self: @This()) std.os.linux.timespec {
333 return .{276 return self.ctim;
334 .sec = self.ctim,
335 .nsec = self.ctim_nsec,
336 };
337 }277 }
338};278};
339
340pub const timeval = extern struct {
341 sec: isize,
342 usec: isize,
343};
344
345pub const timezone = extern struct {
346 minuteswest: i32,
347 dsttime: i32,
348};
349
350pub const Elf_Symndx = u32;
lib/std/os/linux/mips64.zig+38-98
...@@ -1,32 +1,20 @@...@@ -1,32 +1,20 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;
5const SYS = linux.SYS;
6const socklen_t = linux.socklen_t;
7const iovec = std.posix.iovec;
8const iovec_const = std.posix.iovec_const;
9const uid_t = linux.uid_t;
10const gid_t = linux.gid_t;
11const pid_t = linux.pid_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const sockaddr = linux.sockaddr;
15const timespec = linux.timespec;
164
17pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u64 {
18 return asm volatile (6 return asm volatile (
19 \\ syscall7 \\ syscall
20 \\ beq $7, $zero, 1f8 \\ beq $7, $zero, 1f
21 \\ blez $2, 1f9 \\ blez $2, 1f
22 \\ dsubu $2, $0, $210 \\ dsubu $2, $0, $2
23 \\ 1:11 \\ 1:
24 : [ret] "={$2}" (-> usize),12 : [ret] "={$2}" (-> u64),
25 : [number] "{$2}" (@intFromEnum(number)),13 : [number] "{$2}" (@intFromEnum(number)),
26 : .{ .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 });14 : .{ .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 });
27}15}
2816
29pub fn syscall_pipe(fd: *[2]i32) usize {17pub fn syscall_pipe(fd: *[2]i32) u64 {
30 return asm volatile (18 return asm volatile (
31 \\ .set noat19 \\ .set noat
32 \\ .set noreorder20 \\ .set noreorder
...@@ -39,13 +27,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {...@@ -39,13 +27,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
39 \\ sw $2, 0($4)27 \\ sw $2, 0($4)
40 \\ sw $3, 4($4)28 \\ sw $3, 4($4)
41 \\ 2:29 \\ 2:
42 : [ret] "={$2}" (-> usize),30 : [ret] "={$2}" (-> u64),
43 : [number] "{$2}" (@intFromEnum(SYS.pipe)),31 : [number] "{$2}" (@intFromEnum(SYS.pipe)),
44 [fd] "{$4}" (fd),32 [fd] "{$4}" (fd),
45 : .{ .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 });33 : .{ .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 });
46}34}
4735
48pub fn syscall1(number: SYS, arg1: usize) usize {36pub fn syscall1(number: SYS, arg1: u64) u64 {
49 return asm volatile (37 return asm volatile (
50 \\ syscall38 \\ syscall
51 \\ beq $7, $zero, 1f39 \\ beq $7, $zero, 1f
...@@ -53,34 +41,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {...@@ -53,34 +41,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
53 \\ nop41 \\ nop
54 \\ dsubu $2, $0, $242 \\ dsubu $2, $0, $2
55 \\ 1:43 \\ 1:
56 : [ret] "={$2}" (-> usize),44 : [ret] "={$2}" (-> u64),
57 : [number] "{$2}" (@intFromEnum(number)),45 : [number] "{$2}" (@intFromEnum(number)),
58 [arg1] "{$4}" (arg1),46 [arg1] "{$4}" (arg1),
59 : .{ .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 });47 : .{ .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 });
60}48}
6149
62pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {50pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
63 return asm volatile (51 return asm volatile (
64 \\ syscall52 \\ syscall
65 \\ beq $7, $zero, 1f53 \\ beq $7, $zero, 1f
66 \\ blez $2, 1f54 \\ blez $2, 1f
67 \\ dsubu $2, $0, $255 \\ dsubu $2, $0, $2
68 \\ 1:56 \\ 1:
69 : [ret] "={$2}" (-> usize),57 : [ret] "={$2}" (-> u64),
70 : [number] "{$2}" (@intFromEnum(number)),58 : [number] "{$2}" (@intFromEnum(number)),
71 [arg1] "{$4}" (arg1),59 [arg1] "{$4}" (arg1),
72 [arg2] "{$5}" (arg2),60 [arg2] "{$5}" (arg2),
73 : .{ .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 });61 : .{ .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 });
74}62}
7563
76pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {64pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
77 return asm volatile (65 return asm volatile (
78 \\ syscall66 \\ syscall
79 \\ beq $7, $zero, 1f67 \\ beq $7, $zero, 1f
80 \\ blez $2, 1f68 \\ blez $2, 1f
81 \\ dsubu $2, $0, $269 \\ dsubu $2, $0, $2
82 \\ 1:70 \\ 1:
83 : [ret] "={$2}" (-> usize),71 : [ret] "={$2}" (-> u64),
84 : [number] "{$2}" (@intFromEnum(number)),72 : [number] "{$2}" (@intFromEnum(number)),
85 [arg1] "{$4}" (arg1),73 [arg1] "{$4}" (arg1),
86 [arg2] "{$5}" (arg2),74 [arg2] "{$5}" (arg2),
...@@ -88,14 +76,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -88,14 +76,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
88 : .{ .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 });76 : .{ .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 });
89}77}
9078
91pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {79pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
92 return asm volatile (80 return asm volatile (
93 \\ syscall81 \\ syscall
94 \\ beq $7, $zero, 1f82 \\ beq $7, $zero, 1f
95 \\ blez $2, 1f83 \\ blez $2, 1f
96 \\ dsubu $2, $0, $284 \\ dsubu $2, $0, $2
97 \\ 1:85 \\ 1:
98 : [ret] "={$2}" (-> usize),86 : [ret] "={$2}" (-> u64),
99 : [number] "{$2}" (@intFromEnum(number)),87 : [number] "{$2}" (@intFromEnum(number)),
100 [arg1] "{$4}" (arg1),88 [arg1] "{$4}" (arg1),
101 [arg2] "{$5}" (arg2),89 [arg2] "{$5}" (arg2),
...@@ -104,14 +92,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -104,14 +92,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
104 : .{ .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 });92 : .{ .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 });
105}93}
10694
107pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {95pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
108 return asm volatile (96 return asm volatile (
109 \\ syscall97 \\ syscall
110 \\ beq $7, $zero, 1f98 \\ beq $7, $zero, 1f
111 \\ blez $2, 1f99 \\ blez $2, 1f
112 \\ dsubu $2, $0, $2100 \\ dsubu $2, $0, $2
113 \\ 1:101 \\ 1:
114 : [ret] "={$2}" (-> usize),102 : [ret] "={$2}" (-> u64),
115 : [number] "{$2}" (@intFromEnum(number)),103 : [number] "{$2}" (@intFromEnum(number)),
116 [arg1] "{$4}" (arg1),104 [arg1] "{$4}" (arg1),
117 [arg2] "{$5}" (arg2),105 [arg2] "{$5}" (arg2),
...@@ -123,20 +111,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -123,20 +111,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
123111
124pub fn syscall6(112pub fn syscall6(
125 number: SYS,113 number: SYS,
126 arg1: usize,114 arg1: u64,
127 arg2: usize,115 arg2: u64,
128 arg3: usize,116 arg3: u64,
129 arg4: usize,117 arg4: u64,
130 arg5: usize,118 arg5: u64,
131 arg6: usize,119 arg6: u64,
132) usize {120) u64 {
133 return asm volatile (121 return asm volatile (
134 \\ syscall122 \\ syscall
135 \\ beq $7, $zero, 1f123 \\ beq $7, $zero, 1f
136 \\ blez $2, 1f124 \\ blez $2, 1f
137 \\ dsubu $2, $0, $2125 \\ dsubu $2, $0, $2
138 \\ 1:126 \\ 1:
139 : [ret] "={$2}" (-> usize),127 : [ret] "={$2}" (-> u64),
140 : [number] "{$2}" (@intFromEnum(number)),128 : [number] "{$2}" (@intFromEnum(number)),
141 [arg1] "{$4}" (arg1),129 [arg1] "{$4}" (arg1),
142 [arg2] "{$5}" (arg2),130 [arg2] "{$5}" (arg2),
...@@ -149,21 +137,21 @@ pub fn syscall6(...@@ -149,21 +137,21 @@ pub fn syscall6(
149137
150pub fn syscall7(138pub fn syscall7(
151 number: SYS,139 number: SYS,
152 arg1: usize,140 arg1: u64,
153 arg2: usize,141 arg2: u64,
154 arg3: usize,142 arg3: u64,
155 arg4: usize,143 arg4: u64,
156 arg5: usize,144 arg5: u64,
157 arg6: usize,145 arg6: u64,
158 arg7: usize,146 arg7: u64,
159) usize {147) u64 {
160 return asm volatile (148 return asm volatile (
161 \\ syscall149 \\ syscall
162 \\ beq $7, $zero, 1f150 \\ beq $7, $zero, 1f
163 \\ blez $2, 1f151 \\ blez $2, 1f
164 \\ dsubu $2, $0, $2152 \\ dsubu $2, $0, $2
165 \\ 1:153 \\ 1:
166 : [ret] "={$2}" (-> usize),154 : [ret] "={$2}" (-> u64),
167 : [number] "{$2}" (@intFromEnum(number)),155 : [number] "{$2}" (@intFromEnum(number)),
168 [arg1] "{$4}" (arg1),156 [arg1] "{$4}" (arg1),
169 [arg2] "{$5}" (arg2),157 [arg2] "{$5}" (arg2),
...@@ -175,7 +163,7 @@ pub fn syscall7(...@@ -175,7 +163,7 @@ pub fn syscall7(
175 : .{ .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 });163 : .{ .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 });
176}164}
177165
178pub fn clone() callconv(.naked) usize {166pub fn clone() callconv(.naked) u64 {
179 // __clone(func, stack, flags, arg, ptid, tls, ctid)167 // __clone(func, stack, flags, arg, ptid, tls, ctid)
180 // 3, 4, 5, 6, 7, 8, 9168 // 3, 4, 5, 6, 7, 8, 9
181 //169 //
...@@ -222,47 +210,11 @@ pub fn clone() callconv(.naked) usize {...@@ -222,47 +210,11 @@ pub fn clone() callconv(.naked) usize {
222 );210 );
223}211}
224212
225pub const F = struct {
226 pub const DUPFD = 0;
227 pub const GETFD = 1;
228 pub const SETFD = 2;
229 pub const GETFL = 3;
230 pub const SETFL = 4;
231
232 pub const SETOWN = 24;
233 pub const GETOWN = 23;
234 pub const SETSIG = 10;
235 pub const GETSIG = 11;
236
237 pub const GETLK = 33;
238 pub const SETLK = 34;
239 pub const SETLKW = 35;
240
241 pub const RDLCK = 0;
242 pub const WRLCK = 1;
243 pub const UNLCK = 2;
244
245 pub const SETOWN_EX = 15;
246 pub const GETOWN_EX = 16;
247
248 pub const GETOWNER_UIDS = 17;
249};
250
251pub const VDSO = struct {213pub const VDSO = struct {
252 pub const CGT_SYM = "__vdso_clock_gettime";214 pub const CGT_SYM = "__vdso_clock_gettime";
253 pub const CGT_VER = "LINUX_2.6";215 pub const CGT_VER = "LINUX_2.6";
254};216};
255217
256pub const Flock = extern struct {
257 type: i16,
258 whence: i16,
259 __pad0: [4]u8,
260 start: off_t,
261 len: off_t,
262 pid: pid_t,
263 __unused: [4]u8,
264};
265
266pub const blksize_t = u32;218pub const blksize_t = u32;
267pub const nlink_t = u32;219pub const nlink_t = u32;
268pub const time_t = i32;220pub const time_t = i32;
...@@ -279,8 +231,8 @@ pub const Stat = extern struct {...@@ -279,8 +231,8 @@ pub const Stat = extern struct {
279 ino: ino_t,231 ino: ino_t,
280 mode: mode_t,232 mode: mode_t,
281 nlink: nlink_t,233 nlink: nlink_t,
282 uid: uid_t,234 uid: std.os.linux.uid_t,
283 gid: gid_t,235 gid: std.os.linux.gid_t,
284 rdev: dev_t,236 rdev: dev_t,
285 __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).237 __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
286 size: off_t,238 size: off_t,
...@@ -294,36 +246,24 @@ pub const Stat = extern struct {...@@ -294,36 +246,24 @@ pub const Stat = extern struct {
294 __pad3: u32,246 __pad3: u32,
295 blocks: blkcnt_t,247 blocks: blkcnt_t,
296248
297 pub fn atime(self: @This()) timespec {249 pub fn atime(self: @This()) std.os.linux.timespec {
298 return .{250 return .{
299 .sec = self.atim,251 .sec = self.atim,
300 .nsec = self.atim_nsec,252 .nsec = self.atim_nsec,
301 };253 };
302 }254 }
303255
304 pub fn mtime(self: @This()) timespec {256 pub fn mtime(self: @This()) std.os.linux.timespec {
305 return .{257 return .{
306 .sec = self.mtim,258 .sec = self.mtim,
307 .nsec = self.mtim_nsec,259 .nsec = self.mtim_nsec,
308 };260 };
309 }261 }
310262
311 pub fn ctime(self: @This()) timespec {263 pub fn ctime(self: @This()) std.os.linux.timespec {
312 return .{264 return .{
313 .sec = self.ctim,265 .sec = self.ctim,
314 .nsec = self.ctim_nsec,266 .nsec = self.ctim_nsec,
315 };267 };
316 }268 }
317};269};
318
319pub const timeval = extern struct {
320 sec: isize,
321 usec: isize,
322};
323
324pub const timezone = extern struct {
325 minuteswest: i32,
326 dsttime: i32,
327};
328
329pub const Elf_Symndx = u32;
lib/std/os/linux/mipsn32.zig created+271
...@@ -0,0 +1,271 @@
1// TODO: A lot of this file is very likely wrong.
2
3const builtin = @import("builtin");
4const std = @import("../../std.zig");
5const SYS = std.os.linux.SYS;
6
7pub fn syscall0(number: SYS) u32 {
8 return asm volatile (
9 \\ syscall
10 \\ beq $7, $zero, 1f
11 \\ blez $2, 1f
12 \\ dsubu $2, $0, $2
13 \\ 1:
14 : [ret] "={$2}" (-> u32),
15 : [number] "{$2}" (@intFromEnum(number)),
16 : .{ .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 });
17}
18
19pub fn syscall_pipe(fd: *[2]i32) u32 {
20 return asm volatile (
21 \\ .set noat
22 \\ .set noreorder
23 \\ syscall
24 \\ beq $7, $zero, 1f
25 \\ nop
26 \\ b 2f
27 \\ subu $2, $0, $2
28 \\ 1:
29 \\ sw $2, 0($4)
30 \\ sw $3, 4($4)
31 \\ 2:
32 : [ret] "={$2}" (-> u32),
33 : [number] "{$2}" (@intFromEnum(SYS.pipe)),
34 [fd] "{$4}" (fd),
35 : .{ .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 });
36}
37
38pub fn syscall1(number: SYS, arg1: u32) u32 {
39 return asm volatile (
40 \\ syscall
41 \\ beq $7, $zero, 1f
42 \\ blez $2, 1f
43 \\ nop
44 \\ dsubu $2, $0, $2
45 \\ 1:
46 : [ret] "={$2}" (-> u32),
47 : [number] "{$2}" (@intFromEnum(number)),
48 [arg1] "{$4}" (arg1),
49 : .{ .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 });
50}
51
52pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
53 return asm volatile (
54 \\ syscall
55 \\ beq $7, $zero, 1f
56 \\ blez $2, 1f
57 \\ dsubu $2, $0, $2
58 \\ 1:
59 : [ret] "={$2}" (-> u32),
60 : [number] "{$2}" (@intFromEnum(number)),
61 [arg1] "{$4}" (arg1),
62 [arg2] "{$5}" (arg2),
63 : .{ .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 });
64}
65
66pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
67 return asm volatile (
68 \\ syscall
69 \\ beq $7, $zero, 1f
70 \\ blez $2, 1f
71 \\ dsubu $2, $0, $2
72 \\ 1:
73 : [ret] "={$2}" (-> u32),
74 : [number] "{$2}" (@intFromEnum(number)),
75 [arg1] "{$4}" (arg1),
76 [arg2] "{$5}" (arg2),
77 [arg3] "{$6}" (arg3),
78 : .{ .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 });
79}
80
81pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
82 return asm volatile (
83 \\ syscall
84 \\ beq $7, $zero, 1f
85 \\ blez $2, 1f
86 \\ dsubu $2, $0, $2
87 \\ 1:
88 : [ret] "={$2}" (-> u32),
89 : [number] "{$2}" (@intFromEnum(number)),
90 [arg1] "{$4}" (arg1),
91 [arg2] "{$5}" (arg2),
92 [arg3] "{$6}" (arg3),
93 [arg4] "{$7}" (arg4),
94 : .{ .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 });
95}
96
97pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
98 return asm volatile (
99 \\ syscall
100 \\ beq $7, $zero, 1f
101 \\ blez $2, 1f
102 \\ dsubu $2, $0, $2
103 \\ 1:
104 : [ret] "={$2}" (-> u32),
105 : [number] "{$2}" (@intFromEnum(number)),
106 [arg1] "{$4}" (arg1),
107 [arg2] "{$5}" (arg2),
108 [arg3] "{$6}" (arg3),
109 [arg4] "{$7}" (arg4),
110 [arg5] "{$8}" (arg5),
111 : .{ .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 });
112}
113
114pub fn syscall6(
115 number: SYS,
116 arg1: u32,
117 arg2: u32,
118 arg3: u32,
119 arg4: u32,
120 arg5: u32,
121 arg6: u32,
122) u32 {
123 return asm volatile (
124 \\ syscall
125 \\ beq $7, $zero, 1f
126 \\ blez $2, 1f
127 \\ dsubu $2, $0, $2
128 \\ 1:
129 : [ret] "={$2}" (-> u32),
130 : [number] "{$2}" (@intFromEnum(number)),
131 [arg1] "{$4}" (arg1),
132 [arg2] "{$5}" (arg2),
133 [arg3] "{$6}" (arg3),
134 [arg4] "{$7}" (arg4),
135 [arg5] "{$8}" (arg5),
136 [arg6] "{$9}" (arg6),
137 : .{ .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 });
138}
139
140pub fn syscall7(
141 number: SYS,
142 arg1: u32,
143 arg2: u32,
144 arg3: u32,
145 arg4: u32,
146 arg5: u32,
147 arg6: u32,
148 arg7: u32,
149) u32 {
150 return asm volatile (
151 \\ syscall
152 \\ beq $7, $zero, 1f
153 \\ blez $2, 1f
154 \\ dsubu $2, $0, $2
155 \\ 1:
156 : [ret] "={$2}" (-> u32),
157 : [number] "{$2}" (@intFromEnum(number)),
158 [arg1] "{$4}" (arg1),
159 [arg2] "{$5}" (arg2),
160 [arg3] "{$6}" (arg3),
161 [arg4] "{$7}" (arg4),
162 [arg5] "{$8}" (arg5),
163 [arg6] "{$9}" (arg6),
164 [arg7] "{$10}" (arg7),
165 : .{ .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 });
166}
167
168pub fn clone() callconv(.naked) u32 {
169 // __clone(func, stack, flags, arg, ptid, tls, ctid)
170 // 3, 4, 5, 6, 7, 8, 9
171 //
172 // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
173 // 2 4, 5, 6, 7, 8
174 asm volatile (
175 \\ # Save function pointer and argument pointer on new thread stack
176 \\ and $5, $5, -16
177 \\ dsubu $5, $5, 16
178 \\ sd $4, 0($5)
179 \\ sd $7, 8($5)
180 \\ # Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
181 \\ move $4, $6
182 \\ move $6, $8
183 \\ move $7, $9
184 \\ move $8, $10
185 \\ li $2, 5055 # SYS_clone
186 \\ syscall
187 \\ beq $7, $0, 1f
188 \\ nop
189 \\ jr $ra
190 \\ dsubu $2, $0, $2
191 \\1:
192 \\ beq $2, $0, 1f
193 \\ nop
194 \\ jr $ra
195 \\ nop
196 \\1:
197 );
198 if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
199 \\ .cfi_undefined $ra
200 );
201 asm volatile (
202 \\ move $fp, $zero
203 \\ move $ra, $zero
204 \\
205 \\ ld $25, 0($sp)
206 \\ ld $4, 8($sp)
207 \\ jalr $25
208 \\ nop
209 \\ move $4, $2
210 \\ li $2, 5058 # SYS_exit
211 \\ syscall
212 );
213}
214
215pub const VDSO = struct {
216 pub const CGT_SYM = "__vdso_clock_gettime";
217 pub const CGT_VER = "LINUX_2.6";
218};
219
220pub const blksize_t = u32;
221pub const nlink_t = u32;
222pub const time_t = i32;
223pub const mode_t = u32;
224pub const off_t = i64;
225pub const ino_t = u64;
226pub const dev_t = u64;
227pub const blkcnt_t = i64;
228
229// The `stat` definition used by the Linux kernel.
230pub const Stat = extern struct {
231 dev: dev_t,
232 __pad0: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
233 ino: ino_t,
234 mode: mode_t,
235 nlink: nlink_t,
236 uid: std.os.linux.uid_t,
237 gid: std.os.linux.gid_t,
238 rdev: dev_t,
239 __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
240 size: off_t,
241 atim: u32,
242 atim_nsec: u32,
243 mtim: u32,
244 mtim_nsec: u32,
245 ctim: u32,
246 ctim_nsec: u32,
247 blksize: blksize_t,
248 __pad3: u32,
249 blocks: blkcnt_t,
250
251 pub fn atime(self: @This()) std.os.linux.timespec {
252 return .{
253 .sec = self.atim,
254 .nsec = self.atim_nsec,
255 };
256 }
257
258 pub fn mtime(self: @This()) std.os.linux.timespec {
259 return .{
260 .sec = self.mtim,
261 .nsec = self.mtim_nsec,
262 };
263 }
264
265 pub fn ctime(self: @This()) std.os.linux.timespec {
266 return .{
267 .sec = self.ctim,
268 .nsec = self.ctim_nsec,
269 };
270 }
271};
lib/std/os/linux/powerpc.zig+55-113
...@@ -1,61 +1,49 @@...@@ -1,61 +1,49 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;
5const SYS = linux.SYS;
6const socklen_t = linux.socklen_t;
7const iovec = std.posix.iovec;
8const iovec_const = std.posix.iovec_const;
9const uid_t = linux.uid_t;
10const gid_t = linux.gid_t;
11const pid_t = linux.pid_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const sockaddr = linux.sockaddr;
15const timespec = linux.timespec;
164
17pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
18 // r0 is both an input register and a clobber. musl and glibc achieve this with6 // r0 is both an input register and a clobber. musl and glibc achieve this with
19 // a "+" constraint, which isn't supported in Zig, so instead we separately list7 // a "+" constraint, which isn't supported in Zig, so instead we separately list
20 // r0 as both an input and an output. (Listing it as an input and a clobber would8 // r0 as both an input and an output. (Listing it as an input and a clobber would
21 // cause the C backend to emit invalid code; see #25209.)9 // cause the C backend to emit invalid code; see #25209.)
22 var r0_out: usize = undefined;10 var r0_out: u32 = undefined;
23 return asm volatile (11 return asm volatile (
24 \\ sc12 \\ sc
25 \\ bns+ 1f13 \\ bns+ 1f
26 \\ neg 3, 314 \\ neg 3, 3
27 \\ 1:15 \\ 1:
28 : [ret] "={r3}" (-> usize),16 : [ret] "={r3}" (-> u32),
29 [r0_out] "={r0}" (r0_out),17 [r0_out] "={r0}" (r0_out),
30 : [number] "{r0}" (@intFromEnum(number)),18 : [number] "{r0}" (@intFromEnum(number)),
31 : .{ .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 });19 : .{ .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 });
32}20}
3321
34pub fn syscall1(number: SYS, arg1: usize) usize {22pub fn syscall1(number: SYS, arg1: u32) u32 {
35 // r0 is both an input and a clobber.23 // r0 is both an input and a clobber.
36 var r0_out: usize = undefined;24 var r0_out: u32 = undefined;
37 return asm volatile (25 return asm volatile (
38 \\ sc26 \\ sc
39 \\ bns+ 1f27 \\ bns+ 1f
40 \\ neg 3, 328 \\ neg 3, 3
41 \\ 1:29 \\ 1:
42 : [ret] "={r3}" (-> usize),30 : [ret] "={r3}" (-> u32),
43 [r0_out] "={r0}" (r0_out),31 [r0_out] "={r0}" (r0_out),
44 : [number] "{r0}" (@intFromEnum(number)),32 : [number] "{r0}" (@intFromEnum(number)),
45 [arg1] "{r3}" (arg1),33 [arg1] "{r3}" (arg1),
46 : .{ .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 });34 : .{ .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 });
47}35}
4836
49pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {37pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
50 // These registers are both inputs and clobbers.38 // These registers are both inputs and clobbers.
51 var r0_out: usize = undefined;39 var r0_out: u32 = undefined;
52 var r4_out: usize = undefined;40 var r4_out: u32 = undefined;
53 return asm volatile (41 return asm volatile (
54 \\ sc42 \\ sc
55 \\ bns+ 1f43 \\ bns+ 1f
56 \\ neg 3, 344 \\ neg 3, 3
57 \\ 1:45 \\ 1:
58 : [ret] "={r3}" (-> usize),46 : [ret] "={r3}" (-> u32),
59 [r0_out] "={r0}" (r0_out),47 [r0_out] "={r0}" (r0_out),
60 [r4_out] "={r4}" (r4_out),48 [r4_out] "={r4}" (r4_out),
61 : [number] "{r0}" (@intFromEnum(number)),49 : [number] "{r0}" (@intFromEnum(number)),
...@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {...@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
64 : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });52 : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
65}53}
6654
67pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {55pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
68 // These registers are both inputs and clobbers.56 // These registers are both inputs and clobbers.
69 var r0_out: usize = undefined;57 var r0_out: u32 = undefined;
70 var r4_out: usize = undefined;58 var r4_out: u32 = undefined;
71 var r5_out: usize = undefined;59 var r5_out: u32 = undefined;
72 return asm volatile (60 return asm volatile (
73 \\ sc61 \\ sc
74 \\ bns+ 1f62 \\ bns+ 1f
75 \\ neg 3, 363 \\ neg 3, 3
76 \\ 1:64 \\ 1:
77 : [ret] "={r3}" (-> usize),65 : [ret] "={r3}" (-> u32),
78 [r0_out] "={r0}" (r0_out),66 [r0_out] "={r0}" (r0_out),
79 [r4_out] "={r4}" (r4_out),67 [r4_out] "={r4}" (r4_out),
80 [r5_out] "={r5}" (r5_out),68 [r5_out] "={r5}" (r5_out),
...@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
85 : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });73 : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
86}74}
8775
88pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {76pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
89 // These registers are both inputs and clobbers.77 // These registers are both inputs and clobbers.
90 var r0_out: usize = undefined;78 var r0_out: u32 = undefined;
91 var r4_out: usize = undefined;79 var r4_out: u32 = undefined;
92 var r5_out: usize = undefined;80 var r5_out: u32 = undefined;
93 var r6_out: usize = undefined;81 var r6_out: u32 = undefined;
94 return asm volatile (82 return asm volatile (
95 \\ sc83 \\ sc
96 \\ bns+ 1f84 \\ bns+ 1f
97 \\ neg 3, 385 \\ neg 3, 3
98 \\ 1:86 \\ 1:
99 : [ret] "={r3}" (-> usize),87 : [ret] "={r3}" (-> u32),
100 [r0_out] "={r0}" (r0_out),88 [r0_out] "={r0}" (r0_out),
101 [r4_out] "={r4}" (r4_out),89 [r4_out] "={r4}" (r4_out),
102 [r5_out] "={r5}" (r5_out),90 [r5_out] "={r5}" (r5_out),
...@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109 : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });97 : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
110}98}
11199
112pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {100pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
113 // These registers are both inputs and clobbers.101 // These registers are both inputs and clobbers.
114 var r0_out: usize = undefined;102 var r0_out: u32 = undefined;
115 var r4_out: usize = undefined;103 var r4_out: u32 = undefined;
116 var r5_out: usize = undefined;104 var r5_out: u32 = undefined;
117 var r6_out: usize = undefined;105 var r6_out: u32 = undefined;
118 var r7_out: usize = undefined;106 var r7_out: u32 = undefined;
119 return asm volatile (107 return asm volatile (
120 \\ sc108 \\ sc
121 \\ bns+ 1f109 \\ bns+ 1f
122 \\ neg 3, 3110 \\ neg 3, 3
123 \\ 1:111 \\ 1:
124 : [ret] "={r3}" (-> usize),112 : [ret] "={r3}" (-> u32),
125 [r0_out] "={r0}" (r0_out),113 [r0_out] "={r0}" (r0_out),
126 [r4_out] "={r4}" (r4_out),114 [r4_out] "={r4}" (r4_out),
127 [r5_out] "={r5}" (r5_out),115 [r5_out] "={r5}" (r5_out),
...@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
138126
139pub fn syscall6(127pub fn syscall6(
140 number: SYS,128 number: SYS,
141 arg1: usize,129 arg1: u32,
142 arg2: usize,130 arg2: u32,
143 arg3: usize,131 arg3: u32,
144 arg4: usize,132 arg4: u32,
145 arg5: usize,133 arg5: u32,
146 arg6: usize,134 arg6: u32,
147) usize {135) u32 {
148 // These registers are both inputs and clobbers.136 // These registers are both inputs and clobbers.
149 var r0_out: usize = undefined;137 var r0_out: u32 = undefined;
150 var r4_out: usize = undefined;138 var r4_out: u32 = undefined;
151 var r5_out: usize = undefined;139 var r5_out: u32 = undefined;
152 var r6_out: usize = undefined;140 var r6_out: u32 = undefined;
153 var r7_out: usize = undefined;141 var r7_out: u32 = undefined;
154 var r8_out: usize = undefined;142 var r8_out: u32 = undefined;
155 return asm volatile (143 return asm volatile (
156 \\ sc144 \\ sc
157 \\ bns+ 1f145 \\ bns+ 1f
158 \\ neg 3, 3146 \\ neg 3, 3
159 \\ 1:147 \\ 1:
160 : [ret] "={r3}" (-> usize),148 : [ret] "={r3}" (-> u32),
161 [r0_out] "={r0}" (r0_out),149 [r0_out] "={r0}" (r0_out),
162 [r4_out] "={r4}" (r4_out),150 [r4_out] "={r4}" (r4_out),
163 [r5_out] "={r5}" (r5_out),151 [r5_out] "={r5}" (r5_out),
...@@ -174,7 +162,7 @@ pub fn syscall6(...@@ -174,7 +162,7 @@ pub fn syscall6(
174 : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });162 : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
175}163}
176164
177pub fn clone() callconv(.naked) usize {165pub fn clone() callconv(.naked) u32 {
178 // __clone(func, stack, flags, arg, ptid, tls, ctid)166 // __clone(func, stack, flags, arg, ptid, tls, ctid)
179 // 3, 4, 5, 6, 7, 8, 9167 // 3, 4, 5, 6, 7, 8, 9
180 //168 //
...@@ -247,14 +235,14 @@ pub fn clone() callconv(.naked) usize {...@@ -247,14 +235,14 @@ pub fn clone() callconv(.naked) usize {
247pub const restore = restore_rt;235pub const restore = restore_rt;
248236
249pub fn restore_rt() callconv(.naked) noreturn {237pub fn restore_rt() callconv(.naked) noreturn {
250 switch (@import("builtin").zig_backend) {238 switch (builtin.zig_backend) {
251 .stage2_c => asm volatile (239 .stage2_c => asm volatile (
252 \\ li 0, %[number]240 \\ li 0, %[number]
253 \\ sc241 \\ sc
254 :242 :
255 : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),243 : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
256 ),244 ),
257 else => _ = asm volatile (245 else => asm volatile (
258 \\ sc246 \\ sc
259 :247 :
260 : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),248 : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
...@@ -262,48 +250,14 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -262,48 +250,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
262 }250 }
263}251}
264252
265pub const F = struct {
266 pub const DUPFD = 0;
267 pub const GETFD = 1;
268 pub const SETFD = 2;
269 pub const GETFL = 3;
270 pub const SETFL = 4;
271
272 pub const SETOWN = 8;
273 pub const GETOWN = 9;
274 pub const SETSIG = 10;
275 pub const GETSIG = 11;
276
277 pub const GETLK = 12;
278 pub const SETLK = 13;
279 pub const SETLKW = 14;
280
281 pub const SETOWN_EX = 15;
282 pub const GETOWN_EX = 16;
283
284 pub const GETOWNER_UIDS = 17;
285
286 pub const RDLCK = 0;
287 pub const WRLCK = 1;
288 pub const UNLCK = 2;
289};
290
291pub const VDSO = struct {253pub const VDSO = struct {
292 pub const CGT_SYM = "__kernel_clock_gettime";254 pub const CGT_SYM = "__kernel_clock_gettime";
293 pub const CGT_VER = "LINUX_2.6.15";255 pub const CGT_VER = "LINUX_2.6.15";
294};256};
295257
296pub const Flock = extern struct {
297 type: i16,
298 whence: i16,
299 start: off_t,
300 len: off_t,
301 pid: pid_t,
302};
303
304pub const blksize_t = i32;258pub const blksize_t = i32;
305pub const nlink_t = u32;259pub const nlink_t = u32;
306pub const time_t = isize;260pub const time_t = i32;
307pub const mode_t = u32;261pub const mode_t = u32;
308pub const off_t = i64;262pub const off_t = i64;
309pub const ino_t = u64;263pub const ino_t = u64;
...@@ -316,39 +270,27 @@ pub const Stat = extern struct {...@@ -316,39 +270,27 @@ pub const Stat = extern struct {
316 ino: ino_t,270 ino: ino_t,
317 mode: mode_t,271 mode: mode_t,
318 nlink: nlink_t,272 nlink: nlink_t,
319 uid: uid_t,273 uid: std.os.linux.uid_t,
320 gid: gid_t,274 gid: std.os.linux.gid_t,
321 rdev: dev_t,275 rdev: dev_t,
322 __rdev_padding: i16,276 __rdev_padding: i16,
323 size: off_t,277 size: off_t,
324 blksize: blksize_t,278 blksize: blksize_t,
325 blocks: blkcnt_t,279 blocks: blkcnt_t,
326 atim: timespec,280 atim: std.os.linux.timespec,
327 mtim: timespec,281 mtim: std.os.linux.timespec,
328 ctim: timespec,282 ctim: std.os.linux.timespec,
329 __unused: [2]u32,283 __unused: [2]u32,
330284
331 pub fn atime(self: @This()) timespec {285 pub fn atime(self: @This()) std.os.linux.timespec {
332 return self.atim;286 return self.atim;
333 }287 }
334288
335 pub fn mtime(self: @This()) timespec {289 pub fn mtime(self: @This()) std.os.linux.timespec {
336 return self.mtim;290 return self.mtim;
337 }291 }
338292
339 pub fn ctime(self: @This()) timespec {293 pub fn ctime(self: @This()) std.os.linux.timespec {
340 return self.ctim;294 return self.ctim;
341 }295 }
342};296};
343
344pub const timeval = extern struct {
345 sec: time_t,
346 usec: isize,
347};
348
349pub const timezone = extern struct {
350 minuteswest: i32,
351 dsttime: i32,
352};
353
354pub const Elf_Symndx = u32;
lib/std/os/linux/powerpc64.zig+54-113
...@@ -1,61 +1,49 @@...@@ -1,61 +1,49 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;
5const SYS = linux.SYS;
6const socklen_t = linux.socklen_t;
7const iovec = std.posix.iovec;
8const iovec_const = std.posix.iovec_const;
9const uid_t = linux.uid_t;
10const gid_t = linux.gid_t;
11const pid_t = linux.pid_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const sockaddr = linux.sockaddr;
15const timespec = linux.timespec;
164
17pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u64 {
18 // r0 is both an input register and a clobber. musl and glibc achieve this with6 // r0 is both an input register and a clobber. musl and glibc achieve this with
19 // a "+" constraint, which isn't supported in Zig, so instead we separately list7 // a "+" constraint, which isn't supported in Zig, so instead we separately list
20 // r0 as both an input and an output. (Listing it as an input and a clobber would8 // r0 as both an input and an output. (Listing it as an input and a clobber would
21 // cause the C backend to emit invalid code; see #25209.)9 // cause the C backend to emit invalid code; see #25209.)
22 var r0_out: usize = undefined;10 var r0_out: u64 = undefined;
23 return asm volatile (11 return asm volatile (
24 \\ sc12 \\ sc
25 \\ bns+ 1f13 \\ bns+ 1f
26 \\ neg 3, 314 \\ neg 3, 3
27 \\ 1:15 \\ 1:
28 : [ret] "={r3}" (-> usize),16 : [ret] "={r3}" (-> u64),
29 [r0_out] "={r0}" (r0_out),17 [r0_out] "={r0}" (r0_out),
30 : [number] "{r0}" (@intFromEnum(number)),18 : [number] "{r0}" (@intFromEnum(number)),
31 : .{ .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 });19 : .{ .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 });
32}20}
3321
34pub fn syscall1(number: SYS, arg1: usize) usize {22pub fn syscall1(number: SYS, arg1: u64) u64 {
35 // r0 is both an input and a clobber.23 // r0 is both an input and a clobber.
36 var r0_out: usize = undefined;24 var r0_out: u64 = undefined;
37 return asm volatile (25 return asm volatile (
38 \\ sc26 \\ sc
39 \\ bns+ 1f27 \\ bns+ 1f
40 \\ neg 3, 328 \\ neg 3, 3
41 \\ 1:29 \\ 1:
42 : [ret] "={r3}" (-> usize),30 : [ret] "={r3}" (-> u64),
43 [r0_out] "={r0}" (r0_out),31 [r0_out] "={r0}" (r0_out),
44 : [number] "{r0}" (@intFromEnum(number)),32 : [number] "{r0}" (@intFromEnum(number)),
45 [arg1] "{r3}" (arg1),33 [arg1] "{r3}" (arg1),
46 : .{ .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 });34 : .{ .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 });
47}35}
4836
49pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {37pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
50 // These registers are both inputs and clobbers.38 // These registers are both inputs and clobbers.
51 var r0_out: usize = undefined;39 var r0_out: u64 = undefined;
52 var r4_out: usize = undefined;40 var r4_out: u64 = undefined;
53 return asm volatile (41 return asm volatile (
54 \\ sc42 \\ sc
55 \\ bns+ 1f43 \\ bns+ 1f
56 \\ neg 3, 344 \\ neg 3, 3
57 \\ 1:45 \\ 1:
58 : [ret] "={r3}" (-> usize),46 : [ret] "={r3}" (-> u64),
59 [r0_out] "={r0}" (r0_out),47 [r0_out] "={r0}" (r0_out),
60 [r4_out] "={r4}" (r4_out),48 [r4_out] "={r4}" (r4_out),
61 : [number] "{r0}" (@intFromEnum(number)),49 : [number] "{r0}" (@intFromEnum(number)),
...@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {...@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
64 : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });52 : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
65}53}
6654
67pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {55pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
68 // These registers are both inputs and clobbers.56 // These registers are both inputs and clobbers.
69 var r0_out: usize = undefined;57 var r0_out: u64 = undefined;
70 var r4_out: usize = undefined;58 var r4_out: u64 = undefined;
71 var r5_out: usize = undefined;59 var r5_out: u64 = undefined;
72 return asm volatile (60 return asm volatile (
73 \\ sc61 \\ sc
74 \\ bns+ 1f62 \\ bns+ 1f
75 \\ neg 3, 363 \\ neg 3, 3
76 \\ 1:64 \\ 1:
77 : [ret] "={r3}" (-> usize),65 : [ret] "={r3}" (-> u64),
78 [r0_out] "={r0}" (r0_out),66 [r0_out] "={r0}" (r0_out),
79 [r4_out] "={r4}" (r4_out),67 [r4_out] "={r4}" (r4_out),
80 [r5_out] "={r5}" (r5_out),68 [r5_out] "={r5}" (r5_out),
...@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
85 : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });73 : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
86}74}
8775
88pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {76pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
89 // These registers are both inputs and clobbers.77 // These registers are both inputs and clobbers.
90 var r0_out: usize = undefined;78 var r0_out: u64 = undefined;
91 var r4_out: usize = undefined;79 var r4_out: u64 = undefined;
92 var r5_out: usize = undefined;80 var r5_out: u64 = undefined;
93 var r6_out: usize = undefined;81 var r6_out: u64 = undefined;
94 return asm volatile (82 return asm volatile (
95 \\ sc83 \\ sc
96 \\ bns+ 1f84 \\ bns+ 1f
97 \\ neg 3, 385 \\ neg 3, 3
98 \\ 1:86 \\ 1:
99 : [ret] "={r3}" (-> usize),87 : [ret] "={r3}" (-> u64),
100 [r0_out] "={r0}" (r0_out),88 [r0_out] "={r0}" (r0_out),
101 [r4_out] "={r4}" (r4_out),89 [r4_out] "={r4}" (r4_out),
102 [r5_out] "={r5}" (r5_out),90 [r5_out] "={r5}" (r5_out),
...@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
109 : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });97 : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
110}98}
11199
112pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {100pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
113 // These registers are both inputs and clobbers.101 // These registers are both inputs and clobbers.
114 var r0_out: usize = undefined;102 var r0_out: u64 = undefined;
115 var r4_out: usize = undefined;103 var r4_out: u64 = undefined;
116 var r5_out: usize = undefined;104 var r5_out: u64 = undefined;
117 var r6_out: usize = undefined;105 var r6_out: u64 = undefined;
118 var r7_out: usize = undefined;106 var r7_out: u64 = undefined;
119 return asm volatile (107 return asm volatile (
120 \\ sc108 \\ sc
121 \\ bns+ 1f109 \\ bns+ 1f
122 \\ neg 3, 3110 \\ neg 3, 3
123 \\ 1:111 \\ 1:
124 : [ret] "={r3}" (-> usize),112 : [ret] "={r3}" (-> u64),
125 [r0_out] "={r0}" (r0_out),113 [r0_out] "={r0}" (r0_out),
126 [r4_out] "={r4}" (r4_out),114 [r4_out] "={r4}" (r4_out),
127 [r5_out] "={r5}" (r5_out),115 [r5_out] "={r5}" (r5_out),
...@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
138126
139pub fn syscall6(127pub fn syscall6(
140 number: SYS,128 number: SYS,
141 arg1: usize,129 arg1: u64,
142 arg2: usize,130 arg2: u64,
143 arg3: usize,131 arg3: u64,
144 arg4: usize,132 arg4: u64,
145 arg5: usize,133 arg5: u64,
146 arg6: usize,134 arg6: u64,
147) usize {135) u64 {
148 // These registers are both inputs and clobbers.136 // These registers are both inputs and clobbers.
149 var r0_out: usize = undefined;137 var r0_out: u64 = undefined;
150 var r4_out: usize = undefined;138 var r4_out: u64 = undefined;
151 var r5_out: usize = undefined;139 var r5_out: u64 = undefined;
152 var r6_out: usize = undefined;140 var r6_out: u64 = undefined;
153 var r7_out: usize = undefined;141 var r7_out: u64 = undefined;
154 var r8_out: usize = undefined;142 var r8_out: u64 = undefined;
155 return asm volatile (143 return asm volatile (
156 \\ sc144 \\ sc
157 \\ bns+ 1f145 \\ bns+ 1f
158 \\ neg 3, 3146 \\ neg 3, 3
159 \\ 1:147 \\ 1:
160 : [ret] "={r3}" (-> usize),148 : [ret] "={r3}" (-> u64),
161 [r0_out] "={r0}" (r0_out),149 [r0_out] "={r0}" (r0_out),
162 [r4_out] "={r4}" (r4_out),150 [r4_out] "={r4}" (r4_out),
163 [r5_out] "={r5}" (r5_out),151 [r5_out] "={r5}" (r5_out),
...@@ -174,7 +162,7 @@ pub fn syscall6(...@@ -174,7 +162,7 @@ pub fn syscall6(
174 : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });162 : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
175}163}
176164
177pub fn clone() callconv(.naked) usize {165pub fn clone() callconv(.naked) u64 {
178 // __clone(func, stack, flags, arg, ptid, tls, ctid)166 // __clone(func, stack, flags, arg, ptid, tls, ctid)
179 // 3, 4, 5, 6, 7, 8, 9167 // 3, 4, 5, 6, 7, 8, 9
180 //168 //
...@@ -232,14 +220,14 @@ pub fn clone() callconv(.naked) usize {...@@ -232,14 +220,14 @@ pub fn clone() callconv(.naked) usize {
232pub const restore = restore_rt;220pub const restore = restore_rt;
233221
234pub fn restore_rt() callconv(.naked) noreturn {222pub fn restore_rt() callconv(.naked) noreturn {
235 switch (@import("builtin").zig_backend) {223 switch (builtin.zig_backend) {
236 .stage2_c => asm volatile (224 .stage2_c => asm volatile (
237 \\ li 0, %[number]225 \\ li 0, %[number]
238 \\ sc226 \\ sc
239 :227 :
240 : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),228 : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
241 ),229 ),
242 else => _ = asm volatile (230 else => asm volatile (
243 \\ sc231 \\ sc
244 :232 :
245 : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),233 : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
...@@ -247,46 +235,11 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -247,46 +235,11 @@ pub fn restore_rt() callconv(.naked) noreturn {
247 }235 }
248}236}
249237
250pub const F = struct {
251 pub const DUPFD = 0;
252 pub const GETFD = 1;
253 pub const SETFD = 2;
254 pub const GETFL = 3;
255 pub const SETFL = 4;
256
257 pub const SETOWN = 8;
258 pub const GETOWN = 9;
259 pub const SETSIG = 10;
260 pub const GETSIG = 11;
261
262 pub const GETLK = 5;
263 pub const SETLK = 6;
264 pub const SETLKW = 7;
265
266 pub const RDLCK = 0;
267 pub const WRLCK = 1;
268 pub const UNLCK = 2;
269
270 pub const SETOWN_EX = 15;
271 pub const GETOWN_EX = 16;
272
273 pub const GETOWNER_UIDS = 17;
274};
275
276pub const VDSO = struct {238pub const VDSO = struct {
277 pub const CGT_SYM = "__kernel_clock_gettime";239 pub const CGT_SYM = "__kernel_clock_gettime";
278 pub const CGT_VER = "LINUX_2.6.15";240 pub const CGT_VER = "LINUX_2.6.15";
279};241};
280242
281pub const Flock = extern struct {
282 type: i16,
283 whence: i16,
284 start: off_t,
285 len: off_t,
286 pid: pid_t,
287 __unused: [4]u8,
288};
289
290pub const blksize_t = i64;243pub const blksize_t = i64;
291pub const nlink_t = u64;244pub const nlink_t = u64;
292pub const time_t = i64;245pub const time_t = i64;
...@@ -302,38 +255,26 @@ pub const Stat = extern struct {...@@ -302,38 +255,26 @@ pub const Stat = extern struct {
302 ino: ino_t,255 ino: ino_t,
303 nlink: nlink_t,256 nlink: nlink_t,
304 mode: mode_t,257 mode: mode_t,
305 uid: uid_t,258 uid: std.os.linux.uid_t,
306 gid: gid_t,259 gid: std.os.linux.gid_t,
307 rdev: dev_t,260 rdev: dev_t,
308 size: off_t,261 size: off_t,
309 blksize: blksize_t,262 blksize: blksize_t,
310 blocks: blkcnt_t,263 blocks: blkcnt_t,
311 atim: timespec,264 atim: std.os.linux.timespec,
312 mtim: timespec,265 mtim: std.os.linux.timespec,
313 ctim: timespec,266 ctim: std.os.linux.timespec,
314 __unused: [3]u64,267 __unused: [3]u64,
315268
316 pub fn atime(self: @This()) timespec {269 pub fn atime(self: @This()) std.os.linux.timespec {
317 return self.atim;270 return self.atim;
318 }271 }
319272
320 pub fn mtime(self: @This()) timespec {273 pub fn mtime(self: @This()) std.os.linux.timespec {
321 return self.mtim;274 return self.mtim;
322 }275 }
323276
324 pub fn ctime(self: @This()) timespec {277 pub fn ctime(self: @This()) std.os.linux.timespec {
325 return self.ctim;278 return self.ctim;
326 }279 }
327};280};
328
329pub const timeval = extern struct {
330 sec: isize,
331 usec: isize,
332};
333
334pub const timezone = extern struct {
335 minuteswest: i32,
336 dsttime: i32,
337};
338
339pub const Elf_Symndx = u32;
lib/std/os/linux/riscv32.zig+31-82
...@@ -1,45 +1,34 @@...@@ -1,45 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const iovec = std.posix.iovec;3const SYS = std.os.linux.SYS;
4const iovec_const = std.posix.iovec_const;
5const linux = std.os.linux;
6const SYS = linux.SYS;
7const uid_t = std.os.linux.uid_t;
8const gid_t = std.os.linux.gid_t;
9const pid_t = std.os.linux.pid_t;
10const stack_t = linux.stack_t;
11const sigset_t = linux.sigset_t;
12const sockaddr = linux.sockaddr;
13const socklen_t = linux.socklen_t;
14const timespec = std.os.linux.timespec;
154
16pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
17 return asm volatile ("ecall"6 return asm volatile ("ecall"
18 : [ret] "={x10}" (-> usize),7 : [ret] "={x10}" (-> u32),
19 : [number] "{x17}" (@intFromEnum(number)),8 : [number] "{x17}" (@intFromEnum(number)),
20 : .{ .memory = true });9 : .{ .memory = true });
21}10}
2211
23pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u32) u32 {
24 return asm volatile ("ecall"13 return asm volatile ("ecall"
25 : [ret] "={x10}" (-> usize),14 : [ret] "={x10}" (-> u32),
26 : [number] "{x17}" (@intFromEnum(number)),15 : [number] "{x17}" (@intFromEnum(number)),
27 [arg1] "{x10}" (arg1),16 [arg1] "{x10}" (arg1),
28 : .{ .memory = true });17 : .{ .memory = true });
29}18}
3019
31pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
32 return asm volatile ("ecall"21 return asm volatile ("ecall"
33 : [ret] "={x10}" (-> usize),22 : [ret] "={x10}" (-> u32),
34 : [number] "{x17}" (@intFromEnum(number)),23 : [number] "{x17}" (@intFromEnum(number)),
35 [arg1] "{x10}" (arg1),24 [arg1] "{x10}" (arg1),
36 [arg2] "{x11}" (arg2),25 [arg2] "{x11}" (arg2),
37 : .{ .memory = true });26 : .{ .memory = true });
38}27}
3928
40pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
41 return asm volatile ("ecall"30 return asm volatile ("ecall"
42 : [ret] "={x10}" (-> usize),31 : [ret] "={x10}" (-> u32),
43 : [number] "{x17}" (@intFromEnum(number)),32 : [number] "{x17}" (@intFromEnum(number)),
44 [arg1] "{x10}" (arg1),33 [arg1] "{x10}" (arg1),
45 [arg2] "{x11}" (arg2),34 [arg2] "{x11}" (arg2),
...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47 : .{ .memory = true });36 : .{ .memory = true });
48}37}
4938
50pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
51 return asm volatile ("ecall"40 return asm volatile ("ecall"
52 : [ret] "={x10}" (-> usize),41 : [ret] "={x10}" (-> u32),
53 : [number] "{x17}" (@intFromEnum(number)),42 : [number] "{x17}" (@intFromEnum(number)),
54 [arg1] "{x10}" (arg1),43 [arg1] "{x10}" (arg1),
55 [arg2] "{x11}" (arg2),44 [arg2] "{x11}" (arg2),
...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58 : .{ .memory = true });47 : .{ .memory = true });
59}48}
6049
61pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
62 return asm volatile ("ecall"51 return asm volatile ("ecall"
63 : [ret] "={x10}" (-> usize),52 : [ret] "={x10}" (-> u32),
64 : [number] "{x17}" (@intFromEnum(number)),53 : [number] "{x17}" (@intFromEnum(number)),
65 [arg1] "{x10}" (arg1),54 [arg1] "{x10}" (arg1),
66 [arg2] "{x11}" (arg2),55 [arg2] "{x11}" (arg2),
...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7261
73pub fn syscall6(62pub fn syscall6(
74 number: SYS,63 number: SYS,
75 arg1: usize,64 arg1: u32,
76 arg2: usize,65 arg2: u32,
77 arg3: usize,66 arg3: u32,
78 arg4: usize,67 arg4: u32,
79 arg5: usize,68 arg5: u32,
80 arg6: usize,69 arg6: u32,
81) usize {70) u32 {
82 return asm volatile ("ecall"71 return asm volatile ("ecall"
83 : [ret] "={x10}" (-> usize),72 : [ret] "={x10}" (-> u32),
84 : [number] "{x17}" (@intFromEnum(number)),73 : [number] "{x17}" (@intFromEnum(number)),
85 [arg1] "{x10}" (arg1),74 [arg1] "{x10}" (arg1),
86 [arg2] "{x11}" (arg2),75 [arg2] "{x11}" (arg2),
...@@ -91,7 +80,7 @@ pub fn syscall6(...@@ -91,7 +80,7 @@ pub fn syscall6(
91 : .{ .memory = true });80 : .{ .memory = true });
92}81}
9382
94pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u32 {
95 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
96 // a0, a1, a2, a3, a4, a5, a685 // a0, a1, a2, a3, a4, a5, a6
97 //86 //
...@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {...@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {
135 );124 );
136}125}
137126
138pub const F = struct {
139 pub const DUPFD = 0;
140 pub const GETFD = 1;
141 pub const SETFD = 2;
142 pub const GETFL = 3;
143 pub const SETFL = 4;
144 pub const GETLK = 5;
145 pub const SETLK = 6;
146 pub const SETLKW = 7;
147 pub const SETOWN = 8;
148 pub const GETOWN = 9;
149 pub const SETSIG = 10;
150 pub const GETSIG = 11;
151
152 pub const RDLCK = 0;
153 pub const WRLCK = 1;
154 pub const UNLCK = 2;
155
156 pub const SETOWN_EX = 15;
157 pub const GETOWN_EX = 16;
158
159 pub const GETOWNER_UIDS = 17;
160};
161
162pub const blksize_t = i32;127pub const blksize_t = i32;
163pub const nlink_t = u32;128pub const nlink_t = u32;
164pub const time_t = i64;129pub const time_t = i64;
...@@ -168,54 +133,38 @@ pub const ino_t = u64;...@@ -168,54 +133,38 @@ pub const ino_t = u64;
168pub const dev_t = u64;133pub const dev_t = u64;
169pub const blkcnt_t = i64;134pub const blkcnt_t = i64;
170135
171pub const timeval = extern struct {
172 sec: time_t,
173 usec: i64,
174};
175
176pub const Flock = extern struct {
177 type: i16,
178 whence: i16,
179 start: off_t,
180 len: off_t,
181 pid: pid_t,
182 __unused: [4]u8,
183};
184
185// The `stat` definition used by the Linux kernel.136// The `stat` definition used by the Linux kernel.
186pub const Stat = extern struct {137pub const Stat = extern struct {
187 dev: dev_t,138 dev: dev_t,
188 ino: ino_t,139 ino: ino_t,
189 mode: mode_t,140 mode: mode_t,
190 nlink: nlink_t,141 nlink: nlink_t,
191 uid: uid_t,142 uid: std.os.linux.uid_t,
192 gid: gid_t,143 gid: std.os.linux.gid_t,
193 rdev: dev_t,144 rdev: dev_t,
194 __pad: usize,145 __pad: u32,
195 size: off_t,146 size: off_t,
196 blksize: blksize_t,147 blksize: blksize_t,
197 __pad2: i32,148 __pad2: i32,
198 blocks: blkcnt_t,149 blocks: blkcnt_t,
199 atim: timespec,150 atim: std.os.linux.timespec,
200 mtim: timespec,151 mtim: std.os.linux.timespec,
201 ctim: timespec,152 ctim: std.os.linux.timespec,
202 __unused: [2]u32,153 __unused: [2]u32,
203154
204 pub fn atime(self: @This()) timespec {155 pub fn atime(self: @This()) std.os.linux.timespec {
205 return self.atim;156 return self.atim;
206 }157 }
207158
208 pub fn mtime(self: @This()) timespec {159 pub fn mtime(self: @This()) std.os.linux.timespec {
209 return self.mtim;160 return self.mtim;
210 }161 }
211162
212 pub fn ctime(self: @This()) timespec {163 pub fn ctime(self: @This()) std.os.linux.timespec {
213 return self.ctim;164 return self.ctim;
214 }165 }
215};166};
216167
217pub const Elf_Symndx = u32;
218
219pub const VDSO = struct {168pub const VDSO = struct {
220 pub const CGT_SYM = "__vdso_clock_gettime";169 pub const CGT_SYM = "__vdso_clock_gettime";
221 pub const CGT_VER = "LINUX_4.15";170 pub const CGT_VER = "LINUX_4.15";
lib/std/os/linux/riscv64.zig+31-82
...@@ -1,45 +1,34 @@...@@ -1,45 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const iovec = std.posix.iovec;3const SYS = std.os.linux.SYS;
4const iovec_const = std.posix.iovec_const;
5const linux = std.os.linux;
6const SYS = linux.SYS;
7const uid_t = std.os.linux.uid_t;
8const gid_t = std.os.linux.gid_t;
9const pid_t = std.os.linux.pid_t;
10const stack_t = linux.stack_t;
11const sigset_t = linux.sigset_t;
12const sockaddr = linux.sockaddr;
13const socklen_t = linux.socklen_t;
14const timespec = std.os.linux.timespec;
154
16pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u64 {
17 return asm volatile ("ecall"6 return asm volatile ("ecall"
18 : [ret] "={x10}" (-> usize),7 : [ret] "={x10}" (-> u64),
19 : [number] "{x17}" (@intFromEnum(number)),8 : [number] "{x17}" (@intFromEnum(number)),
20 : .{ .memory = true });9 : .{ .memory = true });
21}10}
2211
23pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u64) u64 {
24 return asm volatile ("ecall"13 return asm volatile ("ecall"
25 : [ret] "={x10}" (-> usize),14 : [ret] "={x10}" (-> u64),
26 : [number] "{x17}" (@intFromEnum(number)),15 : [number] "{x17}" (@intFromEnum(number)),
27 [arg1] "{x10}" (arg1),16 [arg1] "{x10}" (arg1),
28 : .{ .memory = true });17 : .{ .memory = true });
29}18}
3019
31pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
32 return asm volatile ("ecall"21 return asm volatile ("ecall"
33 : [ret] "={x10}" (-> usize),22 : [ret] "={x10}" (-> u64),
34 : [number] "{x17}" (@intFromEnum(number)),23 : [number] "{x17}" (@intFromEnum(number)),
35 [arg1] "{x10}" (arg1),24 [arg1] "{x10}" (arg1),
36 [arg2] "{x11}" (arg2),25 [arg2] "{x11}" (arg2),
37 : .{ .memory = true });26 : .{ .memory = true });
38}27}
3928
40pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
41 return asm volatile ("ecall"30 return asm volatile ("ecall"
42 : [ret] "={x10}" (-> usize),31 : [ret] "={x10}" (-> u64),
43 : [number] "{x17}" (@intFromEnum(number)),32 : [number] "{x17}" (@intFromEnum(number)),
44 [arg1] "{x10}" (arg1),33 [arg1] "{x10}" (arg1),
45 [arg2] "{x11}" (arg2),34 [arg2] "{x11}" (arg2),
...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47 : .{ .memory = true });36 : .{ .memory = true });
48}37}
4938
50pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
51 return asm volatile ("ecall"40 return asm volatile ("ecall"
52 : [ret] "={x10}" (-> usize),41 : [ret] "={x10}" (-> u64),
53 : [number] "{x17}" (@intFromEnum(number)),42 : [number] "{x17}" (@intFromEnum(number)),
54 [arg1] "{x10}" (arg1),43 [arg1] "{x10}" (arg1),
55 [arg2] "{x11}" (arg2),44 [arg2] "{x11}" (arg2),
...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58 : .{ .memory = true });47 : .{ .memory = true });
59}48}
6049
61pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
62 return asm volatile ("ecall"51 return asm volatile ("ecall"
63 : [ret] "={x10}" (-> usize),52 : [ret] "={x10}" (-> u64),
64 : [number] "{x17}" (@intFromEnum(number)),53 : [number] "{x17}" (@intFromEnum(number)),
65 [arg1] "{x10}" (arg1),54 [arg1] "{x10}" (arg1),
66 [arg2] "{x11}" (arg2),55 [arg2] "{x11}" (arg2),
...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7261
73pub fn syscall6(62pub fn syscall6(
74 number: SYS,63 number: SYS,
75 arg1: usize,64 arg1: u64,
76 arg2: usize,65 arg2: u64,
77 arg3: usize,66 arg3: u64,
78 arg4: usize,67 arg4: u64,
79 arg5: usize,68 arg5: u64,
80 arg6: usize,69 arg6: u64,
81) usize {70) u64 {
82 return asm volatile ("ecall"71 return asm volatile ("ecall"
83 : [ret] "={x10}" (-> usize),72 : [ret] "={x10}" (-> u64),
84 : [number] "{x17}" (@intFromEnum(number)),73 : [number] "{x17}" (@intFromEnum(number)),
85 [arg1] "{x10}" (arg1),74 [arg1] "{x10}" (arg1),
86 [arg2] "{x11}" (arg2),75 [arg2] "{x11}" (arg2),
...@@ -91,7 +80,7 @@ pub fn syscall6(...@@ -91,7 +80,7 @@ pub fn syscall6(
91 : .{ .memory = true });80 : .{ .memory = true });
92}81}
9382
94pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u64 {
95 // __clone(func, stack, flags, arg, ptid, tls, ctid)84 // __clone(func, stack, flags, arg, ptid, tls, ctid)
96 // a0, a1, a2, a3, a4, a5, a685 // a0, a1, a2, a3, a4, a5, a6
97 //86 //
...@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {...@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {
135 );124 );
136}125}
137126
138pub const F = struct {
139 pub const DUPFD = 0;
140 pub const GETFD = 1;
141 pub const SETFD = 2;
142 pub const GETFL = 3;
143 pub const SETFL = 4;
144 pub const GETLK = 5;
145 pub const SETLK = 6;
146 pub const SETLKW = 7;
147 pub const SETOWN = 8;
148 pub const GETOWN = 9;
149 pub const SETSIG = 10;
150 pub const GETSIG = 11;
151
152 pub const RDLCK = 0;
153 pub const WRLCK = 1;
154 pub const UNLCK = 2;
155
156 pub const SETOWN_EX = 15;
157 pub const GETOWN_EX = 16;
158
159 pub const GETOWNER_UIDS = 17;
160};
161
162pub const blksize_t = i32;127pub const blksize_t = i32;
163pub const nlink_t = u32;128pub const nlink_t = u32;
164pub const time_t = i64;129pub const time_t = i64;
...@@ -168,54 +133,38 @@ pub const ino_t = u64;...@@ -168,54 +133,38 @@ pub const ino_t = u64;
168pub const dev_t = u64;133pub const dev_t = u64;
169pub const blkcnt_t = i64;134pub const blkcnt_t = i64;
170135
171pub const timeval = extern struct {
172 sec: time_t,
173 usec: i64,
174};
175
176pub const Flock = extern struct {
177 type: i16,
178 whence: i16,
179 start: off_t,
180 len: off_t,
181 pid: pid_t,
182 __unused: [4]u8,
183};
184
185// The `stat` definition used by the Linux kernel.136// The `stat` definition used by the Linux kernel.
186pub const Stat = extern struct {137pub const Stat = extern struct {
187 dev: dev_t,138 dev: dev_t,
188 ino: ino_t,139 ino: ino_t,
189 mode: mode_t,140 mode: mode_t,
190 nlink: nlink_t,141 nlink: nlink_t,
191 uid: uid_t,142 uid: std.os.linux.uid_t,
192 gid: gid_t,143 gid: std.os.linux.gid_t,
193 rdev: dev_t,144 rdev: dev_t,
194 __pad: usize,145 __pad: u64,
195 size: off_t,146 size: off_t,
196 blksize: blksize_t,147 blksize: blksize_t,
197 __pad2: i32,148 __pad2: i32,
198 blocks: blkcnt_t,149 blocks: blkcnt_t,
199 atim: timespec,150 atim: std.os.linux.timespec,
200 mtim: timespec,151 mtim: std.os.linux.timespec,
201 ctim: timespec,152 ctim: std.os.linux.timespec,
202 __unused: [2]u32,153 __unused: [2]u32,
203154
204 pub fn atime(self: @This()) timespec {155 pub fn atime(self: @This()) std.os.linux.timespec {
205 return self.atim;156 return self.atim;
206 }157 }
207158
208 pub fn mtime(self: @This()) timespec {159 pub fn mtime(self: @This()) std.os.linux.timespec {
209 return self.mtim;160 return self.mtim;
210 }161 }
211162
212 pub fn ctime(self: @This()) timespec {163 pub fn ctime(self: @This()) std.os.linux.timespec {
213 return self.ctim;164 return self.ctim;
214 }165 }
215};166};
216167
217pub const Elf_Symndx = u32;
218
219pub const VDSO = struct {168pub const VDSO = struct {
220 pub const CGT_SYM = "__vdso_clock_gettime";169 pub const CGT_SYM = "__vdso_clock_gettime";
221 pub const CGT_VER = "LINUX_4.15";170 pub const CGT_VER = "LINUX_4.15";
lib/std/os/linux/s390x.zig+25-71
...@@ -1,45 +1,34 @@...@@ -1,45 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const iovec = std.posix.iovec;3const SYS = std.os.linux.SYS;
4const iovec_const = std.posix.iovec_const;4
5const linux = std.os.linux;5pub fn syscall0(number: SYS) u64 {
6const SYS = linux.SYS;
7const uid_t = std.os.linux.uid_t;
8const gid_t = std.os.linux.gid_t;
9const pid_t = std.os.linux.pid_t;
10const sockaddr = linux.sockaddr;
11const socklen_t = linux.socklen_t;
12const timespec = std.os.linux.timespec;
13const stack_t = std.os.linux.stack_t;
14const sigset_t = std.os.linux.sigset_t;
15
16pub fn syscall0(number: SYS) usize {
17 return asm volatile ("svc 0"6 return asm volatile ("svc 0"
18 : [ret] "={r2}" (-> usize),7 : [ret] "={r2}" (-> u64),
19 : [number] "{r1}" (@intFromEnum(number)),8 : [number] "{r1}" (@intFromEnum(number)),
20 : .{ .memory = true });9 : .{ .memory = true });
21}10}
2211
23pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u64) u64 {
24 return asm volatile ("svc 0"13 return asm volatile ("svc 0"
25 : [ret] "={r2}" (-> usize),14 : [ret] "={r2}" (-> u64),
26 : [number] "{r1}" (@intFromEnum(number)),15 : [number] "{r1}" (@intFromEnum(number)),
27 [arg1] "{r2}" (arg1),16 [arg1] "{r2}" (arg1),
28 : .{ .memory = true });17 : .{ .memory = true });
29}18}
3019
31pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
32 return asm volatile ("svc 0"21 return asm volatile ("svc 0"
33 : [ret] "={r2}" (-> usize),22 : [ret] "={r2}" (-> u64),
34 : [number] "{r1}" (@intFromEnum(number)),23 : [number] "{r1}" (@intFromEnum(number)),
35 [arg1] "{r2}" (arg1),24 [arg1] "{r2}" (arg1),
36 [arg2] "{r3}" (arg2),25 [arg2] "{r3}" (arg2),
37 : .{ .memory = true });26 : .{ .memory = true });
38}27}
3928
40pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
41 return asm volatile ("svc 0"30 return asm volatile ("svc 0"
42 : [ret] "={r2}" (-> usize),31 : [ret] "={r2}" (-> u64),
43 : [number] "{r1}" (@intFromEnum(number)),32 : [number] "{r1}" (@intFromEnum(number)),
44 [arg1] "{r2}" (arg1),33 [arg1] "{r2}" (arg1),
45 [arg2] "{r3}" (arg2),34 [arg2] "{r3}" (arg2),
...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
47 : .{ .memory = true });36 : .{ .memory = true });
48}37}
4938
50pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
51 return asm volatile ("svc 0"40 return asm volatile ("svc 0"
52 : [ret] "={r2}" (-> usize),41 : [ret] "={r2}" (-> u64),
53 : [number] "{r1}" (@intFromEnum(number)),42 : [number] "{r1}" (@intFromEnum(number)),
54 [arg1] "{r2}" (arg1),43 [arg1] "{r2}" (arg1),
55 [arg2] "{r3}" (arg2),44 [arg2] "{r3}" (arg2),
...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
58 : .{ .memory = true });47 : .{ .memory = true });
59}48}
6049
61pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
62 return asm volatile ("svc 0"51 return asm volatile ("svc 0"
63 : [ret] "={r2}" (-> usize),52 : [ret] "={r2}" (-> u64),
64 : [number] "{r1}" (@intFromEnum(number)),53 : [number] "{r1}" (@intFromEnum(number)),
65 [arg1] "{r2}" (arg1),54 [arg1] "{r2}" (arg1),
66 [arg2] "{r3}" (arg2),55 [arg2] "{r3}" (arg2),
...@@ -70,9 +59,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -70,9 +59,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
70 : .{ .memory = true });59 : .{ .memory = true });
71}60}
7261
73pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {62pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
74 return asm volatile ("svc 0"63 return asm volatile ("svc 0"
75 : [ret] "={r2}" (-> usize),64 : [ret] "={r2}" (-> u64),
76 : [number] "{r1}" (@intFromEnum(number)),65 : [number] "{r1}" (@intFromEnum(number)),
77 [arg1] "{r2}" (arg1),66 [arg1] "{r2}" (arg1),
78 [arg2] "{r3}" (arg2),67 [arg2] "{r3}" (arg2),
...@@ -83,7 +72,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -83,7 +72,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
83 : .{ .memory = true });72 : .{ .memory = true });
84}73}
8574
86pub fn clone() callconv(.naked) usize {75pub fn clone() callconv(.naked) u64 {
87 asm volatile (76 asm volatile (
88 \\# int clone(77 \\# int clone(
89 \\# fn, a = r278 \\# fn, a = r2
...@@ -157,26 +146,6 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -157,26 +146,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
157 );146 );
158}147}
159148
160pub const F = struct {
161 pub const DUPFD = 0;
162 pub const GETFD = 1;
163 pub const SETFD = 2;
164 pub const GETFL = 3;
165 pub const SETFL = 4;
166 pub const GETLK = 5;
167 pub const SETLK = 6;
168 pub const SETLKW = 7;
169 pub const SETOWN = 8;
170 pub const GETOWN = 9;
171 pub const SETSIG = 10;
172 pub const GETSIG = 11;
173
174 pub const SETOWN_EX = 15;
175 pub const GETOWN_EX = 16;
176
177 pub const GETOWNER_UIDS = 17;
178};
179
180pub const blksize_t = i64;149pub const blksize_t = i64;
181pub const nlink_t = u64;150pub const nlink_t = u64;
182pub const time_t = i64;151pub const time_t = i64;
...@@ -186,51 +155,36 @@ pub const ino_t = u64;...@@ -186,51 +155,36 @@ pub const ino_t = u64;
186pub const dev_t = u64;155pub const dev_t = u64;
187pub const blkcnt_t = i64;156pub const blkcnt_t = i64;
188157
189pub const timeval = extern struct {
190 sec: time_t,
191 usec: i64,
192};
193
194pub const Flock = extern struct {
195 type: i16,
196 whence: i16,
197 start: off_t,
198 len: off_t,
199 pid: pid_t,
200};
201
202// The `stat` definition used by the Linux kernel.158// The `stat` definition used by the Linux kernel.
203pub const Stat = extern struct {159pub const Stat = extern struct {
204 dev: dev_t,160 dev: dev_t,
205 ino: ino_t,161 ino: ino_t,
206 nlink: nlink_t,162 nlink: nlink_t,
207 mode: mode_t,163 mode: mode_t,
208 uid: uid_t,164 uid: std.os.linux.uid_t,
209 gid: gid_t,165 gid: std.os.linux.gid_t,
210 rdev: dev_t,166 rdev: dev_t,
211 size: off_t,167 size: off_t,
212 atim: timespec,168 atim: std.os.linux.timespec,
213 mtim: timespec,169 mtim: std.os.linux.timespec,
214 ctim: timespec,170 ctim: std.os.linux.timespec,
215 blksize: blksize_t,171 blksize: blksize_t,
216 blocks: blkcnt_t,172 blocks: blkcnt_t,
217 __unused: [3]c_ulong,173 __unused: [3]c_ulong,
218174
219 pub fn atime(self: @This()) timespec {175 pub fn atime(self: @This()) std.os.linux.timespec {
220 return self.atim;176 return self.atim;
221 }177 }
222178
223 pub fn mtime(self: @This()) timespec {179 pub fn mtime(self: @This()) std.os.linux.timespec {
224 return self.mtim;180 return self.mtim;
225 }181 }
226182
227 pub fn ctime(self: @This()) timespec {183 pub fn ctime(self: @This()) std.os.linux.timespec {
228 return self.ctim;184 return self.ctim;
229 }185 }
230};186};
231187
232pub const Elf_Symndx = u64;
233
234pub const VDSO = struct {188pub const VDSO = struct {
235 pub const CGT_SYM = "__kernel_clock_gettime";189 pub const CGT_SYM = "__kernel_clock_gettime";
236 pub const CGT_VER = "LINUX_2.6.29";190 pub const CGT_VER = "LINUX_2.6.29";
lib/std/os/linux/sparc64.zig+46-101
...@@ -1,21 +1,8 @@...@@ -1,21 +1,8 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const pid_t = linux.pid_t;
5const uid_t = linux.uid_t;
6const clock_t = linux.clock_t;
7const stack_t = linux.stack_t;
8const sigset_t = linux.sigset_t;
94
10const linux = std.os.linux;5pub fn syscall_pipe(fd: *[2]i32) u64 {
11const SYS = linux.SYS;
12const sockaddr = linux.sockaddr;
13const socklen_t = linux.socklen_t;
14const iovec = std.posix.iovec;
15const iovec_const = std.posix.iovec_const;
16const timespec = linux.timespec;
17
18pub fn syscall_pipe(fd: *[2]i32) usize {
19 return asm volatile (6 return asm volatile (
20 \\ mov %[arg], %%g37 \\ mov %[arg], %%g3
21 \\ t 0x6d8 \\ t 0x6d
...@@ -29,13 +16,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {...@@ -29,13 +16,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
29 \\ st %%o1, [%%g3+4]16 \\ st %%o1, [%%g3+4]
30 \\ clr %%o017 \\ clr %%o0
31 \\2:18 \\2:
32 : [ret] "={o0}" (-> usize),19 : [ret] "={o0}" (-> u64),
33 : [number] "{g1}" (@intFromEnum(SYS.pipe)),20 : [number] "{g1}" (@intFromEnum(SYS.pipe)),
34 [arg] "r" (fd),21 [arg] "r" (fd),
35 : .{ .memory = true, .g3 = true });22 : .{ .memory = true, .g3 = true });
36}23}
3724
38pub fn syscall_fork() usize {25pub fn syscall_fork() u64 {
39 // Linux/sparc64 fork() returns two values in %o0 and %o1:26 // Linux/sparc64 fork() returns two values in %o0 and %o1:
40 // - On the parent's side, %o0 is the child's PID and %o1 is 0.27 // - On the parent's side, %o0 is the child's PID and %o1 is 0.
41 // - On the child's side, %o0 is the parent's PID and %o1 is 1.28 // - On the child's side, %o0 is the parent's PID and %o1 is 1.
...@@ -52,58 +39,58 @@ pub fn syscall_fork() usize {...@@ -52,58 +39,58 @@ pub fn syscall_fork() usize {
52 \\ dec %%o139 \\ dec %%o1
53 \\ and %%o1, %%o0, %%o040 \\ and %%o1, %%o0, %%o0
54 \\ 2:41 \\ 2:
55 : [ret] "={o0}" (-> usize),42 : [ret] "={o0}" (-> u64),
56 : [number] "{g1}" (@intFromEnum(SYS.fork)),43 : [number] "{g1}" (@intFromEnum(SYS.fork)),
57 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });44 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
58}45}
5946
60pub fn syscall0(number: SYS) usize {47pub fn syscall0(number: SYS) u64 {
61 return asm volatile (48 return asm volatile (
62 \\ t 0x6d49 \\ t 0x6d
63 \\ bcc,pt %%xcc, 1f50 \\ bcc,pt %%xcc, 1f
64 \\ nop51 \\ nop
65 \\ neg %%o052 \\ neg %%o0
66 \\ 1:53 \\ 1:
67 : [ret] "={o0}" (-> usize),54 : [ret] "={o0}" (-> u64),
68 : [number] "{g1}" (@intFromEnum(number)),55 : [number] "{g1}" (@intFromEnum(number)),
69 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });56 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
70}57}
7158
72pub fn syscall1(number: SYS, arg1: usize) usize {59pub fn syscall1(number: SYS, arg1: u64) u64 {
73 return asm volatile (60 return asm volatile (
74 \\ t 0x6d61 \\ t 0x6d
75 \\ bcc,pt %%xcc, 1f62 \\ bcc,pt %%xcc, 1f
76 \\ nop63 \\ nop
77 \\ neg %%o064 \\ neg %%o0
78 \\ 1:65 \\ 1:
79 : [ret] "={o0}" (-> usize),66 : [ret] "={o0}" (-> u64),
80 : [number] "{g1}" (@intFromEnum(number)),67 : [number] "{g1}" (@intFromEnum(number)),
81 [arg1] "{o0}" (arg1),68 [arg1] "{o0}" (arg1),
82 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });69 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
83}70}
8471
85pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {72pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
86 return asm volatile (73 return asm volatile (
87 \\ t 0x6d74 \\ t 0x6d
88 \\ bcc,pt %%xcc, 1f75 \\ bcc,pt %%xcc, 1f
89 \\ nop76 \\ nop
90 \\ neg %%o077 \\ neg %%o0
91 \\ 1:78 \\ 1:
92 : [ret] "={o0}" (-> usize),79 : [ret] "={o0}" (-> u64),
93 : [number] "{g1}" (@intFromEnum(number)),80 : [number] "{g1}" (@intFromEnum(number)),
94 [arg1] "{o0}" (arg1),81 [arg1] "{o0}" (arg1),
95 [arg2] "{o1}" (arg2),82 [arg2] "{o1}" (arg2),
96 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });83 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
97}84}
9885
99pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {86pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
100 return asm volatile (87 return asm volatile (
101 \\ t 0x6d88 \\ t 0x6d
102 \\ bcc,pt %%xcc, 1f89 \\ bcc,pt %%xcc, 1f
103 \\ nop90 \\ nop
104 \\ neg %%o091 \\ neg %%o0
105 \\ 1:92 \\ 1:
106 : [ret] "={o0}" (-> usize),93 : [ret] "={o0}" (-> u64),
107 : [number] "{g1}" (@intFromEnum(number)),94 : [number] "{g1}" (@intFromEnum(number)),
108 [arg1] "{o0}" (arg1),95 [arg1] "{o0}" (arg1),
109 [arg2] "{o1}" (arg2),96 [arg2] "{o1}" (arg2),
...@@ -111,14 +98,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -111,14 +98,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
111 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });98 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
112}99}
113100
114pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {101pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
115 return asm volatile (102 return asm volatile (
116 \\ t 0x6d103 \\ t 0x6d
117 \\ bcc,pt %%xcc, 1f104 \\ bcc,pt %%xcc, 1f
118 \\ nop105 \\ nop
119 \\ neg %%o0106 \\ neg %%o0
120 \\ 1:107 \\ 1:
121 : [ret] "={o0}" (-> usize),108 : [ret] "={o0}" (-> u64),
122 : [number] "{g1}" (@intFromEnum(number)),109 : [number] "{g1}" (@intFromEnum(number)),
123 [arg1] "{o0}" (arg1),110 [arg1] "{o0}" (arg1),
124 [arg2] "{o1}" (arg2),111 [arg2] "{o1}" (arg2),
...@@ -127,14 +114,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -127,14 +114,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
127 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });114 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
128}115}
129116
130pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {117pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
131 return asm volatile (118 return asm volatile (
132 \\ t 0x6d119 \\ t 0x6d
133 \\ bcc,pt %%xcc, 1f120 \\ bcc,pt %%xcc, 1f
134 \\ nop121 \\ nop
135 \\ neg %%o0122 \\ neg %%o0
136 \\ 1:123 \\ 1:
137 : [ret] "={o0}" (-> usize),124 : [ret] "={o0}" (-> u64),
138 : [number] "{g1}" (@intFromEnum(number)),125 : [number] "{g1}" (@intFromEnum(number)),
139 [arg1] "{o0}" (arg1),126 [arg1] "{o0}" (arg1),
140 [arg2] "{o1}" (arg2),127 [arg2] "{o1}" (arg2),
...@@ -146,20 +133,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -146,20 +133,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
146133
147pub fn syscall6(134pub fn syscall6(
148 number: SYS,135 number: SYS,
149 arg1: usize,136 arg1: u64,
150 arg2: usize,137 arg2: u64,
151 arg3: usize,138 arg3: u64,
152 arg4: usize,139 arg4: u64,
153 arg5: usize,140 arg5: u64,
154 arg6: usize,141 arg6: u64,
155) usize {142) u64 {
156 return asm volatile (143 return asm volatile (
157 \\ t 0x6d144 \\ t 0x6d
158 \\ bcc,pt %%xcc, 1f145 \\ bcc,pt %%xcc, 1f
159 \\ nop146 \\ nop
160 \\ neg %%o0147 \\ neg %%o0
161 \\ 1:148 \\ 1:
162 : [ret] "={o0}" (-> usize),149 : [ret] "={o0}" (-> u64),
163 : [number] "{g1}" (@intFromEnum(number)),150 : [number] "{g1}" (@intFromEnum(number)),
164 [arg1] "{o0}" (arg1),151 [arg1] "{o0}" (arg1),
165 [arg2] "{o1}" (arg2),152 [arg2] "{o1}" (arg2),
...@@ -170,7 +157,7 @@ pub fn syscall6(...@@ -170,7 +157,7 @@ pub fn syscall6(
170 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });157 : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
171}158}
172159
173pub fn clone() callconv(.naked) usize {160pub fn clone() callconv(.naked) u64 {
174 // __clone(func, stack, flags, arg, ptid, tls, ctid)161 // __clone(func, stack, flags, arg, ptid, tls, ctid)
175 // i0, i1, i2, i3, i4, i5, sp162 // i0, i1, i2, i3, i4, i5, sp
176 //163 //
...@@ -236,93 +223,51 @@ pub fn restore_rt() callconv(.c) void {...@@ -236,93 +223,51 @@ pub fn restore_rt() callconv(.c) void {
236 : .{ .memory = true, .icc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });223 : .{ .memory = true, .icc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
237}224}
238225
239pub const F = struct {
240 pub const DUPFD = 0;
241 pub const GETFD = 1;
242 pub const SETFD = 2;
243 pub const GETFL = 3;
244 pub const SETFL = 4;
245
246 pub const SETOWN = 5;
247 pub const GETOWN = 6;
248 pub const GETLK = 7;
249 pub const SETLK = 8;
250 pub const SETLKW = 9;
251
252 pub const RDLCK = 1;
253 pub const WRLCK = 2;
254 pub const UNLCK = 3;
255
256 pub const SETOWN_EX = 15;
257 pub const GETOWN_EX = 16;
258
259 pub const GETOWNER_UIDS = 17;
260};
261
262pub const VDSO = struct {226pub const VDSO = struct {
263 pub const CGT_SYM = "__vdso_clock_gettime";227 pub const CGT_SYM = "__vdso_clock_gettime";
264 pub const CGT_VER = "LINUX_2.6";228 pub const CGT_VER = "LINUX_2.6";
265};229};
266230
267pub const Flock = extern struct {
268 type: i16,
269 whence: i16,
270 start: off_t,
271 len: off_t,
272 pid: pid_t,
273};
274
275pub const off_t = i64;231pub const off_t = i64;
276pub const ino_t = u64;232pub const ino_t = u64;
277pub const time_t = isize;233pub const time_t = i64;
278pub const mode_t = u32;234pub const mode_t = u32;
279pub const dev_t = usize;235pub const dev_t = u64;
280pub const nlink_t = u32;236pub const nlink_t = u32;
281pub const blksize_t = isize;237pub const blksize_t = i64;
282pub const blkcnt_t = isize;238pub const blkcnt_t = i64;
283239
284// The `stat64` definition used by the kernel.240// The `stat64` definition used by the kernel.
285pub const Stat = extern struct {241pub const Stat = extern struct {
286 dev: u64,242 dev: dev_t,
287 ino: u64,243 ino: ino_t,
288 nlink: u64,244 nlink: nlink_t,
245 _pad: i32,
289246
290 mode: u32,247 mode: mode_t,
291 uid: u32,248 uid: std.os.linux.uid_t,
292 gid: u32,249 gid: std.os.linux.gid_t,
293 __pad0: u32,250 __pad0: u32,
294251
295 rdev: u64,252 rdev: dev_t,
296 size: i64,253 size: i64,
297 blksize: i64,254 blksize: blksize_t,
298 blocks: i64,255 blocks: blkcnt_t,
299256
300 atim: timespec,257 atim: std.os.linux.timespec,
301 mtim: timespec,258 mtim: std.os.linux.timespec,
302 ctim: timespec,259 ctim: std.os.linux.timespec,
303 __unused: [3]u64,260 __unused: [3]u64,
304261
305 pub fn atime(self: @This()) timespec {262 pub fn atime(self: @This()) std.os.linux.timespec {
306 return self.atim;263 return self.atim;
307 }264 }
308265
309 pub fn mtime(self: @This()) timespec {266 pub fn mtime(self: @This()) std.os.linux.timespec {
310 return self.mtim;267 return self.mtim;
311 }268 }
312269
313 pub fn ctime(self: @This()) timespec {270 pub fn ctime(self: @This()) std.os.linux.timespec {
314 return self.ctim;271 return self.ctim;
315 }272 }
316};273};
317
318pub const timeval = extern struct {
319 sec: isize,
320 usec: i32,
321};
322
323pub const timezone = extern struct {
324 minuteswest: i32,
325 dsttime: i32,
326};
327
328pub const Elf_Symndx = u32;
lib/std/os/linux/thumb.zig+28-43
...@@ -4,64 +4,55 @@...@@ -4,64 +4,55 @@
4//! Save and restore r7 around the syscall without touching the stack pointer not4//! Save and restore r7 around the syscall without touching the stack pointer not
5//! to break the frame chain.5//! to break the frame chain.
6const std = @import("../../std.zig");6const std = @import("../../std.zig");
7const linux = std.os.linux;7const SYS = std.os.linux.SYS;
8const SYS = linux.SYS;
98
10pub fn syscall0(number: SYS) usize {9pub fn syscall0(number: SYS) u32 {
11 @setRuntimeSafety(false);10 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
12
13 var buf: [2]usize = .{ @intFromEnum(number), undefined };
14 return asm volatile (11 return asm volatile (
15 \\ str r7, [%[tmp], #4]12 \\ str r7, [%[tmp], #4]
16 \\ ldr r7, [%[tmp]]13 \\ ldr r7, [%[tmp]]
17 \\ svc #014 \\ svc #0
18 \\ ldr r7, [%[tmp], #4]15 \\ ldr r7, [%[tmp], #4]
19 : [ret] "={r0}" (-> usize),16 : [ret] "={r0}" (-> u32),
20 : [tmp] "{r1}" (&buf),17 : [tmp] "{r1}" (&buf),
21 : .{ .memory = true });18 : .{ .memory = true });
22}19}
2320
24pub fn syscall1(number: SYS, arg1: usize) usize {21pub fn syscall1(number: SYS, arg1: u32) u32 {
25 @setRuntimeSafety(false);22 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
26
27 var buf: [2]usize = .{ @intFromEnum(number), undefined };
28 return asm volatile (23 return asm volatile (
29 \\ str r7, [%[tmp], #4]24 \\ str r7, [%[tmp], #4]
30 \\ ldr r7, [%[tmp]]25 \\ ldr r7, [%[tmp]]
31 \\ svc #026 \\ svc #0
32 \\ ldr r7, [%[tmp], #4]27 \\ ldr r7, [%[tmp], #4]
33 : [ret] "={r0}" (-> usize),28 : [ret] "={r0}" (-> u32),
34 : [tmp] "{r1}" (&buf),29 : [tmp] "{r1}" (&buf),
35 [arg1] "{r0}" (arg1),30 [arg1] "{r0}" (arg1),
36 : .{ .memory = true });31 : .{ .memory = true });
37}32}
3833
39pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {34pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
40 @setRuntimeSafety(false);35 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
41
42 var buf: [2]usize = .{ @intFromEnum(number), undefined };
43 return asm volatile (36 return asm volatile (
44 \\ str r7, [%[tmp], #4]37 \\ str r7, [%[tmp], #4]
45 \\ ldr r7, [%[tmp]]38 \\ ldr r7, [%[tmp]]
46 \\ svc #039 \\ svc #0
47 \\ ldr r7, [%[tmp], #4]40 \\ ldr r7, [%[tmp], #4]
48 : [ret] "={r0}" (-> usize),41 : [ret] "={r0}" (-> u32),
49 : [tmp] "{r2}" (&buf),42 : [tmp] "{r2}" (&buf),
50 [arg1] "{r0}" (arg1),43 [arg1] "{r0}" (arg1),
51 [arg2] "{r1}" (arg2),44 [arg2] "{r1}" (arg2),
52 : .{ .memory = true });45 : .{ .memory = true });
53}46}
5447
55pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {48pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
56 @setRuntimeSafety(false);49 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
57
58 var buf: [2]usize = .{ @intFromEnum(number), undefined };
59 return asm volatile (50 return asm volatile (
60 \\ str r7, [%[tmp], #4]51 \\ str r7, [%[tmp], #4]
61 \\ ldr r7, [%[tmp]]52 \\ ldr r7, [%[tmp]]
62 \\ svc #053 \\ svc #0
63 \\ ldr r7, [%[tmp], #4]54 \\ ldr r7, [%[tmp], #4]
64 : [ret] "={r0}" (-> usize),55 : [ret] "={r0}" (-> u32),
65 : [tmp] "{r3}" (&buf),56 : [tmp] "{r3}" (&buf),
66 [arg1] "{r0}" (arg1),57 [arg1] "{r0}" (arg1),
67 [arg2] "{r1}" (arg2),58 [arg2] "{r1}" (arg2),
...@@ -69,16 +60,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -69,16 +60,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
69 : .{ .memory = true });60 : .{ .memory = true });
70}61}
7162
72pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {63pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
73 @setRuntimeSafety(false);64 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
74
75 var buf: [2]usize = .{ @intFromEnum(number), undefined };
76 return asm volatile (65 return asm volatile (
77 \\ str r7, [%[tmp], #4]66 \\ str r7, [%[tmp], #4]
78 \\ ldr r7, [%[tmp]]67 \\ ldr r7, [%[tmp]]
79 \\ svc #068 \\ svc #0
80 \\ ldr r7, [%[tmp], #4]69 \\ ldr r7, [%[tmp], #4]
81 : [ret] "={r0}" (-> usize),70 : [ret] "={r0}" (-> u32),
82 : [tmp] "{r4}" (&buf),71 : [tmp] "{r4}" (&buf),
83 [arg1] "{r0}" (arg1),72 [arg1] "{r0}" (arg1),
84 [arg2] "{r1}" (arg2),73 [arg2] "{r1}" (arg2),
...@@ -87,16 +76,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -87,16 +76,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
87 : .{ .memory = true });76 : .{ .memory = true });
88}77}
8978
90pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {79pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
91 @setRuntimeSafety(false);80 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
92
93 var buf: [2]usize = .{ @intFromEnum(number), undefined };
94 return asm volatile (81 return asm volatile (
95 \\ str r7, [%[tmp], #4]82 \\ str r7, [%[tmp], #4]
96 \\ ldr r7, [%[tmp]]83 \\ ldr r7, [%[tmp]]
97 \\ svc #084 \\ svc #0
98 \\ ldr r7, [%[tmp], #4]85 \\ ldr r7, [%[tmp], #4]
99 : [ret] "={r0}" (-> usize),86 : [ret] "={r0}" (-> u32),
100 : [tmp] "{r5}" (&buf),87 : [tmp] "{r5}" (&buf),
101 [arg1] "{r0}" (arg1),88 [arg1] "{r0}" (arg1),
102 [arg2] "{r1}" (arg2),89 [arg2] "{r1}" (arg2),
...@@ -108,22 +95,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -108,22 +95,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
10895
109pub fn syscall6(96pub fn syscall6(
110 number: SYS,97 number: SYS,
111 arg1: usize,98 arg1: u32,
112 arg2: usize,99 arg2: u32,
113 arg3: usize,100 arg3: u32,
114 arg4: usize,101 arg4: u32,
115 arg5: usize,102 arg5: u32,
116 arg6: usize,103 arg6: u32,
117) usize {104) u32 {
118 @setRuntimeSafety(false);105 var buf: [2]u32 = .{ @intFromEnum(number), undefined };
119
120 var buf: [2]usize = .{ @intFromEnum(number), undefined };
121 return asm volatile (106 return asm volatile (
122 \\ str r7, [%[tmp], #4]107 \\ str r7, [%[tmp], #4]
123 \\ ldr r7, [%[tmp]]108 \\ ldr r7, [%[tmp]]
124 \\ svc #0109 \\ svc #0
125 \\ ldr r7, [%[tmp], #4]110 \\ ldr r7, [%[tmp], #4]
126 : [ret] "={r0}" (-> usize),111 : [ret] "={r0}" (-> u32),
127 : [tmp] "{r6}" (&buf),112 : [tmp] "{r6}" (&buf),
128 [arg1] "{r0}" (arg1),113 [arg1] "{r0}" (arg1),
129 [arg2] "{r1}" (arg2),114 [arg2] "{r1}" (arg2),
lib/std/os/linux/tls.zig+1-2
...@@ -16,7 +16,6 @@ const math = std.math;...@@ -16,7 +16,6 @@ const math = std.math;
16const assert = std.debug.assert;16const assert = std.debug.assert;
17const native_arch = @import("builtin").cpu.arch;17const native_arch = @import("builtin").cpu.arch;
18const linux = std.os.linux;18const linux = std.os.linux;
19const posix = std.posix;
20const page_size_min = std.heap.page_size_min;19const page_size_min = std.heap.page_size_min;
2120
22/// Represents an ELF TLS variant.21/// Represents an ELF TLS variant.
...@@ -523,7 +522,7 @@ pub fn initStatic(phdrs: []elf.Phdr) void {...@@ -523,7 +522,7 @@ pub fn initStatic(phdrs: []elf.Phdr) void {
523}522}
524523
525inline fn mmap_tls(length: usize) usize {524inline fn mmap_tls(length: usize) usize {
526 const prot = posix.PROT.READ | posix.PROT.WRITE;525 const prot = linux.PROT.READ | linux.PROT.WRITE;
527 const flags: linux.MAP = .{ .TYPE = .PRIVATE, .ANONYMOUS = true };526 const flags: linux.MAP = .{ .TYPE = .PRIVATE, .ANONYMOUS = true };
528527
529 if (@hasField(linux.SYS, "mmap2")) {528 if (@hasField(linux.SYS, "mmap2")) {
lib/std/os/linux/x32.zig created+192
...@@ -0,0 +1,192 @@
1// TODO: A lot of this file is very likely wrong.
2
3const builtin = @import("builtin");
4const std = @import("../../std.zig");
5const SYS = std.os.linux.SYS;
6
7pub fn syscall0(number: SYS) u32 {
8 return asm volatile ("syscall"
9 : [ret] "={rax}" (-> u32),
10 : [number] "{rax}" (@intFromEnum(number)),
11 : .{ .rcx = true, .r11 = true, .memory = true });
12}
13
14pub fn syscall1(number: SYS, arg1: u32) u32 {
15 return asm volatile ("syscall"
16 : [ret] "={rax}" (-> u32),
17 : [number] "{rax}" (@intFromEnum(number)),
18 [arg1] "{rdi}" (arg1),
19 : .{ .rcx = true, .r11 = true, .memory = true });
20}
21
22pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
23 return asm volatile ("syscall"
24 : [ret] "={rax}" (-> u32),
25 : [number] "{rax}" (@intFromEnum(number)),
26 [arg1] "{rdi}" (arg1),
27 [arg2] "{rsi}" (arg2),
28 : .{ .rcx = true, .r11 = true, .memory = true });
29}
30
31pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
32 return asm volatile ("syscall"
33 : [ret] "={rax}" (-> u32),
34 : [number] "{rax}" (@intFromEnum(number)),
35 [arg1] "{rdi}" (arg1),
36 [arg2] "{rsi}" (arg2),
37 [arg3] "{rdx}" (arg3),
38 : .{ .rcx = true, .r11 = true, .memory = true });
39}
40
41pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
42 return asm volatile ("syscall"
43 : [ret] "={rax}" (-> u32),
44 : [number] "{rax}" (@intFromEnum(number)),
45 [arg1] "{rdi}" (arg1),
46 [arg2] "{rsi}" (arg2),
47 [arg3] "{rdx}" (arg3),
48 [arg4] "{r10}" (arg4),
49 : .{ .rcx = true, .r11 = true, .memory = true });
50}
51
52pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
53 return asm volatile ("syscall"
54 : [ret] "={rax}" (-> u32),
55 : [number] "{rax}" (@intFromEnum(number)),
56 [arg1] "{rdi}" (arg1),
57 [arg2] "{rsi}" (arg2),
58 [arg3] "{rdx}" (arg3),
59 [arg4] "{r10}" (arg4),
60 [arg5] "{r8}" (arg5),
61 : .{ .rcx = true, .r11 = true, .memory = true });
62}
63
64pub fn syscall6(
65 number: SYS,
66 arg1: u32,
67 arg2: u32,
68 arg3: u32,
69 arg4: u32,
70 arg5: u32,
71 arg6: u32,
72) u32 {
73 return asm volatile ("syscall"
74 : [ret] "={rax}" (-> u32),
75 : [number] "{rax}" (@intFromEnum(number)),
76 [arg1] "{rdi}" (arg1),
77 [arg2] "{rsi}" (arg2),
78 [arg3] "{rdx}" (arg3),
79 [arg4] "{r10}" (arg4),
80 [arg5] "{r8}" (arg5),
81 [arg6] "{r9}" (arg6),
82 : .{ .rcx = true, .r11 = true, .memory = true });
83}
84
85pub fn clone() callconv(.naked) u32 {
86 asm volatile (
87 \\ movl $56,%%eax // SYS_clone
88 \\ movq %%rdi,%%r11
89 \\ movq %%rdx,%%rdi
90 \\ movq %%r8,%%rdx
91 \\ movq %%r9,%%r8
92 \\ movq 8(%%rsp),%%r10
93 \\ movq %%r11,%%r9
94 \\ andq $-16,%%rsi
95 \\ subq $8,%%rsi
96 \\ movq %%rcx,(%%rsi)
97 \\ syscall
98 \\ testq %%rax,%%rax
99 \\ jz 1f
100 \\ retq
101 \\
102 \\1:
103 );
104 if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
105 \\ .cfi_undefined %%rip
106 );
107 asm volatile (
108 \\ xorl %%ebp,%%ebp
109 \\
110 \\ popq %%rdi
111 \\ callq *%%r9
112 \\ movl %%eax,%%edi
113 \\ movl $60,%%eax // SYS_exit
114 \\ syscall
115 \\
116 );
117}
118
119pub const restore = restore_rt;
120
121pub fn restore_rt() callconv(.naked) noreturn {
122 switch (builtin.zig_backend) {
123 .stage2_c => asm volatile (
124 \\ movl %[number], %%eax
125 \\ syscall
126 :
127 : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
128 ),
129 else => asm volatile (
130 \\ syscall
131 :
132 : [number] "{rax}" (@intFromEnum(SYS.rt_sigreturn)),
133 ),
134 }
135}
136
137pub const mode_t = u32;
138pub const time_t = i32;
139pub const nlink_t = u32;
140pub const blksize_t = i32;
141pub const blkcnt_t = i32;
142pub const off_t = i64;
143pub const ino_t = u64;
144pub const dev_t = u64;
145
146pub const VDSO = struct {
147 pub const CGT_SYM = "__vdso_clock_gettime";
148 pub const CGT_VER = "LINUX_2.6";
149
150 pub const GETCPU_SYM = "__vdso_getcpu";
151 pub const GETCPU_VER = "LINUX_2.6";
152};
153
154pub const ARCH = struct {
155 pub const SET_GS = 0x1001;
156 pub const SET_FS = 0x1002;
157 pub const GET_FS = 0x1003;
158 pub const GET_GS = 0x1004;
159};
160
161// The `stat` definition used by the Linux kernel.
162pub const Stat = extern struct {
163 dev: dev_t,
164 ino: ino_t,
165 nlink: nlink_t,
166
167 mode: mode_t,
168 uid: std.os.linux.uid_t,
169 gid: std.os.linux.gid_t,
170 __pad0: u32,
171 rdev: dev_t,
172 size: off_t,
173 blksize: blksize_t,
174 blocks: i64,
175
176 atim: std.os.linux.timespec,
177 mtim: std.os.linux.timespec,
178 ctim: std.os.linux.timespec,
179 __unused: [3]i32,
180
181 pub fn atime(self: @This()) std.os.linux.timespec {
182 return self.atim;
183 }
184
185 pub fn mtime(self: @This()) std.os.linux.timespec {
186 return self.mtim;
187 }
188
189 pub fn ctime(self: @This()) std.os.linux.timespec {
190 return self.ctim;
191 }
192};
lib/std/os/linux/x86.zig+38-94
...@@ -1,46 +1,34 @@...@@ -1,46 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;
5const SYS = linux.SYS;
6const socklen_t = linux.socklen_t;
7const iovec = std.posix.iovec;
8const iovec_const = std.posix.iovec_const;
9const uid_t = linux.uid_t;
10const gid_t = linux.gid_t;
11const pid_t = linux.pid_t;
12const stack_t = linux.stack_t;
13const sigset_t = linux.sigset_t;
14const sockaddr = linux.sockaddr;
15const timespec = linux.timespec;
164
17pub fn syscall0(number: SYS) usize {5pub fn syscall0(number: SYS) u32 {
18 return asm volatile ("int $0x80"6 return asm volatile ("int $0x80"
19 : [ret] "={eax}" (-> usize),7 : [ret] "={eax}" (-> u32),
20 : [number] "{eax}" (@intFromEnum(number)),8 : [number] "{eax}" (@intFromEnum(number)),
21 : .{ .memory = true });9 : .{ .memory = true });
22}10}
2311
24pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u32) u32 {
25 return asm volatile ("int $0x80"13 return asm volatile ("int $0x80"
26 : [ret] "={eax}" (-> usize),14 : [ret] "={eax}" (-> u32),
27 : [number] "{eax}" (@intFromEnum(number)),15 : [number] "{eax}" (@intFromEnum(number)),
28 [arg1] "{ebx}" (arg1),16 [arg1] "{ebx}" (arg1),
29 : .{ .memory = true });17 : .{ .memory = true });
30}18}
3119
32pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
33 return asm volatile ("int $0x80"21 return asm volatile ("int $0x80"
34 : [ret] "={eax}" (-> usize),22 : [ret] "={eax}" (-> u32),
35 : [number] "{eax}" (@intFromEnum(number)),23 : [number] "{eax}" (@intFromEnum(number)),
36 [arg1] "{ebx}" (arg1),24 [arg1] "{ebx}" (arg1),
37 [arg2] "{ecx}" (arg2),25 [arg2] "{ecx}" (arg2),
38 : .{ .memory = true });26 : .{ .memory = true });
39}27}
4028
41pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
42 return asm volatile ("int $0x80"30 return asm volatile ("int $0x80"
43 : [ret] "={eax}" (-> usize),31 : [ret] "={eax}" (-> u32),
44 : [number] "{eax}" (@intFromEnum(number)),32 : [number] "{eax}" (@intFromEnum(number)),
45 [arg1] "{ebx}" (arg1),33 [arg1] "{ebx}" (arg1),
46 [arg2] "{ecx}" (arg2),34 [arg2] "{ecx}" (arg2),
...@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
48 : .{ .memory = true });36 : .{ .memory = true });
49}37}
5038
51pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
52 return asm volatile ("int $0x80"40 return asm volatile ("int $0x80"
53 : [ret] "={eax}" (-> usize),41 : [ret] "={eax}" (-> u32),
54 : [number] "{eax}" (@intFromEnum(number)),42 : [number] "{eax}" (@intFromEnum(number)),
55 [arg1] "{ebx}" (arg1),43 [arg1] "{ebx}" (arg1),
56 [arg2] "{ecx}" (arg2),44 [arg2] "{ecx}" (arg2),
...@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
59 : .{ .memory = true });47 : .{ .memory = true });
60}48}
6149
62pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
63 return asm volatile ("int $0x80"51 return asm volatile ("int $0x80"
64 : [ret] "={eax}" (-> usize),52 : [ret] "={eax}" (-> u32),
65 : [number] "{eax}" (@intFromEnum(number)),53 : [number] "{eax}" (@intFromEnum(number)),
66 [arg1] "{ebx}" (arg1),54 [arg1] "{ebx}" (arg1),
67 [arg2] "{ecx}" (arg2),55 [arg2] "{ecx}" (arg2),
...@@ -73,20 +61,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -73,20 +61,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7361
74pub fn syscall6(62pub fn syscall6(
75 number: SYS,63 number: SYS,
76 arg1: usize,64 arg1: u32,
77 arg2: usize,65 arg2: u32,
78 arg3: usize,66 arg3: u32,
79 arg4: usize,67 arg4: u32,
80 arg5: usize,68 arg5: u32,
81 arg6: usize,69 arg6: u32,
82) usize {70) u32 {
83 // arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer71 // arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer
84 // and there are no more GPRs available; so we'll need a memory operand for it. Adding that72 // and there are no more GPRs available; so we'll need a memory operand for it. Adding that
85 // memory operand means that on PIC we might need a reference to the GOT, which in turn needs73 // memory operand means that on PIC we might need a reference to the GOT, which in turn needs
86 // *its* own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get74 // *its* own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get
87 // right, because we can't touch esp or ebp until we're done with the memory input (as that75 // right, because we can't touch esp or ebp until we're done with the memory input (as that
88 // input could be relative to esp or ebp).76 // input could be relative to esp or ebp).
89 const args56: [2]usize = .{ arg5, arg6 };77 const args56: [2]u32 = .{ arg5, arg6 };
90 return asm volatile (78 return asm volatile (
91 \\ push %[args56]79 \\ push %[args56]
92 \\ push %%ebp80 \\ push %%ebp
...@@ -99,7 +87,7 @@ pub fn syscall6(...@@ -99,7 +87,7 @@ pub fn syscall6(
99 \\ int $0x8087 \\ int $0x80
100 \\ pop %%ebp88 \\ pop %%ebp
101 \\ pop %%edi89 \\ pop %%edi
102 : [ret] "={eax}" (-> usize),90 : [ret] "={eax}" (-> u32),
103 : [number] "{eax}" (@intFromEnum(number)),91 : [number] "{eax}" (@intFromEnum(number)),
104 [arg1] "{ebx}" (arg1),92 [arg1] "{ebx}" (arg1),
105 [arg2] "{ecx}" (arg2),93 [arg2] "{ecx}" (arg2),
...@@ -109,16 +97,16 @@ pub fn syscall6(...@@ -109,16 +97,16 @@ pub fn syscall6(
109 : .{ .memory = true });97 : .{ .memory = true });
110}98}
11199
112pub fn socketcall(call: usize, args: [*]const usize) usize {100pub fn socketcall(call: u32, args: [*]const u32) u32 {
113 return asm volatile ("int $0x80"101 return asm volatile ("int $0x80"
114 : [ret] "={eax}" (-> usize),102 : [ret] "={eax}" (-> u32),
115 : [number] "{eax}" (@intFromEnum(SYS.socketcall)),103 : [number] "{eax}" (@intFromEnum(SYS.socketcall)),
116 [arg1] "{ebx}" (call),104 [arg1] "{ebx}" (call),
117 [arg2] "{ecx}" (@intFromPtr(args)),105 [arg2] "{ecx}" (@intFromPtr(args)),
118 : .{ .memory = true });106 : .{ .memory = true });
119}107}
120108
121pub fn clone() callconv(.naked) usize {109pub fn clone() callconv(.naked) u32 {
122 // __clone(func, stack, flags, arg, ptid, tls, ctid)110 // __clone(func, stack, flags, arg, ptid, tls, ctid)
123 // +8, +12, +16, +20, +24, +28, +32111 // +8, +12, +16, +20, +24, +28, +32
124 //112 //
...@@ -169,23 +157,23 @@ pub fn clone() callconv(.naked) usize {...@@ -169,23 +157,23 @@ pub fn clone() callconv(.naked) usize {
169}157}
170158
171pub fn restore() callconv(.naked) noreturn {159pub fn restore() callconv(.naked) noreturn {
172 switch (@import("builtin").zig_backend) {160 switch (builtin.zig_backend) {
173 .stage2_c => asm volatile (161 .stage2_c => asm volatile (
174 \\ movl %[number], %%eax162 \\ movl %[number], %%eax
175 \\ int $0x80163 \\ int $0x80
176 :164 :
177 : [number] "i" (@intFromEnum(SYS.sigreturn)),165 : [number] "i" (@intFromEnum(SYS.sigreturn)),
178 : .{ .memory = true }),166 ),
179 else => asm volatile (167 else => asm volatile (
180 \\ int $0x80168 \\ int $0x80
181 :169 :
182 : [number] "{eax}" (@intFromEnum(SYS.sigreturn)),170 : [number] "{eax}" (@intFromEnum(SYS.sigreturn)),
183 : .{ .memory = true }),171 ),
184 }172 }
185}173}
186174
187pub fn restore_rt() callconv(.naked) noreturn {175pub fn restore_rt() callconv(.naked) noreturn {
188 switch (@import("builtin").zig_backend) {176 switch (builtin.zig_backend) {
189 .stage2_c => asm volatile (177 .stage2_c => asm volatile (
190 \\ movl %[number], %%eax178 \\ movl %[number], %%eax
191 \\ int $0x80179 \\ int $0x80
...@@ -200,46 +188,14 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -200,46 +188,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
200 }188 }
201}189}
202190
203pub const F = struct {
204 pub const DUPFD = 0;
205 pub const GETFD = 1;
206 pub const SETFD = 2;
207 pub const GETFL = 3;
208 pub const SETFL = 4;
209 pub const SETOWN = 8;
210 pub const GETOWN = 9;
211 pub const SETSIG = 10;
212 pub const GETSIG = 11;
213 pub const GETLK = 12;
214 pub const SETLK = 13;
215 pub const SETLKW = 14;
216 pub const SETOWN_EX = 15;
217 pub const GETOWN_EX = 16;
218 pub const GETOWNER_UIDS = 17;
219
220 pub const RDLCK = 0;
221 pub const WRLCK = 1;
222 pub const UNLCK = 2;
223};
224
225pub const VDSO = struct {191pub const VDSO = struct {
226 pub const CGT_SYM = "__vdso_clock_gettime";192 pub const CGT_SYM = "__vdso_clock_gettime";
227 pub const CGT_VER = "LINUX_2.6";193 pub const CGT_VER = "LINUX_2.6";
228};194};
229195
230pub const ARCH = struct {};
231
232pub const Flock = extern struct {
233 type: i16,
234 whence: i16,
235 start: off_t,
236 len: off_t,
237 pid: pid_t,
238};
239
240pub const blksize_t = i32;196pub const blksize_t = i32;
241pub const nlink_t = u32;197pub const nlink_t = u32;
242pub const time_t = isize;198pub const time_t = i32;
243pub const mode_t = u32;199pub const mode_t = u32;
244pub const off_t = i64;200pub const off_t = i64;
245pub const ino_t = u64;201pub const ino_t = u64;
...@@ -253,43 +209,31 @@ pub const Stat = extern struct {...@@ -253,43 +209,31 @@ pub const Stat = extern struct {
253 __ino_truncated: u32,209 __ino_truncated: u32,
254 mode: mode_t,210 mode: mode_t,
255 nlink: nlink_t,211 nlink: nlink_t,
256 uid: uid_t,212 uid: std.os.linux.uid_t,
257 gid: gid_t,213 gid: std.os.linux.gid_t,
258 rdev: dev_t,214 rdev: dev_t,
259 __rdev_padding: u32,215 __rdev_padding: u32,
260 size: off_t,216 size: off_t,
261 blksize: blksize_t,217 blksize: blksize_t,
262 blocks: blkcnt_t,218 blocks: blkcnt_t,
263 atim: timespec,219 atim: std.os.linux.timespec,
264 mtim: timespec,220 mtim: std.os.linux.timespec,
265 ctim: timespec,221 ctim: std.os.linux.timespec,
266 ino: ino_t,222 ino: ino_t,
267223
268 pub fn atime(self: @This()) timespec {224 pub fn atime(self: @This()) std.os.linux.timespec {
269 return self.atim;225 return self.atim;
270 }226 }
271227
272 pub fn mtime(self: @This()) timespec {228 pub fn mtime(self: @This()) std.os.linux.timespec {
273 return self.mtim;229 return self.mtim;
274 }230 }
275231
276 pub fn ctime(self: @This()) timespec {232 pub fn ctime(self: @This()) std.os.linux.timespec {
277 return self.ctim;233 return self.ctim;
278 }234 }
279};235};
280236
281pub const timeval = extern struct {
282 sec: i32,
283 usec: i32,
284};
285
286pub const timezone = extern struct {
287 minuteswest: i32,
288 dsttime: i32,
289};
290
291pub const Elf_Symndx = u32;
292
293pub const user_desc = extern struct {237pub const user_desc = extern struct {
294 entry_number: u32,238 entry_number: u32,
295 base_addr: u32,239 base_addr: u32,
lib/std/os/linux/x86_64.zig+43-101
...@@ -1,48 +1,34 @@...@@ -1,48 +1,34 @@
1const builtin = @import("builtin");1const builtin = @import("builtin");
2const std = @import("../../std.zig");2const std = @import("../../std.zig");
3const maxInt = std.math.maxInt;3const SYS = std.os.linux.SYS;
4const linux = std.os.linux;4
5const SYS = linux.SYS;5pub fn syscall0(number: SYS) u64 {
6const iovec = std.posix.iovec;
7const iovec_const = std.posix.iovec_const;
8
9const pid_t = linux.pid_t;
10const uid_t = linux.uid_t;
11const gid_t = linux.gid_t;
12const clock_t = linux.clock_t;
13const stack_t = linux.stack_t;
14const sigset_t = linux.sigset_t;
15const sockaddr = linux.sockaddr;
16const socklen_t = linux.socklen_t;
17const timespec = linux.timespec;
18
19pub fn syscall0(number: SYS) usize {
20 return asm volatile ("syscall"6 return asm volatile ("syscall"
21 : [ret] "={rax}" (-> usize),7 : [ret] "={rax}" (-> u64),
22 : [number] "{rax}" (@intFromEnum(number)),8 : [number] "{rax}" (@intFromEnum(number)),
23 : .{ .rcx = true, .r11 = true, .memory = true });9 : .{ .rcx = true, .r11 = true, .memory = true });
24}10}
2511
26pub fn syscall1(number: SYS, arg1: usize) usize {12pub fn syscall1(number: SYS, arg1: u64) u64 {
27 return asm volatile ("syscall"13 return asm volatile ("syscall"
28 : [ret] "={rax}" (-> usize),14 : [ret] "={rax}" (-> u64),
29 : [number] "{rax}" (@intFromEnum(number)),15 : [number] "{rax}" (@intFromEnum(number)),
30 [arg1] "{rdi}" (arg1),16 [arg1] "{rdi}" (arg1),
31 : .{ .rcx = true, .r11 = true, .memory = true });17 : .{ .rcx = true, .r11 = true, .memory = true });
32}18}
3319
34pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {20pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
35 return asm volatile ("syscall"21 return asm volatile ("syscall"
36 : [ret] "={rax}" (-> usize),22 : [ret] "={rax}" (-> u64),
37 : [number] "{rax}" (@intFromEnum(number)),23 : [number] "{rax}" (@intFromEnum(number)),
38 [arg1] "{rdi}" (arg1),24 [arg1] "{rdi}" (arg1),
39 [arg2] "{rsi}" (arg2),25 [arg2] "{rsi}" (arg2),
40 : .{ .rcx = true, .r11 = true, .memory = true });26 : .{ .rcx = true, .r11 = true, .memory = true });
41}27}
4228
43pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {29pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
44 return asm volatile ("syscall"30 return asm volatile ("syscall"
45 : [ret] "={rax}" (-> usize),31 : [ret] "={rax}" (-> u64),
46 : [number] "{rax}" (@intFromEnum(number)),32 : [number] "{rax}" (@intFromEnum(number)),
47 [arg1] "{rdi}" (arg1),33 [arg1] "{rdi}" (arg1),
48 [arg2] "{rsi}" (arg2),34 [arg2] "{rsi}" (arg2),
...@@ -50,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {...@@ -50,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
50 : .{ .rcx = true, .r11 = true, .memory = true });36 : .{ .rcx = true, .r11 = true, .memory = true });
51}37}
5238
53pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {39pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
54 return asm volatile ("syscall"40 return asm volatile ("syscall"
55 : [ret] "={rax}" (-> usize),41 : [ret] "={rax}" (-> u64),
56 : [number] "{rax}" (@intFromEnum(number)),42 : [number] "{rax}" (@intFromEnum(number)),
57 [arg1] "{rdi}" (arg1),43 [arg1] "{rdi}" (arg1),
58 [arg2] "{rsi}" (arg2),44 [arg2] "{rsi}" (arg2),
...@@ -61,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)...@@ -61,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
61 : .{ .rcx = true, .r11 = true, .memory = true });47 : .{ .rcx = true, .r11 = true, .memory = true });
62}48}
6349
64pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {50pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
65 return asm volatile ("syscall"51 return asm volatile ("syscall"
66 : [ret] "={rax}" (-> usize),52 : [ret] "={rax}" (-> u64),
67 : [number] "{rax}" (@intFromEnum(number)),53 : [number] "{rax}" (@intFromEnum(number)),
68 [arg1] "{rdi}" (arg1),54 [arg1] "{rdi}" (arg1),
69 [arg2] "{rsi}" (arg2),55 [arg2] "{rsi}" (arg2),
...@@ -75,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,...@@ -75,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
7561
76pub fn syscall6(62pub fn syscall6(
77 number: SYS,63 number: SYS,
78 arg1: usize,64 arg1: u64,
79 arg2: usize,65 arg2: u64,
80 arg3: usize,66 arg3: u64,
81 arg4: usize,67 arg4: u64,
82 arg5: usize,68 arg5: u64,
83 arg6: usize,69 arg6: u64,
84) usize {70) u64 {
85 return asm volatile ("syscall"71 return asm volatile ("syscall"
86 : [ret] "={rax}" (-> usize),72 : [ret] "={rax}" (-> u64),
87 : [number] "{rax}" (@intFromEnum(number)),73 : [number] "{rax}" (@intFromEnum(number)),
88 [arg1] "{rdi}" (arg1),74 [arg1] "{rdi}" (arg1),
89 [arg2] "{rsi}" (arg2),75 [arg2] "{rsi}" (arg2),
...@@ -94,7 +80,7 @@ pub fn syscall6(...@@ -94,7 +80,7 @@ pub fn syscall6(
94 : .{ .rcx = true, .r11 = true, .memory = true });80 : .{ .rcx = true, .r11 = true, .memory = true });
95}81}
9682
97pub fn clone() callconv(.naked) usize {83pub fn clone() callconv(.naked) u64 {
98 asm volatile (84 asm volatile (
99 \\ movl $56,%%eax // SYS_clone85 \\ movl $56,%%eax // SYS_clone
100 \\ movq %%rdi,%%r1186 \\ movq %%rdi,%%r11
...@@ -131,7 +117,7 @@ pub fn clone() callconv(.naked) usize {...@@ -131,7 +117,7 @@ pub fn clone() callconv(.naked) usize {
131pub const restore = restore_rt;117pub const restore = restore_rt;
132118
133pub fn restore_rt() callconv(.naked) noreturn {119pub fn restore_rt() callconv(.naked) noreturn {
134 switch (@import("builtin").zig_backend) {120 switch (builtin.zig_backend) {
135 .stage2_c => asm volatile (121 .stage2_c => asm volatile (
136 \\ movl %[number], %%eax122 \\ movl %[number], %%eax
137 \\ syscall123 \\ syscall
...@@ -146,34 +132,14 @@ pub fn restore_rt() callconv(.naked) noreturn {...@@ -146,34 +132,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
146 }132 }
147}133}
148134
149pub const mode_t = usize;135pub const mode_t = u64;
150pub const time_t = isize;136pub const time_t = i64;
151pub const nlink_t = usize;137pub const nlink_t = u64;
152pub const blksize_t = isize;138pub const blksize_t = i64;
153pub const blkcnt_t = isize;139pub const blkcnt_t = i64;
154140pub const off_t = i64;
155pub const F = struct {141pub const ino_t = u64;
156 pub const DUPFD = 0;142pub const dev_t = u64;
157 pub const GETFD = 1;
158 pub const SETFD = 2;
159 pub const GETFL = 3;
160 pub const SETFL = 4;
161 pub const GETLK = 5;
162 pub const SETLK = 6;
163 pub const SETLKW = 7;
164 pub const SETOWN = 8;
165 pub const GETOWN = 9;
166 pub const SETSIG = 10;
167 pub const GETSIG = 11;
168
169 pub const SETOWN_EX = 15;
170 pub const GETOWN_EX = 16;
171 pub const GETOWNER_UIDS = 17;
172
173 pub const RDLCK = 0;
174 pub const WRLCK = 1;
175 pub const UNLCK = 2;
176};
177143
178pub const VDSO = struct {144pub const VDSO = struct {
179 pub const CGT_SYM = "__vdso_clock_gettime";145 pub const CGT_SYM = "__vdso_clock_gettime";
...@@ -190,59 +156,35 @@ pub const ARCH = struct {...@@ -190,59 +156,35 @@ pub const ARCH = struct {
190 pub const GET_GS = 0x1004;156 pub const GET_GS = 0x1004;
191};157};
192158
193pub const Flock = extern struct {
194 type: i16,
195 whence: i16,
196 start: off_t,
197 len: off_t,
198 pid: pid_t,
199};
200
201pub const off_t = i64;
202pub const ino_t = u64;
203pub const dev_t = u64;
204
205// The `stat` definition used by the Linux kernel.159// The `stat` definition used by the Linux kernel.
206pub const Stat = extern struct {160pub const Stat = extern struct {
207 dev: dev_t,161 dev: dev_t,
208 ino: ino_t,162 ino: ino_t,
209 nlink: usize,163 nlink: u64,
210164
211 mode: u32,165 mode: u32,
212 uid: uid_t,166 uid: std.os.linux.uid_t,
213 gid: gid_t,167 gid: std.os.linux.gid_t,
214 __pad0: u32,168 __pad0: u32,
215 rdev: dev_t,169 rdev: dev_t,
216 size: off_t,170 size: off_t,
217 blksize: isize,171 blksize: i64,
218 blocks: i64,172 blocks: i64,
219173
220 atim: timespec,174 atim: std.os.linux.timespec,
221 mtim: timespec,175 mtim: std.os.linux.timespec,
222 ctim: timespec,176 ctim: std.os.linux.timespec,
223 __unused: [3]isize,177 __unused: [3]i64,
224178
225 pub fn atime(self: @This()) timespec {179 pub fn atime(self: @This()) std.os.linux.timespec {
226 return self.atim;180 return self.atim;
227 }181 }
228182
229 pub fn mtime(self: @This()) timespec {183 pub fn mtime(self: @This()) std.os.linux.timespec {
230 return self.mtim;184 return self.mtim;
231 }185 }
232186
233 pub fn ctime(self: @This()) timespec {187 pub fn ctime(self: @This()) std.os.linux.timespec {
234 return self.ctim;188 return self.ctim;
235 }189 }
236};190};
237
238pub const timeval = extern struct {
239 sec: isize,
240 usec: isize,
241};
242
243pub const timezone = extern struct {
244 minuteswest: i32,
245 dsttime: i32,
246};
247
248pub const Elf_Symndx = u32;