ubsan: Port runtime library to (32- and 64-bit) Windows.

[majnemer]

lib/sanitizer_common/sanitizer_common.h

662–665 ↗

(On Diff #28831)

This could probably be _ReadWriteBarrier();

[pcc]

Use _ReadWriteBarrier

lib/sanitizer_common/sanitizer_common.h

662–665 ↗

(On Diff #28831)

I think it can; done.

[samsonov]

lib/sanitizer_common/sanitizer_atomic_msvc.h

157 ↗

(On Diff #28833)

IIRC this is only available since Visual Studio 2013. I'm not aware of the minimum version we support, adding Reid.

lib/ubsan/ubsan_diag.cc

189 ↗

(On Diff #28833)

SANITIZER_WINDOWS

lib/ubsan/ubsan_flags.cc

75 ↗

(On Diff #28833)

What does this function mean?

lib/ubsan/ubsan_platform.h

20 ↗

(On Diff #28833)

Group OS together. Also, consider #including sanitizer_platform.h and using SANITIZER_LINUX, SANITIZER_WINDOWS etc.

[rnk]

lib/sanitizer_common/sanitizer_atomic_msvc.h

157 ↗

(On Diff #28833)

VS 2013 is the minimum toolchain requirement for LLVM, so this should be fine.

lib/ubsan/ubsan_flags.cc

75 ↗

(On Diff #28833)

Peter, at some point we might implement attribute weak in clang the way mingw does, where we automatically create a new symbol and a weak alias to it with the original name, so you might want to make this #elif SANITIZER_WINDOWS.

[pcc]

• Address review comments

lib/ubsan/ubsan_diag.cc

189 ↗

(On Diff #28833)

Done

lib/ubsan/ubsan_flags.cc

75 ↗

(On Diff #28833)

Did you misread line 69 of the new code as #if SANITIZER_SUPPORTS_WEAK_HOOKS? I think SANITIZER_SUPPORTS_WEAK_HOOKS means "do the sanitizers support hooks (either through attribute weak or /alternatename)" rather than "does the compiler support attribute weak". This does seem a little silly, but I was trying to be consistent with the stuff in lib/asan/asan_win.cc.

lib/ubsan/ubsan_platform.h

20 ↗

(On Diff #28833)

Group OS together.

Won't work, at least with cl.exe; that compiler does not define the architecture macros.

[samsonov]

LGTM

lib/ubsan/ubsan_platform.h

20 ↗

(On Diff #28844)

Alright... but the boolean expression is really hard to parse. Just move _WIN32 to another branch?

#if defined(_WIN32)
# define CAN_SANITIZE_UB 1
#elif (defined(__linux__) || ....
# define CAN_SANITIZE_UB 1
#else
# define CAN_SANITIZE_UB 0
#endif

[pcc]

lib/ubsan/ubsan_platform.h

20 ↗

(On Diff #28844)

Done

compiler-rt/trunk/cmake/config-ix.cmake

if("${LLVM_NATIVE_ARCH}" STREQUAL "X86")
     if(NOT MSVC)
       test_target_arch(x86_64 "" "-m64")
       # FIXME: We build runtimes for both i686 and i386, as "clang -m32" may
       # target different variant than "$CMAKE_C_COMPILER -m32". This part should
       # be gone after we resolve PR14109.
       test_target_arch(i686 __i686__ "-m32")
       test_target_arch(i386 __i386__ "-m32")
     else()
+      if (CMAKE_SIZEOF_VOID_P EQUAL 4)
         test_target_arch(i386 "" "")
+      else()
+        test_target_arch(x86_64 "" "")
+      endif()
     endif()
   elseif("${LLVM_NATIVE_ARCH}" STREQUAL "PowerPC")
     TEST_BIG_ENDIAN(HOST_IS_BIG_ENDIAN)
     if(HOST_IS_BIG_ENDIAN)
       test_target_arch(powerpc64 "" "-m64")
     else()
       test_target_arch(powerpc64le "" "-m64")
     endif()

 if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 
 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 AND CMAKE_SIZEOF_VOID_P EQUAL 4)))
+    (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 ASAN_SUPPORTED_ARCH)
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND
+    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
   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()

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD")
   set(COMPILER_RT_HAS_TSAN TRUE)
 else()
   set(COMPILER_RT_HAS_TSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Darwin|Linux|FreeBSD")
+    OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
   set(COMPILER_RT_HAS_UBSAN TRUE)
 else()
   set(COMPILER_RT_HAS_UBSAN FALSE)
 endif()
 
 # -msse3 flag is not valid for Mips therefore clang gives a warning
 # message with -msse3. But check_c_compiler_flags() checks only for
 # compiler error messages. Therefore COMPILER_RT_HAS_MSSE3_FLAG turns out to be

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

 #define SANITIZER_ATOMIC_MSVC_H
 
 extern "C" void _ReadWriteBarrier();
 #pragma intrinsic(_ReadWriteBarrier)
 extern "C" void _mm_mfence();
 #pragma intrinsic(_mm_mfence)
 extern "C" void _mm_pause();
 #pragma intrinsic(_mm_pause)
+extern "C" char _InterlockedExchange8(   // NOLINT
+    char volatile *Addend, char Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange8)
+extern "C" short _InterlockedExchange16(   // NOLINT
+    short volatile *Addend, short Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange16)
+extern "C" long _InterlockedExchange(    // NOLINT
+    long volatile *Addend, long Value);  // NOLINT
+#pragma intrinsic(_InterlockedExchange)
 extern "C" long _InterlockedExchangeAdd(  // NOLINT
     long volatile * Addend, long Value);  // NOLINT
 #pragma intrinsic(_InterlockedExchangeAdd)
 extern "C" short _InterlockedCompareExchange16(  // NOLINT
     short volatile *Destination,                 // NOLINT
     short Exchange, short Comparand);            // NOLINT
 #pragma intrinsic(_InterlockedCompareExchange16)
 extern "C"
return (uptr)_InterlockedExchangeAdd(
       (volatile long*)&a->val_dont_use, -(long)v);  // NOLINT
 #endif
 }
 
 INLINE u8 atomic_exchange(volatile atomic_uint8_t *a,
     u8 v, memory_order mo) {
   (void)mo;
   DCHECK(!((uptr)a % sizeof(*a)));
-  __asm {
-    mov eax, a
-    mov cl, v
-    xchg [eax], cl  // NOLINT
-    mov v, cl
-  }
-  return v;
+  return (u8)_InterlockedExchange8((volatile char*)&a->val_dont_use, v);
 }
 
 INLINE u16 atomic_exchange(volatile atomic_uint16_t *a,
     u16 v, memory_order mo) {
   (void)mo;
   DCHECK(!((uptr)a % sizeof(*a)));
-  __asm {
-    mov eax, a
-    mov cx, v
-    xchg [eax], cx  // NOLINT
-    mov v, cx
-  }
-  return v;
+  return (u16)_InterlockedExchange16((volatile short*)&a->val_dont_use, v);
+
+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) {
   (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);
   if (prev == cmpv)

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

 
 INLINE uptr RoundUpToPowerOfTwo(uptr size) {
   CHECK(size);
   if (IsPowerOfTwo(size)) return size;
 
   uptr up = MostSignificantSetBitIndex(size);
   CHECK(size < (1ULL << (up + 1)));
   CHECK(size > (1ULL << up));
-  return 1UL << (up + 1);
+  return 1ULL << (up + 1);
 }
 
 INLINE uptr RoundUpTo(uptr size, uptr boundary) {
   CHECK(IsPowerOfTwo(boundary));
   return (size + boundary - 1) & ~(boundary - 1);
 }
 
 INLINE uptr RoundDownTo(uptr x, uptr boundary) {

 void MaybeStartBackgroudThread();
 
 // Make the compiler think that something is going on there.
 // Use this inside a loop that looks like memset/memcpy/etc to prevent the
 // compiler from recognising it and turning it into an actual call to
 // memset/memcpy/etc.
 static inline void SanitizerBreakOptimization(void *arg) {
 #if _MSC_VER
-  // FIXME: make sure this is actually enough.
-  __asm;
+  _ReadWriteBarrier();
 #else
   __asm__ __volatile__("" : : "r" (arg) : "memory");
 #endif
 }
 
 struct SignalContext {
   void *context;
   uptr addr;

compiler-rt/trunk/lib/ubsan/ubsan_diag.cc

if (*Msg != '%') {
           Printf("%llu", (unsigned long long)A.UInt);
         else
           PrintHex(A.UInt);
         break;
       case Diag::AK_Float: {
         // FIXME: Support floating-point formatting in sanitizer_common's
         //        printf, and stop using snprintf here.
         char Buffer[32];
+#if SANITIZER_WINDOWS
+        sprintf_s(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
+#else
         snprintf(Buffer, sizeof(Buffer), "%Lg", (long double)A.Float);
+#endif
         Printf("%s", Buffer);
         break;
       }
       case Diag::AK_Pointer:
         Printf("%p", A.Pointer);
         break;
       }
     }

compiler-rt/trunk/lib/ubsan/ubsan_flags.cc

void InitializeFlags() {
   parser.ParseString(MaybeCallUbsanDefaultOptions());
   // Override from environment variable.
   parser.ParseString(GetEnv("UBSAN_OPTIONS"));
   SetVerbosity(common_flags()->verbosity);
 }
 
 }  // namespace __ubsan
 
-#if !SANITIZER_SUPPORTS_WEAK_HOOKS
 extern "C" {
+
+#if !SANITIZER_SUPPORTS_WEAK_HOOKS
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 const char *__ubsan_default_options() { return ""; }
-}  // extern "C"
 #endif
 
+#if SANITIZER_WINDOWS
+const char *__ubsan_default_default_options() { return ""; }
+#pragma comment(linker, "/alternatename:__ubsan_default_options=__ubsan_default_default_options")
+#endif
+
+}  // extern "C"
+
 #endif  // CAN_SANITIZE_UB

compiler-rt/trunk/lib/ubsan/ubsan_platform.h

 #ifndef UBSAN_PLATFORM_H
 #define UBSAN_PLATFORM_H
 
 // Other platforms should be easy to add, and probably work as-is.
 #if (defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)) && \
     (defined(__x86_64__) || defined(__i386__) || defined(__arm__) || \
      defined(__aarch64__) || defined(__mips__) || defined(__powerpc64__))
 # define CAN_SANITIZE_UB 1
+#elif defined(_WIN32)
+# define CAN_SANITIZE_UB 1
 #else
 # define CAN_SANITIZE_UB 0
 #endif
 
 #endif