[thirdparty/gcc.git] / libsanitizer / sanitizer_common / sanitizer_atomic_msvc.h

//===-- sanitizer_atomic_msvc.h ---------------------------------*- C++ -*-===//
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is a part of ThreadSanitizer/AddressSanitizer runtime.
// Not intended for direct inclusion. Include sanitizer_atomic.h.
//
//===----------------------------------------------------------------------===//

#ifndef 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" 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"
long long _InterlockedCompareExchange64(  // NOLINT
    long long volatile *Destination,              // NOLINT
    long long Exchange, long long Comparand);     // NOLINT
#pragma intrinsic(_InterlockedCompareExchange64)

#ifdef _WIN64
extern "C" long long _InterlockedExchangeAdd64(     // NOLINT
    long long volatile * Addend, long long Value);  // NOLINT
#pragma intrinsic(_InterlockedExchangeAdd64)
extern "C" void *_InterlockedCompareExchangePointer(
    void *volatile *Destination,
    void *Exchange, void *Comparand);
#pragma intrinsic(_InterlockedCompareExchangePointer)
#else
// There's no _InterlockedCompareExchangePointer intrinsic on x86,
// so call _InterlockedCompareExchange instead.
extern "C"
long __cdecl _InterlockedCompareExchange(  // NOLINT
    long volatile *Destination,            // NOLINT
    long Exchange, long Comparand);        // NOLINT
#pragma intrinsic(_InterlockedCompareExchange)

inline static void *_InterlockedCompareExchangePointer(
    void *volatile *Destination,
    void *Exchange, void *Comparand) {
  return reinterpret_cast<void*>(
      _InterlockedCompareExchange(
          reinterpret_cast<long volatile*>(Destination),  // NOLINT
          reinterpret_cast<long>(Exchange),               // NOLINT
          reinterpret_cast<long>(Comparand)));            // NOLINT
}
#endif

namespace __sanitizer {

INLINE void atomic_signal_fence(memory_order) {
  _ReadWriteBarrier();
}

INLINE void atomic_thread_fence(memory_order) {
  _mm_mfence();
}

INLINE void proc_yield(int cnt) {
  for (int i = 0; i < cnt; i++)
    _mm_pause();
}

template<typename T>
INLINE typename T::Type atomic_load(
    const volatile T *a, memory_order mo) {
  DCHECK(mo & (memory_order_relaxed | memory_order_consume
      | memory_order_acquire | memory_order_seq_cst));
  DCHECK(!((uptr)a % sizeof(*a)));
  typename T::Type v;
  // FIXME(dvyukov): 64-bit load is not atomic on 32-bits.
  if (mo == memory_order_relaxed) {
    v = a->val_dont_use;
  } else {
    atomic_signal_fence(memory_order_seq_cst);
    v = a->val_dont_use;
    atomic_signal_fence(memory_order_seq_cst);
  }
  return v;
}

template<typename T>
INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
  DCHECK(mo & (memory_order_relaxed | memory_order_release
      | memory_order_seq_cst));
  DCHECK(!((uptr)a % sizeof(*a)));
  // FIXME(dvyukov): 64-bit store is not atomic on 32-bits.
  if (mo == memory_order_relaxed) {
    a->val_dont_use = v;
  } else {
    atomic_signal_fence(memory_order_seq_cst);
    a->val_dont_use = v;
    atomic_signal_fence(memory_order_seq_cst);
  }
  if (mo == memory_order_seq_cst)
    atomic_thread_fence(memory_order_seq_cst);
}

INLINE u32 atomic_fetch_add(volatile atomic_uint32_t *a,
    u32 v, memory_order mo) {
  (void)mo;
  DCHECK(!((uptr)a % sizeof(*a)));
  return (u32)_InterlockedExchangeAdd(
      (volatile long*)&a->val_dont_use, (long)v);  // NOLINT
}

INLINE uptr atomic_fetch_add(volatile atomic_uintptr_t *a,
    uptr v, memory_order mo) {
  (void)mo;
  DCHECK(!((uptr)a % sizeof(*a)));
#ifdef _WIN64
  return (uptr)_InterlockedExchangeAdd64(
      (volatile long long*)&a->val_dont_use, (long long)v);  // NOLINT
#else
  return (uptr)_InterlockedExchangeAdd(
      (volatile long*)&a->val_dont_use, (long)v);  // NOLINT
#endif
}

INLINE u32 atomic_fetch_sub(volatile atomic_uint32_t *a,
    u32 v, memory_order mo) {
  (void)mo;
  DCHECK(!((uptr)a % sizeof(*a)));
  return (u32)_InterlockedExchangeAdd(
      (volatile long*)&a->val_dont_use, -(long)v);  // NOLINT
}

INLINE uptr atomic_fetch_sub(volatile atomic_uintptr_t *a,
    uptr v, memory_order mo) {
  (void)mo;
  DCHECK(!((uptr)a % sizeof(*a)));
#ifdef _WIN64
  return (uptr)_InterlockedExchangeAdd64(
      (volatile long long*)&a->val_dont_use, -(long long)v);  // NOLINT
#else
  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;
}

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;
}

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;
}

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)
    return true;
  *cmp = prev;
  return false;
}

INLINE bool atomic_compare_exchange_strong(volatile atomic_uint16_t *a,
                                           u16 *cmp,
                                           u16 xchg,
                                           memory_order mo) {
  u16 cmpv = *cmp;
  u16 prev = (u16)_InterlockedCompareExchange16(
      (volatile short*)&a->val_dont_use, (short)xchg, (short)cmpv);
  if (prev == cmpv)
    return true;
  *cmp = prev;
  return false;
}

INLINE bool atomic_compare_exchange_strong(volatile atomic_uint32_t *a,
                                           u32 *cmp,
                                           u32 xchg,
                                           memory_order mo) {
  u32 cmpv = *cmp;
  u32 prev = (u32)_InterlockedCompareExchange(
      (volatile long*)&a->val_dont_use, (long)xchg, (long)cmpv);
  if (prev == cmpv)
    return true;
  *cmp = prev;
  return false;
}

INLINE bool atomic_compare_exchange_strong(volatile atomic_uint64_t *a,
                                           u64 *cmp,
                                           u64 xchg,
                                           memory_order mo) {
  u64 cmpv = *cmp;
  u64 prev = (u64)_InterlockedCompareExchange64(
      (volatile long long*)&a->val_dont_use, (long long)xchg, (long long)cmpv);
  if (prev == cmpv)
    return true;
  *cmp = prev;
  return false;
}

template<typename T>
INLINE bool atomic_compare_exchange_weak(volatile T *a,
                                         typename T::Type *cmp,
                                         typename T::Type xchg,
                                         memory_order mo) {
  return atomic_compare_exchange_strong(a, cmp, xchg, mo);
}

}  // namespace __sanitizer

#endif  // SANITIZER_ATOMIC_CLANG_H
Commit	Line	Data
f35db108 WM	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)
dee5ea7a KS	25	extern "C" short _InterlockedCompareExchange16( // NOLINT
	26	short volatile *Destination, // NOLINT
	27	short Exchange, short Comparand); // NOLINT
	28	#pragma intrinsic(_InterlockedCompareExchange16)
	29	extern "C"
	30	long long _InterlockedCompareExchange64( // NOLINT
	31	long long volatile *Destination, // NOLINT
	32	long long Exchange, long long Comparand); // NOLINT
	33	#pragma intrinsic(_InterlockedCompareExchange64)
e9772e16 KS	34
e9772e16 KS	35	#ifdef _WIN64
dee5ea7a KS	36	extern "C" long long _InterlockedExchangeAdd64( // NOLINT
	37	long long volatile * Addend, long long Value); // NOLINT
	38	#pragma intrinsic(_InterlockedExchangeAdd64)
e9772e16	39	extern "C" void *_InterlockedCompareExchangePointer(
f35db108 WM	40	void volatile Destination,
f35db108 WM	41	void Exchange, void Comparand);
e9772e16 KS	42	#pragma intrinsic(_InterlockedCompareExchangePointer)
	43	#else
	44	// There's no _InterlockedCompareExchangePointer intrinsic on x86,
	45	// so call _InterlockedCompareExchange instead.
	46	extern "C"
	47	long __cdecl _InterlockedCompareExchange( // NOLINT
	48	long volatile *Destination, // NOLINT
	49	long Exchange, long Comparand); // NOLINT
	50	#pragma intrinsic(_InterlockedCompareExchange)
	51
	52	inline static void *_InterlockedCompareExchangePointer(
	53	void volatile Destination,
	54	void Exchange, void Comparand) {
	55	return reinterpret_cast<void*>(
	56	_InterlockedCompareExchange(
	57	reinterpret_cast<long volatile*>(Destination), // NOLINT
	58	reinterpret_cast<long>(Exchange), // NOLINT
	59	reinterpret_cast<long>(Comparand))); // NOLINT
	60	}
	61	#endif
f35db108 WM	62
	63	namespace __sanitizer {
	64
	65	INLINE void atomic_signal_fence(memory_order) {
	66	_ReadWriteBarrier();
	67	}
	68
	69	INLINE void atomic_thread_fence(memory_order) {
	70	_mm_mfence();
	71	}
	72
	73	INLINE void proc_yield(int cnt) {
	74	for (int i = 0; i < cnt; i++)
	75	_mm_pause();
	76	}
	77
	78	template<typename T>
	79	INLINE typename T::Type atomic_load(
	80	const volatile T *a, memory_order mo) {
	81	DCHECK(mo & (memory_order_relaxed \| memory_order_consume
	82	\| memory_order_acquire \| memory_order_seq_cst));
	83	DCHECK(!((uptr)a % sizeof(*a)));
	84	typename T::Type v;
2660d12d	85	// FIXME(dvyukov): 64-bit load is not atomic on 32-bits.
f35db108 WM	86	if (mo == memory_order_relaxed) {
	87	v = a->val_dont_use;
	88	} else {
	89	atomic_signal_fence(memory_order_seq_cst);
	90	v = a->val_dont_use;
	91	atomic_signal_fence(memory_order_seq_cst);
	92	}
	93	return v;
	94	}
	95
	96	template<typename T>
	97	INLINE void atomic_store(volatile T *a, typename T::Type v, memory_order mo) {
	98	DCHECK(mo & (memory_order_relaxed \| memory_order_release
	99	\| memory_order_seq_cst));
	100	DCHECK(!((uptr)a % sizeof(*a)));
2660d12d	101	// FIXME(dvyukov): 64-bit store is not atomic on 32-bits.
f35db108 WM	102	if (mo == memory_order_relaxed) {
	103	a->val_dont_use = v;
	104	} else {
	105	atomic_signal_fence(memory_order_seq_cst);
	106	a->val_dont_use = v;
	107	atomic_signal_fence(memory_order_seq_cst);
	108	}
	109	if (mo == memory_order_seq_cst)
	110	atomic_thread_fence(memory_order_seq_cst);
	111	}
	112
	113	INLINE u32 atomic_fetch_add(volatile atomic_uint32_t *a,
	114	u32 v, memory_order mo) {
	115	(void)mo;
	116	DCHECK(!((uptr)a % sizeof(*a)));
	117	return (u32)_InterlockedExchangeAdd(
	118	(volatile long*)&a->val_dont_use, (long)v); // NOLINT
	119	}
	120
dee5ea7a KS	121	INLINE uptr atomic_fetch_add(volatile atomic_uintptr_t *a,
	122	uptr v, memory_order mo) {
	123	(void)mo;
	124	DCHECK(!((uptr)a % sizeof(*a)));
	125	#ifdef _WIN64
	126	return (uptr)_InterlockedExchangeAdd64(
	127	(volatile long long*)&a->val_dont_use, (long long)v); // NOLINT
	128	#else
	129	return (uptr)_InterlockedExchangeAdd(
	130	(volatile long*)&a->val_dont_use, (long)v); // NOLINT
	131	#endif
	132	}
	133
	134	INLINE u32 atomic_fetch_sub(volatile atomic_uint32_t *a,
	135	u32 v, memory_order mo) {
	136	(void)mo;
	137	DCHECK(!((uptr)a % sizeof(*a)));
	138	return (u32)_InterlockedExchangeAdd(
	139	(volatile long*)&a->val_dont_use, -(long)v); // NOLINT
	140	}
	141
	142	INLINE uptr atomic_fetch_sub(volatile atomic_uintptr_t *a,
	143	uptr v, memory_order mo) {
	144	(void)mo;
	145	DCHECK(!((uptr)a % sizeof(*a)));
	146	#ifdef _WIN64
	147	return (uptr)_InterlockedExchangeAdd64(
	148	(volatile long long*)&a->val_dont_use, -(long long)v); // NOLINT
	149	#else
	150	return (uptr)_InterlockedExchangeAdd(
	151	(volatile long*)&a->val_dont_use, -(long)v); // NOLINT
	152	#endif
	153	}
	154
f35db108 WM	155	INLINE u8 atomic_exchange(volatile atomic_uint8_t *a,
	156	u8 v, memory_order mo) {
	157	(void)mo;
	158	DCHECK(!((uptr)a % sizeof(*a)));
	159	__asm {
	160	mov eax, a
	161	mov cl, v
	162	xchg [eax], cl // NOLINT
	163	mov v, cl
	164	}
	165	return v;
	166	}
	167
	168	INLINE u16 atomic_exchange(volatile atomic_uint16_t *a,
	169	u16 v, memory_order mo) {
	170	(void)mo;
	171	DCHECK(!((uptr)a % sizeof(*a)));
	172	__asm {
	173	mov eax, a
	174	mov cx, v
	175	xchg [eax], cx // NOLINT
	176	mov v, cx
	177	}
	178	return v;
	179	}
	180
ef1b3fda KS	181	INLINE bool atomic_compare_exchange_strong(volatile atomic_uint8_t *a,
	182	u8 *cmp,
	183	u8 xchgv,
	184	memory_order mo) {
	185	(void)mo;
	186	DCHECK(!((uptr)a % sizeof(*a)));
	187	u8 cmpv = *cmp;
	188	u8 prev;
	189	__asm {
	190	mov al, cmpv
	191	mov ecx, a
	192	mov dl, xchgv
	193	lock cmpxchg [ecx], dl
	194	mov prev, al
	195	}
	196	if (prev == cmpv)
	197	return true;
	198	*cmp = prev;
	199	return false;
	200	}
	201
f35db108 WM	202	INLINE bool atomic_compare_exchange_strong(volatile atomic_uintptr_t *a,
	203	uptr *cmp,
	204	uptr xchg,
	205	memory_order mo) {
	206	uptr cmpv = *cmp;
e9772e16	207	uptr prev = (uptr)_InterlockedCompareExchangePointer(
f35db108 WM	208	(voidvolatile)&a->val_dont_use, (void)xchg, (void)cmpv);
	209	if (prev == cmpv)
	210	return true;
	211	*cmp = prev;
	212	return false;
	213	}
	214
dee5ea7a KS	215	INLINE bool atomic_compare_exchange_strong(volatile atomic_uint16_t *a,
	216	u16 *cmp,
	217	u16 xchg,
	218	memory_order mo) {
	219	u16 cmpv = *cmp;
	220	u16 prev = (u16)_InterlockedCompareExchange16(
	221	(volatile short*)&a->val_dont_use, (short)xchg, (short)cmpv);
	222	if (prev == cmpv)
	223	return true;
	224	*cmp = prev;
	225	return false;
	226	}
	227
	228	INLINE bool atomic_compare_exchange_strong(volatile atomic_uint32_t *a,
	229	u32 *cmp,
	230	u32 xchg,
	231	memory_order mo) {
	232	u32 cmpv = *cmp;
	233	u32 prev = (u32)_InterlockedCompareExchange(
	234	(volatile long*)&a->val_dont_use, (long)xchg, (long)cmpv);
	235	if (prev == cmpv)
	236	return true;
	237	*cmp = prev;
	238	return false;
	239	}
	240
	241	INLINE bool atomic_compare_exchange_strong(volatile atomic_uint64_t *a,
	242	u64 *cmp,
	243	u64 xchg,
	244	memory_order mo) {
	245	u64 cmpv = *cmp;
	246	u64 prev = (u64)_InterlockedCompareExchange64(
	247	(volatile long long*)&a->val_dont_use, (long long)xchg, (long long)cmpv);
	248	if (prev == cmpv)
	249	return true;
	250	*cmp = prev;
	251	return false;
	252	}
	253
f35db108 WM	254	template<typename T>
f35db108 WM	255	INLINE bool atomic_compare_exchange_weak(volatile T *a,
ef1b3fda KS	256	typename T::Type *cmp,
	257	typename T::Type xchg,
	258	memory_order mo) {
f35db108 WM	259	return atomic_compare_exchange_strong(a, cmp, xchg, mo);
	260	}
	261
	262	} // namespace __sanitizer
	263
	264	#endif // SANITIZER_ATOMIC_CLANG_H