Revert "[ESan][MIPS] Adds support for MIPS64"

[zhaoqin]

Summary

This reverts commit 62b3eecdbe72af0255f0639b0446087a47efbf48. (D23799)

The CL cause 13 ESan test failure on x86_64:
Failing Tests (13):

  EfficiencySanitizer-x86_64 :: TestCases/large-stack-linux.c
  EfficiencySanitizer-x86_64 :: TestCases/libc-intercept.c
  EfficiencySanitizer-x86_64 :: TestCases/mmap-shadow-conflict.c
  EfficiencySanitizer-x86_64 :: TestCases/struct-simple.cpp
  EfficiencySanitizer-x86_64 :: TestCases/verbose-simple.c
  EfficiencySanitizer-x86_64 :: TestCases/workingset-early-fault.c
  EfficiencySanitizer-x86_64 :: TestCases/workingset-memset.cpp
  EfficiencySanitizer-x86_64 :: TestCases/workingset-midreport.cpp
  EfficiencySanitizer-x86_64 :: TestCases/workingset-samples.cpp
  EfficiencySanitizer-x86_64 :: TestCases/workingset-signal-posix.cpp
  EfficiencySanitizer-x86_64 :: TestCases/workingset-simple.cpp
  EfficiencySanitizer-x86_64 :: Unit/circular_buffer.cpp
  EfficiencySanitizer-x86_64 :: Unit/hashtable.cpp

Unexpected Failures: 13

[bruening]

Just a pure revert, right?

[zhaoqin]

In D24350#537239, @bruening wrote:

Just a pure revert, right?

Yes

compiler-rt/trunk/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} ${MIPS64})
+set(ALL_ESAN_SUPPORTED_ARCH ${X86_64})
 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)

compiler-rt/trunk/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);

compiler-rt/trunk/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) {

compiler-rt/trunk/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__) || SANITIZER_MIPS64)
+#if SANITIZER_LINUX && defined(__x86_64__)
   // 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);

compiler-rt/trunk/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__) 
+#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
 // [0x00007e00'00000000, 0x00007fff'ff600000) libraries + stack, part 1

 // 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;
-  };
-
-  const uptr OffsetArray40[3] = {
-    0x0000001300000000u,
-    0x0000002200000000u,
-    0x0000004400000000u,
-  };
-
-  const uptr OffsetArray47[3] = {
+  void initialize(uptr ShadowScale) {
+    static const uptr OffsetArray[3] = {
         0x0000130000000000u,
         0x0000220000000000u,
         0x0000440000000000u,
     };
-
-  void initialize(uptr ShadowScale) {
     Scale = ShadowScale;
-    switch (VmaSize) {
-      case 40: {
-        if (Scale <= 2)
-          Offset = OffsetArray40[Scale];
-        else
-          Offset = OffsetArray40[0] << Scale;
-      }
-      break;
-      case 47: {
-        if (Scale <= 2)
-          Offset = OffsetArray47[Scale];
-        else
-          Offset = OffsetArray47[0] << Scale;
-      }
-      break;
-      default: {
-        Printf("ERROR: %d-bit virtual memory address size not supported\n", VmaSize);
-        Die();
-      }
-    }
+      Offset = OffsetArray[Scale];
+      Offset = OffsetArray[0] << Scale;
   }
 };
 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) {
-  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();
-    }
-  }
+  return (((App & ShadowMapping::Mask) + Mapping.Offset) >> Mapping.Scale);
 }
 
 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) {

compiler-rt/trunk/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}

compiler-rt/trunk/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_MIPS64) && !SANITIZER_GO
+#if defined(__x86_64__) && !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);

compiler-rt/trunk/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__) || SANITIZER_MIPS64
+#if defined(__x86_64__)
 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_MIPS64) && !SANITIZER_GO
+#if defined(__x86_64__) && !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;

compiler-rt/trunk/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)

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_limits_posix.h

 #else
   struct __sanitizer_kernel_sigset_t {
     u8 sig[8];
   };
 #endif
 
   // 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;
   extern uptr sig_dfl;
   extern uptr sa_siginfo;
 
 #if SANITIZER_LINUX
   extern int e_tabsz;

compiler-rt/trunk/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 --check-prefix=CHECK-%arch %s
+// RUN: %env_esan_opts="verbosity=1 log_exe_name=1" %run %t 2>&1 | FileCheck %s
 
 int main(int argc, char **argv) {
   // CHECK:      in esan::initializeLibrary
   // (There can be a re-exec for stack limit here.)
-  // 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-13c0000000) (1GB)
-  // CHECK-mips64: Shadow #2: [14c0000000-1500000000) (1GB)
-  // CHECK: in esan::finalizeLibrary
-  // CHECK: ==verbose-simple{{.*}}EfficiencySanitizer: total struct field access count = 0
+  // 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
   return 0;
 }

compiler-rt/trunk/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 not in ['x86_64', 'mips64'] :
+if config.host_os not in ['Linux'] or config.target_arch != 'x86_64':
   config.unsupported = True

compiler-rt/trunk/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 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
   # 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 "