Index: cmake/config-ix.cmake
===================================================================
--- cmake/config-ix.cmake
+++ cmake/config-ix.cmake
@@ -159,7 +159,7 @@
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64})
-set(ALL_ESAN_SUPPORTED_ARCH ${X86_64})
+set(ALL_ESAN_SUPPORTED_ARCH ${X86_64} ${MIPS64})
 set(ALL_SCUDO_SUPPORTED_ARCH ${X86_64})
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64})
 
Index: lib/esan/esan.h
===================================================================
--- lib/esan/esan.h
+++ lib/esan/esan.h
@@ -34,6 +34,7 @@
 
 extern bool EsanIsInitialized;
 extern bool EsanDuringInit;
+extern uptr vmaSize;
 
 void initializeLibrary(ToolType Tool);
 int finalizeLibrary();
Index: lib/esan/esan.cpp
===================================================================
--- lib/esan/esan.cpp
+++ lib/esan/esan.cpp
@@ -141,9 +141,14 @@
 }
 #endif
 
+uptr vmaSize;
+
 static void initializeShadow() {
   verifyAddressSpace();
 
+  vmaSize =
+    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1); 
+
   DCHECK(verifyShadowScheme());
 
   Mapping.initialize(ShadowScale[__esan_which_tool]);
Index: lib/esan/esan_linux.cpp
===================================================================
--- lib/esan/esan_linux.cpp
+++ lib/esan/esan_linux.cpp
@@ -25,7 +25,7 @@
 namespace __esan {
 
 void verifyAddressSpace() {
-#if SANITIZER_LINUX && defined(__x86_64__)
+#if SANITIZER_LINUX && (defined(__x86_64__) || SANITIZER_MIPS64)
   // The kernel determines its mmap base from the stack size limit.
   // Our Linux 64-bit shadow mapping assumes the stack limit is less than a
   // terabyte, which keeps the mmap region above 0x7e00'.
Index: lib/esan/esan_shadow.h
===================================================================
--- lib/esan/esan_shadow.h
+++ lib/esan/esan_shadow.h
@@ -15,6 +15,7 @@
 #ifndef ESAN_SHADOW_H
 #define ESAN_SHADOW_H
 
+#include "esan.h"
 #include <sanitizer_common/sanitizer_platform.h>
 
 #if SANITIZER_WORDSIZE != 64
@@ -23,7 +24,13 @@
 
 namespace __esan {
 
-#if SANITIZER_LINUX && defined(__x86_64__)
+struct ApplicationRegion {
+  uptr Start;
+  uptr End;
+  bool ShadowMergedWithPrev;
+};
+
+#if SANITIZER_LINUX && defined(__x86_64__) 
 // Linux x86_64
 //
 // Application memory falls into these 5 regions (ignoring the corner case
@@ -89,12 +96,6 @@
 // [0x000015ff'ff601000, 0x00001600'00000000]
 // [0x000015ff'ff600000, 0x000015ff'ff601000]
 
-struct ApplicationRegion {
-  uptr Start;
-  uptr End;
-  bool ShadowMergedWithPrev;
-};
-
 static const struct ApplicationRegion AppRegions[] = {
   {0x0000000000000000ull, 0x0000010000000000u, false},
   {0x0000550000000000u,   0x0000570000000000u, false},
@@ -105,6 +106,31 @@
   {0x00007fffff601000u,   0x0000800000000000u, true},
   {0xffffffffff600000u,   0xffffffffff601000u, true},
 };
+
+#elif SANITIZER_LINUX && SANITIZER_MIPS64
+
+// Application memory falls into these 3 regions
+//
+// [0x00000001'00000000, 0x00000002'00000000) non-PIE + heap
+// [0x000000aa'00000000, 0x000000ab'00000000) PIE
+// [0x000000ff'00000000, 0x000000ff'ffffffff) libraries + stack
+//
+// The resulting shadow memory regions for a 0 scaling are:
+//
+// [0x00000014'00000000, 0x00000015'00000000)
+// [0x0000001d'00000000, 0x0000001e'00000000)
+// [0x00000022'00000000, 0x00000022'ffffffff)
+
+static const struct ApplicationRegion AppRegions[] = {
+  {0x0100000000u, 0x0200000000u, false},
+  {0xaa00000000u, 0xab00000000u, false},
+  {0xff00000000u, 0xffffffffffu, true},
+};
+
+#else
+#error Platform not supported
+#endif
+
 static const u32 NumAppRegions = sizeof(AppRegions)/sizeof(AppRegions[0]);
 
 // See the comment above: we do not currently support a stack size rlimit
@@ -113,16 +139,31 @@
 
 class ShadowMapping {
 public:
-  static const uptr Mask = 0x00000fffffffffffu;
+  uptr Mask;
   // The scale and offset vary by tool.
   uptr Scale;
   uptr Offset;
   void initialize(uptr ShadowScale) {
-    static const uptr OffsetArray[3] = {
-        0x0000130000000000u,
-        0x0000220000000000u,
-        0x0000440000000000u,
-    };
+    static uptr OffsetArray[3];
+    switch(vmaSize)
+    {
+      case 40:
+      {
+        OffsetArray[0] = 0x0000001300000000u;
+        OffsetArray[1] = 0x0000002200000000u;
+        OffsetArray[2] = 0x0000004400000000u;
+        Mask = 0x0000000fffffffffu;
+      }
+      break;
+      case 47:
+      {
+        OffsetArray[0] = 0x0000130000000000u;
+        OffsetArray[1] = 0x0000220000000000u;
+        OffsetArray[2] = 0x0000440000000000u;
+        Mask = 0x00000fffffffffffu;
+      }
+      break;
+    }
     Scale = ShadowScale;
     if (Scale <= 2)
       Offset = OffsetArray[Scale];
@@ -131,11 +172,6 @@
   }
 };
 extern ShadowMapping Mapping;
-#else
-// We'll want to use templatized functions over the ShadowMapping once
-// we support more platforms.
-#error Platform not supported
-#endif
 
 static inline bool getAppRegion(u32 i, uptr *Start, uptr *End) {
   if (i >= NumAppRegions)
@@ -156,7 +192,7 @@
 
 ALWAYS_INLINE
 uptr appToShadow(uptr App) {
-  return (((App & ShadowMapping::Mask) + Mapping.Offset) >> Mapping.Scale);
+  return (((App & Mapping.Mask) + Mapping.Offset) >> Mapping.Scale);
 }
 
 static inline bool getShadowRegion(u32 i, uptr *Start, uptr *End) {
Index: lib/sanitizer_common/CMakeLists.txt
===================================================================
--- lib/sanitizer_common/CMakeLists.txt
+++ lib/sanitizer_common/CMakeLists.txt
@@ -37,6 +37,8 @@
 if(UNIX AND NOT APPLE)
   list(APPEND SANITIZER_SOURCES_NOTERMINATION
     sanitizer_linux_x86_64.S)
+  list(APPEND SANITIZER_SOURCES_NOTERMINATION
+    sanitizer_linux_mips64.S)  
 endif()
 
 set(SANITIZER_SOURCES
@@ -147,6 +149,8 @@
   # CMAKE_C*_FLAGS and re-add as a source property to all the non-.S files).
   set_source_files_properties(sanitizer_linux_x86_64.S
     PROPERTIES COMPILE_FLAGS "-w")
+  set_source_files_properties(sanitizer_linux_mips64.S
+    PROPERTIES COMPILE_FLAGS "-w")
 endif ()
 
 if(APPLE)
Index: lib/sanitizer_common/sanitizer_linux.h
===================================================================
--- lib/sanitizer_common/sanitizer_linux.h
+++ lib/sanitizer_common/sanitizer_linux.h
@@ -42,7 +42,7 @@
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
-#if defined(__x86_64__) && !SANITIZER_GO
+#if (defined(__x86_64__) || SANITIZER_MIPS64) && !SANITIZER_GO
 // Uses a raw system call to avoid interceptors.
 int internal_sigaction_syscall(int signum, const void *act, void *oldact);
 #endif
Index: lib/sanitizer_common/sanitizer_linux.cc
===================================================================
--- lib/sanitizer_common/sanitizer_linux.cc
+++ lib/sanitizer_common/sanitizer_linux.cc
@@ -99,7 +99,7 @@
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
 #endif
 
-#if defined(__x86_64__)
+#if defined(__x86_64__) || SANITIZER_MIPS64
 extern "C" {
 extern void internal_sigreturn();
 }
@@ -671,7 +671,7 @@
 // Invokes sigaction via a raw syscall with a restorer, but does not support
 // all platforms yet.
 // We disable for Go simply because we have not yet added to buildgo.sh.
-#if defined(__x86_64__) && !SANITIZER_GO
+#if (defined(__x86_64__) || SANITIZER_MIPS64) && !SANITIZER_GO
 int internal_sigaction_syscall(int signum, const void *act, void *oldact) {
   if (act == nullptr)
     return internal_sigaction_norestorer(signum, act, oldact);
Index: lib/sanitizer_common/sanitizer_linux_mips64.S
===================================================================
--- /dev/null
+++ lib/sanitizer_common/sanitizer_linux_mips64.S
@@ -0,0 +1,24 @@
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+
+// Avoid being marked as needing an executable stack:
+#if defined(__linux__) && defined(__ELF__)
+.section .note.GNU-stack,"",%progbits
+#endif
+
+// Further contents are mips64 only:
+#if defined(__linux__) && defined(__mips64)
+
+.section .text
+.set noreorder
+.globl internal_sigreturn
+.type internal_sigreturn, @function
+internal_sigreturn:
+
+        li $v0,5211
+        syscall
+        nop
+
+.size internal_sigreturn, .-internal_sigreturn
+
+#endif // defined(__linux__) && defined(__mips64)
Index: lib/sanitizer_common/sanitizer_platform_limits_posix.h
===================================================================
--- lib/sanitizer_common/sanitizer_platform_limits_posix.h
+++ lib/sanitizer_common/sanitizer_platform_limits_posix.h
@@ -617,13 +617,21 @@
 
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
   struct __sanitizer_kernel_sigaction_t {
+#if SANITIZER_MIPS
+    unsigned long sa_flags;
+#endif
     union {
       void (*handler)(int signo);
       void (*sigaction)(int signo, void *info, void *ctx);
     };
+#if !SANITIZER_MIPS
     unsigned long sa_flags;
     void (*sa_restorer)(void);
+#endif
     __sanitizer_kernel_sigset_t sa_mask;
+#if SANITIZER_MIPS
+    void (*sa_restorer)(void);
+#endif
   };
 
   extern uptr sig_ign;
Index: test/esan/TestCases/verbose-simple.c
===================================================================
--- test/esan/TestCases/verbose-simple.c
+++ test/esan/TestCases/verbose-simple.c
@@ -1,14 +1,17 @@
 // RUN: %clang_esan_frag -O0 %s -o %t 2>&1
-// RUN: %env_esan_opts="verbosity=1 log_exe_name=1" %run %t 2>&1 | FileCheck %s
+// RUN: %env_esan_opts="verbosity=1 log_exe_name=1" %run %t 2>&1 | FileCheck --check-prefix=CHECK-%arch %s
 
 int main(int argc, char **argv) {
   // CHECK:      in esan::initializeLibrary
   // (There can be a re-exec for stack limit here.)
-  // CHECK:      Shadow scale=2 offset=0x440000000000
-  // CHECK-NEXT: Shadow #0: [110000000000-114000000000) (256GB)
-  // CHECK-NEXT: Shadow #1: [124000000000-12c000000000) (512GB)
-  // CHECK-NEXT: Shadow #2: [148000000000-150000000000) (512GB)
-  // CHECK-NEXT: in esan::finalizeLibrary
-  // CHECK-NEXT: ==verbose-simple{{.*}}EfficiencySanitizer: total struct field access count = 0
+  // CHECK-x86_64: Shadow scale=2 offset=0x440000000000
+  // CHECK-x86_64: Shadow #0: [110000000000-114000000000) (256GB)
+  // CHECK-x86_64: Shadow #1: [124000000000-12c000000000) (512GB)
+  // CHECK-x86_64: Shadow #2: [148000000000-150000000000) (512GB)
+  // CHECK-mips64: Shadow scale=2 offset=0x4400000000
+  // CHECK-mips64: Shadow #0: [1140000000-1180000000) (1GB)
+  // CHECK-mips64: Shadow #1: [1380000000-1500000000) (6GB) 
+  // CHECK: in esan::finalizeLibrary
+  // CHECK: ==verbose-simple{{.*}}EfficiencySanitizer: total struct field access count = 0
   return 0;
 }
Index: test/esan/lit.cfg
===================================================================
--- test/esan/lit.cfg
+++ test/esan/lit.cfg
@@ -40,5 +40,5 @@
 config.suffixes = ['.c', '.cpp']
 
 # EfficiencySanitizer tests are currently supported on Linux x86-64 only.
-if config.host_os not in ['Linux'] or config.target_arch != 'x86_64':
+if config.host_os not in ['Linux'] or config.target_arch not in ['x86_64', 'mips64'] :
   config.unsupported = True
Index: test/lit.common.cfg
===================================================================
--- test/lit.common.cfg
+++ test/lit.common.cfg
@@ -87,6 +87,9 @@
 # Define CHECK-%os to check for OS-dependent output.
 config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
 
+# Define CHECK-%arch to check for architecture-dependent output.
+config.substitutions.append( ('CHECK-%arch', ("CHECK-" + config.host_arch)))
+
 if config.host_os == 'Windows':
   # FIXME: This isn't quite right. Specifically, it will succeed if the program
   # does not crash but exits with a non-zero exit code. We ought to merge