#include <xatomic0.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <intrin.h>
#include <xutility>

Macros
#define	_XATOMIC_H

#define	_Compiler_barrier() _ReadWriteBarrier()

#define	_CONCATX(x, y) x ## y

#define	_CONCAT(x, y) _CONCATX(x, y)

#define	ATOMIC_BOOL_LOCK_FREE (1 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_CHAR_LOCK_FREE (1 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_CHAR16_T_LOCK_FREE (2 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_CHAR32_T_LOCK_FREE (2 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_WCHAR_T_LOCK_FREE (_WCHAR_T_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_SHORT_LOCK_FREE (_SHORT_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_INT_LOCK_FREE (_INT_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_LONG_LOCK_FREE (_LONG_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_ATOMIC_LLONG_LOCK_FREE (_LONGLONG_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	ATOMIC_POINTER_LOCK_FREE (_ADDR_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define	_INTRIN_RELAXED(x) x

#define	_INTRIN_ACQUIRE(x) x

#define	_INTRIN_RELEASE(x) x

#define	_INTRIN_SEQ_CST(x) x

#define	_ATOMIC_FLAG_TEST_AND_SET _Atomic_flag_test_and_set

#define	_ATOMIC_FLAG_CLEAR _Atomic_flag_clear

#define	_ATOMIC_THREAD_FENCE _Atomic_thread_fence

#define	_ATOMIC_SIGNAL_FENCE _Atomic_signal_fence

#define	_INVALID_MEMORY_ORDER

#define	_YIELD_PROCESSOR

Typedefs
typedef unsigned short	_Uint2_t

typedef unsigned _LONGLONG	_Uint8_t

Functions
memory_order	_Memory_order_upper_bound (memory_order _Order1, memory_order _Order2)

void	_Validate_compare_exchange_memory_order (memory_order _Success, memory_order _Failure)

void	_Store_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

void	_Store_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

void	_Store_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

void	_Atomic_store_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

_Uint1_t	_Load_seq_cst_1 (volatile _Uint1_t *_Tgt)

_Uint1_t	_Load_relaxed_1 (volatile _Uint1_t *_Tgt)

_Uint1_t	_Load_acquire_1 (volatile _Uint1_t *_Tgt)

_Uint1_t	_Atomic_load_1 (volatile _Uint1_t *_Tgt, memory_order _Order)

_Uint1_t	_Exchange_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Exchange_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Exchange_acquire_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Exchange_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Atomic_exchange_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

int	_Compare_exchange_seq_cst_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value)

int	_Compare_exchange_relaxed_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value)

int	_Compare_exchange_acquire_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value)

int	_Compare_exchange_release_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value)

int	_Atomic_compare_exchange_strong_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value, memory_order _Order1, memory_order _Order2)

int	_Atomic_compare_exchange_weak_1 (volatile _Uint1_t _Tgt, _Uint1_t _Exp, _Uint1_t _Value, memory_order _Order1, memory_order _Order2)

_Uint1_t	_Fetch_add_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_add_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_add_acquire_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_add_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Atomic_fetch_add_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

_Uint1_t	_Atomic_fetch_sub_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

_Uint1_t	_Fetch_and_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_and_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_and_acquire_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_and_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Atomic_fetch_and_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

_Uint1_t	_Fetch_or_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_or_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_or_acquire_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_or_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Atomic_fetch_or_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

_Uint1_t	_Fetch_xor_seq_cst_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_xor_relaxed_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_xor_acquire_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Fetch_xor_release_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value)

_Uint1_t	_Atomic_fetch_xor_1 (volatile _Uint1_t *_Tgt, _Uint1_t _Value, memory_order _Order)

void	_Store_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

void	_Store_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

void	_Store_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

void	_Atomic_store_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

_Uint2_t	_Load_seq_cst_2 (volatile _Uint2_t *_Tgt)

_Uint2_t	_Load_relaxed_2 (volatile _Uint2_t *_Tgt)

_Uint2_t	_Load_acquire_2 (volatile _Uint2_t *_Tgt)

_Uint2_t	_Atomic_load_2 (volatile _Uint2_t *_Tgt, memory_order _Order)

_Uint2_t	_Exchange_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Exchange_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Exchange_acquire_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Exchange_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Atomic_exchange_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

int	_Compare_exchange_seq_cst_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value)

int	_Compare_exchange_relaxed_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value)

int	_Compare_exchange_acquire_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value)

int	_Compare_exchange_release_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value)

int	_Atomic_compare_exchange_strong_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value, memory_order _Order1, memory_order _Order2)

int	_Atomic_compare_exchange_weak_2 (volatile _Uint2_t _Tgt, _Uint2_t _Exp, _Uint2_t _Value, memory_order _Order1, memory_order _Order2)

_Uint2_t	_Fetch_add_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_add_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_add_acquire_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_add_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Atomic_fetch_add_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

_Uint2_t	_Atomic_fetch_sub_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

_Uint2_t	_Fetch_and_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_and_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_and_acquire_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_and_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Atomic_fetch_and_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

_Uint2_t	_Fetch_or_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_or_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_or_acquire_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_or_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Atomic_fetch_or_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

_Uint2_t	_Fetch_xor_seq_cst_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_xor_relaxed_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_xor_acquire_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Fetch_xor_release_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value)

_Uint2_t	_Atomic_fetch_xor_2 (volatile _Uint2_t *_Tgt, _Uint2_t _Value, memory_order _Order)

void	_Store_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

void	_Store_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

void	_Store_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

void	_Atomic_store_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

_Uint4_t	_Load_seq_cst_4 (volatile _Uint4_t *_Tgt)

_Uint4_t	_Load_relaxed_4 (volatile _Uint4_t *_Tgt)

_Uint4_t	_Load_acquire_4 (volatile _Uint4_t *_Tgt)

_Uint4_t	_Atomic_load_4 (volatile _Uint4_t *_Tgt, memory_order _Order)

_Uint4_t	_Exchange_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Exchange_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Exchange_acquire_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Exchange_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Atomic_exchange_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

int	_Compare_exchange_seq_cst_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value)

int	_Compare_exchange_relaxed_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value)

int	_Compare_exchange_acquire_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value)

int	_Compare_exchange_release_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value)

int	_Atomic_compare_exchange_strong_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value, memory_order _Order1, memory_order _Order2)

int	_Atomic_compare_exchange_weak_4 (volatile _Uint4_t _Tgt, _Uint4_t _Exp, _Uint4_t _Value, memory_order _Order1, memory_order _Order2)

_Uint4_t	_Fetch_add_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_add_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_add_acquire_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_add_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Atomic_fetch_add_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

_Uint4_t	_Atomic_fetch_sub_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

_Uint4_t	_Fetch_and_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_and_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_and_acquire_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_and_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Atomic_fetch_and_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

_Uint4_t	_Fetch_or_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_or_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_or_acquire_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_or_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Atomic_fetch_or_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

_Uint4_t	_Fetch_xor_seq_cst_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_xor_relaxed_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_xor_acquire_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Fetch_xor_release_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value)

_Uint4_t	_Atomic_fetch_xor_4 (volatile _Uint4_t *_Tgt, _Uint4_t _Value, memory_order _Order)

void	_Store_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

void	_Store_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

void	_Store_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

void	_Atomic_store_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

_Uint8_t	_Load_seq_cst_8 (volatile _Uint8_t *_Tgt)

_Uint8_t	_Load_relaxed_8 (volatile _Uint8_t *_Tgt)

_Uint8_t	_Load_acquire_8 (volatile _Uint8_t *_Tgt)

_Uint8_t	_Atomic_load_8 (volatile _Uint8_t *_Tgt, memory_order _Order)

_Uint8_t	_Exchange_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Exchange_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Exchange_acquire_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Exchange_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Atomic_exchange_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

int	_Compare_exchange_seq_cst_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value)

int	_Compare_exchange_relaxed_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value)

int	_Compare_exchange_acquire_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value)

int	_Compare_exchange_release_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value)

int	_Atomic_compare_exchange_strong_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value, memory_order _Order1, memory_order _Order2)

int	_Atomic_compare_exchange_weak_8 (volatile _Uint8_t _Tgt, _Uint8_t _Exp, _Uint8_t _Value, memory_order _Order1, memory_order _Order2)

_Uint8_t	_Fetch_add_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_add_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_add_acquire_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_add_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Atomic_fetch_add_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

_Uint8_t	_Atomic_fetch_sub_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

_Uint8_t	_Fetch_and_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_and_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_and_acquire_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_and_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Atomic_fetch_and_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

_Uint8_t	_Fetch_or_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_or_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_or_acquire_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_or_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Atomic_fetch_or_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

_Uint8_t	_Fetch_xor_seq_cst_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_xor_relaxed_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_xor_acquire_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Fetch_xor_release_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value)

_Uint8_t	_Atomic_fetch_xor_8 (volatile _Uint8_t *_Tgt, _Uint8_t _Value, memory_order _Order)

int	_Atomic_flag_test_and_set (volatile _Atomic_flag_t *_Flag, memory_order _Order)

void	_Atomic_flag_clear (volatile _Atomic_flag_t *_Flag, memory_order _Order)

void	_Atomic_thread_fence (memory_order _Order)

void	_Atomic_signal_fence (memory_order _Order)

void	_Lock_spin_lock (volatile _Atomic_flag_t *_Flag)

void	_Unlock_spin_lock (volatile _Atomic_flag_t *_Flag)

void	_Atomic_copy (volatile _Atomic_flag_t _Flag, size_t _Size, volatile void _Tgt, volatile const void *_Src, memory_order _Order)

void	_Atomic_exchange (volatile _Atomic_flag_t _Flag, size_t _Size, volatile void _Tgt, volatile void *_Src, memory_order _Order)

int	_Atomic_compare_exchange_weak (volatile _Atomic_flag_t _Flag, size_t _Size, volatile void _Tgt, volatile void _Exp, const volatile void _Src, memory_order _Order1, memory_order _Order2)

int	_Atomic_compare_exchange_strong (volatile _Atomic_flag_t _Flag, size_t _Size, volatile void _Tgt, volatile void _Exp, const volatile void _Src, memory_order _Order1, memory_order _Order2)

int	_Atomic_is_lock_free_1 (void)

int	_Atomic_is_lock_free_2 (void)

int	_Atomic_is_lock_free_4 (void)

int	_Atomic_is_lock_free_8 (void)

_Atomic_integral_t	_Inc_atomic_counter_explicit (_Atomic_counter_t &_Counter, memory_order _Order)

_Atomic_integral_t	_Inc_atomic_counter (_Atomic_counter_t &_Counter)

_Atomic_integral_t	_Dec_atomic_counter_explicit (_Atomic_counter_t &_Counter, memory_order _Order)

_Atomic_integral_t	_Dec_atomic_counter (_Atomic_counter_t &_Counter)

_Atomic_integral_t	_Load_atomic_counter_explicit (_Atomic_counter_t &_Counter, memory_order _Order)

_Atomic_integral_t	_Load_atomic_counter (_Atomic_counter_t &_Counter)

_Atomic_integral_t	_Compare_increment_atomic_counter_explicit (_Atomic_counter_t &_Counter, _Atomic_integral_t _Expected, memory_order _Order)

_Atomic_integral_t	_Compare_increment_atomic_counter (_Atomic_counter_t &_Counter, _Atomic_integral_t _Expected)

Variables
_STD_BEGIN typedef unsigned char	_Uint1_t

Macro Definition Documentation

#define _ATOMIC_CHAR16_T_LOCK_FREE (2 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_CHAR32_T_LOCK_FREE (2 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_CHAR_LOCK_FREE (1 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_FLAG_CLEAR _Atomic_flag_clear

#define _ATOMIC_FLAG_TEST_AND_SET _Atomic_flag_test_and_set

#define _ATOMIC_INT_LOCK_FREE (_INT_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_LLONG_LOCK_FREE (_LONGLONG_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_LONG_LOCK_FREE (_LONG_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_SHORT_LOCK_FREE (_SHORT_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _ATOMIC_SIGNAL_FENCE _Atomic_signal_fence

#define _ATOMIC_THREAD_FENCE _Atomic_thread_fence

#define _ATOMIC_WCHAR_T_LOCK_FREE (_WCHAR_T_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define _Compiler_barrier ( ) _ReadWriteBarrier()

#define _CONCAT	(	x,
		y
	)	_CONCATX(x, y)

#define _CONCATX	(	x,
		y
	)	x ## y

#define _INTRIN_ACQUIRE ( x ) x

#define _INTRIN_RELAXED ( x ) x

#define _INTRIN_RELEASE ( x ) x

#define _INTRIN_SEQ_CST ( x ) x

#define _INVALID_MEMORY_ORDER

#define _XATOMIC_H

#define _YIELD_PROCESSOR

#define ATOMIC_BOOL_LOCK_FREE (1 <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

#define ATOMIC_POINTER_LOCK_FREE (_ADDR_SIZE <= _ATOMIC_MAXBYTES_LOCK_FREE ? 2 : 0)

Typedef Documentation

typedef unsigned short _Uint2_t

typedef unsigned _LONGLONG _Uint8_t

Function Documentation

int _Atomic_compare_exchange_strong	(	volatile _Atomic_flag_t *	_Flag,
		size_t	_Size,
		volatile void *	_Tgt,
		volatile void *	_Exp,
		const volatile void *	_Src,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* atomically compare and exchange with memory ordering */
     return (_Atomic_compare_exchange_weak(_Flag, _Size, _Tgt, _Exp, _Src,
         _Order1, _Order2));
     }

int _Atomic_compare_exchange_strong_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     _Validate_compare_exchange_memory_order(_Order1, _Order2);
 
     switch (_Memory_order_upper_bound(_Order1, _Order2))
         {
         case memory_order_relaxed:
             return (_Compare_exchange_relaxed_1(_Tgt, _Exp, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Compare_exchange_acquire_1(_Tgt, _Exp, _Value));
 
         case memory_order_release:
             return (_Compare_exchange_release_1(_Tgt, _Exp, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Compare_exchange_seq_cst_1(_Tgt, _Exp, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

int _Atomic_compare_exchange_strong_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     _Validate_compare_exchange_memory_order(_Order1, _Order2);
 
     switch (_Memory_order_upper_bound(_Order1, _Order2))
         {
         case memory_order_relaxed:
             return (_Compare_exchange_relaxed_2(_Tgt, _Exp, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Compare_exchange_acquire_2(_Tgt, _Exp, _Value));
 
         case memory_order_release:
             return (_Compare_exchange_release_2(_Tgt, _Exp, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Compare_exchange_seq_cst_2(_Tgt, _Exp, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

int _Atomic_compare_exchange_strong_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     _Validate_compare_exchange_memory_order(_Order1, _Order2);
 
     switch (_Memory_order_upper_bound(_Order1, _Order2))
         {
         case memory_order_relaxed:
             return (_Compare_exchange_relaxed_4(_Tgt, _Exp, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Compare_exchange_acquire_4(_Tgt, _Exp, _Value));
 
         case memory_order_release:
             return (_Compare_exchange_release_4(_Tgt, _Exp, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Compare_exchange_seq_cst_4(_Tgt, _Exp, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

int _Atomic_compare_exchange_strong_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     _Validate_compare_exchange_memory_order(_Order1, _Order2);
 
     switch (_Memory_order_upper_bound(_Order1, _Order2))
         {
         case memory_order_relaxed:
             return (_Compare_exchange_relaxed_8(_Tgt, _Exp, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Compare_exchange_acquire_8(_Tgt, _Exp, _Value));
 
         case memory_order_release:
             return (_Compare_exchange_release_8(_Tgt, _Exp, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Compare_exchange_seq_cst_8(_Tgt, _Exp, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

int _Atomic_compare_exchange_weak	(	volatile _Atomic_flag_t *	_Flag,
		size_t	_Size,
		volatile void *	_Tgt,
		volatile void *	_Exp,
		const volatile void *	_Src,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* atomically compare and exchange with memory ordering */
     int _Result;
 
     _Lock_spin_lock(_Flag);
     _Result = _CSTD memcmp((const void *)_Tgt, (const void *)_Exp, _Size) == 0;
     if (_Result != 0)
         _CSTD memcpy((void *)_Tgt, (void *)_Src, _Size);
     else
         _CSTD memcpy((void *)_Exp, (void *)_Tgt, _Size);
     _Unlock_spin_lock(_Flag);
     return (_Result);
     }

int _Atomic_compare_exchange_weak_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     /* No weak compare-exchange is currently available,
        even for ARM, so fall back to strong */
     return (_Atomic_compare_exchange_strong_1(_Tgt, _Exp, _Value,
         _Order1, _Order2));
     }

int _Atomic_compare_exchange_weak_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     /* No weak compare-exchange is currently available,
        even for ARM, so fall back to strong */
     return (_Atomic_compare_exchange_strong_2(_Tgt, _Exp, _Value,
         _Order1, _Order2));
     }

int _Atomic_compare_exchange_weak_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     /* No weak compare-exchange is currently available,
        even for ARM, so fall back to strong */
     return (_Atomic_compare_exchange_strong_4(_Tgt, _Exp, _Value,
         _Order1, _Order2));
     }

int _Atomic_compare_exchange_weak_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value,
		memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* compare and exchange values atomically */
     /* No weak compare-exchange is currently available,
        even for ARM, so fall back to strong */
     return (_Atomic_compare_exchange_strong_8(_Tgt, _Exp, _Value,
         _Order1, _Order2));
     }

void _Atomic_copy	(	volatile _Atomic_flag_t *	_Flag,
		size_t	_Size,
		volatile void *	_Tgt,
		volatile const void *	_Src,
		memory_order	_Order
	)

inline

     {   /* atomically copy *_Src to *_Tgt with memory ordering */
     _Lock_spin_lock(_Flag);
     _CSTD memcpy((void *)_Tgt, (void *)_Src, _Size);
     _Unlock_spin_lock(_Flag);
     }

void _Atomic_exchange	(	volatile _Atomic_flag_t *	_Flag,
		size_t	_Size,
		volatile void *	_Tgt,
		volatile void *	_Src,
		memory_order	_Order
	)

inline

     {   /* atomically swap *_Src and *_Tgt with memory ordering */
     unsigned char *_Left = (unsigned char *)_Tgt;
     unsigned char *_Right = (unsigned char *)_Src;
 
     _Lock_spin_lock(_Flag);
     for (; 0 < _Size; --_Size)
         {   /* copy bytes */
         unsigned char _Tmp = *_Left;
         *_Left++ = *_Right;
         *_Right++ = _Tmp;
         }
     _Unlock_spin_lock(_Flag);
     }

_Uint1_t _Atomic_exchange_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* exchange _Value and *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Exchange_relaxed_1(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Exchange_acquire_1(_Tgt, _Value));
 
         case memory_order_release:
             return (_Exchange_release_1(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Exchange_seq_cst_1(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_exchange_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* exchange _Value and *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Exchange_relaxed_2(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Exchange_acquire_2(_Tgt, _Value));
 
         case memory_order_release:
             return (_Exchange_release_2(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Exchange_seq_cst_2(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_exchange_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* exchange _Value and *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Exchange_relaxed_4(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Exchange_acquire_4(_Tgt, _Value));
 
         case memory_order_release:
             return (_Exchange_release_4(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Exchange_seq_cst_4(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_exchange_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* exchange _Value and *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Exchange_relaxed_8(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Exchange_acquire_8(_Tgt, _Value));
 
         case memory_order_release:
             return (_Exchange_release_8(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Exchange_seq_cst_8(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint1_t _Atomic_fetch_add_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* add _Value to *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_add_relaxed_1(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_add_acquire_1(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_add_release_1(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_add_seq_cst_1(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_fetch_add_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* add _Value to *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_add_relaxed_2(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_add_acquire_2(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_add_release_2(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_add_seq_cst_2(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_fetch_add_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* add _Value to *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_add_relaxed_4(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_add_acquire_4(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_add_release_4(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_add_seq_cst_4(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_fetch_add_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* add _Value to *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_add_relaxed_8(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_add_acquire_8(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_add_release_8(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_add_seq_cst_8(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint1_t _Atomic_fetch_and_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* and _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_and_relaxed_1(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_and_acquire_1(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_and_release_1(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_and_seq_cst_1(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_fetch_and_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* and _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_and_relaxed_2(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_and_acquire_2(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_and_release_2(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_and_seq_cst_2(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_fetch_and_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* and _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_and_relaxed_4(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_and_acquire_4(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_and_release_4(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_and_seq_cst_4(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_fetch_and_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* and _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_and_relaxed_8(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_and_acquire_8(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_and_release_8(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_and_seq_cst_8(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint1_t _Atomic_fetch_or_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* or _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_or_relaxed_1(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_or_acquire_1(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_or_release_1(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_or_seq_cst_1(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_fetch_or_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* or _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_or_relaxed_2(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_or_acquire_2(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_or_release_2(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_or_seq_cst_2(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_fetch_or_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* or _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_or_relaxed_4(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_or_acquire_4(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_or_release_4(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_or_seq_cst_4(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_fetch_or_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* or _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_or_relaxed_8(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_or_acquire_8(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_or_release_8(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_or_seq_cst_8(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint1_t _Atomic_fetch_sub_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* subtract _Value from *_Tgt atomically */
     return (_Atomic_fetch_add_1(_Tgt, 0 - _Value, _Order));
     }

_Uint2_t _Atomic_fetch_sub_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* subtract _Value from *_Tgt atomically */
     return (_Atomic_fetch_add_2(_Tgt, 0 - _Value, _Order));
     }

_Uint4_t _Atomic_fetch_sub_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* subtract _Value from *_Tgt atomically */
     return (_Atomic_fetch_add_4(_Tgt, 0 - _Value, _Order));
     }

_Uint8_t _Atomic_fetch_sub_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* subtract _Value from *_Tgt atomically */
     return (_Atomic_fetch_add_8(_Tgt, 0 - _Value, _Order));
     }

_Uint1_t _Atomic_fetch_xor_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* xor _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_xor_relaxed_1(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_xor_acquire_1(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_xor_release_1(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_xor_seq_cst_1(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_fetch_xor_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* xor _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_xor_relaxed_2(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_xor_acquire_2(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_xor_release_2(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_xor_seq_cst_2(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_fetch_xor_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* xor _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_xor_relaxed_4(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_xor_acquire_4(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_xor_release_4(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_xor_seq_cst_4(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_fetch_xor_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* xor _Value with *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Fetch_xor_relaxed_8(_Tgt, _Value));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Fetch_xor_acquire_8(_Tgt, _Value));
 
         case memory_order_release:
             return (_Fetch_xor_release_8(_Tgt, _Value));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_Fetch_xor_seq_cst_8(_Tgt, _Value));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

void _Atomic_flag_clear	(	volatile _Atomic_flag_t *	_Flag,
		memory_order	_Order
	)

inline

     {   /* atomically clear flag */
     static_assert(sizeof(_Atomic_flag_t) == sizeof(_Uint4_t),
         "Unexpected _Atomic_flag_t size");
 
     switch (_Order)
         {
         case memory_order_relaxed:
         case memory_order_release:
         case memory_order_seq_cst:
             _Atomic_store_4((volatile _Uint4_t *)_Flag, 0, _Order);
             break;
 
         default:
             _INVALID_MEMORY_ORDER;
             break;
         }
     }

int _Atomic_flag_test_and_set	(	volatile _Atomic_flag_t *	_Flag,
		memory_order	_Order
	)

inline

     {   /* atomically test flag and set to true */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_INTRIN_RELAXED(_interlockedbittestandset)(_Flag, 0));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_INTRIN_ACQUIRE(_interlockedbittestandset)(_Flag, 0));
 
         case memory_order_release:
             return (_INTRIN_RELEASE(_interlockedbittestandset)(_Flag, 0));
 
         case memory_order_acq_rel:
         case memory_order_seq_cst:
             return (_INTRIN_SEQ_CST(_interlockedbittestandset)(_Flag, 0));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

int _Atomic_is_lock_free_1 ( void )

inline

     {   /* return true if 1-byte atomic values are lock-free */
     return (1 <= _ATOMIC_MAXBYTES_LOCK_FREE);
     }

int _Atomic_is_lock_free_2 ( void )

inline

     {   /* return true if 2-byte atomic values are lock-free */
     return (2 <= _ATOMIC_MAXBYTES_LOCK_FREE);
     }

int _Atomic_is_lock_free_4 ( void )

inline

     {   /* return true if 4-byte atomic values are lock-free */
     return (4 <= _ATOMIC_MAXBYTES_LOCK_FREE);
     }

int _Atomic_is_lock_free_8 ( void )

inline

     {   /* return true if 8-byte atomic values are lock-free */
     return (8 <= _ATOMIC_MAXBYTES_LOCK_FREE);
     }

_Uint1_t _Atomic_load_1	(	volatile _Uint1_t *	_Tgt,
		memory_order	_Order
	)

inline

     {   /* load from *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Load_relaxed_1(_Tgt));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Load_acquire_1(_Tgt));
 
         case memory_order_seq_cst:
             return (_Load_seq_cst_1(_Tgt));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint2_t _Atomic_load_2	(	volatile _Uint2_t *	_Tgt,
		memory_order	_Order
	)

inline

     {   /* load from *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Load_relaxed_2(_Tgt));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Load_acquire_2(_Tgt));
 
         case memory_order_seq_cst:
             return (_Load_seq_cst_2(_Tgt));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint4_t _Atomic_load_4	(	volatile _Uint4_t *	_Tgt,
		memory_order	_Order
	)

inline

     {   /* load from *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Load_relaxed_4(_Tgt));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Load_acquire_4(_Tgt));
 
         case memory_order_seq_cst:
             return (_Load_seq_cst_4(_Tgt));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

_Uint8_t _Atomic_load_8	(	volatile _Uint8_t *	_Tgt,
		memory_order	_Order
	)

inline

     {   /* load from *_Tgt atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             return (_Load_relaxed_8(_Tgt));
 
         case memory_order_consume:
         case memory_order_acquire:
             return (_Load_acquire_8(_Tgt));
 
         case memory_order_seq_cst:
             return (_Load_seq_cst_8(_Tgt));
 
         default:
             _INVALID_MEMORY_ORDER;
             return (0);
         }
     }

void _Atomic_signal_fence ( memory_order _Order )

inline

     {   /* inhibit compiler reordering */
     _Compiler_barrier();
     }

void _Atomic_store_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value,
		memory_order	_Order
	)

inline

     {   /* store _Value atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             _Store_relaxed_1(_Tgt, _Value);
             break;
 
         case memory_order_release:
             _Store_release_1(_Tgt, _Value);
             break;
 
         case memory_order_seq_cst:
             _Store_seq_cst_1(_Tgt, _Value);
             break;
 
         default:
             _INVALID_MEMORY_ORDER;
             break;
         }
     }

void _Atomic_store_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value,
		memory_order	_Order
	)

inline

     {   /* store _Value atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             _Store_relaxed_2(_Tgt, _Value);
             break;
 
         case memory_order_release:
             _Store_release_2(_Tgt, _Value);
             break;
 
         case memory_order_seq_cst:
             _Store_seq_cst_2(_Tgt, _Value);
             break;
 
         default:
             _INVALID_MEMORY_ORDER;
             break;
         }
     }

void _Atomic_store_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value,
		memory_order	_Order
	)

inline

     {   /* store _Value atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             _Store_relaxed_4(_Tgt, _Value);
             break;
 
         case memory_order_release:
             _Store_release_4(_Tgt, _Value);
             break;
 
         case memory_order_seq_cst:
             _Store_seq_cst_4(_Tgt, _Value);
             break;
 
         default:
             _INVALID_MEMORY_ORDER;
             break;
         }
     }

void _Atomic_store_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value,
		memory_order	_Order
	)

inline

     {   /* store _Value atomically */
     switch (_Order)
         {
         case memory_order_relaxed:
             _Store_relaxed_8(_Tgt, _Value);
             break;
 
         case memory_order_release:
             _Store_release_8(_Tgt, _Value);
             break;
 
         case memory_order_seq_cst:
             _Store_seq_cst_8(_Tgt, _Value);
             break;
 
         default:
             _INVALID_MEMORY_ORDER;
             break;
         }
     }

void _Atomic_thread_fence ( memory_order _Order )

inline

     {   /* force memory visibility and inhibit compiler reordering */
  #if defined(_M_ARM) || defined(_M_ARM64)
     if (_Order != memory_order_relaxed)
         {
         _Memory_barrier();
         }
 
  #else
     _Compiler_barrier();
     if (_Order == memory_order_seq_cst)
         {   /* force visibility */
         static _Uint4_t _Guard;
         _Atomic_exchange_4(&_Guard, 0, memory_order_seq_cst);
         _Compiler_barrier();
         }
  #endif
     }

int _Compare_exchange_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             acquire memory order */
     _Uint1_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint1_t _Prev = _INTRIN_ACQUIRE(_InterlockedCompareExchange8)((volatile char *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             acquire memory order */
     _Uint2_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint2_t _Prev = _INTRIN_ACQUIRE(_InterlockedCompareExchange16)((volatile short *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             acquire memory order */
     _Uint4_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint4_t _Prev = _INTRIN_ACQUIRE(_InterlockedCompareExchange)((volatile long *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             acquire memory order */
     _Uint8_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint8_t _Prev = _INTRIN_ACQUIRE(_InterlockedCompareExchange64)((volatile _LONGLONG *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             relaxed memory order */
     _Uint1_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint1_t _Prev = _INTRIN_RELAXED(_InterlockedCompareExchange8)((volatile char *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             relaxed memory order */
     _Uint2_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint2_t _Prev = _INTRIN_RELAXED(_InterlockedCompareExchange16)((volatile short *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             relaxed memory order */
     _Uint4_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint4_t _Prev = _INTRIN_RELAXED(_InterlockedCompareExchange)((volatile long *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             relaxed memory order */
     _Uint8_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint8_t _Prev = _INTRIN_RELAXED(_InterlockedCompareExchange64)((volatile _LONGLONG *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             release memory order */
     _Uint1_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint1_t _Prev = _INTRIN_RELEASE(_InterlockedCompareExchange8)((volatile char *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             release memory order */
     _Uint2_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint2_t _Prev = _INTRIN_RELEASE(_InterlockedCompareExchange16)((volatile short *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             release memory order */
     _Uint4_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint4_t _Prev = _INTRIN_RELEASE(_InterlockedCompareExchange)((volatile long *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             release memory order */
     _Uint8_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint8_t _Prev = _INTRIN_RELEASE(_InterlockedCompareExchange64)((volatile _LONGLONG *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t *	_Exp,
		_Uint1_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             sequentially consistent memory order */
     _Uint1_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint1_t _Prev = _INTRIN_SEQ_CST(_InterlockedCompareExchange8)((volatile char *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t *	_Exp,
		_Uint2_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             sequentially consistent memory order */
     _Uint2_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint2_t _Prev = _INTRIN_SEQ_CST(_InterlockedCompareExchange16)((volatile short *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t *	_Exp,
		_Uint4_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             sequentially consistent memory order */
     _Uint4_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint4_t _Prev = _INTRIN_SEQ_CST(_InterlockedCompareExchange)((volatile long *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

int _Compare_exchange_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t *	_Exp,
		_Uint8_t	_Value
	)

inline

     {   /* compare and exchange values atomically with
             sequentially consistent memory order */
     _Uint8_t _Old_exp = *_Exp;  /* read before atomic operation */
 
     _Uint8_t _Prev = _INTRIN_SEQ_CST(_InterlockedCompareExchange64)((volatile _LONGLONG *)_Tgt,
         _Value, _Old_exp);
 
     if (_Prev == _Old_exp)
         return (1);
     else
         {   /* copy old value */
         *_Exp = _Prev;
         return (0);
         }
     }

_Atomic_integral_t _Compare_increment_atomic_counter	(	_Atomic_counter_t &	_Counter,
		_Atomic_integral_t	_Expected
	)

inline

     {   // atomically compare and increment counter and return result
     return (_Compare_increment_atomic_counter_explicit(
         _Counter, _Expected, memory_order_seq_cst));
     }

_Atomic_integral_t _Compare_increment_atomic_counter_explicit	(	_Atomic_counter_t &	_Counter,
		_Atomic_integral_t	_Expected,
		memory_order	_Order
	)

inline

     {   // atomically compare and increment counter and return result
     return (_Atomic_compare_exchange_weak_4(
         &_Counter, &_Expected, _Expected + 1,
         _Order, _Order));
     }

_Atomic_integral_t _Dec_atomic_counter ( _Atomic_counter_t & _Counter )

inline

     {   // atomically decrement counter and return result
     return (_Dec_atomic_counter_explicit(_Counter, memory_order_seq_cst));
     }

_Atomic_integral_t _Dec_atomic_counter_explicit	(	_Atomic_counter_t &	_Counter,
		memory_order	_Order
	)

inline

     {   // atomically decrement counter and return result
     return (_Atomic_fetch_sub_4(&_Counter, 1, _Order) - 1);
     }

_Uint1_t _Exchange_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchange8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Exchange_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchange16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Exchange_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchange)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Exchange_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Exchange_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchange8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Exchange_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchange16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Exchange_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchange)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Exchange_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Exchange_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchange8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Exchange_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchange16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Exchange_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchange)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Exchange_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Exchange_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchange8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Exchange_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchange16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Exchange_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchange)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Exchange_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* exchange _Value and *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_add_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchangeAdd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_add_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchangeAdd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_add_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchangeAdd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_add_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedExchangeAdd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_add_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchangeAdd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_add_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchangeAdd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_add_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchangeAdd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_add_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedExchangeAdd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_add_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchangeAdd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_add_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchangeAdd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_add_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchangeAdd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_add_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedExchangeAdd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_add_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchangeAdd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_add_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchangeAdd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_add_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchangeAdd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_add_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* add _Value to *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedExchangeAdd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_and_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedAnd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_and_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedAnd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_and_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedAnd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_and_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedAnd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_and_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedAnd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_and_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedAnd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_and_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedAnd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_and_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedAnd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_and_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedAnd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_and_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedAnd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_and_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedAnd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_and_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedAnd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_and_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedAnd8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_and_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedAnd16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_and_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedAnd)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_and_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* and _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedAnd64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_or_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedOr8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_or_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedOr16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_or_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedOr)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_or_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedOr64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_or_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedOr8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_or_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedOr16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_or_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedOr)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_or_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedOr64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_or_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedOr8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_or_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedOr16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_or_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedOr)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_or_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedOr64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_or_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedOr8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_or_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedOr16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_or_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedOr)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_or_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* or _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedOr64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_xor_acquire_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedXor8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_xor_acquire_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedXor16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_xor_acquire_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedXor)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_xor_acquire_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             acquire memory order */
 
     return (_INTRIN_ACQUIRE(_InterlockedXor64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_xor_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedXor8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_xor_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedXor16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_xor_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedXor)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_xor_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             relaxed memory order */
 
     return (_INTRIN_RELAXED(_InterlockedXor64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_xor_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedXor8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_xor_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedXor16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_xor_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedXor)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_xor_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             release memory order */
 
     return (_INTRIN_RELEASE(_InterlockedXor64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Uint1_t _Fetch_xor_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedXor8)((volatile char *)_Tgt, _Value));
     }

_Uint2_t _Fetch_xor_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedXor16)((volatile short *)_Tgt, _Value));
     }

_Uint4_t _Fetch_xor_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedXor)((volatile long *)_Tgt, _Value));
     }

_Uint8_t _Fetch_xor_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* xor _Value with *_Tgt atomically with
             sequentially consistent memory order */
 
     return (_INTRIN_SEQ_CST(_InterlockedXor64)((volatile _LONGLONG *)_Tgt, _Value));
     }

_Atomic_integral_t _Inc_atomic_counter ( _Atomic_counter_t & _Counter )

inline

     {   // atomically increment counter and return result
     return (_Inc_atomic_counter_explicit(_Counter, memory_order_seq_cst));
     }

_Atomic_integral_t _Inc_atomic_counter_explicit	(	_Atomic_counter_t &	_Counter,
		memory_order	_Order
	)

inline

     {   // atomically increment counter and return result
     return (_Atomic_fetch_add_4(&_Counter, 1, _Order) + 1);
     }

_Uint1_t _Load_acquire_1 ( volatile _Uint1_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             acquire memory order */
 
     return (_Load_seq_cst_1(_Tgt));
     }

_Uint2_t _Load_acquire_2 ( volatile _Uint2_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             acquire memory order */
 
     return (_Load_seq_cst_2(_Tgt));
     }

_Uint4_t _Load_acquire_4 ( volatile _Uint4_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             acquire memory order */
 
     return (_Load_seq_cst_4(_Tgt));
     }

_Uint8_t _Load_acquire_8 ( volatile _Uint8_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             acquire memory order */
 
     return (_Load_seq_cst_8(_Tgt));
     }

_Atomic_integral_t _Load_atomic_counter ( _Atomic_counter_t & _Counter )

inline

     {   // atomically load counter and return result
     return (_Load_atomic_counter_explicit(_Counter, memory_order_seq_cst));
     }

_Atomic_integral_t _Load_atomic_counter_explicit	(	_Atomic_counter_t &	_Counter,
		memory_order	_Order
	)

inline

     {   // atomically load counter and return result
     return (_Atomic_load_4(&_Counter, _Order));
     }

_Uint1_t _Load_relaxed_1 ( volatile _Uint1_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             relaxed memory order */
     _Uint1_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load8((volatile char *)_Tgt);
 
  #else
     _Value = *_Tgt;
  #endif
 
     return (_Value);
     }

_Uint2_t _Load_relaxed_2 ( volatile _Uint2_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             relaxed memory order */
     _Uint2_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load16((volatile short *)_Tgt);
 
  #else
     _Value = *_Tgt;
  #endif
 
     return (_Value);
     }

_Uint4_t _Load_relaxed_4 ( volatile _Uint4_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             relaxed memory order */
     _Uint4_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load32((volatile int *)_Tgt);
 
  #else
     _Value = *_Tgt;
  #endif
 
     return (_Value);
     }

_Uint8_t _Load_relaxed_8 ( volatile _Uint8_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             relaxed memory order */
     _Uint8_t _Value;
 
  #if defined(_M_X64)
     _Value = *_Tgt;
 
  #elif defined(_M_ARM)
     _Value = __ldrexd((volatile _LONGLONG *)_Tgt);
 
  #elif defined(_M_ARM64)
     _Value = __iso_volatile_load64((volatile _LONGLONG *)_Tgt);
 
  #else
     _Value = _InterlockedOr64((volatile _LONGLONG *)_Tgt, 0);
  #endif
 
     return (_Value);
     }

_Uint1_t _Load_seq_cst_1 ( volatile _Uint1_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             sequentially consistent memory order */
     _Uint1_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load8((volatile char *)_Tgt);
     _Memory_barrier();
 
  #else
     _Value = *_Tgt;
     _Compiler_barrier();
  #endif
 
     return (_Value);
     }

_Uint2_t _Load_seq_cst_2 ( volatile _Uint2_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             sequentially consistent memory order */
     _Uint2_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load16((volatile short *)_Tgt);
     _Memory_barrier();
 
  #else
     _Value = *_Tgt;
     _Compiler_barrier();
  #endif
 
     return (_Value);
     }

_Uint4_t _Load_seq_cst_4 ( volatile _Uint4_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             sequentially consistent memory order */
     _Uint4_t _Value;
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Value = __iso_volatile_load32((volatile int *)_Tgt);
     _Memory_barrier();
 
  #else
     _Value = *_Tgt;
     _Compiler_barrier();
  #endif
 
     return (_Value);
     }

_Uint8_t _Load_seq_cst_8 ( volatile _Uint8_t * _Tgt )

inline

     {   /* load from *_Tgt atomically with
             sequentially consistent memory order */
     _Uint8_t _Value;
 
  #if defined(_M_X64)
     _Value = *_Tgt;
     _Compiler_barrier();
 
  #elif defined(_M_ARM)
     _Value = __ldrexd((volatile _LONGLONG *)_Tgt);
     _Memory_barrier();
 
  #elif defined(_M_ARM64)
     _Value = __iso_volatile_load64((volatile _LONGLONG *)_Tgt);
     _Memory_barrier();
 
  #else
     _Value = _InterlockedOr64((volatile _LONGLONG *)_Tgt, 0);
  #endif
 
     return (_Value);
     }

void _Lock_spin_lock ( volatile _Atomic_flag_t * _Flag )

inline

     {   /* spin until _Flag successfully set */
     while (_ATOMIC_FLAG_TEST_AND_SET(_Flag, memory_order_acquire))
         _YIELD_PROCESSOR;
     }

memory_order _Memory_order_upper_bound	(	memory_order	_Order1,
		memory_order	_Order2
	)

inline

     {   /* find upper bound of two memory orders,
             based on the following partial order:
 
                                seq_cst
                                   |
                                acq_rel
                                /     \
                            acquire  release
                               |       |
                            consume    |
                                \     /
                                relaxed
 
         */
 
     static const memory_order _Upper[6][6] = {  /* combined upper bounds */ // TRANSITION, VSO#202551
         { memory_order_relaxed, memory_order_consume, memory_order_acquire,
         memory_order_release, memory_order_acq_rel, memory_order_seq_cst },
         { memory_order_consume, memory_order_consume, memory_order_acquire,
         memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst },
         { memory_order_acquire, memory_order_acquire, memory_order_acquire,
         memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst },
         { memory_order_release, memory_order_acq_rel, memory_order_acq_rel,
         memory_order_release, memory_order_acq_rel, memory_order_seq_cst },
         { memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel,
         memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst },
         { memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst,
         memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst
         }
         };
 
     if ((_Order1 < 0) || (6 <= _Order1)
         || (_Order2 < 0) || (6 <= _Order2))
         {   /* launder memory order */
         _INVALID_MEMORY_ORDER;
         return (memory_order_seq_cst);
         }
     return (_Upper[_Order1][_Order2]);
     }

void _Store_relaxed_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* store _Value atomically with relaxed memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     __iso_volatile_store8((volatile char *)_Tgt, _Value);
 
  #else
     *_Tgt = _Value;
  #endif
     }

void _Store_relaxed_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* store _Value atomically with relaxed memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     __iso_volatile_store16((volatile short *)_Tgt, _Value);
 
  #else
     *_Tgt = _Value;
  #endif
     }

void _Store_relaxed_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* store _Value atomically with relaxed memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     __iso_volatile_store32((volatile int *)_Tgt, _Value);
 
  #else
     *_Tgt = _Value;
  #endif
     }

void _Store_relaxed_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* store _Value atomically with relaxed memory order */
 
  #if defined(_M_X64)
     *_Tgt = _Value;
 
  #elif defined(_M_ARM64)
     __iso_volatile_store64((volatile _LONGLONG *)_Tgt, _Value);
 
  #else
     _INTRIN_RELAXED(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value);
  #endif
     }

void _Store_release_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* store _Value atomically with release memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store8((volatile char *)_Tgt, _Value);
 
  #else
     _Compiler_barrier();
     *_Tgt = _Value;
  #endif
     }

void _Store_release_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* store _Value atomically with release memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store16((volatile short *)_Tgt, _Value);
 
  #else
     _Compiler_barrier();
     *_Tgt = _Value;
  #endif
     }

void _Store_release_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* store _Value atomically with release memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store32((volatile int *)_Tgt, _Value);
 
  #else
     _Compiler_barrier();
     *_Tgt = _Value;
  #endif
     }

void _Store_release_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* store _Value atomically with release memory order */
 
  #if defined(_M_X64)
     _Compiler_barrier();
     *_Tgt = _Value;
 
  #elif defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store64((volatile _LONGLONG *)_Tgt, _Value);
 
  #else
     _INTRIN_RELEASE(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value);
  #endif
     }

void _Store_seq_cst_1	(	volatile _Uint1_t *	_Tgt,
		_Uint1_t	_Value
	)

inline

     {   /* store _Value atomically with
             sequentially consistent memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store8((volatile char *)_Tgt, _Value);
     _Memory_barrier();
 
  #else
     _INTRIN_SEQ_CST(_InterlockedExchange8)((volatile char *)_Tgt, _Value);
  #endif
     }

void _Store_seq_cst_2	(	volatile _Uint2_t *	_Tgt,
		_Uint2_t	_Value
	)

inline

     {   /* store _Value atomically with
             sequentially consistent memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store16((volatile short *)_Tgt, _Value);
     _Memory_barrier();
 
  #else
     _INTRIN_SEQ_CST(_InterlockedExchange16)((volatile short *)_Tgt, _Value);
  #endif
     }

void _Store_seq_cst_4	(	volatile _Uint4_t *	_Tgt,
		_Uint4_t	_Value
	)

inline

     {   /* store _Value atomically with
             sequentially consistent memory order */
 
  #if defined(_M_ARM) || defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store32((volatile int *)_Tgt, _Value);
     _Memory_barrier();
 
  #else
     _INTRIN_SEQ_CST(_InterlockedExchange)((volatile long *)_Tgt, _Value);
  #endif
     }

void _Store_seq_cst_8	(	volatile _Uint8_t *	_Tgt,
		_Uint8_t	_Value
	)

inline

     {   /* store _Value atomically with
             sequentially consistent memory order */
 
  #if defined(_M_ARM64)
     _Memory_barrier();
     __iso_volatile_store64((volatile _LONGLONG *)_Tgt, _Value);
     _Memory_barrier();
 
  #else
     _INTRIN_SEQ_CST(_InterlockedExchange64)((volatile _LONGLONG *)_Tgt, _Value);
  #endif
     }

void _Unlock_spin_lock ( volatile _Atomic_flag_t * _Flag )

inline

     {   /* release previously obtained lock */
     _ATOMIC_FLAG_CLEAR(_Flag, memory_order_release);
     }

void _Validate_compare_exchange_memory_order	(	memory_order	_Success,
		memory_order	_Failure
	)

inline

     {   /* validate success/failure */
     /* _Failure may not be memory_order_release or memory_order_acq_rel
         and may not be stronger than _Success */
     switch (_Failure)
         {
     case memory_order_relaxed:
         break;
 
     case memory_order_seq_cst:
         if (_Success != memory_order_seq_cst)
             _INVALID_MEMORY_ORDER;
         break;
 
     case memory_order_acquire:
         if ((_Success == memory_order_consume) ||
             (_Success == memory_order_relaxed))
             _INVALID_MEMORY_ORDER;
         break;
 
     case memory_order_consume:
         if (_Success == memory_order_relaxed)
             _INVALID_MEMORY_ORDER;
         break;
 
     default:
         _INVALID_MEMORY_ORDER;
         break;
         }
     }

Variable Documentation

_STD_BEGIN typedef unsigned char _Uint1_t

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation