From 4ebcf64864eeec6c2086826242f53eedc69275ad Mon Sep 17 00:00:00 2001
From: LemonBoy <thatlemon@gmail.com>
Date: Sat, 21 Sep 2019 23:00:36 +0200
Subject: [PATCH] =?UTF-8?q?Initial=20support=20for=20mipsel=20architecture?=
 =?UTF-8?q?=C2=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/std/hash/auto_hash.zig              |   2 +
 lib/std/os/bits/linux.zig               |  95 +++--
 lib/std/os/bits/linux/mipsel.zig        | 516 ++++++++++++++++++++++++
 lib/std/os/linux.zig                    |   1 +
 lib/std/os/linux/mipsel.zig             | 124 ++++++
 lib/std/os/linux/tls.zig                |   4 +
 lib/std/special/c.zig                   |  35 ++
 lib/std/special/start.zig               |   8 +
 src/analyze.cpp                         |   2 +
 src/link.cpp                            |   6 +-
 src/target.cpp                          |   7 +-
 src/target.hpp                          |   1 +
 test/stage1/behavior/byteswap.zig       |   2 +
 test/stage1/behavior/new_stack_call.zig |   1 +
 test/stage1/behavior/shuffle.zig        |   2 +-
 test/tests.zig                          |  10 +
 16 files changed, 770 insertions(+), 46 deletions(-)
 create mode 100644 lib/std/os/bits/linux/mipsel.zig
 create mode 100644 lib/std/os/linux/mipsel.zig

diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index 8a22788e5c..7018df5414 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -355,6 +355,8 @@ test "testHash union" {
 }
 
 test "testHash vector" {
+    if (@import("builtin").arch == .mipsel) return error.SkipZigTest;
+
     const a: @Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };
     const b: @Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };
     testing.expect(testHash(a) == testHash(a));
diff --git a/lib/std/os/bits/linux.zig b/lib/std/os/bits/linux.zig
index 939d203e8d..ed4d704447 100644
--- a/lib/std/os/bits/linux.zig
+++ b/lib/std/os/bits/linux.zig
@@ -9,9 +9,12 @@ pub usingnamespace switch (builtin.arch) {
     .aarch64 => @import("linux/arm64.zig"),
     .arm => @import("linux/arm-eabi.zig"),
     .riscv64 => @import("linux/riscv64.zig"),
+    .mipsel => @import("linux/mipsel.zig"),
     else => struct {},
 };
 
+const is_mips = builtin.arch == .mipsel;
+
 pub const pid_t = i32;
 pub const fd_t = i32;
 pub const uid_t = i32;
@@ -96,21 +99,21 @@ pub const MAP_TYPE = 0x0f;
 pub const MAP_FIXED = 0x10;
 
 /// don't use a file
-pub const MAP_ANONYMOUS = 0x20;
+pub const MAP_ANONYMOUS = if (is_mips) 0x800 else 0x20;
 
 // MAP_ 0x0100 - 0x4000 flags are per architecture
 
 /// populate (prefault) pagetables
-pub const MAP_POPULATE = 0x8000;
+pub const MAP_POPULATE = if (is_mips) 0x10000 else 0x8000;
 
 /// do not block on IO
-pub const MAP_NONBLOCK = 0x10000;
+pub const MAP_NONBLOCK = if (is_mips) 0x20000 else 0x10000;
 
 /// give out an address that is best suited for process/thread stacks
-pub const MAP_STACK = 0x20000;
+pub const MAP_STACK = if (is_mips) 0x40000 else 0x20000;
 
 /// create a huge page mapping
-pub const MAP_HUGETLB = 0x40000;
+pub const MAP_HUGETLB = if (is_mips) 0x80000 else 0x40000;
 
 /// perform synchronous page faults for the mapping
 pub const MAP_SYNC = 0x80000;
@@ -247,15 +250,15 @@ pub const SHUT_RD = 0;
 pub const SHUT_WR = 1;
 pub const SHUT_RDWR = 2;
 
-pub const SOCK_STREAM = 1;
-pub const SOCK_DGRAM = 2;
+pub const SOCK_STREAM = if (is_mips) 2 else 1;
+pub const SOCK_DGRAM = if (is_mips) 1 else 2;
 pub const SOCK_RAW = 3;
 pub const SOCK_RDM = 4;
 pub const SOCK_SEQPACKET = 5;
 pub const SOCK_DCCP = 6;
 pub const SOCK_PACKET = 10;
 pub const SOCK_CLOEXEC = 0o2000000;
-pub const SOCK_NONBLOCK = 0o4000;
+pub const SOCK_NONBLOCK = if (is_mips) 0o200 else 0o4000;
 
 pub const PF_UNSPEC = 0;
 pub const PF_LOCAL = 1;
@@ -355,32 +358,38 @@ pub const AF_QIPCRTR = PF_QIPCRTR;
 pub const AF_SMC = PF_SMC;
 pub const AF_MAX = PF_MAX;
 
-pub const SO_DEBUG = 1;
-pub const SO_REUSEADDR = 2;
-pub const SO_TYPE = 3;
-pub const SO_ERROR = 4;
-pub const SO_DONTROUTE = 5;
-pub const SO_BROADCAST = 6;
-pub const SO_SNDBUF = 7;
-pub const SO_RCVBUF = 8;
-pub const SO_KEEPALIVE = 9;
-pub const SO_OOBINLINE = 10;
-pub const SO_NO_CHECK = 11;
-pub const SO_PRIORITY = 12;
-pub const SO_LINGER = 13;
-pub const SO_BSDCOMPAT = 14;
-pub const SO_REUSEPORT = 15;
-pub const SO_PASSCRED = 16;
-pub const SO_PEERCRED = 17;
-pub const SO_RCVLOWAT = 18;
-pub const SO_SNDLOWAT = 19;
-pub const SO_RCVTIMEO = 20;
-pub const SO_SNDTIMEO = 21;
-pub const SO_ACCEPTCONN = 30;
-pub const SO_SNDBUFFORCE = 32;
-pub const SO_RCVBUFFORCE = 33;
-pub const SO_PROTOCOL = 38;
-pub const SO_DOMAIN = 39;
+pub usingnamespace if (!@hasDecl(@This(), "SO_DEBUG"))
+    struct {
+        const SO_DEBUG = 1;
+        const SO_REUSEADDR = 2;
+        const SO_TYPE = 3;
+        const SO_ERROR = 4;
+        const SO_DONTROUTE = 5;
+        const SO_BROADCAST = 6;
+        const SO_SNDBUF = 7;
+        const SO_RCVBUF = 8;
+        const SO_KEEPALIVE = 9;
+        const SO_OOBINLINE = 10;
+        const SO_NO_CHECK = 11;
+        const SO_PRIORITY = 12;
+        const SO_LINGER = 13;
+        const SO_BSDCOMPAT = 14;
+        const SO_REUSEPORT = 15;
+        const SO_PASSCRED = 16;
+        const SO_PEERCRED = 17;
+        const SO_RCVLOWAT = 18;
+        const SO_SNDLOWAT = 19;
+        const SO_RCVTIMEO = 20;
+        const SO_SNDTIMEO = 21;
+        const SO_ACCEPTCONN = 30;
+        const SO_PEERSEC = 31;
+        const SO_SNDBUFFORCE = 32;
+        const SO_RCVBUFFORCE = 33;
+        const SO_PROTOCOL = 38;
+        const SO_DOMAIN = 39;
+    }
+else
+    struct {};
 
 pub const SO_SECURITY_AUTHENTICATION = 22;
 pub const SO_SECURITY_ENCRYPTION_TRANSPORT = 23;
@@ -394,11 +403,11 @@ pub const SO_GET_FILTER = SO_ATTACH_FILTER;
 
 pub const SO_PEERNAME = 28;
 pub const SO_TIMESTAMP_OLD = 29;
-pub const SO_PEERSEC = 31;
 pub const SO_PASSSEC = 34;
 pub const SO_TIMESTAMPNS_OLD = 35;
 pub const SO_MARK = 36;
 pub const SO_TIMESTAMPING_OLD = 37;
+
 pub const SO_RXQ_OVFL = 40;
 pub const SO_WIFI_STATUS = 41;
 pub const SCM_WIFI_STATUS = SO_WIFI_STATUS;
@@ -432,7 +441,7 @@ pub const SO_RCVTIMEO_NEW = 66;
 pub const SO_SNDTIMEO_NEW = 67;
 pub const SO_DETACH_REUSEPORT_BPF = 68;
 
-pub const SOL_SOCKET = 1;
+pub const SOL_SOCKET = if (is_mips) 65535 else 1;
 
 pub const SOL_IP = 0;
 pub const SOL_IPV6 = 41;
@@ -496,7 +505,7 @@ pub const DT_LNK = 10;
 pub const DT_SOCK = 12;
 pub const DT_WHT = 14;
 
-pub const TCGETS = 0x5401;
+pub const TCGETS = if (is_mips) 0x540D else 0x5401;
 pub const TCSETS = 0x5402;
 pub const TCSETSW = 0x5403;
 pub const TCSETSF = 0x5404;
@@ -512,17 +521,17 @@ pub const TIOCNXCL = 0x540D;
 pub const TIOCSCTTY = 0x540E;
 pub const TIOCGPGRP = 0x540F;
 pub const TIOCSPGRP = 0x5410;
-pub const TIOCOUTQ = 0x5411;
+pub const TIOCOUTQ = if (is_mips) 0x7472 else 0x5411;
 pub const TIOCSTI = 0x5412;
-pub const TIOCGWINSZ = 0x5413;
-pub const TIOCSWINSZ = 0x5414;
+pub const TIOCGWINSZ = if (is_mips) 0x40087468 else 0x5413;
+pub const TIOCSWINSZ = if (is_mips) 0x40087467 else 0x5414;
 pub const TIOCMGET = 0x5415;
 pub const TIOCMBIS = 0x5416;
 pub const TIOCMBIC = 0x5417;
 pub const TIOCMSET = 0x5418;
 pub const TIOCGSOFTCAR = 0x5419;
 pub const TIOCSSOFTCAR = 0x541A;
-pub const FIONREAD = 0x541B;
+pub const FIONREAD = if (is_mips) 0x467F else 0x541B;
 pub const TIOCINQ = FIONREAD;
 pub const TIOCLINUX = 0x541C;
 pub const TIOCCONS = 0x541D;
@@ -563,8 +572,8 @@ pub const EPOLLPRI = 0x002;
 pub const EPOLLOUT = 0x004;
 pub const EPOLLRDNORM = 0x040;
 pub const EPOLLRDBAND = 0x080;
-pub const EPOLLWRNORM = 0x100;
-pub const EPOLLWRBAND = 0x200;
+pub const EPOLLWRNORM = if (is_mips) 0x004 else 0x100;
+pub const EPOLLWRBAND = if (is_mips) 0x100 else 0x200;
 pub const EPOLLMSG = 0x400;
 pub const EPOLLERR = 0x008;
 pub const EPOLLHUP = 0x010;
diff --git a/lib/std/os/bits/linux/mipsel.zig b/lib/std/os/bits/linux/mipsel.zig
new file mode 100644
index 0000000000..928b974c0e
--- /dev/null
+++ b/lib/std/os/bits/linux/mipsel.zig
@@ -0,0 +1,516 @@
+const std = @import("../../../std.zig");
+const linux = std.os.linux;
+const socklen_t = linux.socklen_t;
+const iovec = linux.iovec;
+const iovec_const = linux.iovec_const;
+const uid_t = linux.uid_t;
+const gid_t = linux.gid_t;
+
+pub const SYS_Linux = 4000;
+pub const SYS_syscall = (SYS_Linux + 0);
+pub const SYS_exit = (SYS_Linux + 1);
+pub const SYS_fork = (SYS_Linux + 2);
+pub const SYS_read = (SYS_Linux + 3);
+pub const SYS_write = (SYS_Linux + 4);
+pub const SYS_open = (SYS_Linux + 5);
+pub const SYS_close = (SYS_Linux + 6);
+pub const SYS_waitpid = (SYS_Linux + 7);
+pub const SYS_creat = (SYS_Linux + 8);
+pub const SYS_link = (SYS_Linux + 9);
+pub const SYS_unlink = (SYS_Linux + 10);
+pub const SYS_execve = (SYS_Linux + 11);
+pub const SYS_chdir = (SYS_Linux + 12);
+pub const SYS_time = (SYS_Linux + 13);
+pub const SYS_mknod = (SYS_Linux + 14);
+pub const SYS_chmod = (SYS_Linux + 15);
+pub const SYS_lchown = (SYS_Linux + 16);
+pub const SYS_break = (SYS_Linux + 17);
+pub const SYS_unused18 = (SYS_Linux + 18);
+pub const SYS_lseek = (SYS_Linux + 19);
+pub const SYS_getpid = (SYS_Linux + 20);
+pub const SYS_mount = (SYS_Linux + 21);
+pub const SYS_umount = (SYS_Linux + 22);
+pub const SYS_setuid = (SYS_Linux + 23);
+pub const SYS_getuid = (SYS_Linux + 24);
+pub const SYS_stime = (SYS_Linux + 25);
+pub const SYS_ptrace = (SYS_Linux + 26);
+pub const SYS_alarm = (SYS_Linux + 27);
+pub const SYS_unused28 = (SYS_Linux + 28);
+pub const SYS_pause = (SYS_Linux + 29);
+pub const SYS_utime = (SYS_Linux + 30);
+pub const SYS_stty = (SYS_Linux + 31);
+pub const SYS_gtty = (SYS_Linux + 32);
+pub const SYS_access = (SYS_Linux + 33);
+pub const SYS_nice = (SYS_Linux + 34);
+pub const SYS_ftime = (SYS_Linux + 35);
+pub const SYS_sync = (SYS_Linux + 36);
+pub const SYS_kill = (SYS_Linux + 37);
+pub const SYS_rename = (SYS_Linux + 38);
+pub const SYS_mkdir = (SYS_Linux + 39);
+pub const SYS_rmdir = (SYS_Linux + 40);
+pub const SYS_dup = (SYS_Linux + 41);
+pub const SYS_pipe = (SYS_Linux + 42);
+pub const SYS_times = (SYS_Linux + 43);
+pub const SYS_prof = (SYS_Linux + 44);
+pub const SYS_brk = (SYS_Linux + 45);
+pub const SYS_setgid = (SYS_Linux + 46);
+pub const SYS_getgid = (SYS_Linux + 47);
+pub const SYS_signal = (SYS_Linux + 48);
+pub const SYS_geteuid = (SYS_Linux + 49);
+pub const SYS_getegid = (SYS_Linux + 50);
+pub const SYS_acct = (SYS_Linux + 51);
+pub const SYS_umount2 = (SYS_Linux + 52);
+pub const SYS_lock = (SYS_Linux + 53);
+pub const SYS_ioctl = (SYS_Linux + 54);
+pub const SYS_fcntl = (SYS_Linux + 55);
+pub const SYS_mpx = (SYS_Linux + 56);
+pub const SYS_setpgid = (SYS_Linux + 57);
+pub const SYS_ulimit = (SYS_Linux + 58);
+pub const SYS_unused59 = (SYS_Linux + 59);
+pub const SYS_umask = (SYS_Linux + 60);
+pub const SYS_chroot = (SYS_Linux + 61);
+pub const SYS_ustat = (SYS_Linux + 62);
+pub const SYS_dup2 = (SYS_Linux + 63);
+pub const SYS_getppid = (SYS_Linux + 64);
+pub const SYS_getpgrp = (SYS_Linux + 65);
+pub const SYS_setsid = (SYS_Linux + 66);
+pub const SYS_sigaction = (SYS_Linux + 67);
+pub const SYS_sgetmask = (SYS_Linux + 68);
+pub const SYS_ssetmask = (SYS_Linux + 69);
+pub const SYS_setreuid = (SYS_Linux + 70);
+pub const SYS_setregid = (SYS_Linux + 71);
+pub const SYS_sigsuspend = (SYS_Linux + 72);
+pub const SYS_sigpending = (SYS_Linux + 73);
+pub const SYS_sethostname = (SYS_Linux + 74);
+pub const SYS_setrlimit = (SYS_Linux + 75);
+pub const SYS_getrlimit = (SYS_Linux + 76);
+pub const SYS_getrusage = (SYS_Linux + 77);
+pub const SYS_gettimeofday = (SYS_Linux + 78);
+pub const SYS_settimeofday = (SYS_Linux + 79);
+pub const SYS_getgroups = (SYS_Linux + 80);
+pub const SYS_setgroups = (SYS_Linux + 81);
+pub const SYS_reserved82 = (SYS_Linux + 82);
+pub const SYS_symlink = (SYS_Linux + 83);
+pub const SYS_unused84 = (SYS_Linux + 84);
+pub const SYS_readlink = (SYS_Linux + 85);
+pub const SYS_uselib = (SYS_Linux + 86);
+pub const SYS_swapon = (SYS_Linux + 87);
+pub const SYS_reboot = (SYS_Linux + 88);
+pub const SYS_readdir = (SYS_Linux + 89);
+pub const SYS_mmap = (SYS_Linux + 90);
+pub const SYS_munmap = (SYS_Linux + 91);
+pub const SYS_truncate = (SYS_Linux + 92);
+pub const SYS_ftruncate = (SYS_Linux + 93);
+pub const SYS_fchmod = (SYS_Linux + 94);
+pub const SYS_fchown = (SYS_Linux + 95);
+pub const SYS_getpriority = (SYS_Linux + 96);
+pub const SYS_setpriority = (SYS_Linux + 97);
+pub const SYS_profil = (SYS_Linux + 98);
+pub const SYS_statfs = (SYS_Linux + 99);
+pub const SYS_fstatfs = (SYS_Linux + 100);
+pub const SYS_ioperm = (SYS_Linux + 101);
+pub const SYS_socketcall = (SYS_Linux + 102);
+pub const SYS_syslog = (SYS_Linux + 103);
+pub const SYS_setitimer = (SYS_Linux + 104);
+pub const SYS_getitimer = (SYS_Linux + 105);
+pub const SYS_stat = (SYS_Linux + 106);
+pub const SYS_lstat = (SYS_Linux + 107);
+pub const SYS_fstat = (SYS_Linux + 108);
+pub const SYS_unused109 = (SYS_Linux + 109);
+pub const SYS_iopl = (SYS_Linux + 110);
+pub const SYS_vhangup = (SYS_Linux + 111);
+pub const SYS_idle = (SYS_Linux + 112);
+pub const SYS_vm86 = (SYS_Linux + 113);
+pub const SYS_wait4 = (SYS_Linux + 114);
+pub const SYS_swapoff = (SYS_Linux + 115);
+pub const SYS_sysinfo = (SYS_Linux + 116);
+pub const SYS_ipc = (SYS_Linux + 117);
+pub const SYS_fsync = (SYS_Linux + 118);
+pub const SYS_sigreturn = (SYS_Linux + 119);
+pub const SYS_clone = (SYS_Linux + 120);
+pub const SYS_setdomainname = (SYS_Linux + 121);
+pub const SYS_uname = (SYS_Linux + 122);
+pub const SYS_modify_ldt = (SYS_Linux + 123);
+pub const SYS_adjtimex = (SYS_Linux + 124);
+pub const SYS_mprotect = (SYS_Linux + 125);
+pub const SYS_sigprocmask = (SYS_Linux + 126);
+pub const SYS_create_module = (SYS_Linux + 127);
+pub const SYS_init_module = (SYS_Linux + 128);
+pub const SYS_delete_module = (SYS_Linux + 129);
+pub const SYS_get_kernel_syms = (SYS_Linux + 130);
+pub const SYS_quotactl = (SYS_Linux + 131);
+pub const SYS_getpgid = (SYS_Linux + 132);
+pub const SYS_fchdir = (SYS_Linux + 133);
+pub const SYS_bdflush = (SYS_Linux + 134);
+pub const SYS_sysfs = (SYS_Linux + 135);
+pub const SYS_personality = (SYS_Linux + 136);
+pub const SYS_afs_syscall = (SYS_Linux + 137);
+pub const SYS_setfsuid = (SYS_Linux + 138);
+pub const SYS_setfsgid = (SYS_Linux + 139);
+pub const SYS__llseek = (SYS_Linux + 140);
+pub const SYS_getdents = (SYS_Linux + 141);
+pub const SYS__newselect = (SYS_Linux + 142);
+pub const SYS_flock = (SYS_Linux + 143);
+pub const SYS_msync = (SYS_Linux + 144);
+pub const SYS_readv = (SYS_Linux + 145);
+pub const SYS_writev = (SYS_Linux + 146);
+pub const SYS_cacheflush = (SYS_Linux + 147);
+pub const SYS_cachectl = (SYS_Linux + 148);
+pub const SYS_sysmips = (SYS_Linux + 149);
+pub const SYS_unused150 = (SYS_Linux + 150);
+pub const SYS_getsid = (SYS_Linux + 151);
+pub const SYS_fdatasync = (SYS_Linux + 152);
+pub const SYS__sysctl = (SYS_Linux + 153);
+pub const SYS_mlock = (SYS_Linux + 154);
+pub const SYS_munlock = (SYS_Linux + 155);
+pub const SYS_mlockall = (SYS_Linux + 156);
+pub const SYS_munlockall = (SYS_Linux + 157);
+pub const SYS_sched_setparam = (SYS_Linux + 158);
+pub const SYS_sched_getparam = (SYS_Linux + 159);
+pub const SYS_sched_setscheduler = (SYS_Linux + 160);
+pub const SYS_sched_getscheduler = (SYS_Linux + 161);
+pub const SYS_sched_yield = (SYS_Linux + 162);
+pub const SYS_sched_get_priority_max = (SYS_Linux + 163);
+pub const SYS_sched_get_priority_min = (SYS_Linux + 164);
+pub const SYS_sched_rr_get_interval = (SYS_Linux + 165);
+pub const SYS_nanosleep = (SYS_Linux + 166);
+pub const SYS_mremap = (SYS_Linux + 167);
+pub const SYS_accept = (SYS_Linux + 168);
+pub const SYS_bind = (SYS_Linux + 169);
+pub const SYS_connect = (SYS_Linux + 170);
+pub const SYS_getpeername = (SYS_Linux + 171);
+pub const SYS_getsockname = (SYS_Linux + 172);
+pub const SYS_getsockopt = (SYS_Linux + 173);
+pub const SYS_listen = (SYS_Linux + 174);
+pub const SYS_recv = (SYS_Linux + 175);
+pub const SYS_recvfrom = (SYS_Linux + 176);
+pub const SYS_recvmsg = (SYS_Linux + 177);
+pub const SYS_send = (SYS_Linux + 178);
+pub const SYS_sendmsg = (SYS_Linux + 179);
+pub const SYS_sendto = (SYS_Linux + 180);
+pub const SYS_setsockopt = (SYS_Linux + 181);
+pub const SYS_shutdown = (SYS_Linux + 182);
+pub const SYS_socket = (SYS_Linux + 183);
+pub const SYS_socketpair = (SYS_Linux + 184);
+pub const SYS_setresuid = (SYS_Linux + 185);
+pub const SYS_getresuid = (SYS_Linux + 186);
+pub const SYS_query_module = (SYS_Linux + 187);
+pub const SYS_poll = (SYS_Linux + 188);
+pub const SYS_nfsservctl = (SYS_Linux + 189);
+pub const SYS_setresgid = (SYS_Linux + 190);
+pub const SYS_getresgid = (SYS_Linux + 191);
+pub const SYS_prctl = (SYS_Linux + 192);
+pub const SYS_rt_sigreturn = (SYS_Linux + 193);
+pub const SYS_rt_sigaction = (SYS_Linux + 194);
+pub const SYS_rt_sigprocmask = (SYS_Linux + 195);
+pub const SYS_rt_sigpending = (SYS_Linux + 196);
+pub const SYS_rt_sigtimedwait = (SYS_Linux + 197);
+pub const SYS_rt_sigqueueinfo = (SYS_Linux + 198);
+pub const SYS_rt_sigsuspend = (SYS_Linux + 199);
+pub const SYS_pread64 = (SYS_Linux + 200);
+pub const SYS_pwrite64 = (SYS_Linux + 201);
+pub const SYS_chown = (SYS_Linux + 202);
+pub const SYS_getcwd = (SYS_Linux + 203);
+pub const SYS_capget = (SYS_Linux + 204);
+pub const SYS_capset = (SYS_Linux + 205);
+pub const SYS_sigaltstack = (SYS_Linux + 206);
+pub const SYS_sendfile = (SYS_Linux + 207);
+pub const SYS_getpmsg = (SYS_Linux + 208);
+pub const SYS_putpmsg = (SYS_Linux + 209);
+pub const SYS_mmap2 = (SYS_Linux + 210);
+pub const SYS_truncate64 = (SYS_Linux + 211);
+pub const SYS_ftruncate64 = (SYS_Linux + 212);
+pub const SYS_stat64 = (SYS_Linux + 213);
+pub const SYS_lstat64 = (SYS_Linux + 214);
+pub const SYS_fstat64 = (SYS_Linux + 215);
+pub const SYS_pivot_root = (SYS_Linux + 216);
+pub const SYS_mincore = (SYS_Linux + 217);
+pub const SYS_madvise = (SYS_Linux + 218);
+pub const SYS_getdents64 = (SYS_Linux + 219);
+pub const SYS_fcntl64 = (SYS_Linux + 220);
+pub const SYS_reserved221 = (SYS_Linux + 221);
+pub const SYS_gettid = (SYS_Linux + 222);
+pub const SYS_readahead = (SYS_Linux + 223);
+pub const SYS_setxattr = (SYS_Linux + 224);
+pub const SYS_lsetxattr = (SYS_Linux + 225);
+pub const SYS_fsetxattr = (SYS_Linux + 226);
+pub const SYS_getxattr = (SYS_Linux + 227);
+pub const SYS_lgetxattr = (SYS_Linux + 228);
+pub const SYS_fgetxattr = (SYS_Linux + 229);
+pub const SYS_listxattr = (SYS_Linux + 230);
+pub const SYS_llistxattr = (SYS_Linux + 231);
+pub const SYS_flistxattr = (SYS_Linux + 232);
+pub const SYS_removexattr = (SYS_Linux + 233);
+pub const SYS_lremovexattr = (SYS_Linux + 234);
+pub const SYS_fremovexattr = (SYS_Linux + 235);
+pub const SYS_tkill = (SYS_Linux + 236);
+pub const SYS_sendfile64 = (SYS_Linux + 237);
+pub const SYS_futex = (SYS_Linux + 238);
+pub const SYS_sched_setaffinity = (SYS_Linux + 239);
+pub const SYS_sched_getaffinity = (SYS_Linux + 240);
+pub const SYS_io_setup = (SYS_Linux + 241);
+pub const SYS_io_destroy = (SYS_Linux + 242);
+pub const SYS_io_getevents = (SYS_Linux + 243);
+pub const SYS_io_submit = (SYS_Linux + 244);
+pub const SYS_io_cancel = (SYS_Linux + 245);
+pub const SYS_exit_group = (SYS_Linux + 246);
+pub const SYS_lookup_dcookie = (SYS_Linux + 247);
+pub const SYS_epoll_create = (SYS_Linux + 248);
+pub const SYS_epoll_ctl = (SYS_Linux + 249);
+pub const SYS_epoll_wait = (SYS_Linux + 250);
+pub const SYS_remap_file_pages = (SYS_Linux + 251);
+pub const SYS_set_tid_address = (SYS_Linux + 252);
+pub const SYS_restart_syscall = (SYS_Linux + 253);
+pub const SYS_fadvise64 = (SYS_Linux + 254);
+pub const SYS_statfs64 = (SYS_Linux + 255);
+pub const SYS_fstatfs64 = (SYS_Linux + 256);
+pub const SYS_timer_create = (SYS_Linux + 257);
+pub const SYS_timer_settime = (SYS_Linux + 258);
+pub const SYS_timer_gettime = (SYS_Linux + 259);
+pub const SYS_timer_getoverrun = (SYS_Linux + 260);
+pub const SYS_timer_delete = (SYS_Linux + 261);
+pub const SYS_clock_settime = (SYS_Linux + 262);
+pub const SYS_clock_gettime = (SYS_Linux + 263);
+pub const SYS_clock_getres = (SYS_Linux + 264);
+pub const SYS_clock_nanosleep = (SYS_Linux + 265);
+pub const SYS_tgkill = (SYS_Linux + 266);
+pub const SYS_utimes = (SYS_Linux + 267);
+pub const SYS_mbind = (SYS_Linux + 268);
+pub const SYS_get_mempolicy = (SYS_Linux + 269);
+pub const SYS_set_mempolicy = (SYS_Linux + 270);
+pub const SYS_mq_open = (SYS_Linux + 271);
+pub const SYS_mq_unlink = (SYS_Linux + 272);
+pub const SYS_mq_timedsend = (SYS_Linux + 273);
+pub const SYS_mq_timedreceive = (SYS_Linux + 274);
+pub const SYS_mq_notify = (SYS_Linux + 275);
+pub const SYS_mq_getsetattr = (SYS_Linux + 276);
+pub const SYS_vserver = (SYS_Linux + 277);
+pub const SYS_waitid = (SYS_Linux + 278);
+pub const SYS_add_key = (SYS_Linux + 280);
+pub const SYS_request_key = (SYS_Linux + 281);
+pub const SYS_keyctl = (SYS_Linux + 282);
+pub const SYS_set_thread_area = (SYS_Linux + 283);
+pub const SYS_inotify_init = (SYS_Linux + 284);
+pub const SYS_inotify_add_watch = (SYS_Linux + 285);
+pub const SYS_inotify_rm_watch = (SYS_Linux + 286);
+pub const SYS_migrate_pages = (SYS_Linux + 287);
+pub const SYS_openat = (SYS_Linux + 288);
+pub const SYS_mkdirat = (SYS_Linux + 289);
+pub const SYS_mknodat = (SYS_Linux + 290);
+pub const SYS_fchownat = (SYS_Linux + 291);
+pub const SYS_futimesat = (SYS_Linux + 292);
+pub const SYS_fstatat64 = (SYS_Linux + 293);
+pub const SYS_unlinkat = (SYS_Linux + 294);
+pub const SYS_renameat = (SYS_Linux + 295);
+pub const SYS_linkat = (SYS_Linux + 296);
+pub const SYS_symlinkat = (SYS_Linux + 297);
+pub const SYS_readlinkat = (SYS_Linux + 298);
+pub const SYS_fchmodat = (SYS_Linux + 299);
+pub const SYS_faccessat = (SYS_Linux + 300);
+pub const SYS_pselect6 = (SYS_Linux + 301);
+pub const SYS_ppoll = (SYS_Linux + 302);
+pub const SYS_unshare = (SYS_Linux + 303);
+pub const SYS_splice = (SYS_Linux + 304);
+pub const SYS_sync_file_range = (SYS_Linux + 305);
+pub const SYS_tee = (SYS_Linux + 306);
+pub const SYS_vmsplice = (SYS_Linux + 307);
+pub const SYS_move_pages = (SYS_Linux + 308);
+pub const SYS_set_robust_list = (SYS_Linux + 309);
+pub const SYS_get_robust_list = (SYS_Linux + 310);
+pub const SYS_kexec_load = (SYS_Linux + 311);
+pub const SYS_getcpu = (SYS_Linux + 312);
+pub const SYS_epoll_pwait = (SYS_Linux + 313);
+pub const SYS_ioprio_set = (SYS_Linux + 314);
+pub const SYS_ioprio_get = (SYS_Linux + 315);
+pub const SYS_utimensat = (SYS_Linux + 316);
+pub const SYS_signalfd = (SYS_Linux + 317);
+pub const SYS_timerfd = (SYS_Linux + 318);
+pub const SYS_eventfd = (SYS_Linux + 319);
+pub const SYS_fallocate = (SYS_Linux + 320);
+pub const SYS_timerfd_create = (SYS_Linux + 321);
+pub const SYS_timerfd_gettime = (SYS_Linux + 322);
+pub const SYS_timerfd_settime = (SYS_Linux + 323);
+pub const SYS_signalfd4 = (SYS_Linux + 324);
+pub const SYS_eventfd2 = (SYS_Linux + 325);
+pub const SYS_epoll_create1 = (SYS_Linux + 326);
+pub const SYS_dup3 = (SYS_Linux + 327);
+pub const SYS_pipe2 = (SYS_Linux + 328);
+pub const SYS_inotify_init1 = (SYS_Linux + 329);
+pub const SYS_preadv = (SYS_Linux + 330);
+pub const SYS_pwritev = (SYS_Linux + 331);
+pub const SYS_rt_tgsigqueueinfo = (SYS_Linux + 332);
+pub const SYS_perf_event_open = (SYS_Linux + 333);
+pub const SYS_accept4 = (SYS_Linux + 334);
+pub const SYS_recvmmsg = (SYS_Linux + 335);
+pub const SYS_fanotify_init = (SYS_Linux + 336);
+pub const SYS_fanotify_mark = (SYS_Linux + 337);
+pub const SYS_prlimit64 = (SYS_Linux + 338);
+pub const SYS_name_to_handle_at = (SYS_Linux + 339);
+pub const SYS_open_by_handle_at = (SYS_Linux + 340);
+pub const SYS_clock_adjtime = (SYS_Linux + 341);
+pub const SYS_syncfs = (SYS_Linux + 342);
+pub const SYS_sendmmsg = (SYS_Linux + 343);
+pub const SYS_setns = (SYS_Linux + 344);
+pub const SYS_process_vm_readv = (SYS_Linux + 345);
+pub const SYS_process_vm_writev = (SYS_Linux + 346);
+pub const SYS_kcmp = (SYS_Linux + 347);
+pub const SYS_finit_module = (SYS_Linux + 348);
+pub const SYS_sched_setattr = (SYS_Linux + 349);
+pub const SYS_sched_getattr = (SYS_Linux + 350);
+pub const SYS_renameat2 = (SYS_Linux + 351);
+pub const SYS_seccomp = (SYS_Linux + 352);
+pub const SYS_getrandom = (SYS_Linux + 353);
+pub const SYS_memfd_create = (SYS_Linux + 354);
+pub const SYS_bpf = (SYS_Linux + 355);
+pub const SYS_execveat = (SYS_Linux + 356);
+pub const SYS_userfaultfd = (SYS_Linux + 357);
+pub const SYS_membarrier = (SYS_Linux + 358);
+pub const SYS_mlock2 = (SYS_Linux + 359);
+pub const SYS_copy_file_range = (SYS_Linux + 360);
+pub const SYS_preadv2 = (SYS_Linux + 361);
+pub const SYS_pwritev2 = (SYS_Linux + 362);
+pub const SYS_pkey_mprotect = (SYS_Linux + 363);
+pub const SYS_pkey_alloc = (SYS_Linux + 364);
+pub const SYS_pkey_free = (SYS_Linux + 365);
+pub const SYS_statx = (SYS_Linux + 366);
+pub const SYS_rseq = (SYS_Linux + 367);
+pub const SYS_io_pgetevents = (SYS_Linux + 368);
+
+pub const O_CREAT = 0o0400;
+pub const O_EXCL = 0o02000;
+pub const O_NOCTTY = 0o04000;
+pub const O_TRUNC = 0o01000;
+pub const O_APPEND = 0o0010;
+pub const O_NONBLOCK = 0o0200;
+pub const O_DSYNC = 0o0020;
+pub const O_SYNC = 0o040020;
+pub const O_RSYNC = 0o040020;
+pub const O_DIRECTORY = 0o0200000;
+pub const O_NOFOLLOW = 0o0400000;
+pub const O_CLOEXEC = 0o02000000;
+
+pub const O_ASYNC = 0o010000;
+pub const O_DIRECT = 0o0100000;
+pub const O_LARGEFILE = 0o020000;
+pub const O_NOATIME = 0o01000000;
+pub const O_PATH = 0o010000000;
+pub const O_TMPFILE = 0o020200000;
+pub const O_NDELAY = O_NONBLOCK;
+
+pub const F_DUPFD = 0;
+pub const F_GETFD = 1;
+pub const F_SETFD = 2;
+pub const F_GETFL = 3;
+pub const F_SETFL = 4;
+
+pub const F_SETOWN = 24;
+pub const F_GETOWN = 23;
+pub const F_SETSIG = 10;
+pub const F_GETSIG = 11;
+
+pub const F_GETLK = 33;
+pub const F_SETLK = 34;
+pub const F_SETLKW = 35;
+
+pub const F_SETOWN_EX = 15;
+pub const F_GETOWN_EX = 16;
+
+pub const F_GETOWNER_UIDS = 17;
+
+pub const MMAP2_UNIT = 4096;
+
+pub const MAP_NORESERVE = 0x0400;
+pub const MAP_GROWSDOWN = 0x1000;
+pub const MAP_DENYWRITE = 0x2000;
+pub const MAP_EXECUTABLE = 0x4000;
+pub const MAP_LOCKED = 0x8000;
+pub const MAP_32BIT = 0x40;
+
+pub const SO_DEBUG = 1;
+pub const SO_REUSEADDR = 0x0004;
+pub const SO_KEEPALIVE = 0x0008;
+pub const SO_DONTROUTE = 0x0010;
+pub const SO_BROADCAST = 0x0020;
+pub const SO_LINGER = 0x0080;
+pub const SO_OOBINLINE = 0x0100;
+pub const SO_REUSEPORT = 0x0200;
+pub const SO_SNDBUF = 0x1001;
+pub const SO_RCVBUF = 0x1002;
+pub const SO_SNDLOWAT = 0x1003;
+pub const SO_RCVLOWAT = 0x1004;
+pub const SO_RCVTIMEO = 0x1006;
+pub const SO_SNDTIMEO = 0x1005;
+pub const SO_ERROR = 0x1007;
+pub const SO_TYPE = 0x1008;
+pub const SO_ACCEPTCONN = 0x1009;
+pub const SO_PROTOCOL = 0x1028;
+pub const SO_DOMAIN = 0x1029;
+pub const SO_NO_CHECK = 11;
+pub const SO_PRIORITY = 12;
+pub const SO_BSDCOMPAT = 14;
+pub const SO_PASSCRED = 17;
+pub const SO_PEERCRED = 18;
+pub const SO_PEERSEC = 30;
+pub const SO_SNDBUFFORCE = 31;
+pub const SO_RCVBUFFORCE = 33;
+
+pub const VDSO_USEFUL = true;
+pub const VDSO_CGT_SYM = "__kernel_clock_gettime";
+pub const VDSO_CGT_VER = "LINUX_2.6.39";
+
+pub const blksize_t = i32;
+pub const nlink_t = u32;
+pub const time_t = isize;
+pub const mode_t = u32;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = usize;
+pub const blkcnt_t = i64;
+
+pub const Stat = extern struct {
+    dev: u32,
+    __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: [1]u32,
+    blocks: blkcnt_t,
+
+    pub fn atime(self: Stat) timespec {
+        return self.atim;
+    }
+
+    pub fn mtime(self: Stat) timespec {
+        return self.mtim;
+    }
+
+    pub fn ctime(self: Stat) timespec {
+        return self.ctim;
+    }
+};
+
+pub const timespec = extern struct {
+    tv_sec: isize,
+    tv_nsec: isize,
+};
+
+pub const timeval = extern struct {
+    tv_sec: isize,
+    tv_usec: isize,
+};
+
+pub const timezone = extern struct {
+    tz_minuteswest: i32,
+    tz_dsttime: i32,
+};
+
+pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 7dcd01572e..eb2f71cf99 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -19,6 +19,7 @@ pub usingnamespace switch (builtin.arch) {
     .aarch64 => @import("linux/arm64.zig"),
     .arm => @import("linux/arm-eabi.zig"),
     .riscv64 => @import("linux/riscv64.zig"),
+    .mipsel => @import("linux/mipsel.zig"),
     else => struct {},
 };
 pub usingnamespace @import("bits.zig");
diff --git a/lib/std/os/linux/mipsel.zig b/lib/std/os/linux/mipsel.zig
new file mode 100644
index 0000000000..09826753b8
--- /dev/null
+++ b/lib/std/os/linux/mipsel.zig
@@ -0,0 +1,124 @@
+pub fn syscall0(number: usize) usize {
+    return asm volatile (
+        \\ syscall
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall1(number: usize, arg1: usize) usize {
+    return asm volatile (
+        \\ syscall
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall2(number: usize, arg1: usize, arg2: usize) usize {
+    return asm volatile (
+        \\ syscall
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
+    return asm volatile (
+        \\ syscall
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall4(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+    return asm volatile (
+        \\ syscall
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall5(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+    return asm volatile (
+        \\ .set noat
+        \\ subu $sp, $sp, 24
+        \\ sw %[arg5], 16($sp)
+        \\ syscall
+        \\ addu $sp, $sp, 24
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "r" (arg5)
+        : "memory", "cc", "$7"
+    );
+}
+
+pub fn syscall6(
+    number: usize,
+    arg1: usize,
+    arg2: usize,
+    arg3: usize,
+    arg4: usize,
+    arg5: usize,
+    arg6: usize,
+) usize {
+    return asm volatile (
+        \\ .set noat
+        \\ subu $sp, $sp, 24
+        \\ sw %[arg5], 16($sp)
+        \\ sw %[arg6], 20($sp)
+        \\ syscall
+        \\ addu $sp, $sp, 24
+        \\ blez $7, 1f
+        \\ subu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> usize)
+        : [number] "{$2}" (number),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "r" (arg5),
+          [arg6] "r" (arg6)
+        : "memory", "cc", "$7"
+    );
+}
+
+/// This matches the libc clone function.
+pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, arg: usize, ptid: *i32, tls: usize, ctid: *i32) usize;
diff --git a/lib/std/os/linux/tls.zig b/lib/std/os/linux/tls.zig
index 167839570e..849a9ef405 100644
--- a/lib/std/os/linux/tls.zig
+++ b/lib/std/os/linux/tls.zig
@@ -137,6 +137,10 @@ pub fn setThreadPointer(addr: usize) void {
                 : [addr] "r" (addr)
             );
         },
+        .mipsel => {
+            const rc = std.os.linux.syscall1(std.os.linux.SYS_set_thread_area, addr);
+            assert(rc == 0);
+        },
         else => @compileError("Unsupported architecture"),
     }
 }
diff --git a/lib/std/special/c.zig b/lib/std/special/c.zig
index f030dbe90b..b2fca86db3 100644
--- a/lib/std/special/c.zig
+++ b/lib/std/special/c.zig
@@ -310,6 +310,41 @@ nakedcc fn clone() void {
                 \\    ecall
             );
         },
+        .mipsel => {
+            asm volatile (
+                \\  # Save function pointer and argument pointer on new thread stack
+                \\  and $5, $5, -8
+                \\  subu $5, $5, 16
+                \\  sw $4, 0($5)
+                \\  sw $7, 4($5)
+                \\  # Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
+                \\  move $4, $6
+                \\  lw $6, 16($sp)
+                \\  lw $7, 20($sp)
+                \\  lw $9, 24($sp)
+                \\  subu $sp, $sp, 16
+                \\  sw $9, 16($sp)
+                \\  li $2, 4120
+                \\  syscall
+                \\  beq $7, $0, 1f
+                \\  nop
+                \\  addu $sp, $sp, 16
+                \\  jr $ra
+                \\  subu $2, $0, $2
+                \\1:  beq $2, $0, 1f
+                \\  nop
+                \\  addu $sp, $sp, 16
+                \\  jr $ra
+                \\  nop
+                \\1:  lw $25, 0($sp)
+                \\  lw $4, 4($sp)
+                \\  jalr $25
+                \\  nop
+                \\  move $4, $2
+                \\  li $2, 4001
+                \\  syscall
+            );
+        },
         else => @compileError("Implement clone() for this arch."),
     }
 }
diff --git a/lib/std/special/start.zig b/lib/std/special/start.zig
index ca7d7986ed..69ae65be5e 100644
--- a/lib/std/special/start.zig
+++ b/lib/std/special/start.zig
@@ -80,6 +80,14 @@ nakedcc fn _start() noreturn {
                 : [argc] "=r" (-> [*]usize)
             );
         },
+        .mipsel => {
+            // Need noat here because LLVM is free to pick any register
+            starting_stack_ptr = asm (
+                \\ .set noat
+                \\ move %[argc], $sp
+                : [argc] "=r" (-> [*]usize)
+            );
+        },
         else => @compileError("unsupported arch"),
     }
     // If LLVM inlines stack variables into _start, they will overwrite
diff --git a/src/analyze.cpp b/src/analyze.cpp
index 5a3551a7c2..c03d145c5d 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -918,6 +918,8 @@ bool want_first_arg_sret(CodeGen *g, FnTypeId *fn_type_id) {
         return abi_class == X64CABIClass_MEMORY;
     } else if (target_is_arm(g->zig_target)) {
         return type_size(g, fn_type_id->return_type) > 16;
+    } else if (g->zig_target->arch == ZigLLVM_mipsel) {
+        return false;
     }
     zig_panic("TODO implement C ABI for this architecture. See https://github.com/ziglang/zig/issues/1481");
 }
diff --git a/src/link.cpp b/src/link.cpp
index 785b522993..6690f48838 100644
--- a/src/link.cpp
+++ b/src/link.cpp
@@ -1813,10 +1813,14 @@ static void construct_linker_job_elf(LinkJob *lj) {
         lj->args.append("--allow-shlib-undefined");
     }
 
-    if (g->zig_target->os == OsZen) {
+    // MIPS entry point name is __start instead of _start, force the linker to
+    // use the latter
+    if (target_is_mips(g->zig_target) || g->zig_target->os == OsZen) {
         lj->args.append("-e");
         lj->args.append("_start");
+    }
 
+    if (g->zig_target->os == OsZen) {
         lj->args.append("--image-base=0x10000000");
     }
 }
diff --git a/src/target.cpp b/src/target.cpp
index 70c5b169ce..3f7bd75011 100644
--- a/src/target.cpp
+++ b/src/target.cpp
@@ -1450,6 +1450,7 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) {
         case ZigLLVM_aarch64_32:
         case ZigLLVM_riscv32:
         case ZigLLVM_riscv64:
+        case ZigLLVM_mipsel:
             return "sp";
 
         case ZigLLVM_amdgcn:
@@ -1469,7 +1470,6 @@ const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) {
         case ZigLLVM_mips:
         case ZigLLVM_mips64:
         case ZigLLVM_mips64el:
-        case ZigLLVM_mipsel:
         case ZigLLVM_msp430:
         case ZigLLVM_nvptx:
         case ZigLLVM_nvptx64:
@@ -1886,6 +1886,11 @@ bool target_is_riscv(const ZigTarget *target) {
     return target->arch == ZigLLVM_riscv32 || target->arch == ZigLLVM_riscv64;
 }
 
+bool target_is_mips(const ZigTarget *target) {
+    return target->arch == ZigLLVM_mips || target->arch == ZigLLVM_mipsel ||
+        target->arch == ZigLLVM_mips64 || target->arch == ZigLLVM_mips64el;
+}
+
 unsigned target_fn_align(const ZigTarget *target) {
     return 16;
 }
diff --git a/src/target.hpp b/src/target.hpp
index b89b0bdc9d..c157b40011 100644
--- a/src/target.hpp
+++ b/src/target.hpp
@@ -172,6 +172,7 @@ bool target_can_exec(const ZigTarget *host_target, const ZigTarget *guest_target
 ZigLLVM_OSType get_llvm_os_type(Os os_type);
 
 bool target_is_arm(const ZigTarget *target);
+bool target_is_mips(const ZigTarget *target);
 bool target_allows_addr_zero(const ZigTarget *target);
 bool target_has_valgrind_support(const ZigTarget *target);
 bool target_os_is_darwin(Os os);
diff --git a/test/stage1/behavior/byteswap.zig b/test/stage1/behavior/byteswap.zig
index d8fc554808..ab7265bf77 100644
--- a/test/stage1/behavior/byteswap.zig
+++ b/test/stage1/behavior/byteswap.zig
@@ -39,6 +39,8 @@ test "@byteSwap integers" {
 }
 
 test "@byteSwap vectors" {
+    if (@import("builtin").arch == .mipsel) return error.SkipZigTest;
+
     const ByteSwapVectorTest = struct {
         fn run() void {
             t(u8, 2, [_]u8{ 0x12, 0x13 }, [_]u8{ 0x12, 0x13 });
diff --git a/test/stage1/behavior/new_stack_call.zig b/test/stage1/behavior/new_stack_call.zig
index 2200407882..2fef4816d3 100644
--- a/test/stage1/behavior/new_stack_call.zig
+++ b/test/stage1/behavior/new_stack_call.zig
@@ -6,6 +6,7 @@ var new_stack_bytes: [1024]u8 align(16) = undefined;
 test "calling a function with a new stack" {
     // TODO: https://github.com/ziglang/zig/issues/3268
     if (@import("builtin").arch == .aarch64) return error.SkipZigTest;
+    if (@import("builtin").arch == .mipsel) return error.SkipZigTest;
 
     const arg = 1234;
 
diff --git a/test/stage1/behavior/shuffle.zig b/test/stage1/behavior/shuffle.zig
index 2029ec582f..fc8c2b56de 100644
--- a/test/stage1/behavior/shuffle.zig
+++ b/test/stage1/behavior/shuffle.zig
@@ -33,7 +33,7 @@ test "@shuffle" {
             expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 2147483647, 3, -2, 4 }));
 
             // bool
-            {
+            if (@import("builtin").arch != .mipsel) {
                 var x2: @Vector(4, bool) = [4]bool{ false, true, false, true };
                 var v4: @Vector(2, bool) = [2]bool{ true, false };
                 const mask5: @Vector(4, i32) = [4]i32{ 0, ~i32(1), 1, 2 };
diff --git a/test/tests.zig b/test/tests.zig
index 1b51a0c694..4a9b2c89e6 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -131,6 +131,16 @@ const test_targets = [_]TestTarget{
     //    .link_libc = true,
     //},
 
+    TestTarget{
+        .target = Target{
+            .Cross = CrossTarget{
+                .os = .linux,
+                .arch = .mipsel,
+                .abi = .none,
+            },
+        },
+    },
+
     TestTarget{
         .target = Target{
             .Cross = CrossTarget{