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;