[ESan][MIPS] Adds support for MIPS64

[slthakur]

Summary

With this patch 12 out of 13 tests are passing.

[slthakur]

• vmaSize for x86_64 case was not correct in previous diff.
• Corrected expected output for test verbose-simple.c

[bruening]

lib/esan/esan.cpp

144

Style

150

This is making assumptions about where the initial stack is allocated. Please comment those assumptions (and why they would hold on all supported platforms X ulimit or other stack parameters).

lib/esan/esan.h

37

Please follow LLVM style in these new files: variables should start with upper-case

lib/esan/esan_shadow.h

118

Providing the formula would help clarify

127

The final 2 aren't adjacent, so I don't understand why they would be merged?

136

It may be worth keeping this comment, as the shadow translation is getting more expensive with extra variable loads that we could turn back into constants.

185

Style: h (

186

Style: { on prior line

188

Style: { on prior line

203

Seems best to have a default raising an error

lib/sanitizer_common/sanitizer_linux_mips64.S

19

Suggest: a comment identifying this magic # 5211 as SYS_rt_sigreturn

21

Why a nop?

[slthakur]

Addressed review comments

lib/esan/esan_shadow.h

127

Yes, the last two don't need to be merged.

lib/sanitizer_common/sanitizer_linux_mips64.S

21

Sorry a nop is not required there. I felt that a syscall would require a delay slot but thats not the case.

[bruening]

lib/esan/esan.cpp

150

nit: for x86-64 the vsyscall region is a higher address than the stack

lib/esan/esan_shadow.h

136

This was overlooked?

[slthakur]

lib/esan/esan.cpp

150

Okay. The vsyscall region is placed in the upper half of the canonical address space which is used by the kernel. So would it be correct to say that "the initial stack is always allocated
in the topmost segment of the user address space" ?

lib/esan/esan_shadow.h

136

The comment was preserved in the updated diff. I forgot to mark this as "done".

[bruening]

lib/esan/esan.cpp

150

Works for me

lib/esan/esan_shadow.h

136

The comment as-is is not really relevant though b/c even more platforms beyond these 2 are unlikely to change the picture: adding the 2nd one here is what moved several constants to variables and that's what we might want to templatize away.

[slthakur]

Used templatized functions over ShadowMapping.

[slthakur]

Changed comment in esan.cpp as per suggestion.

[bruening]

lib/esan/esan_shadow.h

243

I think the prevailing LLVM style is to not indent the cases, though an if..else is always faster than a switch for so few cases. However, given that the associated compiler instrumentation is hardcoded for one target, do we need to pay a runtime cost when a different library is going to picked for MIPS vs x86? I.e., is there a reason not to hardcode the library in the same way as the compiler instru?

I don't want to drag this out, and maybe this should be measured before over-thinking it, though with all of the memsets and memcpys coming here intuition says that appToShadow is going to be a bottleneck. I'm fine with either the prior diff or sthg like this one with a comment about making the mask static. The offset and scale are already loaded and not constants unfortunately.

[slthakur]

lib/esan/esan_shadow.h

243

Yes, we can hard code the mask just like we did in the compiler instrumentation to avoid runtime cost in the library. I have added a TODO in the current diff and committed it to the repository (rL280795.). In my next patch I will try to make the mask static and replace switch cases with if...else construct where cases are few,

[slthakur]

This patch was reverted due to failures on x86. The reason of failures was that the shadow offsets were zero on x86 because the offset array was defined as class variable. In this diff I have defined the offset array in the initialize() function which resolves the issue. Tested this patch along with its dependents on x86 and the test results are clean.

[zhaoqin]

I am not sure this CL can be build on non-mips64.
Could you please test on a non-mips64 (e.g. x86_64) so we can avoid unnecessary bot failure?

test/esan/TestCases/mmap-shadow-conflict.c

16

Are you sure the code can be compiled on non-mips64?
Please at least build and test on one non-mips64 (e.g., x86_64) machine

[slthakur]

test/esan/TestCases/mmap-shadow-conflict.c

16

Sorry, there was a mistake in uploading of the diff. This test case was tested on x86_64 with a different diff which included this line of mmap and all tests were passing. I just uploaded the wrong diff here.

[slthakur]

Ping?

[zhaoqin]

A few questions.
Nothing major, but better to have another round.

lib/esan/esan_shadow.h

193–212

We are using virtual address in the user space to determine the shadow memory translation.
Are we sure it would work for all the archs that have the same VmaSize?
I guess it would work for now. so just curious how likely it would work for any possible future arch/os.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

631

Why multiple #if separate from each other?
Can we move them together?

test/esan/TestCases/mmap-shadow-conflict.c

30–37

hmm feel better if we can add CHECK, something like CHECK-x86_64 and CHECK-NEXT-x86_64.
forget about it if it is too hard to do so.

test/esan/TestCases/verbose-simple.c

15

Are we sure CHECK still works if we use --check-prefix option?
It probably is true, just be cautious.

test/lit.common.cfg

91

can we do similar thing as CHECK-%os by adding CHECK-%arch, or there will be a conflict.

[slthakur]

lib/esan/esan_shadow.h

193–212

Yes, it would work on any arch with same VmaSize provided that proper application memory ranges for that arch are defined.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

631

Yes we can move them together.

test/esan/TestCases/mmap-shadow-conflict.c

30–37

We can do a similar thing for CHECK-%acrh as done for CHECK-%os but we will not be able to check the order of output lines with CHECK-NEXT-%arch. Thats why I switched to --check-prefix=%arch only.

test/esan/TestCases/verbose-simple.c

15

No it does not work. The CHECK lines are not checked by FileCheck. I will add --check-prefix=CHECK to the FileCheck command to make it work. Thanks for catching this.

test/lit.common.cfg

91

We can do a similar thing for CHECK-%acrh as done for CHECK-%os but we will not be able to check the order of output lines with CHECK-NEXT-%arch. Thats why I switched to --check-prefix=%arch only.

[slthakur]

Addressed review comments.

[zhaoqin]

LGTM

[Eugene.Zelenko]

Committed in rL280795, but reverted in rL280954.

[slthakur]

Committed revision 283435

cmake/config-ix.cmake

 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${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} ${ARM32})
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)

lib/esan/esan.h

 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "esan_interface_internal.h"
 
 namespace __esan {
 
 extern bool EsanIsInitialized;
 extern bool EsanDuringInit;
+extern uptr VmaSize;
 
 void initializeLibrary(ToolType Tool);
 int finalizeLibrary();
 void reportResults();
 unsigned int getSampleCount();
 // Esan creates the variable per tool per compilation unit at compile time
 // and passes its pointer Ptr to the runtime library.
 void processCompilationUnitInit(void *Ptr);

lib/esan/esan.cpp

for (int i = 0; getShadowRegion(i, &ShadowAStart, &ShadowAEnd); ++i) {
                ShadowAEnd <= ShadowBStart);
       }
     }
   }
   return true;
 }
 #endif
 
+uptr VmaSize;
+
 static void initializeShadow() {
   verifyAddressSpace();
 
+  // This is based on the assumption that the intial stack is always allocated
+  // in the topmost segment of the user address space and the assumption
+  // holds true on all the platforms currently supported.
+  VmaSize =
+    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
+
   DCHECK(verifyShadowScheme());
 
   Mapping.initialize(ShadowScale[__esan_which_tool]);
 
   VPrintf(1, "Shadow scale=%d offset=%p\n", Mapping.Scale, Mapping.Offset);
 
   uptr ShadowStart, ShadowEnd;
   for (int i = 0; getShadowRegion(i, &ShadowStart, &ShadowEnd); ++i) {

lib/esan/esan_linux.cpp

 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include <sys/mman.h>
 #include <errno.h>
 
 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'.
   uptr StackLimit = GetStackSizeLimitInBytes();
   if (StackSizeIsUnlimited() || StackLimit > MaxStackSize) {
     VReport(1, "The stack size limit is beyond the maximum supported.\n"
             "Re-execing with a stack size below 1TB.\n");
     SetStackSizeLimitInBytes(MaxStackSize);

lib/esan/esan_shadow.h

 // This file is a part of EfficiencySanitizer, a family of performance tuners.
 //
 // Shadow memory mappings for the esan run-time.
 //===----------------------------------------------------------------------===//
 
 #ifndef ESAN_SHADOW_H
 #define ESAN_SHADOW_H
 
+#include "esan.h"
 #include <sanitizer_common/sanitizer_platform.h>
 
 #if SANITIZER_WORDSIZE != 64
 #error Only 64-bit is supported
 #endif
 
 namespace __esan {
 
+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
 // of PIE with a non-zero PT_LOAD base):
 //
 // [0x00000000'00000000, 0x00000100'00000000) non-PIE + heap
 // [0x00005500'00000000, 0x00005700'00000000) PIE

 // disjoint from shadow(app):
 //
 // [0x00001600'00000000, 0x00001700'00000000)
 // [0x00001b00'00000000, 0x00001d00'00000000)
 // [0x00001400'00000000, 0x000015ff'ff600000]
 // [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},
   // We make one shadow mapping to hold the shadow regions for all 3 of these
   // app regions, as the mappings interleave, and the gap between the 3rd and
   // 4th scales down below a page.
   {0x00007e0000000000u,   0x00007fffff600000u, false},
   {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
+//
+// This formula translates from application memory to shadow memory:
+//
+//   shadow(app) = ((app & 0x00000f'ffffffff) + offset) >> scale
+//
+// Where the offset for 1:1 is 0x000013'00000000.  For other scales, the
+// offset is shifted left by the scale, except for scales of 1 and 2 where
+// it must be tweaked in order to pass the double-shadow test
+// (see the "shadow(shadow)" comments below):
+//   scale == 0: 0x000013'00000000
+//   scale == 1: 0x000022'00000000
+//   scale == 2: 0x000044'00000000
+//   scale >= 3: (0x000013'00000000 << scale)
+//
+// The resulting shadow memory regions for a 0 scaling are:
+//
+// [0x00000014'00000000, 0x00000015'00000000)
+// [0x0000001d'00000000, 0x0000001e'00000000)
+// [0x00000022'00000000, 0x00000022'ffffffff)
+//
+// We also want to ensure that a wild access by the application into the shadow
+// regions will not corrupt our own shadow memory. shadow(shadow) ends up
+// disjoint from shadow(app):
+//
+// [0x00000017'00000000, 0x00000018'00000000)
+// [0x00000020'00000000, 0x00000021'00000000)
+// [0x00000015'00000000, 0x00000015'ffffffff]
+
+static const struct ApplicationRegion AppRegions[] = {
+  {0x0100000000u, 0x0200000000u, false},
+  {0xaa00000000u, 0xab00000000u, false},
+  {0xff00000000u, 0xffffffffffu, false},
+};
+
+#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
 // equal to or larger than 1TB.
 static const uptr MaxStackSize = (1ULL << 40) - 4096;
 
 class ShadowMapping {
 public:
-  static const uptr Mask = 0x00000fffffffffffu;
+
   // The scale and offset vary by tool.
   uptr Scale;
   uptr Offset;
+
+  // TODO(sagar.thakur): Try to hardcode the mask as done in the compiler
+  // instrumentation to reduce the runtime cost of appToShadow.
+  struct ShadowMemoryMask40 {
+    static const uptr Mask = 0x0000000fffffffffu;
+  };
+
+  struct ShadowMemoryMask47 {
+    static const uptr Mask = 0x00000fffffffffffu;
+  };
+
   void initialize(uptr ShadowScale) {
-    static const uptr OffsetArray[3] = {
-        0x0000130000000000u,
-        0x0000220000000000u,
-        0x0000440000000000u,
+
+    const uptr OffsetArray40[3] = {
+      0x0000001300000000u,
+      0x0000002200000000u,
+      0x0000004400000000u,
+    };
+
+    const uptr OffsetArray47[3] = {
     };
+
     Scale = ShadowScale;
+    switch (VmaSize) {
+      case 40: {
+        if (Scale <= 2)
+          Offset = OffsetArray40[Scale];
+        else
+          Offset = OffsetArray40[0] << Scale;
+      }
+      break;
+      case 47: {
         if (Scale <= 2)
-      Offset = OffsetArray[Scale];
+          Offset = OffsetArray47[Scale];
         else
-      Offset = OffsetArray[0] << Scale;
+          Offset = OffsetArray47[0] << Scale;
+      }
+      break;
+      default: {
+        Printf("ERROR: %d-bit virtual memory address size not supported\n", VmaSize);
+        Die();
+      }
+    }
   }
 };
 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)
     return false;
   *Start = AppRegions[i].Start;
   *End = AppRegions[i].End;
   return true;
 }
 
 ALWAYS_INLINE
 bool isAppMem(uptr Mem) {
   for (u32 i = 0; i < NumAppRegions; ++i) {
     if (Mem >= AppRegions[i].Start && Mem < AppRegions[i].End)
       return true;
   }
   return false;
 }
 
+template<typename Params>
+uptr appToShadowImpl(uptr App) {
+  return (((App & Params::Mask) + Mapping.Offset) >> Mapping.Scale);
+}
+
 ALWAYS_INLINE
 uptr appToShadow(uptr App) {
-  return (((App & ShadowMapping::Mask) + Mapping.Offset) >> Mapping.Scale);
+  switch (VmaSize) {
+    case 40: return appToShadowImpl<ShadowMapping::ShadowMemoryMask40>(App);
+    case 47: return appToShadowImpl<ShadowMapping::ShadowMemoryMask47>(App);
+    default: {
+      Printf("ERROR: %d-bit virtual memory address size not supported\n", VmaSize);
+      Die();
+    }
+  }
 }
 
 static inline bool getShadowRegion(u32 i, uptr *Start, uptr *End) {
   if (i >= NumAppRegions)
     return false;
   u32 UnmergedShadowCount = 0;
   u32 AppIdx;
   for (AppIdx = 0; AppIdx < NumAppRegions; ++AppIdx) {

lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_SOURCES_NOTERMINATION
   sanitizer_symbolizer_win.cc
   sanitizer_tls_get_addr.cc
   sanitizer_thread_registry.cc
   sanitizer_win.cc)
 
 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
   ${SANITIZER_SOURCES_NOTERMINATION} sanitizer_termination.cc)
 
 # Libc functions stubs. These sources should be linked instead of
 # SANITIZER_LIBCDEP_SOURCES when sanitizer_common library must not depend on
 # libc.
if (LLVM_ENABLE_PEDANTIC AND UNIX AND NOT APPLE)
   # With -pedantic, our .S files raise warnings about empty macro arguments
   # from __USER_LABEL_PREFIX__ being an empty arg to GLUE().  Unfortunately,
   # there is no simple way to test for an empty define, nor to disable just
   # that warning or to disable -pedantic.  There is also no simple way to
   # remove -pedantic from just this file (we'd have to remove from
   # 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)
   set(OS_OPTION OS ${SANITIZER_COMMON_SUPPORTED_OS})
 endif()
 
 add_compiler_rt_object_libraries(RTSanitizerCommon
   ${OS_OPTION}

lib/sanitizer_common/sanitizer_linux.h

 
 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (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
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
 #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) \
   || defined(__powerpc64__) || defined(__s390__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);

lib/sanitizer_common/sanitizer_linux.cc

 // but it still needs to use 64-bit syscalls.
 #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \
     SANITIZER_WORDSIZE == 64)
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1
 #else
 # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0
 #endif
 
-#if defined(__x86_64__)
+#if defined(__x86_64__) || SANITIZER_MIPS64
 extern "C" {
 extern void internal_sigreturn();
 }
 #endif
 
 namespace __sanitizer {
 
 #if SANITIZER_LINUX && defined(__x86_64__)

 #endif
   }
   return result;
 }
 
 // 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);
   __sanitizer_sigaction u_adjust;
   internal_memcpy(&u_adjust, act, sizeof(u_adjust));
 #if !SANITIZER_ANDROID || !SANITIZER_MIPS32
     if (u_adjust.sa_restorer == nullptr) {
       u_adjust.sa_restorer = internal_sigreturn;

lib/sanitizer_common/sanitizer_linux_mips64.S

+// 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 // #5211 is for SYS_rt_sigreturn
+        syscall
+
+.size internal_sigreturn, .-internal_sigreturn
+
+#endif // defined(__linux__) && defined(__mips64)

lib/sanitizer_common/sanitizer_platform_limits_posix.h

#elif defined(__mips__)
   };
 #else
   struct __sanitizer_kernel_sigset_t {
     u8 sig[8];
   };
 #endif
 
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
+#if SANITIZER_MIPS
+  struct __sanitizer_kernel_sigaction_t {
+    unsigned int sa_flags;
+    union {
+      void (*handler)(int signo);
+      void (*sigaction)(int signo, void *info, void *ctx);
+    };
+    __sanitizer_kernel_sigset_t sa_mask;
+    void (*sa_restorer)(void);
+  };
+#else
   struct __sanitizer_kernel_sigaction_t {
     union {
       void (*handler)(int signo);
       void (*sigaction)(int signo, void *info, void *ctx);
     };
     unsigned long sa_flags;
     void (*sa_restorer)(void);
     __sanitizer_kernel_sigset_t sa_mask;
   };
+#endif
 
   extern uptr sig_ign;
   extern uptr sig_dfl;
   extern uptr sa_siginfo;
 
 #if SANITIZER_LINUX
   extern int e_tabsz;
 #endif

test/esan/TestCases/mmap-shadow-conflict.c

 // RUN: %clang_esan_frag -O0 %s -o %t 2>&1
-// RUN: %env_esan_opts=verbosity=1 %run %t 2>&1 | FileCheck %s
+// RUN: %env_esan_opts=verbosity=1 %run %t 2>&1 | FileCheck --check-prefix=%arch --check-prefix=CHECK %s
 
 #include <unistd.h>
 #include <sys/mman.h>
 #include <stdio.h>
 
 int main(int argc, char **argv) {
+#if defined(__mips64)
+  void *Map = mmap((void *)0x0000001600000000ULL, 0x1000, PROT_READ,
+                   MAP_ANON|MAP_PRIVATE|MAP_FIXED, -1, 0);
+#else
   void *Map = mmap((void *)0x0000016000000000ULL, 0x1000, PROT_READ,
                    MAP_ANON|MAP_PRIVATE|MAP_FIXED, -1, 0);
+#endif
   if (Map == (void *)-1)
     fprintf(stderr, "map failed\n");
   else
     fprintf(stderr, "mapped %p\n", Map);
+#if defined(__mips64)
+  Map = mmap((void *)0x0000001600000000ULL, 0x1000, PROT_READ,
+                   MAP_ANON|MAP_PRIVATE, -1, 0);
+#else
   Map = mmap((void *)0x0000016000000000ULL, 0x1000, PROT_READ,
                    MAP_ANON|MAP_PRIVATE, -1, 0);
+#endif
   fprintf(stderr, "mapped %p\n", Map);
   // 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)
+  // x86_64:      Shadow scale=2 offset=0x440000000000
+  // x86_64-NEXT: Shadow #0: [110000000000-114000000000) (256GB)
+  // x86_64-NEXT: Shadow #1: [124000000000-12c000000000) (512GB)
+  // x86_64-NEXT: Shadow #2: [148000000000-150000000000) (512GB)
+  // mips64:      Shadow scale=2 offset=0x4400000000
+  // mips64-NEXT: Shadow #0: [1140000000-1180000000) (1GB)
+  // mips64-NEXT: Shadow #1: [1380000000-13c0000000) (1GB)
+  // mips64-NEXT: Shadow #2: [14c0000000-1500000000) (1GB)
   // CHECK-NEXT: mmap conflict: {{.*}}
   // CHECK-NEXT: map failed
   // CHECK-NEXT: mmap conflict: {{.*}}
   // CHECK-NEXT: mapped {{.*}}
   // CHECK-NEXT: in esan::finalizeLibrary
   return 0;
 }

test/esan/TestCases/verbose-simple.c

 // 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=%arch --check-prefix=CHECK %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
+  // x86_64:      Shadow scale=2 offset=0x440000000000
+  // x86_64-NEXT: Shadow #0: [110000000000-114000000000) (256GB)
+  // x86_64-NEXT: Shadow #1: [124000000000-12c000000000) (512GB)
+  // x86_64-NEXT: Shadow #2: [148000000000-150000000000) (512GB)
+  // mips64:      Shadow scale=2 offset=0x4400000000
+  // mips64-NEXT: Shadow #0: [1140000000-1180000000) (1GB)
+  // mips64-NEXT: Shadow #1: [1380000000-13c0000000) (1GB)
+  // mips64-NEXT: Shadow #2: [14c0000000-1500000000) (1GB)
+  // CHECK: in esan::finalizeLibrary
+  // CHECK: ==verbose-simple{{.*}}EfficiencySanitizer: total struct field access count = 0
   return 0;
 }

test/esan/lit.cfg

 default_esan_opts = ''
 config.substitutions.append(('%env_esan_opts=',
                              'env ESAN_OPTIONS=' + default_esan_opts))
 
 # Default test suffixes.
 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

test/lit.common.cfg

config.substitutions.append(
      instead define '%clangXXX' substitution in lit config. ***\n\n""") )
 
 # Allow tests to be executed on a simulator or remotely.
 config.substitutions.append( ('%run', config.emulator) )
 
 # Define CHECK-%os to check for OS-dependent output.
 config.substitutions.append( ('CHECK-%os', ("CHECK-" + config.host_os)))
 
+# Define %arch to check for architecture-dependent output.
+config.substitutions.append( ('%arch', (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
   # KillTheDoctor and not --crash to make the latter more useful and remove the
   # need for this substitution.
   config.expect_crash = "not KillTheDoctor "
 else:
   config.expect_crash = "not --crash "