[compiler-rt] Fix memmove/memcpy overlap detection on windows

[etienneb]

Summary

The memcpy and memmove functions are the same on windows.
The overlap detection logic is incorrect.

printf-1 test:

stdin>:2:114: note: possible intended match here
==877412==ERROR: AddressSanitizer: memcpy-param-overlap: memory ranges [0x0000002bf2a8,0x0000002bf2ad) and [0x0000002bf2a9, 0x0000002bf2ae) overlap
```                                                                                                                 ^

[rnk]

lib/asan/asan_interceptors.cc

433

Should we go back, intercept memmove instead of memcpy, and then initialize REAL(memset) to REAL(memmove) so that we don't crash when calling it?

Suppose the user calls memcpy or memmove on free memory. The stack trace can either contain asam_memcpy or asan_memmove. Which do you think is better?

[etienneb]

move to an different approach

[etienneb]

I tried the other approach, and it seems to work fine.

[etienneb]

fix unittests

[rnk]

lgtm

lib/asan/asan_interceptors.cc

#define ASAN_MEMSET_IMPL(ctx, block, c, size) do {                             \
     }                                                                          \
     return REAL(memset)(block, c, size);                                       \
   } while (0)
 
 void *__asan_memset(void *block, int c, uptr size) {
   ASAN_MEMSET_IMPL(nullptr, block, c, size);
 }
 
 #define ASAN_MEMMOVE_IMPL(ctx, to, from, size) do {                            \
     if (UNLIKELY(!asan_inited))                                                \
       return internal_memmove(to, from, size);                                 \
     ENSURE_ASAN_INITED();                                                      \
     if (flags()->replace_intrin) {                                             \
       ASAN_READ_RANGE(ctx, from, size);                                        \
       ASAN_WRITE_RANGE(ctx, to, size);                                         \
     }                                                                          \
     return internal_memmove(to, from, size);                                   \

 namespace __asan {
 void InitializeAsanInterceptors() {
   static bool was_called_once;
   CHECK(was_called_once == false);
   was_called_once = true;
   InitializeCommonInterceptors();
 
   // Intercept mem* functions.
-  ASAN_INTERCEPT_FUNC(memcpy);
   ASAN_INTERCEPT_FUNC(memset);
-  if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
-    // In asan, REAL(memmove) is not used, but it is used in msan.
-    ASAN_INTERCEPT_FUNC(memmove);
+  if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) {
+    ASAN_INTERCEPT_FUNC(memcpy);
+  } else {
+    *&REAL(memcpy) = REAL(memmove);
   }
   CHECK(REAL(memcpy));
 
   // Intercept str* functions.
   ASAN_INTERCEPT_FUNC(strcat);  // NOLINT
   ASAN_INTERCEPT_FUNC(strcpy);  // NOLINT
   ASAN_INTERCEPT_FUNC(wcslen);
   ASAN_INTERCEPT_FUNC(strncat);

lib/asan/tests/asan_str_test.cc

 TEST(AddressSanitizer, StrArgsOverlapTest) {
   size_t size = Ident(100);
   char *str = Ident((char*)malloc(size));
 
 // Do not check memcpy() on OS X 10.7 and later, where it actually aliases
 // memmove().
 #if !defined(__APPLE__) || !defined(MAC_OS_X_VERSION_10_7) || \
     (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7)
+#if PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE
   // Check "memcpy". Use Ident() to avoid inlining.
   memset(str, 'z', size);
   Ident(memcpy)(str + 1, str + 11, 10);
   Ident(memcpy)(str, str, 0);
   EXPECT_DEATH(Ident(memcpy)(str, str + 14, 15), OverlapErrorMessage("memcpy"));
   EXPECT_DEATH(Ident(memcpy)(str + 14, str, 15), OverlapErrorMessage("memcpy"));
 #endif
+#endif
 
   // We do not treat memcpy with to==from as a bug.
   // See http://llvm.org/bugs/show_bug.cgi?id=11763.
   // EXPECT_DEATH(Ident(memcpy)(str + 20, str + 20, 1),
   //              OverlapErrorMessage("memcpy"));
 
   // Check "strcpy".
   memset(str, 'z', size);