libasan/sanitizer_common/sanitizer_atomic_msvc.h

   1 //===-- sanitizer_atomic_msvc.h ---------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
   9 // Not intended for direct inclusion. Include sanitizer_atomic.h.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef SANITIZER_ATOMIC_MSVC_H
  14 #define SANITIZER_ATOMIC_MSVC_H
  15
  16 extern "C" void _ReadWriteBarrier();
  17 #pragma intrinsic(_ReadWriteBarrier)
  18 extern "C" void _mm_mfence();
  19 #pragma intrinsic(_mm_mfence)
  20 extern "C" void _mm_pause();
  21 #pragma intrinsic(_mm_pause)
  22 extern "C" long _InterlockedExchangeAdd(  // NOLINT
  23     long volatile * Addend, long Value);  // NOLINT
  24 #pragma intrinsic(_InterlockedExchangeAdd)
  25 extern "C" void *InterlockedCompareExchangePointer(
  26     void *volatile *Destination,
  27     void *Exchange, void *Comparand);
  28
  29 namespace __sanitizer {
  30
  31 INLINE void atomic_signal_fence(memory_order) {
  32   _ReadWriteBarrier();
  33 }
  34
  35 INLINE void atomic_thread_fence(memory_order) {
  36   _mm_mfence();
  37 }
  38
  39 INLINE void proc_yield(int cnt) {
  40   for (int i = 0; i < cnt; i++)
  41     _mm_pause();
  42 }
  43
  44 template<typename T>
  45 INLINE typename T::Type atomic_load(
  46     const volatile T *a, memory_order mo) {
  47   DCHECK(mo & (memory_order_relaxed | memory_order_consume
  48       | memory_order_acquire | memory_order_seq_cst));
  49   DCHECK(!((uptr)a % sizeof(*a)));
  50   typename T::Type v;
  51   if (mo == memory_order_relaxed) {
  52     v = a->val_dont_use;
  53   } else {
  54     atomic_signal_fence(memory_order_seq_cst);
  55     v = a->val_dont_use;
  56     atomic_signal_fence(memory_order_seq_cst);
  57   }
  58   return v;
  59 }
  60
  61 template<typename T>
  62 INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
  63   DCHECK(mo & (memory_order_relaxed | memory_order_release
  64       | memory_order_seq_cst));
  65   DCHECK(!((uptr)a % sizeof(*a)));
  66   if (mo == memory_order_relaxed) {
  67     a->val_dont_use = v;
  68   } else {
  69     atomic_signal_fence(memory_order_seq_cst);
  70     a->val_dont_use = v;
  71     atomic_signal_fence(memory_order_seq_cst);
  72   }
  73   if (mo == memory_order_seq_cst)
  74     atomic_thread_fence(memory_order_seq_cst);
  75 }
  76
  77 INLINE u32 atomic_fetch_add(volatile atomic_uint32_t *a,
  78     u32 v, memory_order mo) {
  79   (void)mo;
  80   DCHECK(!((uptr)a % sizeof(*a)));
  81   return (u32)_InterlockedExchangeAdd(
  82       (volatile long*)&a->val_dont_use, (long)v);  // NOLINT
  83 }
  84
  85 INLINE u8 atomic_exchange(volatile atomic_uint8_t *a,
  86     u8 v, memory_order mo) {
  87   (void)mo;
  88   DCHECK(!((uptr)a % sizeof(*a)));
  89   __asm {
  90     mov eax, a
  91     mov cl, v
  92     xchg [eax], cl  // NOLINT
  93     mov v, cl
  94   }
  95   return v;
  96 }
  97
  98 INLINE u16 atomic_exchange(volatile atomic_uint16_t *a,
  99     u16 v, memory_order mo) {
 100   (void)mo;
 101   DCHECK(!((uptr)a % sizeof(*a)));
 102   __asm {
 103     mov eax, a
 104     mov cx, v
 105     xchg [eax], cx  // NOLINT
 106     mov v, cx
 107   }
 108   return v;
 109 }
 110
 111 INLINE bool atomic_compare_exchange_strong(volatile atomic_uintptr_t *a,
 112                                            uptr *cmp,
 113                                            uptr xchg,
 114                                            memory_order mo) {
 115   uptr cmpv = *cmp;
 116   uptr prev = (uptr)InterlockedCompareExchangePointer(
 117       (void*volatile*)&a->val_dont_use, (void*)xchg, (void*)cmpv);
 118   if (prev == cmpv)
 119     return true;
 120   *cmp = prev;
 121   return false;
 122 }
 123
 124 template<typename T>
 125 INLINE bool atomic_compare_exchange_weak(volatile T *a,
 126                                            typename T::Type *cmp,
 127                                            typename T::Type xchg,
 128                                            memory_order mo) {
 129   return atomic_compare_exchange_strong(a, cmp, xchg, mo);
 130 }
 131
 132 }  // namespace __sanitizer
 133
 134 #endif  // SANITIZER_ATOMIC_CLANG_H