[asan Win64] Implement atomic_compare_exchange_strong for 8 bit

[wang0109]

Summary

[asan Win64] Implement atomic_compare_exchange_strong for 8 bit

[etienneb]

lib/sanitizer_common/sanitizer_atomic_msvc.h

37 ↗

(On Diff #62595)

please, align the // NOLINT comment with the previous one

186 ↗

(On Diff #62595)

The 4 following line are the same on both 32/64.
Lift them after the #endif

191 ↗

(On Diff #62595)

lift this line above the #ifdef _WIN64.
The parameter is not used in both case.

[wang0109]

• update diff: remove some duplicate codes

[etienneb]

lib/sanitizer_common/sanitizer_atomic_msvc.h

190 ↗

(On Diff #62604)

I wonder if it worth keeping assembly for 32-bits if intrinsic are working.
rnk@ what do you think?

[etienneb]

I'm wondering why this unittest wasn't failing in 64-bits before you fixed the code:

TEST(SanitizerCommon, AtomicCompareExchangeTest) {

[etienneb]

As I get it, the unittests are using the clang version.
Which means there is no coverage for the MSVC atomics operation.

#if defined(__clang__) || defined(__GNUC__)
# include "sanitizer_atomic_clang.h"
#elif defined(_MSC_VER)
# include "sanitizer_atomic_msvc.h"
#else
# error "Unsupported compiler"
#endif

[rnk]

lgtm

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

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" char _InterlockedCompareExchange8(  // NOLINT
+    char volatile *Destination,                // NOLINT
+    char Exchange, char Comparand);            // NOLINT
+#pragma intrinsic(_InterlockedCompareExchange8)
 extern "C" short _InterlockedCompareExchange16(  // NOLINT
     short volatile *Destination,                 // NOLINT
     short Exchange, short Comparand);            // NOLINT
 #pragma intrinsic(_InterlockedCompareExchange16)
 extern "C"
 long long _InterlockedCompareExchange64(  // NOLINT
     long long volatile *Destination,              // NOLINT
     long long Exchange, long long Comparand);     // NOLINT
INLINE u32 atomic_exchange(volatile atomic_uint32_t *a,
   DCHECK(!((uptr)a % sizeof(*a)));
   return (u32)_InterlockedExchange((volatile long*)&a->val_dont_use, v);
 }
 
 INLINE bool atomic_compare_exchange_strong(volatile atomic_uint8_t *a,
                                            u8 *cmp,
                                            u8 xchgv,
                                            memory_order mo) {
-#ifdef _WIN64
-  // TODO(wwchrome): 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;
+#ifdef _WIN64
+  u8 prev = (u8)_InterlockedCompareExchange8(
+      (volatile char*)&a->val_dont_use, (char)xchgv, (char)cmpv);
+#else
   u8 prev;
   __asm {
     mov al, cmpv
     mov ecx, a
     mov dl, xchgv
     lock cmpxchg [ecx], dl
     mov prev, al
   }
+#endif
   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(