[Compiler-rt][Sanitizer][MSan][MIPS] Adding support for MIPS32

[mohit.bhakkad]

Summary

Most of the changes are specific to MIPS32 architecture to support Memory Sanitizer.

[samsonov]

Deferring this to Evgeniy. Just a couple of drive-by comments.

lib/msan/msan.cc

29

Can you #define those things where they are actually used for the first time?

513

#if should start from the beginning of the line:

#if defined(__mips__)
  char *ptr;
  // more code
#else
  // more code
#endif

[eugenis]

lib/msan/CMakeLists.txt

37

Cool. You don't need this if() now.

lib/msan/msan.cc

510–511

This is only used in MSanDR (DynamoRio helper tool) which does not support MIPS. Better not change it, or disable it with #ifdef.

lib/msan/msan.h

29

This gives you only 512Mb usable application memory in [0x60000000, 0x80000000),
and requires that all application code is mapped in that region. The latter depends on the kernel. Just FYI.

lib/msan/msan_allocator.cc

44

No point in 3Tb allocation limit, you have only 512Mb application memory.

[mohit.bhakkad]

Changed indentation and done suggested changes.

[eugenis]

What's the overall status of this work? Proper support of a new platform (and a new bitness) would require a lot more changes than this. If you have a larger patch, please upload it here for a general discussion.

[mohit.bhakkad]

In D5672#10, @eugenis wrote:

What's the overall status of this work? Proper support of a new platform (and a new bitness) would require a lot more changes than this. If you have a larger patch, please upload it here for a general discussion.

I have tried to change every architecture specific code as per my understanding, please suggest on anything we missed out.
Below are the test results on mips32 board:

19 test cases are failing out of 88:

• 3 are x86_64 specific
• 2 are working after changing addresses in program(64--->32)
• 9 are failing because of minor differences with expected o/p
• I am working on remaining 5 failing tests.

I am going to submit a separate patch for testing related changes.

[mohit.bhakkad]

This patch (when synced with ToT) functions properly with mips32, but it is kept on waiting for i386 support.
I have tried to provide i386 support for MSan in D6433, but it is stuck with
some issue in lit framework, please see if we can have green flag for this patch.

I am changing the status of patch to "Plan Changes" i.e. to be synced with current ToT.

cmake/config-ix.cmake

 filter_available_targets(ASAN_SUPPORTED_ARCH
   x86_64 i386 i686 powerpc64 arm mips)
 filter_available_targets(DFSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(LSAN_SUPPORTED_ARCH x86_64)
 # LSan common files should be available on all architectures supported
 # by other sanitizers (even if they build into dummy object files).
 filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
   ${SANITIZER_COMMON_SUPPORTED_ARCH})
-filter_available_targets(MSAN_SUPPORTED_ARCH x86_64)
+filter_available_targets(MSAN_SUPPORTED_ARCH x86_64 mips)
 filter_available_targets(PROFILE_SUPPORTED_ARCH x86_64 i386 i686 arm mips mips64 mipsel mips64el aarch64)
 filter_available_targets(TSAN_SUPPORTED_ARCH x86_64)
 filter_available_targets(UBSAN_SUPPORTED_ARCH x86_64 i386 i686 arm aarch64 mips)
 
 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")

lib/msan/CMakeLists.txt

 append_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE MSAN_RTL_CFLAGS)
 # Prevent clang from generating libc calls.
 append_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding MSAN_RTL_CFLAGS)
 
 set(MSAN_RUNTIME_LIBRARIES)
 
 # Static runtime library.
 add_custom_target(msan)
-set(arch "x86_64")
-if(CAN_TARGET_${arch})
+foreach(arch ${MSAN_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.msan-${arch} ${arch} STATIC
     SOURCES ${MSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
     CFLAGS ${MSAN_RTL_CFLAGS})
   add_dependencies(msan clang_rt.msan-${arch})
   list(APPEND MSAN_RUNTIME_LIBRARIES clang_rt.msan-${arch})
   if(UNIX)
     add_sanitizer_rt_symbols(clang_rt.msan-${arch} msan.syms.extra)
     add_dependencies(msan clang_rt.msan-${arch}-symbols)
   endif()
-endif()
+endforeach()
 
 add_compiler_rt_resource_file(msan_blacklist msan_blacklist.txt)
 add_dependencies(msan msan_blacklist)
 add_dependencies(compiler-rt msan)
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()

lib/msan/msan.h

 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "msan_interface_internal.h"
 #include "msan_flags.h"
 
 #ifndef MSAN_REPLACE_OPERATORS_NEW_AND_DELETE
 # define MSAN_REPLACE_OPERATORS_NEW_AND_DELETE 1
 #endif
 
+#if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
+#define MEM_TO_SHADOW(mem)       (((uptr)mem) & ~0x40000000UL)
+#define SHADOW_TO_ORIGIN(shadow) (((uptr)shadow) + 0x20000000UL)
+#define MEM_TO_ORIGIN(mem)       (SHADOW_TO_ORIGIN(MEM_TO_SHADOW(mem)))
+#define MEM_IS_APP(mem)          ((uptr)mem >= 0x60000000UL)
+#define MEM_IS_SHADOW(mem) \
+  ((uptr)mem >= 0x20000000UL && (uptr)mem <= 0x40000000UL)
+#else
 #define MEM_TO_SHADOW(mem)       (((uptr)mem) & ~0x400000000000ULL)
 #define SHADOW_TO_ORIGIN(shadow) (((uptr)shadow) + 0x200000000000ULL)
 #define MEM_TO_ORIGIN(mem)       (SHADOW_TO_ORIGIN(MEM_TO_SHADOW(mem)))
 #define MEM_IS_APP(mem)          ((uptr)mem >= 0x600000000000ULL)
 #define MEM_IS_SHADOW(mem) \
   ((uptr)mem >= 0x200000000000ULL && (uptr)mem <= 0x400000000000ULL)
+#endif
 
 const int kMsanParamTlsSizeInWords = 100;
 const int kMsanRetvalTlsSizeInWords = 100;
 
 namespace __msan {
 extern int msan_inited;
 extern bool msan_init_is_running;
 extern int msan_report_count;

lib/msan/msan.cc

 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 
 
 // ACHTUNG! No system header includes in this file.
 
 using namespace __sanitizer;
 
 // Globals.
 static THREADLOCAL int msan_expect_umr = 0;
 static THREADLOCAL int msan_expected_umr_found = 0;
 
 static bool msan_running_under_dr;
int  __msan_has_dynamic_component() {
   return msan_running_under_dr;
 }
 
 NOINLINE
 void __msan_clear_on_return() {
   __msan_param_tls[0] = 0;
 }
 
 static void* get_tls_base() {
+#ifdef __x86_64__
   u64 p;
   asm("mov %%fs:0, %0"
       : "=r"(p) ::);
   return (void*)p;
+#else
+  return 0;
+#endif /* __x86_64__ */
 }
 
 int __msan_get_retval_tls_offset() {
   // volatile here is needed to avoid UB, because the compiler thinks that we
   // are doing address arithmetics on unrelated pointers, and takes some
   // shortcuts
   volatile sptr retval_tls_p = (sptr)&__msan_retval_tls;
   volatile sptr tls_base_p = (sptr)get_tls_base();

lib/msan/msan_allocator.cc

void OnUnmap(uptr p, uptr size) const {
     // We are about to unmap a chunk of user memory.
     // Mark the corresponding shadow memory as not needed.
     FlushUnneededShadowMemory(MEM_TO_SHADOW(p), size);
     if (__msan_get_track_origins())
       FlushUnneededShadowMemory(MEM_TO_ORIGIN(p), size);
   }
 };
 
+#if defined (__mips__) && (SANITIZER_WORDSIZE == 32)
+static const uptr kMaxAllowedMallocSize = 1UL << 29;  // 512M.
+static const uptr kRegionSizeLog = 20;
+static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+typedef FlatByteMap<kNumRegions> ByteMap;
+typedef CompactSizeClassMap SizeClassMap;
+typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE, sizeof(Metadata),
+                             SizeClassMap, kRegionSizeLog, ByteMap,
+                             MsanMapUnmapCallback> PrimaryAllocator;
+#else
 static const uptr kAllocatorSpace = 0x600000000000ULL;
 static const uptr kAllocatorSize   = 0x80000000000;  // 8T.
 static const uptr kMetadataSize  = sizeof(Metadata);
 static const uptr kMaxAllowedMallocSize = 8UL << 30;
 
 typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize, kMetadataSize,
                              DefaultSizeClassMap,
                              MsanMapUnmapCallback> PrimaryAllocator;
+#endif
 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
 typedef LargeMmapAllocator<MsanMapUnmapCallback> SecondaryAllocator;
 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
                           SecondaryAllocator> Allocator;
 
 static Allocator allocator;
 static AllocatorCache fallback_allocator_cache;
 static SpinMutex fallback_mutex;

lib/msan/msan_linux.cc

 #include <sys/time.h>
 #include <sys/resource.h>
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 
 namespace __msan {
 
+#if defined (__mips__) && (SANITIZER_WORDSIZE == 32)
+static const uptr kMemBeg     = 0x60000000;
+static const uptr kMemEnd     = 0x7fffffff;
+#else
 static const uptr kMemBeg     = 0x600000000000;
 static const uptr kMemEnd     = 0x7fffffffffff;
+#endif
 static const uptr kShadowBeg  = MEM_TO_SHADOW(kMemBeg);
 static const uptr kShadowEnd  = MEM_TO_SHADOW(kMemEnd);
 static const uptr kBad1Beg    = 0;
 static const uptr kBad1End    = kShadowBeg - 1;
 static const uptr kBad2Beg    = kShadowEnd + 1;
 static const uptr kBad2End    = kMemBeg - 1;
 static const uptr kOriginsBeg = kBad2Beg;
 static const uptr kOriginsEnd = kBad2End;

lib/sanitizer_common/sanitizer_platform_interceptors.h

#define SANITIZER_INTERCEPT_STATFS64 \
   (SI_MAC && !SI_IOS) || SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATVFS SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_STATVFS64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_INITGROUPS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_ETHER_NTOA_ATON SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_ETHER_HOST SI_MAC || SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_ETHER_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_SHMCTL \
-  (SI_LINUX_NOT_ANDROID && SANITIZER_WORDSIZE == 64)
+  (SI_LINUX_NOT_ANDROID && (SANITIZER_WORDSIZE == 64 || defined(__mips__)))
 #define SANITIZER_INTERCEPT_RANDOM_R SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETINHERITSCHED \
   SI_MAC || SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL \