[asan] Enable asan Win64 build

[wang0109]

Summary

This patch is activating the build of Asan on Windows 64-bits.
It's fixing compilation errors. The runtime is not yet working.

Missing features:

• OverrideFunction for x64
• an equiv function for inline asm (atomic_compare_exchange_strong)
• shadow memory offset needs to be adjusted
• RoundUpToInstrBoundary for x64

They will be implemented by subsequent patches.

[rnk]

cmake/config-ix.cmake

438

I think this is likely to turn this bot red:
http://lab.llvm.org:8011/builders/clang-x64-ninja-win7/

It builds 'check-all' with compiler-rt on win64, and the tests obviously don't pass yet. I think if you change the code at the end of compiler-rt/test/asan/CMakeLists.txt to set EXCLUDE_FROM_ALL to ON, you can avoid breaking it.

lib/interception/interception_win.cc

154–158

Space after //, here and elsewhere

[wang0109]

Update the patch to clean up the spaces and add more comment

[wang0109]

• Update diff for cmake - avoid buildbot fail (need more tests)

[rnk]

test/asan/CMakeLists.txt

96

You actually want to do this here to affect the main asan test suite, not just the dynamic asan test suite:

if (OS_NAME MATCHES "Windows" AND CMAKE_SIZEOF_VOID_P EQUAL 8)
  set(EXCLUDE_FROM_ALL TRUE)
endif()

[wang0109]

• Update cmake files to disable unsupported tests including asan and ubsan with asan

[rnk]

Functionally this is fine. Etienne, can you commit this on behalf of Wei after the comment stuff is addressed?

lib/sanitizer_common/sanitizer_atomic_msvc.h

179

Can you capitalize your comment sentence starts and end them with a period? Sorry I forgot to raise that earlier.

[wang0109]

• Update comment format

[wang0109]

• Update comment format again

[etienneb]

In D20455#438465, @rnk wrote:

Functionally this is fine. Etienne, can you commit this on behalf of Wei after the comment stuff is addressed?

Ok. I'll do.
I'll try the patch too.

[wang0109]

• Update diff for linting style

[etienneb]

I tested the patch on my windows machine, and it's working fine.
I'm running unittests on linux.

Could you please fix the remaining nits and I'll land this.

lib/asan/asan_win.cc

73

no @

155

There is no "@" here.

lib/interception/interception_win.cc

72

no @

154–158

no @

test/asan/CMakeLists.txt

6

missing (wwchrome)

122

ditto

test/ubsan/CMakeLists.txt

35 ↗

(On Diff #58435)

ditto

[wang0109]

• Update diff to fix username in TODO

[etienneb]

still one missing

lib/sanitizer_common/sanitizer_atomic_msvc.h

179

no @

[wang0109]

• Fix username in TODO again.

[etienneb]

lgtm

I'll land this soon.

[etienneb]

lg

[kubamracek]

compiler-rt/trunk/test/asan/CMakeLists.txt

6–10 ↗

(On Diff #58841)

I’m not getting this change. I read it like 20 times now, but it still seems it’s disabling ASan tests everywhere, *except* for Win64.

cmake/config-ix.cmake

 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD" OR
     (OS_NAME MATCHES "Windows" AND MSVC)))
   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 else()
   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND
-    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
+if (COMPILER_RT_HAS_SANITIZER_COMMON)
   set(COMPILER_RT_HAS_INTERCEPTION TRUE)
 else()
   set(COMPILER_RT_HAS_INTERCEPTION FALSE)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND
-    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH)
   set(COMPILER_RT_HAS_ASAN TRUE)
 else()
   set(COMPILER_RT_HAS_ASAN FALSE)
 endif()
 
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows")
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 else()

lib/asan/asan_win.cc

 // use the /alternatename directive to tell the linker to default a specific
 // symbol to a specific value, which works nicely for allocator hooks and
 // __asan_default_options().
 void __sanitizer_default_malloc_hook(void *ptr, uptr size) { }
 void __sanitizer_default_free_hook(void *ptr) { }
 const char* __asan_default_default_options() { return ""; }
 const char* __asan_default_default_suppressions() { return ""; }
 void __asan_default_on_error() {}
+// 64-bit msvc will not prepend an underscore for symbols
+#ifdef _WIN64
+#pragma comment(linker, "/alternatename:__sanitizer_malloc_hook=__sanitizer_default_malloc_hook")  // NOLINT
+#pragma comment(linker, "/alternatename:__sanitizer_free_hook=__sanitizer_default_free_hook")      // NOLINT
+#pragma comment(linker, "/alternatename:__asan_default_options=__asan_default_default_options")    // NOLINT
+#pragma comment(linker, "/alternatename:__asan_default_suppressions=__asan_default_default_suppressions")    // NOLINT
+#pragma comment(linker, "/alternatename:__asan_on_error=__asan_default_on_error")                  // NOLINT
+#else
 #pragma comment(linker, "/alternatename:___sanitizer_malloc_hook=___sanitizer_default_malloc_hook")  // NOLINT
 #pragma comment(linker, "/alternatename:___sanitizer_free_hook=___sanitizer_default_free_hook")      // NOLINT
 #pragma comment(linker, "/alternatename:___asan_default_options=___asan_default_default_options")    // NOLINT
 #pragma comment(linker, "/alternatename:___asan_default_suppressions=___asan_default_default_suppressions")    // NOLINT
 #pragma comment(linker, "/alternatename:___asan_on_error=___asan_default_on_error")                  // NOLINT
+#endif
 // }}}
 }  // extern "C"
 
 // ---------------------- Windows-specific inteceptors ---------------- {{{
 INTERCEPTOR_WINAPI(void, RaiseException, void *a, void *b, void *c, void *d) {
   CHECK(REAL(RaiseException));
   __asan_handle_no_return();
   REAL(RaiseException)(a, b, c, d);
 }
 
+// TODO: Win64 has no _except_handler3/4, will implement _C_specific_handler instead
+#ifndef _WIN64
 INTERCEPTOR(int, _except_handler3, void *a, void *b, void *c, void *d) {
   CHECK(REAL(_except_handler3));
   __asan_handle_no_return();
   return REAL(_except_handler3)(a, b, c, d);
 }
 
 #if ASAN_DYNAMIC
 // This handler is named differently in -MT and -MD CRTs.
 #define _except_handler4 _except_handler4_common
 #endif
 INTERCEPTOR(int, _except_handler4, void *a, void *b, void *c, void *d) {
   CHECK(REAL(_except_handler4));
   __asan_handle_no_return();
   return REAL(_except_handler4)(a, b, c, d);
 }
+#endif
 
 static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
   AsanThread *t = (AsanThread*)arg;
   SetCurrentThread(t);
   return t->ThreadStart(GetTid(), /* signal_thread_is_registered */ nullptr);
 }
 
 INTERCEPTOR_WINAPI(DWORD, CreateThread,

 
 // }}}
 
 namespace __asan {
 
 void InitializePlatformInterceptors() {
   ASAN_INTERCEPT_FUNC(CreateThread);
   ASAN_INTERCEPT_FUNC(RaiseException);
+
+// TODO: Win64 uses _C_specific_handler instead
+#ifndef _WIN64
   ASAN_INTERCEPT_FUNC(_except_handler3);
   ASAN_INTERCEPT_FUNC(_except_handler4);
+#endif
 
   // NtWaitForWorkViaWorkerFactory is always linked dynamically.
   CHECK(::__interception::OverrideFunction(
       "NtWaitForWorkViaWorkerFactory",
       (uptr)WRAP(NtWaitForWorkViaWorkerFactory),
       (uptr *)&REAL(NtWaitForWorkViaWorkerFactory)));
 }
 

lib/interception/interception_win.cc

 static void _memcpy(void *dst, void *src, size_t sz) {
   char *dst_c = (char*)dst,
        *src_c = (char*)src;
   for (size_t i = 0; i < sz; ++i)
     dst_c[i] = src_c[i];
 }
 
 static void WriteJumpInstruction(char *jmp_from, char *to) {
-  // jmp XXYYZZWW = E9 WW ZZ YY XX, where XXYYZZWW is an offset fromt jmp_from
+  // jmp XXYYZZWW = E9 WW ZZ YY XX, where XXYYZZWW is an offset from jmp_from
   // to the next instruction to the destination.
   ptrdiff_t offset = to - jmp_from - 5;
   *jmp_from = '\xE9';
   *(ptrdiff_t*)(jmp_from + 1) = offset;
 }
 
 static char *GetMemoryForTrampoline(size_t size) {
   // Trampolines are allocated from a common pool.
static char *GetMemoryForTrampoline(size_t size) {
 
   char *ret = pool + pool_used;
   pool_used += size;
   return ret;
 }
 
 // Returns 0 on error.
 static size_t RoundUpToInstrBoundary(size_t size, char *code) {
+#ifdef _WIN64
+  // TODO: implement similar logic for x64 instructions
+  // Win64 RoundUpToInstrBoundary is not supported yet
+  __debugbreak();
+  return 0;
+#else
   size_t cursor = 0;
   while (cursor < size) {
     switch (code[cursor]) {
       case '\x51':  // push ecx
       case '\x52':  // push edx
       case '\x53':  // push ebx
       case '\x54':  // push esp
       case '\x55':  // push ebp
while (cursor < size) {
     // in visible and readable error messages. However, merely calling abort()
     // leads to an infinite recursion in CheckFailed.
     // Do we have a good way to abort with an error message here?
     __debugbreak();
     return 0;
   }
 
   return cursor;
+#endif
 }
 
 bool OverrideFunction(uptr old_func, uptr new_func, uptr *orig_old_func) {
 #ifdef _WIN64
-#error OverrideFunction is not yet supported on x64
-#endif
+  // TODO: implement using x64 jmp
+  // OverrideFunction is not yet supported on x64
+  __debugbreak();
+  return false;
+#else
   // Function overriding works basically like this:
   // We write "jmp <new_func>" (5 bytes) at the beginning of the 'old_func'
   // to override it.
   // We might want to be able to execute the original 'old_func' from the
   // wrapper, in this case we need to keep the leading 5+ bytes ('head')
   // of the original code somewhere with a "jmp <old_func+head>".
   // We call these 'head'+5 bytes of instructions a "trampoline".
   char *old_bytes = (char *)old_func;
#else
   WriteJumpInstruction(old_bytes, (char *)new_func);
   _memset(old_bytes + 5, 0xCC /* int 3 */, head - 5);
 
   // Restore the original permissions.
   if (!VirtualProtect((void *)old_bytes, head, old_prot, &unused_prot))
     return false;  // not clear if this failure bothers us.
 
   return true;
+#endif
 }
 
 static void **InterestingDLLsAvailable() {
   const char *InterestingDLLs[] = {
       "kernel32.dll",
       "msvcr110.dll",      // VS2012
       "msvcr120.dll",      // VS2013
       "vcruntime140.dll",  // VS2015

lib/sanitizer_common/sanitizer_atomic_msvc.h

 
 INLINE u32 atomic_exchange(volatile atomic_uint32_t *a,
     u32 v, memory_order mo) {
   (void)mo;
   DCHECK(!((uptr)a % sizeof(*a)));
   return (u32)_InterlockedExchange((volatile long*)&a->val_dont_use, v);
 }
 
-#ifndef _WIN64
-
 INLINE bool atomic_compare_exchange_strong(volatile atomic_uint8_t *a,
                                            u8 *cmp,
                                            u8 xchgv,
                                            memory_order mo) {
+#ifdef _WIN64
+  // TODO: implement same functionality without inline asm
+  // Inline asm not supported in Win64
+  __debugbreak();
+  return false;
+#else
   (void)mo;
   DCHECK(!((uptr)a % sizeof(*a)));
   u8 cmpv = *cmp;
   u8 prev;
   __asm {
     mov al, cmpv
     mov ecx, a
     mov dl, xchgv
     lock cmpxchg [ecx], dl
     mov prev, al
   }
   if (prev == cmpv)
     return true;
   *cmp = prev;
   return false;
-}
-
 #endif
+}
 
 INLINE bool atomic_compare_exchange_strong(volatile atomic_uintptr_t *a,
                                            uptr *cmp,
                                            uptr xchg,
                                            memory_order mo) {
   uptr cmpv = *cmp;
   uptr prev = (uptr)_InterlockedCompareExchangePointer(
       (void*volatile*)&a->val_dont_use, (void*)xchg, (void*)cmpv);

test/asan/CMakeLists.txt

 set(ASAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(ASAN_TESTSUITES)
 set(ASAN_DYNAMIC_TESTSUITES)
 
 macro(get_bits_for_arch arch bits)
   if (${arch} MATCHES "i386|i686|arm|mips|mipsel")
     set(${bits} 32)
   elseif (${arch} MATCHES "x86_64|powerpc64|powerpc64le|aarch64|mips64|mips64el|s390x")
     set(${bits} 64)
   else()
     message(FATAL_ERROR "Unknown target architecture: ${arch}")
   endif()
 endmacro()
if (NOT ANDROID)
     list(APPEND ASAN_TEST_DEPS AsanUnitTests)
     list(APPEND ASAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
     if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
       list(APPEND ASAN_DYNAMIC_TEST_DEPS AsanDynamicUnitTests)
       list(APPEND ASAN_DYNAMIC_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic)
     endif()
   endif()
 endif()
 
 add_lit_testsuite(check-asan "Running the AddressSanitizer tests"
   ${ASAN_TESTSUITES}
   DEPENDS ${ASAN_TEST_DEPS})
 set_target_properties(check-asan PROPERTIES FOLDER "ASan tests")
 
 if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
   # Add check-dynamic-asan target. It is a part of check-all only on Windows,
   # where we want to always test both dynamic and static runtime.
-  if(NOT OS_NAME MATCHES "Windows")
+
+  # TODO: re-enable the tests for asan Win64 when ready
+  # disable tests for asan Win64 temporarily
+  if(NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 8)
     set(EXCLUDE_FROM_ALL TRUE)
   endif()
   add_lit_testsuite(check-asan-dynamic
                     "Running the AddressSanitizer tests with dynamic runtime"
                     ${ASAN_DYNAMIC_TESTSUITES}
                     DEPENDS ${ASAN_DYNAMIC_TEST_DEPS})
   set_target_properties(check-asan-dynamic
                         PROPERTIES FOLDER "ASan dynamic tests")
-  if(NOT OS_NAME MATCHES "Windows")
+  if(NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 8)
     set(EXCLUDE_FROM_ALL FALSE)
   endif()
 endif()