[compiler-rt] Move logic which replace memcpy interceptor with memmove from asan to sanitizer_common.

[eugenis]

LGTM

compiler-rt/trunk/lib/asan/asan_interceptors.cc

#define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end)                           \
   }
 
 #define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, to, from, size) \
   do {                                                       \
     ASAN_INTERCEPTOR_ENTER(ctx, memmove);                    \
     ASAN_MEMMOVE_IMPL(ctx, to, from, size);                  \
   } while (false)
 
-// At least on 10.7 and 10.8 both memcpy() and memmove() are being replaced
-// with WRAP(memcpy). As a result, false positives are reported for
-// memmove() calls. If we just disable error reporting with
-// ASAN_OPTIONS=replace_intrin=0, memmove() is still replaced with
-// internal_memcpy(), which may lead to crashes, see
-// http://llvm.org/bugs/show_bug.cgi?id=16362.
 #define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, to, from, size) \
   do {                                                      \
     ASAN_INTERCEPTOR_ENTER(ctx, memcpy);                    \
-    if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {        \
-      ASAN_MEMCPY_IMPL(ctx, to, from, size);                \
-    } else {                                                \
-      ASAN_MEMMOVE_IMPL(ctx, to, from, size);               \
-    }                                                       \
+    ASAN_MEMCPY_IMPL(ctx, to, from, size);                  \
   } while (false)
 
 #define COMMON_INTERCEPTOR_MEMSET_IMPL(ctx, block, c, size) \
   do {                                                      \
     ASAN_INTERCEPTOR_ENTER(ctx, memset);                    \
     ASAN_MEMSET_IMPL(ctx, block, c, size);                  \
   } while (false)
 
-// In asan, REAL(memmove) is not used, but it is used in msan.
-#define COMMON_INTERCEPT_FUNCTION_MEMCPY()           \
-  do {                                               \
-    if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { \
-      ASAN_INTERCEPT_FUNC(memcpy);                   \
-    } else {                                         \
-      ASSIGN_REAL(memcpy, memmove);                  \
-    }                                                \
-    CHECK(REAL(memcpy));                             \
-  } while (false)
-
 #include "sanitizer_common/sanitizer_common_interceptors.inc"
 
 // Syscall interceptors don't have contexts, we don't support suppressions
 // for them.
 #define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(nullptr, p, s)
 #define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(nullptr, p, s)
 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \
   do {                                       \

compiler-rt/trunk/lib/asan/asan_internal.h

 void PlatformTSDDtor(void *tsd);
 
 void AppendToErrorMessageBuffer(const char *buffer);
 
 void *AsanDlSymNext(const char *sym);
 
 void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name);
 
-// Platform-specific options.
-#if SANITIZER_MAC
-bool PlatformHasDifferentMemcpyAndMemmove();
-# define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE \
-    (PlatformHasDifferentMemcpyAndMemmove())
-#elif SANITIZER_WINDOWS64
-# define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE false
-#else
-# define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE true
-#endif  // SANITIZER_MAC
-
 // Add convenient macro for interface functions that may be represented as
 // weak hooks.
 #define ASAN_MALLOC_HOOK(ptr, size)                                   \
   do {                                                                \
     if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(ptr, size); \
     RunMallocHooks(ptr, size);                                        \
   } while (false)
 #define ASAN_FREE_HOOK(ptr)                                 \

compiler-rt/trunk/lib/asan/asan_mac.cc

extern "C" {
   extern char ***_NSGetEnviron(void);
 }
 
 namespace __asan {
 
 void InitializePlatformInterceptors() {}
 void InitializePlatformExceptionHandlers() {}
 
-bool PlatformHasDifferentMemcpyAndMemmove() {
-  // On OS X 10.7 memcpy() and memmove() are both resolved
-  // into memmove$VARIANT$sse42.
-  // See also https://github.com/google/sanitizers/issues/34.
-  // TODO(glider): need to check dynamically that memcpy() and memmove() are
-  // actually the same function.
-  return GetMacosVersion() == MACOS_VERSION_SNOW_LEOPARD;
-}
-
 // No-op. Mac does not support static linkage anyway.
 void *AsanDoesNotSupportStaticLinkage() {
   return 0;
 }
 
 // No-op. Mac does not support static linkage anyway.
 void AsanCheckDynamicRTPrereqs() {}
 

compiler-rt/trunk/lib/msan/msan_interceptors.cc

 #define MSAN_INTERCEPT_FUNC_VER(name, ver)                                    \
   do {                                                                        \
     if ((!INTERCEPT_FUNCTION_VER(name, ver) || !REAL(name)))                  \
       VReport(                                                                \
           1, "MemorySanitizer: failed to intercept '" #name "@@" #ver "'\n"); \
   } while (0)
 
 #define COMMON_INTERCEPT_FUNCTION(name) MSAN_INTERCEPT_FUNC(name)
-#define COMMON_INTERCEPT_FUNCTION_MEMCPY() MSAN_INTERCEPT_FUNC(memcpy)
 #define COMMON_INTERCEPT_FUNCTION_VER(name, ver)                          \
   MSAN_INTERCEPT_FUNC_VER(name, ver)
 #define COMMON_INTERCEPTOR_UNPOISON_PARAM(count)  \
   UnpoisonParam(count)
 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
   __msan_unpoison(ptr, size)
 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
   CHECK_UNPOISONED_CTX(ctx, ptr, size)

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common_interceptors.inc

 
 #if SANITIZER_FREEBSD
 #define pthread_setname_np pthread_set_name_np
 #define inet_aton __inet_aton
 #define inet_pton __inet_pton
 #define iconv __bsd_iconv
 #endif
 
+// Platform-specific options.
+#if SANITIZER_MAC
+bool PlatformHasDifferentMemcpyAndMemmove();
+#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE \
+  (PlatformHasDifferentMemcpyAndMemmove())
+#elif SANITIZER_WINDOWS64
+#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE false
+#else
+#define PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE true
+#endif  // SANITIZER_MAC
+
 #ifndef COMMON_INTERCEPTOR_INITIALIZE_RANGE
 #define COMMON_INTERCEPTOR_INITIALIZE_RANGE(p, size) {}
 #endif
 
 #ifndef COMMON_INTERCEPTOR_UNPOISON_PARAM
 #define COMMON_INTERCEPTOR_UNPOISON_PARAM(count) {}
 #endif
 
#define COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size) \
     if (common_flags()->intercept_intrin) {                  \
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);        \
       COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);         \
     }                                                        \
     return REAL(memmove)(dst, src, size);                    \
   }
 #endif
 
-// On OS X, calling internal_memcpy here will cause memory corruptions,
-// because memcpy and memmove are actually aliases of the same
-// implementation.  We need to use internal_memmove here.
-// N.B.: If we switch this to internal_ we'll have to use internal_memmove
-// due to memcpy being an alias of memmove on OS X.
 #ifndef COMMON_INTERCEPTOR_MEMCPY_IMPL
 #define COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, dst, src, size) \
   {                                                         \
     if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED) {        \
       return internal_memmove(dst, src, size);              \
     }                                                       \
     COMMON_INTERCEPTOR_ENTER(ctx, memcpy, dst, src, size);  \
     if (common_flags()->intercept_intrin) {                 \
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, dst, size);       \
       COMMON_INTERCEPTOR_READ_RANGE(ctx, src, size);        \
     }                                                       \
     return REAL(memcpy)(dst, src, size);                    \
   }
 #endif
 
-#ifndef COMMON_INTERCEPT_FUNCTION_MEMCPY
-#define COMMON_INTERCEPT_FUNCTION_MEMCPY() {}
-#endif
-
 struct FileMetadata {
   // For open_memstream().
   char **addr;
   SIZE_T *size;
 };
 
 struct CommonInterceptorMetadata {
   enum {

 
 #define INIT_MEMMOVE COMMON_INTERCEPT_FUNCTION(memmove)
 #else
 #define INIT_MEMMOVE
 #endif
 
 #if SANITIZER_INTERCEPT_MEMCPY
 INTERCEPTOR(void *, memcpy, void *dst, const void *src, uptr size) {
+  // On OS X, calling internal_memcpy here will cause memory corruptions,
+  // because memcpy and memmove are actually aliases of the same
+  // implementation.  We need to use internal_memmove here.
+  // N.B.: If we switch this to internal_ we'll have to use internal_memmove
+  // due to memcpy being an alias of memmove on OS X.
   void *ctx;
+  if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
     COMMON_INTERCEPTOR_MEMCPY_IMPL(ctx, dst, src, size);
+  } else {
+    COMMON_INTERCEPTOR_MEMMOVE_IMPL(ctx, dst, src, size);
+  }
 }
 
-#define INIT_MEMCPY COMMON_INTERCEPT_FUNCTION_MEMCPY()
+#define INIT_MEMCPY                                  \
+  do {                                               \
+    if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { \
+      COMMON_INTERCEPT_FUNCTION(memcpy);             \
+    } else {                                         \
+      ASSIGN_REAL(memcpy, memmove);                  \
+    }                                                \
+    CHECK(REAL(memcpy));                             \
+  } while (false)
+
 #else
 #define INIT_MEMCPY
 #endif
 
 #if SANITIZER_INTERCEPT_MEMCMP
 
 DECLARE_WEAK_INTERCEPTOR_HOOK(__sanitizer_weak_hook_memcmp, uptr called_pc,
                               const void *s1, const void *s2, uptr n,

compiler-rt/trunk/lib/sanitizer_common/sanitizer_mac.cc

MacosVersion result =
       static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
   if (result == MACOS_VERSION_UNINITIALIZED) {
     result = GetMacosVersionInternal();
     atomic_store(cache, result, memory_order_release);
   }
   return result;
 }
 
+bool PlatformHasDifferentMemcpyAndMemmove() {
+  // On OS X 10.7 memcpy() and memmove() are both resolved
+  // into memmove$VARIANT$sse42.
+  // See also https://github.com/google/sanitizers/issues/34.
+  // TODO(glider): need to check dynamically that memcpy() and memmove() are
+  // actually the same function.
+  return GetMacosVersion() == MACOS_VERSION_SNOW_LEOPARD;
+}
+
 uptr GetRSS() {
   struct task_basic_info info;
   unsigned count = TASK_BASIC_INFO_COUNT;
   kern_return_t result =
       task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
   if (UNLIKELY(result != KERN_SUCCESS)) {
     Report("Cannot get task info. Error: %d\n", result);
     Die();