Get mips64(el)-linux working and start testing it

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;
 

lib/std/c.zig

@@ -2722,7 +2722,39 @@ pub const SYS = switch (native_os) {
 };
 /// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
 pub const Sigaction = switch (native_os) {
- .linux => linux.Sigaction,
+ .linux => switch (native_arch) {
+ .mips,
+ .mipsel,
+ .mips64,
+ .mips64el,
+ => if (builtin.target.isMusl())
+ linux.Sigaction
+ else if (builtin.target.ptrBitWidth() == 64) extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ } else extern struct {
+ pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
+ pub const sigaction_fn = *const fn (i32, *const siginfo_t, ?*anyopaque) callconv(.C) void;
+
+ flags: c_uint,
+ handler: extern union {
+ handler: ?handler_fn,
+ sigaction: ?sigaction_fn,
+ },
+ mask: sigset_t,
+ restorer: ?*const fn () callconv(.C) void = null,
+ __resv: [1]c_int = .{0},
+ },
+ else => linux.Sigaction,
+ },
  .emscripten => emscripten.Sigaction,
  .netbsd, .macos, .ios, .tvos, .watchos, .visionos => extern struct {
  pub const handler_fn = *align(1) const fn (i32) callconv(.C) void;
@@ -6326,16 +6358,46 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
- .mips, .mipsel => extern struct {
+ .mips, .mipsel => if (builtin.target.isMusl()) extern struct {
  dev: dev_t,
- __pad0: [2]u32,
+ __pad0: [2]i32,
  ino: ino_t,
  mode: mode_t,
  nlink: nlink_t,
  uid: uid_t,
  gid: gid_t,
  rdev: dev_t,
- __pad1: [2]u32,
+ __pad1: [2]i32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: i32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
  size: off_t,
  atim: timespec,
  mtim: timespec,
@@ -6357,6 +6419,68 @@ pub const Stat = switch (native_os) {
  return self.ctim;
  }
  },
+ .mips64, .mips64el => if (builtin.target.isMusl()) extern struct {
+ dev: dev_t,
+ __pad0: [3]i32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [2]u32,
+ size: off_t,
+ __pad2: i32,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ } else extern struct {
+ dev: dev_t,
+ __pad0: [3]u32,
+ ino: ino_t,
+ mode: mode_t,
+ nlink: nlink_t,
+ uid: uid_t,
+ gid: gid_t,
+ rdev: dev_t,
+ __pad1: [3]u32,
+ size: off_t,
+ atim: timespec,
+ mtim: timespec,
+ ctim: timespec,
+ blksize: blksize_t,
+ __pad3: u32,
+ blocks: blkcnt_t,
+ __pad4: [14]i32,
+
+ pub fn atime(self: @This()) timespec {
+ return self.atim;
+ }
+
+ pub fn mtime(self: @This()) timespec {
+ return self.mtim;
+ }
+
+ pub fn ctime(self: @This()) timespec {
+ return self.ctim;
+ }
+ },
 
  else => std.os.linux.Stat, // libc stat is the same as kernel stat.
  },

lib/std/debug.zig

@@ -56,6 +56,8 @@ pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
  // TODO: Make this work.
  .mips,
  .mipsel,
+ .mips64,
+ .mips64el,
  => false,
 
  // `@returnAddress()` in LLVM 10 gives

lib/std/os/linux.zig

@@ -2272,7 +2272,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
  length_halves[0],
  length_halves[1],
  );
- } else if (comptime native_arch == .mips or native_arch == .mipsel) {
+ } else if (native_arch.isMIPS32()) {
  // MIPS O32 does not deal with the register alignment issue, so pass a dummy value.
 
  const offset_halves = splitValue64(offset);
@@ -2382,7 +2382,7 @@ pub fn map_shadow_stack(addr: u64, size: u64, flags: u32) usize {
 }
 
 pub const E = switch (native_arch) {
- .mips, .mipsel => enum(u16) {
+ .mips, .mipsel, .mips64, .mips64el => enum(u16) {
  /// No error occurred.
  SUCCESS = 0,
 
@@ -6817,53 +6817,166 @@ pub const ifreq = extern struct {
 };
 
 // doc comments copied from musl
-pub const rlimit_resource = if (native_arch.isMIPS() or native_arch.isSPARC())
- arch_bits.rlimit_resource
-else
- enum(c_int) {
- /// Per-process CPU limit, in seconds.
- CPU,
- /// Largest file that can be created, in bytes.
- FSIZE,
- /// Maximum size of data segment, in bytes.
- DATA,
- /// Maximum size of stack segment, in bytes.
- STACK,
- /// Largest core file that can be created, in bytes.
- CORE,
- /// Largest resident set size, in bytes.
- /// This affects swapping; processes that are exceeding their
- /// resident set size will be more likely to have physical memory
- /// taken from them.
- RSS,
- /// Number of processes.
- NPROC,
- /// Number of open files.
- NOFILE,
- /// Locked-in-memory address space.
- MEMLOCK,
- /// Address space limit.
- AS,
- /// Maximum number of file locks.
- LOCKS,
- /// Maximum number of pending signals.
- SIGPENDING,
- /// Maximum bytes in POSIX message queues.
- MSGQUEUE,
- /// Maximum nice priority allowed to raise to.
- /// Nice levels 19 .. -20 correspond to 0 .. 39
- /// values of this resource limit.
- NICE,
- /// Maximum realtime priority allowed for non-privileged
- /// processes.
- RTPRIO,
- /// Maximum CPU time in µs that a process scheduled under a real-time
- /// scheduling policy may consume without making a blocking system
- /// call before being forcibly descheduled.
- RTTIME,
+pub const rlimit_resource = if (native_arch.isMIPS()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
 
- _,
- };
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Number of open files.
+ NOFILE = 5,
+
+ /// Address space limit.
+ AS = 6,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 7,
+
+ /// Number of processes.
+ NPROC = 8,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else if (native_arch.isSPARC()) enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+
+ /// Number of open files.
+ NOFILE = 6,
+
+ /// Number of processes.
+ NPROC = 7,
+
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+
+ /// Address space limit.
+ AS = 9,
+
+ /// Maximum number of file locks.
+ LOCKS = 10,
+
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+} else enum(c_int) {
+ /// Per-process CPU limit, in seconds.
+ CPU = 0,
+ /// Largest file that can be created, in bytes.
+ FSIZE = 1,
+ /// Maximum size of data segment, in bytes.
+ DATA = 2,
+ /// Maximum size of stack segment, in bytes.
+ STACK = 3,
+ /// Largest core file that can be created, in bytes.
+ CORE = 4,
+ /// Largest resident set size, in bytes.
+ /// This affects swapping; processes that are exceeding their
+ /// resident set size will be more likely to have physical memory
+ /// taken from them.
+ RSS = 5,
+ /// Number of processes.
+ NPROC = 6,
+ /// Number of open files.
+ NOFILE = 7,
+ /// Locked-in-memory address space.
+ MEMLOCK = 8,
+ /// Address space limit.
+ AS = 9,
+ /// Maximum number of file locks.
+ LOCKS = 10,
+ /// Maximum number of pending signals.
+ SIGPENDING = 11,
+ /// Maximum bytes in POSIX message queues.
+ MSGQUEUE = 12,
+ /// Maximum nice priority allowed to raise to.
+ /// Nice levels 19 .. -20 correspond to 0 .. 39
+ /// values of this resource limit.
+ NICE = 13,
+ /// Maximum realtime priority allowed for non-privileged
+ /// processes.
+ RTPRIO = 14,
+ /// Maximum CPU time in µs that a process scheduled under a real-time
+ /// scheduling policy may consume without making a blocking system
+ /// call before being forcibly descheduled.
+ RTTIME = 15,
+
+ _,
+};
 
 pub const rlim_t = u64;