From 5bbe97ddaad68812802c6b514e13ce44c1e5174e Mon Sep 17 00:00:00 2001 From: Howard Hinnant Date: Tue, 19 Oct 2010 21:22:10 +0000 Subject: [PATCH] atomic_schar, atomic_uchar, atomic_short, atomic_ushort, atomic_int, atomic_uint, atomic_long, atomic_ulong, atomic_llong, atomic_ullong, atomic_char16_t, atomic_char32_t and atomic_wchar_t. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@116860 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/atomic | 7945 +++++++++++++++++ .../atomics.types.integral/integral.pass.cpp | 66 +- 2 files changed, 8009 insertions(+), 2 deletions(-) diff --git a/include/atomic b/include/atomic index 1d6a4fb2..0d3e6afd 100644 --- a/include/atomic +++ b/include/atomic @@ -3435,6 +3435,7951 @@ atomic_fetch_xor_explicit(atomic_char* __obj, char __v, memory_order __o) __v, __o); } +// atomic_schar + +struct atomic_schar; + +bool atomic_is_lock_free(const volatile atomic_schar*); +bool atomic_is_lock_free(const atomic_schar*); +void atomic_init(volatile atomic_schar*, signed char); +void atomic_init(atomic_schar*, signed char); +void atomic_store(volatile atomic_schar*, signed char); +void atomic_store(atomic_schar*, signed char); +void atomic_store_explicit(volatile atomic_schar*, signed char, memory_order); +void atomic_store_explicit(atomic_schar*, signed char, memory_order); +signed char atomic_load(const volatile atomic_schar*); +signed char atomic_load(const atomic_schar*); +signed char atomic_load_explicit(const volatile atomic_schar*, memory_order); +signed char atomic_load_explicit(const atomic_schar*, memory_order); +signed char atomic_exchange(volatile atomic_schar*, signed char); +signed char atomic_exchange(atomic_schar*, signed char); +signed char atomic_exchange_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_exchange_explicit(atomic_schar*, signed char, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_schar*, signed char*, + signed char); +bool atomic_compare_exchange_weak(atomic_schar*, signed char*, signed char); +bool atomic_compare_exchange_strong(volatile atomic_schar*, signed char*, + signed char); +bool atomic_compare_exchange_strong(atomic_schar*, signed char*, signed char); +bool atomic_compare_exchange_weak_explicit(volatile atomic_schar*, signed char*, + signed char, memory_order, + memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_schar*, signed char*, + signed char, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_schar*, + signed char*, signed char, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_schar*, signed char*, + signed char, memory_order, + memory_order); +signed char atomic_fetch_add(volatile atomic_schar*, signed char); +signed char atomic_fetch_add(atomic_schar*, signed char); +signed char atomic_fetch_add_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_fetch_add_explicit(atomic_schar*, signed char, memory_order); +signed char atomic_fetch_sub(volatile atomic_schar*, signed char); +signed char atomic_fetch_sub(atomic_schar*, signed char); +signed char atomic_fetch_sub_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_fetch_sub_explicit(atomic_schar*, signed char, memory_order); +signed char atomic_fetch_and(volatile atomic_schar*, signed char); +signed char atomic_fetch_and(atomic_schar*, signed char); +signed char atomic_fetch_and_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_fetch_and_explicit(atomic_schar*, signed char, memory_order); +signed char atomic_fetch_or(volatile atomic_schar*, signed char); +signed char atomic_fetch_or(atomic_schar*, signed char); +signed char atomic_fetch_or_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_fetch_or_explicit(atomic_schar*, signed char, memory_order); +signed char atomic_fetch_xor(volatile atomic_schar*, signed char); +signed char atomic_fetch_xor(atomic_schar*, signed char); +signed char atomic_fetch_xor_explicit(volatile atomic_schar*, signed char, + memory_order); +signed char atomic_fetch_xor_explicit(atomic_schar*, signed char, memory_order); + +typedef struct atomic_schar +{ + signed char __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(signed char __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator signed char() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator signed char() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + signed char exchange(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char exchange(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(signed char& __v, signed char __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(signed char& __v, signed char __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(signed char& __v, signed char __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(signed char& __v, signed char __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(signed char& __v, signed char __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(signed char& __v, signed char __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(signed char& __v, signed char __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(signed char& __v, signed char __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_add(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_add(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_sub(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_sub(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_and(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_and(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_or(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_or(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_xor(signed char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + signed char fetch_xor(signed char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_schar() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_schar() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_schar(signed char __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_schar(const atomic_schar&) = delete; + atomic_schar& operator=(const atomic_schar&) = delete; + atomic_schar& operator=(const atomic_schar&) volatile = delete; +#else +private: + atomic_schar(const atomic_schar&); + atomic_schar& operator=(const atomic_schar&); + atomic_schar& operator=(const atomic_schar&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + signed char operator=(signed char __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + signed char operator=(signed char __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + signed char operator++(int) volatile + {typedef signed char type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator++(int) + {typedef signed char type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator--(int) volatile + {typedef signed char type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator--(int) + {typedef signed char type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator++() volatile + {typedef signed char type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char operator++() + {typedef signed char type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char operator--() volatile + {typedef signed char type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char operator--() + {typedef signed char type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char operator+=(char __v) volatile + {typedef signed char type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char operator+=(char __v) + {typedef signed char type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char operator-=(char __v) volatile + {typedef signed char type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char operator-=(char __v) + {typedef signed char type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char operator&=(char __v) volatile + {typedef signed char type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char operator&=(char __v) + {typedef signed char type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char operator|=(char __v) volatile + {typedef signed char type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char operator|=(char __v) + {typedef signed char type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char operator^=(char __v) volatile + {typedef signed char type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + char operator^=(char __v) + {typedef signed char type; return type(fetch_xor(__v) ^ __v);} +} atomic_schar; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_schar*) +{ + typedef signed char type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_schar* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_schar* __obj, signed char __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_schar* __obj, signed char __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_schar* __obj, signed char __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_schar* __obj, signed char __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_schar* __obj, signed char __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_schar* __obj, signed char __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_load(const volatile atomic_schar* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_load(const atomic_schar* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_load_explicit(const volatile atomic_schar* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_load_explicit(const atomic_schar* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_exchange(volatile atomic_schar* __obj, signed char __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_exchange(atomic_schar* __obj, signed char __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_exchange_explicit(volatile atomic_schar* __obj, signed char __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_exchange_explicit(atomic_schar* __obj, signed char __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_schar* __obj, signed char* __exp, + signed char __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_schar* __obj, signed char* __exp, + signed char __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_schar* __obj, signed char* __exp, + signed char __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_schar* __obj, signed char* __exp, + signed char __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_schar* __obj, + signed char* __exp, signed char __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_schar* __obj, signed char* __exp, + signed char __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_schar* __obj, + signed char* __exp, signed char __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_schar* __obj, signed char* __exp, + signed char __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_add(volatile atomic_schar* __obj, signed char __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_add(atomic_schar* __obj, signed char __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_add_explicit(volatile atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_add_explicit(atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_sub(volatile atomic_schar* __obj, signed char __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_sub(atomic_schar* __obj, signed char __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_sub_explicit(volatile atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_sub_explicit(atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_and(volatile atomic_schar* __obj, signed char __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_and(atomic_schar* __obj, signed char __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_and_explicit(volatile atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_and_explicit(atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_or(volatile atomic_schar* __obj, signed char __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_or(atomic_schar* __obj, signed char __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_or_explicit(volatile atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_or_explicit(atomic_schar* __obj, signed char __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_xor(volatile atomic_schar* __obj, signed char __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_xor(atomic_schar* __obj, signed char __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_xor_explicit(volatile atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +signed char +atomic_fetch_xor_explicit(atomic_schar* __obj, signed char __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_uchar + +struct atomic_uchar; + +bool atomic_is_lock_free(const volatile atomic_uchar*); +bool atomic_is_lock_free(const atomic_uchar*); +void atomic_init(volatile atomic_uchar*, unsigned char); +void atomic_init(atomic_uchar*, unsigned char); +void atomic_store(volatile atomic_uchar*, unsigned char); +void atomic_store(atomic_uchar*, unsigned char); +void atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order); +void atomic_store_explicit(atomic_uchar*, unsigned char, memory_order); +unsigned char atomic_load(const volatile atomic_uchar*); +unsigned char atomic_load(const atomic_uchar*); +unsigned char atomic_load_explicit(const volatile atomic_uchar*, memory_order); +unsigned char atomic_load_explicit(const atomic_uchar*, memory_order); +unsigned char atomic_exchange(volatile atomic_uchar*, unsigned char); +unsigned char atomic_exchange(atomic_uchar*, unsigned char); +unsigned char atomic_exchange_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_exchange_explicit(atomic_uchar*, unsigned char, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_uchar*, unsigned char*, + unsigned char); +bool atomic_compare_exchange_weak(atomic_uchar*, unsigned char*, unsigned char); +bool atomic_compare_exchange_strong(volatile atomic_uchar*, unsigned char*, + unsigned char); +bool atomic_compare_exchange_strong(atomic_uchar*, unsigned char*, + unsigned char); +bool atomic_compare_exchange_weak_explicit(volatile atomic_uchar*, + unsigned char*, unsigned char, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_uchar*, unsigned char*, + unsigned char, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_uchar*, + unsigned char*, unsigned char, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_uchar*, unsigned char*, + unsigned char, memory_order, + memory_order); +unsigned char atomic_fetch_add(volatile atomic_uchar*, unsigned char); +unsigned char atomic_fetch_add(atomic_uchar*, unsigned char); +unsigned char atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_add_explicit(atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_sub(volatile atomic_uchar*, unsigned char); +unsigned char atomic_fetch_sub(atomic_uchar*, unsigned char); +unsigned char atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_sub_explicit(atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_and(volatile atomic_uchar*, unsigned char); +unsigned char atomic_fetch_and(atomic_uchar*, unsigned char); +unsigned char atomic_fetch_and_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_and_explicit(atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_or(volatile atomic_uchar*, unsigned char); +unsigned char atomic_fetch_or(atomic_uchar*, unsigned char); +unsigned char atomic_fetch_or_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_or_explicit(atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_xor(volatile atomic_uchar*, unsigned char); +unsigned char atomic_fetch_xor(atomic_uchar*, unsigned char); +unsigned char atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char, + memory_order); +unsigned char atomic_fetch_xor_explicit(atomic_uchar*, unsigned char, + memory_order); + +typedef struct atomic_uchar +{ + unsigned char __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned char __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator unsigned char() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator unsigned char() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + unsigned char exchange(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char exchange(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned char& __v, unsigned char __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned char& __v, unsigned char __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned char& __v, unsigned char __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned char& __v, unsigned char __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned char& __v, unsigned char __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned char& __v, unsigned char __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned char& __v, unsigned char __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned char& __v, unsigned char __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_add(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_add(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_sub(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_sub(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_and(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_and(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_or(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_or(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_xor(unsigned char __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned char fetch_xor(unsigned char __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_uchar() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_uchar() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_uchar(unsigned char __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_uchar(const atomic_uchar&) = delete; + atomic_uchar& operator=(const atomic_uchar&) = delete; + atomic_uchar& operator=(const atomic_uchar&) volatile = delete; +#else +private: + atomic_uchar(const atomic_uchar&); + atomic_uchar& operator=(const atomic_uchar&); + atomic_uchar& operator=(const atomic_uchar&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + unsigned char operator=(unsigned char __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned char operator=(unsigned char __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned char operator++(int) volatile + {typedef unsigned char type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator++(int) + {typedef unsigned char type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator--(int) volatile + {typedef unsigned char type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator--(int) + {typedef unsigned char type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + char operator++() volatile + {typedef unsigned char type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char operator++() + {typedef unsigned char type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char operator--() volatile + {typedef unsigned char type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char operator--() + {typedef unsigned char type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char operator+=(char __v) volatile + {typedef unsigned char type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char operator+=(char __v) + {typedef unsigned char type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char operator-=(char __v) volatile + {typedef unsigned char type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char operator-=(char __v) + {typedef unsigned char type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char operator&=(char __v) volatile + {typedef unsigned char type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char operator&=(char __v) + {typedef unsigned char type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char operator|=(char __v) volatile + {typedef unsigned char type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char operator|=(char __v) + {typedef unsigned char type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char operator^=(char __v) volatile + {typedef unsigned char type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + char operator^=(char __v) + {typedef unsigned char type; return type(fetch_xor(__v) ^ __v);} +} atomic_uchar; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_uchar*) +{ + typedef unsigned char type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_uchar* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_uchar* __obj, unsigned char __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_uchar* __obj, unsigned char __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_uchar* __obj, unsigned char __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_uchar* __obj, unsigned char __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_uchar* __obj, unsigned char __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_uchar* __obj, unsigned char __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_load(const volatile atomic_uchar* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_load(const atomic_uchar* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_load_explicit(const volatile atomic_uchar* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_load_explicit(const atomic_uchar* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_exchange(volatile atomic_uchar* __obj, unsigned char __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_exchange(atomic_uchar* __obj, unsigned char __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_exchange_explicit(volatile atomic_uchar* __obj, unsigned char __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_exchange_explicit(atomic_uchar* __obj, unsigned char __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_uchar* __obj, unsigned char* __exp, + unsigned char __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_uchar* __obj, unsigned char* __exp, + unsigned char __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_uchar* __obj, + unsigned char* __exp, unsigned char __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_uchar* __obj, unsigned char* __exp, + unsigned char __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_uchar* __obj, + unsigned char* __exp, + unsigned char __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_uchar* __obj, unsigned char* __exp, + unsigned char __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_uchar* __obj, + unsigned char* __exp, + unsigned char __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_uchar* __obj, + unsigned char* __exp, + unsigned char __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_add(volatile atomic_uchar* __obj, unsigned char __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_add(atomic_uchar* __obj, unsigned char __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_add_explicit(volatile atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_add_explicit(atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_sub(volatile atomic_uchar* __obj, unsigned char __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_sub(atomic_uchar* __obj, unsigned char __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_sub_explicit(volatile atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_sub_explicit(atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_and(volatile atomic_uchar* __obj, unsigned char __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_and(atomic_uchar* __obj, unsigned char __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_and_explicit(volatile atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_and_explicit(atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_or(volatile atomic_uchar* __obj, unsigned char __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_or(atomic_uchar* __obj, unsigned char __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_or_explicit(volatile atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_or_explicit(atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_xor(volatile atomic_uchar* __obj, unsigned char __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_xor(atomic_uchar* __obj, unsigned char __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_xor_explicit(volatile atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned char +atomic_fetch_xor_explicit(atomic_uchar* __obj, unsigned char __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_short + +struct atomic_short; + +bool atomic_is_lock_free(const volatile atomic_short*); +bool atomic_is_lock_free(const atomic_short*); +void atomic_init(volatile atomic_short*, short); +void atomic_init(atomic_short*, short); +void atomic_store(volatile atomic_short*, short); +void atomic_store(atomic_short*, short); +void atomic_store_explicit(volatile atomic_short*, short, memory_order); +void atomic_store_explicit(atomic_short*, short, memory_order); +short atomic_load(const volatile atomic_short*); +short atomic_load(const atomic_short*); +short atomic_load_explicit(const volatile atomic_short*, memory_order); +short atomic_load_explicit(const atomic_short*, memory_order); +short atomic_exchange(volatile atomic_short*, short); +short atomic_exchange(atomic_short*, short); +short atomic_exchange_explicit(volatile atomic_short*, short, memory_order); +short atomic_exchange_explicit(atomic_short*, short, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_short*, short*, short); +bool atomic_compare_exchange_weak(atomic_short*, short*, short); +bool atomic_compare_exchange_strong(volatile atomic_short*, short*, short); +bool atomic_compare_exchange_strong(atomic_short*, short*, short); +bool atomic_compare_exchange_weak_explicit(volatile atomic_short*, short*, + short, memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_short*, short*, short, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_short*, short*, + short, memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_short*, short*, short, + memory_order, memory_order); +short atomic_fetch_add(volatile atomic_short*, short); +short atomic_fetch_add(atomic_short*, short); +short atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order); +short atomic_fetch_add_explicit(atomic_short*, short, memory_order); +short atomic_fetch_sub(volatile atomic_short*, short); +short atomic_fetch_sub(atomic_short*, short); +short atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order); +short atomic_fetch_sub_explicit(atomic_short*, short, memory_order); +short atomic_fetch_and(volatile atomic_short*, short); +short atomic_fetch_and(atomic_short*, short); +short atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order); +short atomic_fetch_and_explicit(atomic_short*, short, memory_order); +short atomic_fetch_or(volatile atomic_short*, short); +short atomic_fetch_or(atomic_short*, short); +short atomic_fetch_or_explicit(volatile atomic_short*, short, memory_order); +short atomic_fetch_or_explicit(atomic_short*, short, memory_order); +short atomic_fetch_xor(volatile atomic_short*, short); +short atomic_fetch_xor(atomic_short*, short); +short atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order); +short atomic_fetch_xor_explicit(atomic_short*, short, memory_order); + +typedef struct atomic_short +{ + short __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(short __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(short __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + short load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator short() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator short() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + short exchange(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short exchange(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(short& __v, short __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(short& __v, short __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(short& __v, short __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(short& __v, short __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(short& __v, short __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(short& __v, short __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(short& __v, short __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(short& __v, short __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + short fetch_add(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_add(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_sub(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_sub(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_and(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_and(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_or(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_or(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_xor(short __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + short fetch_xor(short __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_short() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_short() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_short(short __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_short(const atomic_short&) = delete; + atomic_short& operator=(const atomic_short&) = delete; + atomic_short& operator=(const atomic_short&) volatile = delete; +#else +private: + atomic_short(const atomic_short&); + atomic_short& operator=(const atomic_short&); + atomic_short& operator=(const atomic_short&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + short operator=(short __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + short operator=(short __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + short operator++(int) volatile + {return fetch_add(short(1));} + _LIBCPP_INLINE_VISIBILITY + short operator++(int) + {return fetch_add(short(1));} + _LIBCPP_INLINE_VISIBILITY + short operator--(int) volatile + {return fetch_sub(short(1));} + _LIBCPP_INLINE_VISIBILITY + short operator--(int) + {return fetch_sub(short(1));} + _LIBCPP_INLINE_VISIBILITY + short operator++() volatile + {return short(fetch_add(short(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + short operator++() + {return short(fetch_add(short(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + short operator--() volatile + {return short(fetch_sub(short(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + short operator--() + {return short(fetch_sub(short(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + short operator+=(short __v) volatile + {return short(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + short operator+=(short __v) + {return short(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + short operator-=(short __v) volatile + {return short(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + short operator-=(short __v) + {return short(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + short operator&=(short __v) volatile + {return short(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + short operator&=(short __v) + {return short(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + short operator|=(short __v) volatile + {return short(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + short operator|=(short __v) + {return short(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + short operator^=(short __v) volatile + {return short(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + short operator^=(short __v) + {return short(fetch_xor(__v) ^ __v);} +} atomic_short; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_short*) +{ + typedef short type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_short* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_short* __obj, short __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_short* __obj, short __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_short* __obj, short __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_short* __obj, short __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_short* __obj, short __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_short* __obj, short __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_load(const volatile atomic_short* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_load(const atomic_short* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_load_explicit(const volatile atomic_short* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_load_explicit(const atomic_short* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_exchange(volatile atomic_short* __obj, short __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_exchange(atomic_short* __obj, short __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_exchange_explicit(volatile atomic_short* __obj, short __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_exchange_explicit(atomic_short* __obj, short __desr, memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_short* __obj, short* __exp, + short __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_short* __obj, short* __exp, short __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_short* __obj, short* __exp, + short __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_short* __obj, short* __exp, short __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_short* __obj, + short* __exp, short __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_short* __obj, short* __exp, + short __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_short* __obj, + short* __exp, short __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_short* __obj, short* __exp, + short __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_add(volatile atomic_short* __obj, short __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_add(atomic_short* __obj, short __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_add_explicit(volatile atomic_short* __obj, short __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_add_explicit(atomic_short* __obj, short __v, memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_sub(volatile atomic_short* __obj, short __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_sub(atomic_short* __obj, short __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_sub_explicit(volatile atomic_short* __obj, short __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_sub_explicit(atomic_short* __obj, short __v, memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_and(volatile atomic_short* __obj, short __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_and(atomic_short* __obj, short __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_and_explicit(volatile atomic_short* __obj, short __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_and_explicit(atomic_short* __obj, short __v, memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_or(volatile atomic_short* __obj, short __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_or(atomic_short* __obj, short __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_or_explicit(volatile atomic_short* __obj, short __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_or_explicit(atomic_short* __obj, short __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_xor(volatile atomic_short* __obj, short __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_xor(atomic_short* __obj, short __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_xor_explicit(volatile atomic_short* __obj, short __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +short +atomic_fetch_xor_explicit(atomic_short* __obj, short __v, memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_ushort + +struct atomic_ushort; + +bool atomic_is_lock_free(const volatile atomic_ushort*); +bool atomic_is_lock_free(const atomic_ushort*); +void atomic_init(volatile atomic_ushort*, unsigned short); +void atomic_init(atomic_ushort*, unsigned short); +void atomic_store(volatile atomic_ushort*, unsigned short); +void atomic_store(atomic_ushort*, unsigned short); +void atomic_store_explicit(volatile atomic_ushort*, unsigned short, + memory_order); +void atomic_store_explicit(atomic_ushort*, unsigned short, memory_order); +unsigned short atomic_load(const volatile atomic_ushort*); +unsigned short atomic_load(const atomic_ushort*); +unsigned short atomic_load_explicit(const volatile atomic_ushort*, + memory_order); +unsigned short atomic_load_explicit(const atomic_ushort*, memory_order); +unsigned short atomic_exchange(volatile atomic_ushort*, unsigned short); +unsigned short atomic_exchange(atomic_ushort*, unsigned short); +unsigned short atomic_exchange_explicit(volatile atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_exchange_explicit(atomic_ushort*, unsigned short, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_ushort*, unsigned short*, + unsigned short); +bool atomic_compare_exchange_weak(atomic_ushort*, unsigned short*, + unsigned short); +bool atomic_compare_exchange_strong(volatile atomic_ushort*, unsigned short*, + unsigned short); +bool atomic_compare_exchange_strong(atomic_ushort*, unsigned short*, + unsigned short); +bool atomic_compare_exchange_weak_explicit(volatile atomic_ushort*, + unsigned short*, unsigned short, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_ushort*, unsigned short*, + unsigned short, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_ushort*, + unsigned short*, unsigned short, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_ushort*, unsigned short*, + unsigned short, memory_order, + memory_order); +unsigned short atomic_fetch_add(volatile atomic_ushort*, unsigned short); +unsigned short atomic_fetch_add(atomic_ushort*, unsigned short); +unsigned short atomic_fetch_add_explicit(volatile atomic_ushort*, + unsigned short, memory_order); +unsigned short atomic_fetch_add_explicit(atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_fetch_sub(volatile atomic_ushort*, unsigned short); +unsigned short atomic_fetch_sub(atomic_ushort*, unsigned short); +unsigned short atomic_fetch_sub_explicit(volatile atomic_ushort*, + unsigned short, memory_order); +unsigned short atomic_fetch_sub_explicit(atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_fetch_and(volatile atomic_ushort*, unsigned short); +unsigned short atomic_fetch_and(atomic_ushort*, unsigned short); +unsigned short atomic_fetch_and_explicit(volatile atomic_ushort*, + unsigned short, memory_order); +unsigned short atomic_fetch_and_explicit(atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_fetch_or(volatile atomic_ushort*, unsigned short); +unsigned short atomic_fetch_or(atomic_ushort*, unsigned short); +unsigned short atomic_fetch_or_explicit(volatile atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_fetch_or_explicit(atomic_ushort*, unsigned short, + memory_order); +unsigned short atomic_fetch_xor(volatile atomic_ushort*, unsigned short); +unsigned short atomic_fetch_xor(atomic_ushort*, unsigned short); +unsigned short atomic_fetch_xor_explicit(volatile atomic_ushort*, + unsigned short, memory_order); +unsigned short atomic_fetch_xor_explicit(atomic_ushort*, unsigned short, + memory_order); + +typedef struct atomic_ushort +{ + unsigned short __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned short __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator unsigned short() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator unsigned short() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + unsigned short exchange(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short exchange(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned short& __v, unsigned short __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned short& __v, unsigned short __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned short& __v, unsigned short __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned short& __v, unsigned short __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned short& __v, unsigned short __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned short& __v, unsigned short __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned short& __v, unsigned short __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned short& __v, unsigned short __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_add(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_add(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_sub(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_sub(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_and(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_and(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_or(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_or(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_xor(unsigned short __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned short fetch_xor(unsigned short __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_ushort() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_ushort() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_ushort(unsigned short __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_ushort(const atomic_ushort&) = delete; + atomic_ushort& operator=(const atomic_ushort&) = delete; + atomic_ushort& operator=(const atomic_ushort&) volatile = delete; +#else +private: + atomic_ushort(const atomic_ushort&); + atomic_ushort& operator=(const atomic_ushort&); + atomic_ushort& operator=(const atomic_ushort&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + unsigned short operator=(unsigned short __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned short operator=(unsigned short __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned short operator++(int) volatile + {typedef unsigned short type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + short operator++(int) + {typedef unsigned short type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + short operator--(int) volatile + {typedef unsigned short type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + short operator--(int) + {typedef unsigned short type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + short operator++() volatile + {typedef unsigned short type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + short operator++() + {typedef unsigned short type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + short operator--() volatile + {typedef unsigned short type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + short operator--() + {typedef unsigned short type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + short operator+=(short __v) volatile + {typedef unsigned short type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + short operator+=(short __v) + {typedef unsigned short type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + short operator-=(short __v) volatile + {typedef unsigned short type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + short operator-=(short __v) + {typedef unsigned short type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + short operator&=(short __v) volatile + {typedef unsigned short type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + short operator&=(short __v) + {typedef unsigned short type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + short operator|=(short __v) volatile + {typedef unsigned short type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + short operator|=(short __v) + {typedef unsigned short type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + short operator^=(short __v) volatile + {typedef unsigned short type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + short operator^=(short __v) + {typedef unsigned short type; return type(fetch_xor(__v) ^ __v);} +} atomic_ushort; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_ushort*) +{ + typedef unsigned short type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_ushort* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_ushort* __obj, unsigned short __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_ushort* __obj, unsigned short __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_ushort* __obj, unsigned short __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_ushort* __obj, unsigned short __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_ushort* __obj, unsigned short __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_ushort* __obj, unsigned short __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_load(const volatile atomic_ushort* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_load(const atomic_ushort* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_load_explicit(const volatile atomic_ushort* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_load_explicit(const atomic_ushort* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_exchange(volatile atomic_ushort* __obj, unsigned short __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_exchange(atomic_ushort* __obj, unsigned short __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_exchange_explicit(volatile atomic_ushort* __obj, unsigned short __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_exchange_explicit(atomic_ushort* __obj, unsigned short __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_ushort* __obj, + unsigned short* __exp, unsigned short __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_ushort* __obj, unsigned short* __exp, + unsigned short __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_ushort* __obj, + unsigned short* __exp, unsigned short __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_ushort* __obj, unsigned short* __exp, + unsigned short __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_ushort* __obj, + unsigned short* __exp, + unsigned short __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_ushort* __obj, + unsigned short* __exp, + unsigned short __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_ushort* __obj, + unsigned short* __exp, + unsigned short __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_ushort* __obj, + unsigned short* __exp, + unsigned short __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_add(volatile atomic_ushort* __obj, unsigned short __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_add(atomic_ushort* __obj, unsigned short __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_add_explicit(volatile atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_add_explicit(atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_sub(volatile atomic_ushort* __obj, unsigned short __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_sub(atomic_ushort* __obj, unsigned short __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_sub_explicit(volatile atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_sub_explicit(atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_and(volatile atomic_ushort* __obj, unsigned short __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_and(atomic_ushort* __obj, unsigned short __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_and_explicit(volatile atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_and_explicit(atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_or(volatile atomic_ushort* __obj, unsigned short __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_or(atomic_ushort* __obj, unsigned short __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_or_explicit(volatile atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_or_explicit(atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_xor(volatile atomic_ushort* __obj, unsigned short __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_xor(atomic_ushort* __obj, unsigned short __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_xor_explicit(volatile atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned short +atomic_fetch_xor_explicit(atomic_ushort* __obj, unsigned short __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_int + +struct atomic_int; + +bool atomic_is_lock_free(const volatile atomic_int*); +bool atomic_is_lock_free(const atomic_int*); +void atomic_init(volatile atomic_int*, int); +void atomic_init(atomic_int*, int); +void atomic_store(volatile atomic_int*, int); +void atomic_store(atomic_int*, int); +void atomic_store_explicit(volatile atomic_int*, int, memory_order); +void atomic_store_explicit(atomic_int*, int, memory_order); +int atomic_load(const volatile atomic_int*); +int atomic_load(const atomic_int*); +int atomic_load_explicit(const volatile atomic_int*, memory_order); +int atomic_load_explicit(const atomic_int*, memory_order); +int atomic_exchange(volatile atomic_int*, int); +int atomic_exchange(atomic_int*, int); +int atomic_exchange_explicit(volatile atomic_int*, int, memory_order); +int atomic_exchange_explicit(atomic_int*, int, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_int*, int*, int); +bool atomic_compare_exchange_weak(atomic_int*, int*, int); +bool atomic_compare_exchange_strong(volatile atomic_int*, int*, int); +bool atomic_compare_exchange_strong(atomic_int*, int*, int); +bool atomic_compare_exchange_weak_explicit(volatile atomic_int*, int*, int, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_int*, int*, int, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_int*, int*, int, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_int*, int*, int, + memory_order, memory_order); +int atomic_fetch_add(volatile atomic_int*, int); +int atomic_fetch_add(atomic_int*, int); +int atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order); +int atomic_fetch_add_explicit(atomic_int*, int, memory_order); +int atomic_fetch_sub(volatile atomic_int*, int); +int atomic_fetch_sub(atomic_int*, int); +int atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order); +int atomic_fetch_sub_explicit(atomic_int*, int, memory_order); +int atomic_fetch_and(volatile atomic_int*, int); +int atomic_fetch_and(atomic_int*, int); +int atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order); +int atomic_fetch_and_explicit(atomic_int*, int, memory_order); +int atomic_fetch_or(volatile atomic_int*, int); +int atomic_fetch_or(atomic_int*, int); +int atomic_fetch_or_explicit(volatile atomic_int*, int, memory_order); +int atomic_fetch_or_explicit(atomic_int*, int, memory_order); +int atomic_fetch_xor(volatile atomic_int*, int); +int atomic_fetch_xor(atomic_int*, int); +int atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order); +int atomic_fetch_xor_explicit(atomic_int*, int, memory_order); + +typedef struct atomic_int +{ + int __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(int __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(int __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + int load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator int() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator int() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + int exchange(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int exchange(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(int& __v, int __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(int& __v, int __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(int& __v, int __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(int& __v, int __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(int& __v, int __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(int& __v, int __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(int& __v, int __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(int& __v, int __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + int fetch_add(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_add(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_sub(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_sub(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_and(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_and(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_or(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_or(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_xor(int __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + int fetch_xor(int __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_int() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_int() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_int(int __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_int(const atomic_int&) = delete; + atomic_int& operator=(const atomic_int&) = delete; + atomic_int& operator=(const atomic_int&) volatile = delete; +#else +private: + atomic_int(const atomic_int&); + atomic_int& operator=(const atomic_int&); + atomic_int& operator=(const atomic_int&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + int operator=(int __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + int operator=(int __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + int operator++(int) volatile + {return fetch_add(int(1));} + _LIBCPP_INLINE_VISIBILITY + int operator++(int) + {return fetch_add(int(1));} + _LIBCPP_INLINE_VISIBILITY + int operator--(int) volatile + {return fetch_sub(int(1));} + _LIBCPP_INLINE_VISIBILITY + int operator--(int) + {return fetch_sub(int(1));} + _LIBCPP_INLINE_VISIBILITY + int operator++() volatile + {return int(fetch_add(int(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + int operator++() + {return int(fetch_add(int(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + int operator--() volatile + {return int(fetch_sub(int(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + int operator--() + {return int(fetch_sub(int(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + int operator+=(int __v) volatile + {return int(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + int operator+=(int __v) + {return int(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + int operator-=(int __v) volatile + {return int(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + int operator-=(int __v) + {return int(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + int operator&=(int __v) volatile + {return int(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + int operator&=(int __v) + {return int(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + int operator|=(int __v) volatile + {return int(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + int operator|=(int __v) + {return int(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + int operator^=(int __v) volatile + {return int(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + int operator^=(int __v) + {return int(fetch_xor(__v) ^ __v);} +} atomic_int; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_int*) +{ + typedef int type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_int* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_int* __obj, int __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_int* __obj, int __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_int* __obj, int __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_int* __obj, int __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_int* __obj, int __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_int* __obj, int __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_load(const volatile atomic_int* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_load(const atomic_int* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_load_explicit(const volatile atomic_int* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_load_explicit(const atomic_int* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_exchange(volatile atomic_int* __obj, int __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_exchange(atomic_int* __obj, int __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_exchange_explicit(volatile atomic_int* __obj, int __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_exchange_explicit(atomic_int* __obj, int __desr, memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_int* __obj, int* __exp, + int __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_int* __obj, int* __exp, int __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_int* __obj, int* __exp, + int __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_int* __obj, int* __exp, int __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_int* __obj, int* __exp, + int __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_int* __obj, int* __exp, + int __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_int* __obj, + int* __exp, int __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_int* __obj, int* __exp, + int __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_add(volatile atomic_int* __obj, int __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_add(atomic_int* __obj, int __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_add_explicit(volatile atomic_int* __obj, int __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_add_explicit(atomic_int* __obj, int __v, memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_sub(volatile atomic_int* __obj, int __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_sub(atomic_int* __obj, int __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_sub_explicit(volatile atomic_int* __obj, int __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_sub_explicit(atomic_int* __obj, int __v, memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_and(volatile atomic_int* __obj, int __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_and(atomic_int* __obj, int __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_and_explicit(volatile atomic_int* __obj, int __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_and_explicit(atomic_int* __obj, int __v, memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_or(volatile atomic_int* __obj, int __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_or(atomic_int* __obj, int __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_or_explicit(volatile atomic_int* __obj, int __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_or_explicit(atomic_int* __obj, int __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_xor(volatile atomic_int* __obj, int __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_xor(atomic_int* __obj, int __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_xor_explicit(volatile atomic_int* __obj, int __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +atomic_fetch_xor_explicit(atomic_int* __obj, int __v, memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_uint + +struct atomic_uint; + +bool atomic_is_lock_free(const volatile atomic_uint*); +bool atomic_is_lock_free(const atomic_uint*); +void atomic_init(volatile atomic_uint*, unsigned int); +void atomic_init(atomic_uint*, unsigned int); +void atomic_store(volatile atomic_uint*, unsigned int); +void atomic_store(atomic_uint*, unsigned int); +void atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order); +void atomic_store_explicit(atomic_uint*, unsigned int, memory_order); +unsigned int atomic_load(const volatile atomic_uint*); +unsigned int atomic_load(const atomic_uint*); +unsigned int atomic_load_explicit(const volatile atomic_uint*, memory_order); +unsigned int atomic_load_explicit(const atomic_uint*, memory_order); +unsigned int atomic_exchange(volatile atomic_uint*, unsigned int); +unsigned int atomic_exchange(atomic_uint*, unsigned int); +unsigned int atomic_exchange_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_exchange_explicit(atomic_uint*, unsigned int, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_uint*, unsigned int*, + unsigned int); +bool atomic_compare_exchange_weak(atomic_uint*, unsigned int*, unsigned int); +bool atomic_compare_exchange_strong(volatile atomic_uint*, unsigned int*, + unsigned int); +bool atomic_compare_exchange_strong(atomic_uint*, unsigned int*, + unsigned int); +bool atomic_compare_exchange_weak_explicit(volatile atomic_uint*, + unsigned int*, unsigned int, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_uint*, unsigned int*, + unsigned int, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_uint*, + unsigned int*, unsigned int, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_uint*, unsigned int*, + unsigned int, memory_order, + memory_order); +unsigned int atomic_fetch_add(volatile atomic_uint*, unsigned int); +unsigned int atomic_fetch_add(atomic_uint*, unsigned int); +unsigned int atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_add_explicit(atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_sub(volatile atomic_uint*, unsigned int); +unsigned int atomic_fetch_sub(atomic_uint*, unsigned int); +unsigned int atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_sub_explicit(atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_and(volatile atomic_uint*, unsigned int); +unsigned int atomic_fetch_and(atomic_uint*, unsigned int); +unsigned int atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_and_explicit(atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_or(volatile atomic_uint*, unsigned int); +unsigned int atomic_fetch_or(atomic_uint*, unsigned int); +unsigned int atomic_fetch_or_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_or_explicit(atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_xor(volatile atomic_uint*, unsigned int); +unsigned int atomic_fetch_xor(atomic_uint*, unsigned int); +unsigned int atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int, + memory_order); +unsigned int atomic_fetch_xor_explicit(atomic_uint*, unsigned int, + memory_order); + +typedef struct atomic_uint +{ + unsigned int __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned int __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator unsigned int() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator unsigned int() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + unsigned int exchange(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int exchange(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned int& __v, unsigned int __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned int& __v, unsigned int __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned int& __v, unsigned int __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned int& __v, unsigned int __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned int& __v, unsigned int __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned int& __v, unsigned int __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned int& __v, unsigned int __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned int& __v, unsigned int __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_add(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_add(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_sub(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_sub(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_and(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_and(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_or(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_or(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_xor(unsigned int __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned int fetch_xor(unsigned int __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_uint() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_uint() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_uint(unsigned int __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_uint(const atomic_uint&) = delete; + atomic_uint& operator=(const atomic_uint&) = delete; + atomic_uint& operator=(const atomic_uint&) volatile = delete; +#else +private: + atomic_uint(const atomic_uint&); + atomic_uint& operator=(const atomic_uint&); + atomic_uint& operator=(const atomic_uint&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + unsigned int operator=(unsigned int __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned int operator=(unsigned int __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned int operator++(int) volatile + {typedef unsigned int type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + int operator++(int) + {typedef unsigned int type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + int operator--(int) volatile + {typedef unsigned int type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + int operator--(int) + {typedef unsigned int type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + int operator++() volatile + {typedef unsigned int type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + int operator++() + {typedef unsigned int type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + int operator--() volatile + {typedef unsigned int type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + int operator--() + {typedef unsigned int type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + int operator+=(int __v) volatile + {typedef unsigned int type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + int operator+=(int __v) + {typedef unsigned int type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + int operator-=(int __v) volatile + {typedef unsigned int type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + int operator-=(int __v) + {typedef unsigned int type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + int operator&=(int __v) volatile + {typedef unsigned int type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + int operator&=(int __v) + {typedef unsigned int type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + int operator|=(int __v) volatile + {typedef unsigned int type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + int operator|=(int __v) + {typedef unsigned int type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + int operator^=(int __v) volatile + {typedef unsigned int type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + int operator^=(int __v) + {typedef unsigned int type; return type(fetch_xor(__v) ^ __v);} +} atomic_uint; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_uint*) +{ + typedef unsigned int type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_uint* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_uint* __obj, unsigned int __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_uint* __obj, unsigned int __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_uint* __obj, unsigned int __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_uint* __obj, unsigned int __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_uint* __obj, unsigned int __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_uint* __obj, unsigned int __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_load(const volatile atomic_uint* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_load(const atomic_uint* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_load_explicit(const volatile atomic_uint* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_load_explicit(const atomic_uint* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_exchange(volatile atomic_uint* __obj, unsigned int __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_exchange(atomic_uint* __obj, unsigned int __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_exchange_explicit(volatile atomic_uint* __obj, unsigned int __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_exchange_explicit(atomic_uint* __obj, unsigned int __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_uint* __obj, unsigned int* __exp, + unsigned int __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_uint* __obj, unsigned int* __exp, + unsigned int __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_uint* __obj, + unsigned int* __exp, unsigned int __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_uint* __obj, unsigned int* __exp, + unsigned int __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_uint* __obj, + unsigned int* __exp, + unsigned int __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_uint* __obj, unsigned int* __exp, + unsigned int __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_uint* __obj, + unsigned int* __exp, + unsigned int __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_uint* __obj, + unsigned int* __exp, + unsigned int __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_add(volatile atomic_uint* __obj, unsigned int __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_add(atomic_uint* __obj, unsigned int __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_add_explicit(volatile atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_add_explicit(atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_sub(volatile atomic_uint* __obj, unsigned int __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_sub(atomic_uint* __obj, unsigned int __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_sub_explicit(volatile atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_sub_explicit(atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_and(volatile atomic_uint* __obj, unsigned int __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_and(atomic_uint* __obj, unsigned int __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_and_explicit(volatile atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_and_explicit(atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_or(volatile atomic_uint* __obj, unsigned int __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_or(atomic_uint* __obj, unsigned int __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_or_explicit(volatile atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_or_explicit(atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_xor(volatile atomic_uint* __obj, unsigned int __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_xor(atomic_uint* __obj, unsigned int __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_xor_explicit(volatile atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned int +atomic_fetch_xor_explicit(atomic_uint* __obj, unsigned int __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_long + +struct atomic_long; + +bool atomic_is_lock_free(const volatile atomic_long*); +bool atomic_is_lock_free(const atomic_long*); +void atomic_init(volatile atomic_long*, long); +void atomic_init(atomic_long*, long); +void atomic_store(volatile atomic_long*, long); +void atomic_store(atomic_long*, long); +void atomic_store_explicit(volatile atomic_long*, long, memory_order); +void atomic_store_explicit(atomic_long*, long, memory_order); +long atomic_load(const volatile atomic_long*); +long atomic_load(const atomic_long*); +long atomic_load_explicit(const volatile atomic_long*, memory_order); +long atomic_load_explicit(const atomic_long*, memory_order); +long atomic_exchange(volatile atomic_long*, long); +long atomic_exchange(atomic_long*, long); +long atomic_exchange_explicit(volatile atomic_long*, long, memory_order); +long atomic_exchange_explicit(atomic_long*, long, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_long*, long*, long); +bool atomic_compare_exchange_weak(atomic_long*, long*, long); +bool atomic_compare_exchange_strong(volatile atomic_long*, long*, long); +bool atomic_compare_exchange_strong(atomic_long*, long*, long); +bool atomic_compare_exchange_weak_explicit(volatile atomic_long*, long*, long, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_long*, long*, long, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_long*, long*, long, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_long*, long*, long, + memory_order, memory_order); +long atomic_fetch_add(volatile atomic_long*, long); +long atomic_fetch_add(atomic_long*, long); +long atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order); +long atomic_fetch_add_explicit(atomic_long*, long, memory_order); +long atomic_fetch_sub(volatile atomic_long*, long); +long atomic_fetch_sub(atomic_long*, long); +long atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order); +long atomic_fetch_sub_explicit(atomic_long*, long, memory_order); +long atomic_fetch_and(volatile atomic_long*, long); +long atomic_fetch_and(atomic_long*, long); +long atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order); +long atomic_fetch_and_explicit(atomic_long*, long, memory_order); +long atomic_fetch_or(volatile atomic_long*, long); +long atomic_fetch_or(atomic_long*, long); +long atomic_fetch_or_explicit(volatile atomic_long*, long, memory_order); +long atomic_fetch_or_explicit(atomic_long*, long, memory_order); +long atomic_fetch_xor(volatile atomic_long*, long); +long atomic_fetch_xor(atomic_long*, long); +long atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order); +long atomic_fetch_xor_explicit(atomic_long*, long, memory_order); + +typedef struct atomic_long +{ + long __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(long __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(long __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + long load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator long() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator long() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + long exchange(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long exchange(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long& __v, long __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long& __v, long __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long& __v, long __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long& __v, long __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long& __v, long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long& __v, long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long& __v, long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long& __v, long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + long fetch_add(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_add(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_sub(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_sub(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_and(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_and(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_or(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_or(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_xor(long __v, memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long fetch_xor(long __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_long() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_long() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_long(long __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_long(const atomic_long&) = delete; + atomic_long& operator=(const atomic_long&) = delete; + atomic_long& operator=(const atomic_long&) volatile = delete; +#else +private: + atomic_long(const atomic_long&); + atomic_long& operator=(const atomic_long&); + atomic_long& operator=(const atomic_long&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + long operator=(long __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + long operator=(long __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + long operator++(int) volatile + {return fetch_add(long(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++(int) + {return fetch_add(long(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) volatile + {return fetch_sub(long(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) + {return fetch_sub(long(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++() volatile + {return long(fetch_add(long(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator++() + {return long(fetch_add(long(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() volatile + {return long(fetch_sub(long(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() + {return long(fetch_sub(long(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) volatile + {return long(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) + {return long(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) volatile + {return long(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) + {return long(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) volatile + {return long(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) + {return long(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) volatile + {return long(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) + {return long(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) volatile + {return long(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) + {return long(fetch_xor(__v) ^ __v);} +} atomic_long; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_long*) +{ + typedef long type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_long* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_long* __obj, long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_long* __obj, long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_long* __obj, long __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_long* __obj, long __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_long* __obj, long __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_long* __obj, long __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_load(const volatile atomic_long* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_load(const atomic_long* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_load_explicit(const volatile atomic_long* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_load_explicit(const atomic_long* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_exchange(volatile atomic_long* __obj, long __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_exchange(atomic_long* __obj, long __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_exchange_explicit(volatile atomic_long* __obj, long __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_exchange_explicit(atomic_long* __obj, long __desr, memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_long* __obj, long* __exp, + long __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_long* __obj, long* __exp, long __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_long* __obj, long* __exp, + long __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_long* __obj, long* __exp, long __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_long* __obj, long* __exp, + long __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_long* __obj, long* __exp, + long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_long* __obj, + long* __exp, long __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_long* __obj, long* __exp, + long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_add(volatile atomic_long* __obj, long __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_add(atomic_long* __obj, long __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_add_explicit(volatile atomic_long* __obj, long __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_add_explicit(atomic_long* __obj, long __v, memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_sub(volatile atomic_long* __obj, long __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_sub(atomic_long* __obj, long __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_sub_explicit(volatile atomic_long* __obj, long __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_sub_explicit(atomic_long* __obj, long __v, memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_and(volatile atomic_long* __obj, long __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_and(atomic_long* __obj, long __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_and_explicit(volatile atomic_long* __obj, long __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_and_explicit(atomic_long* __obj, long __v, memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_or(volatile atomic_long* __obj, long __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_or(atomic_long* __obj, long __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_or_explicit(volatile atomic_long* __obj, long __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_or_explicit(atomic_long* __obj, long __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_xor(volatile atomic_long* __obj, long __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_xor(atomic_long* __obj, long __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_xor_explicit(volatile atomic_long* __obj, long __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long +atomic_fetch_xor_explicit(atomic_long* __obj, long __v, memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_ulong + +struct atomic_ulong; + +bool atomic_is_lock_free(const volatile atomic_ulong*); +bool atomic_is_lock_free(const atomic_ulong*); +void atomic_init(volatile atomic_ulong*, unsigned long); +void atomic_init(atomic_ulong*, unsigned long); +void atomic_store(volatile atomic_ulong*, unsigned long); +void atomic_store(atomic_ulong*, unsigned long); +void atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order); +void atomic_store_explicit(atomic_ulong*, unsigned long, memory_order); +unsigned long atomic_load(const volatile atomic_ulong*); +unsigned long atomic_load(const atomic_ulong*); +unsigned long atomic_load_explicit(const volatile atomic_ulong*, memory_order); +unsigned long atomic_load_explicit(const atomic_ulong*, memory_order); +unsigned long atomic_exchange(volatile atomic_ulong*, unsigned long); +unsigned long atomic_exchange(atomic_ulong*, unsigned long); +unsigned long atomic_exchange_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_exchange_explicit(atomic_ulong*, unsigned long, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_ulong*, unsigned long*, + unsigned long); +bool atomic_compare_exchange_weak(atomic_ulong*, unsigned long*, unsigned long); +bool atomic_compare_exchange_strong(volatile atomic_ulong*, unsigned long*, + unsigned long); +bool atomic_compare_exchange_strong(atomic_ulong*, unsigned long*, + unsigned long); +bool atomic_compare_exchange_weak_explicit(volatile atomic_ulong*, + unsigned long*, unsigned long, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_ulong*, unsigned long*, + unsigned long, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_ulong*, + unsigned long*, unsigned long, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_ulong*, unsigned long*, + unsigned long, memory_order, + memory_order); +unsigned long atomic_fetch_add(volatile atomic_ulong*, unsigned long); +unsigned long atomic_fetch_add(atomic_ulong*, unsigned long); +unsigned long atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_add_explicit(atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_sub(volatile atomic_ulong*, unsigned long); +unsigned long atomic_fetch_sub(atomic_ulong*, unsigned long); +unsigned long atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_sub_explicit(atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_and(volatile atomic_ulong*, unsigned long); +unsigned long atomic_fetch_and(atomic_ulong*, unsigned long); +unsigned long atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_and_explicit(atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_or(volatile atomic_ulong*, unsigned long); +unsigned long atomic_fetch_or(atomic_ulong*, unsigned long); +unsigned long atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_or_explicit(atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_xor(volatile atomic_ulong*, unsigned long); +unsigned long atomic_fetch_xor(atomic_ulong*, unsigned long); +unsigned long atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long, + memory_order); +unsigned long atomic_fetch_xor_explicit(atomic_ulong*, unsigned long, + memory_order); + +typedef struct atomic_ulong +{ + unsigned long __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned long __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator unsigned long() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator unsigned long() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + unsigned long exchange(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long exchange(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long& __v, unsigned long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long& __v, unsigned long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long& __v, unsigned long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long& __v, unsigned long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long& __v, unsigned long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long& __v, unsigned long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long& __v, unsigned long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long& __v, unsigned long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_add(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_add(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_sub(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_sub(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_and(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_and(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_or(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_or(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_xor(unsigned long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long fetch_xor(unsigned long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_ulong() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_ulong() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_ulong(unsigned long __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_ulong(const atomic_ulong&) = delete; + atomic_ulong& operator=(const atomic_ulong&) = delete; + atomic_ulong& operator=(const atomic_ulong&) volatile = delete; +#else +private: + atomic_ulong(const atomic_ulong&); + atomic_ulong& operator=(const atomic_ulong&); + atomic_ulong& operator=(const atomic_ulong&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + unsigned long operator=(unsigned long __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned long operator=(unsigned long __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned long operator++(int) volatile + {typedef unsigned long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++(int) + {typedef unsigned long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) volatile + {typedef unsigned long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) + {typedef unsigned long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++() volatile + {typedef unsigned long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator++() + {typedef unsigned long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() volatile + {typedef unsigned long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() + {typedef unsigned long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) volatile + {typedef unsigned long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) + {typedef unsigned long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) volatile + {typedef unsigned long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) + {typedef unsigned long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) volatile + {typedef unsigned long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) + {typedef unsigned long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) volatile + {typedef unsigned long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) + {typedef unsigned long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) volatile + {typedef unsigned long type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) + {typedef unsigned long type; return type(fetch_xor(__v) ^ __v);} +} atomic_ulong; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_ulong*) +{ + typedef unsigned long type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_ulong* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_ulong* __obj, unsigned long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_ulong* __obj, unsigned long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_ulong* __obj, unsigned long __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_ulong* __obj, unsigned long __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_ulong* __obj, unsigned long __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_ulong* __obj, unsigned long __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_load(const volatile atomic_ulong* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_load(const atomic_ulong* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_load_explicit(const volatile atomic_ulong* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_load_explicit(const atomic_ulong* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_exchange(volatile atomic_ulong* __obj, unsigned long __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_exchange(atomic_ulong* __obj, unsigned long __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_exchange_explicit(volatile atomic_ulong* __obj, unsigned long __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_exchange_explicit(atomic_ulong* __obj, unsigned long __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_ulong* __obj, unsigned long* __exp, + unsigned long __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_ulong* __obj, unsigned long* __exp, + unsigned long __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_ulong* __obj, + unsigned long* __exp, unsigned long __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_ulong* __obj, unsigned long* __exp, + unsigned long __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_ulong* __obj, + unsigned long* __exp, + unsigned long __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_ulong* __obj, unsigned long* __exp, + unsigned long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_ulong* __obj, + unsigned long* __exp, + unsigned long __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_ulong* __obj, + unsigned long* __exp, + unsigned long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_add(volatile atomic_ulong* __obj, unsigned long __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_add(atomic_ulong* __obj, unsigned long __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_add_explicit(volatile atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_add_explicit(atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_sub(volatile atomic_ulong* __obj, unsigned long __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_sub(atomic_ulong* __obj, unsigned long __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_sub_explicit(volatile atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_sub_explicit(atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_and(volatile atomic_ulong* __obj, unsigned long __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_and(atomic_ulong* __obj, unsigned long __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_and_explicit(volatile atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_and_explicit(atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_or(volatile atomic_ulong* __obj, unsigned long __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_or(atomic_ulong* __obj, unsigned long __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_or_explicit(volatile atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_or_explicit(atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_xor(volatile atomic_ulong* __obj, unsigned long __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_xor(atomic_ulong* __obj, unsigned long __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_xor_explicit(volatile atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long +atomic_fetch_xor_explicit(atomic_ulong* __obj, unsigned long __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_llong + +struct atomic_llong; + +bool atomic_is_lock_free(const volatile atomic_llong*); +bool atomic_is_lock_free(const atomic_llong*); +void atomic_init(volatile atomic_llong*, long long); +void atomic_init(atomic_llong*, long long); +void atomic_store(volatile atomic_llong*, long long); +void atomic_store(atomic_llong*, long long); +void atomic_store_explicit(volatile atomic_llong*, long long, memory_order); +void atomic_store_explicit(atomic_llong*, long long, memory_order); +long long atomic_load(const volatile atomic_llong*); +long long atomic_load(const atomic_llong*); +long long atomic_load_explicit(const volatile atomic_llong*, memory_order); +long long atomic_load_explicit(const atomic_llong*, memory_order); +long long atomic_exchange(volatile atomic_llong*, long long); +long long atomic_exchange(atomic_llong*, long long); +long long atomic_exchange_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_exchange_explicit(atomic_llong*, long long, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_llong*, long long*, + long long); +bool atomic_compare_exchange_weak(atomic_llong*, long long*, long long); +bool atomic_compare_exchange_strong(volatile atomic_llong*, long long*, + long long); +bool atomic_compare_exchange_strong(atomic_llong*, long long*, + long long); +bool atomic_compare_exchange_weak_explicit(volatile atomic_llong*, + long long*, long long, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_llong*, long long*, + long long, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_llong*, + long long*, long long, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_llong*, long long*, + long long, memory_order, + memory_order); +long long atomic_fetch_add(volatile atomic_llong*, long long); +long long atomic_fetch_add(atomic_llong*, long long); +long long atomic_fetch_add_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_fetch_add_explicit(atomic_llong*, long long, + memory_order); +long long atomic_fetch_sub(volatile atomic_llong*, long long); +long long atomic_fetch_sub(atomic_llong*, long long); +long long atomic_fetch_sub_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_fetch_sub_explicit(atomic_llong*, long long, + memory_order); +long long atomic_fetch_and(volatile atomic_llong*, long long); +long long atomic_fetch_and(atomic_llong*, long long); +long long atomic_fetch_and_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_fetch_and_explicit(atomic_llong*, long long, + memory_order); +long long atomic_fetch_or(volatile atomic_llong*, long long); +long long atomic_fetch_or(atomic_llong*, long long); +long long atomic_fetch_or_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_fetch_or_explicit(atomic_llong*, long long, + memory_order); +long long atomic_fetch_xor(volatile atomic_llong*, long long); +long long atomic_fetch_xor(atomic_llong*, long long); +long long atomic_fetch_xor_explicit(volatile atomic_llong*, long long, + memory_order); +long long atomic_fetch_xor_explicit(atomic_llong*, long long, + memory_order); + +typedef struct atomic_llong +{ + long long __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(long long __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + long long load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator long long() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator long long() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + long long exchange(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long exchange(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long long& __v, long long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long long& __v, long long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long long& __v, long long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long long& __v, long long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long long& __v, long long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(long long& __v, long long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long long& __v, long long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(long long& __v, long long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + long long fetch_add(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_add(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_sub(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_sub(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_and(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_and(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_or(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_or(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_xor(long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + long long fetch_xor(long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_llong() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_llong() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_llong(long long __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_llong(const atomic_llong&) = delete; + atomic_llong& operator=(const atomic_llong&) = delete; + atomic_llong& operator=(const atomic_llong&) volatile = delete; +#else +private: + atomic_llong(const atomic_llong&); + atomic_llong& operator=(const atomic_llong&); + atomic_llong& operator=(const atomic_llong&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + long long operator=(long long __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + long long operator=(long long __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + long long operator++(int) volatile + {typedef long long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++(int) + {typedef long long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) volatile + {typedef long long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) + {typedef long long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++() volatile + {typedef long long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator++() + {typedef long long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() volatile + {typedef long long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() + {typedef long long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) volatile + {typedef long long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) + {typedef long long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) volatile + {typedef long long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) + {typedef long long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) volatile + {typedef long long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) + {typedef long long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) volatile + {typedef long long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) + {typedef long long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) volatile + {typedef long long type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) + {typedef long long type; return type(fetch_xor(__v) ^ __v);} +} atomic_llong; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_llong*) +{ + typedef long long type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_llong* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_llong* __obj, long long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_llong* __obj, long long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_llong* __obj, long long __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_llong* __obj, long long __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_llong* __obj, long long __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_llong* __obj, long long __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_load(const volatile atomic_llong* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_load(const atomic_llong* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_load_explicit(const volatile atomic_llong* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_load_explicit(const atomic_llong* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_exchange(volatile atomic_llong* __obj, long long __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_exchange(atomic_llong* __obj, long long __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_exchange_explicit(volatile atomic_llong* __obj, long long __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_exchange_explicit(atomic_llong* __obj, long long __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_llong* __obj, long long* __exp, + long long __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_llong* __obj, long long* __exp, + long long __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_llong* __obj, + long long* __exp, long long __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_llong* __obj, long long* __exp, + long long __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_llong* __obj, + long long* __exp, + long long __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_llong* __obj, long long* __exp, + long long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_llong* __obj, + long long* __exp, + long long __desr, memory_order __s, + memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_llong* __obj, + long long* __exp, + long long __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_add(volatile atomic_llong* __obj, long long __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_add(atomic_llong* __obj, long long __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_add_explicit(volatile atomic_llong* __obj, long long __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_add_explicit(atomic_llong* __obj, long long __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_sub(volatile atomic_llong* __obj, long long __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_sub(atomic_llong* __obj, long long __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_sub_explicit(volatile atomic_llong* __obj, long long __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_sub_explicit(atomic_llong* __obj, long long __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_and(volatile atomic_llong* __obj, long long __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_and(atomic_llong* __obj, long long __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_and_explicit(volatile atomic_llong* __obj, long long __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_and_explicit(atomic_llong* __obj, long long __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_or(volatile atomic_llong* __obj, long long __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_or(atomic_llong* __obj, long long __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_or_explicit(volatile atomic_llong* __obj, long long __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_or_explicit(atomic_llong* __obj, long long __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_xor(volatile atomic_llong* __obj, long long __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_xor(atomic_llong* __obj, long long __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_xor_explicit(volatile atomic_llong* __obj, long long __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +long long +atomic_fetch_xor_explicit(atomic_llong* __obj, long long __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_ullong + +struct atomic_ullong; + +bool atomic_is_lock_free(const volatile atomic_ullong*); +bool atomic_is_lock_free(const atomic_ullong*); +void atomic_init(volatile atomic_ullong*, unsigned long long); +void atomic_init(atomic_ullong*, unsigned long long); +void atomic_store(volatile atomic_ullong*, unsigned long long); +void atomic_store(atomic_ullong*, unsigned long long); +void atomic_store_explicit(volatile atomic_ullong*, unsigned long long, + memory_order); +void atomic_store_explicit(atomic_ullong*, unsigned long long, memory_order); +unsigned long long atomic_load(const volatile atomic_ullong*); +unsigned long long atomic_load(const atomic_ullong*); +unsigned long long atomic_load_explicit(const volatile atomic_ullong*, + memory_order); +unsigned long long atomic_load_explicit(const atomic_ullong*, memory_order); +unsigned long long atomic_exchange(volatile atomic_ullong*, unsigned long long); +unsigned long long atomic_exchange(atomic_ullong*, unsigned long long); +unsigned long long atomic_exchange_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_exchange_explicit(atomic_ullong*, unsigned long long, + memory_order); +bool atomic_compare_exchange_weak(volatile atomic_ullong*, unsigned long long*, + unsigned long long); +bool atomic_compare_exchange_weak(atomic_ullong*, unsigned long long*, + unsigned long long); +bool atomic_compare_exchange_strong(volatile atomic_ullong*, + unsigned long long*, unsigned long long); +bool atomic_compare_exchange_strong(atomic_ullong*, unsigned long long*, + unsigned long long); +bool atomic_compare_exchange_weak_explicit(volatile atomic_ullong*, + unsigned long long*, + unsigned long long, + memory_order, memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_ullong*, unsigned long long*, + unsigned long long, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_ullong*, + unsigned long long*, + unsigned long long, + memory_order, memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_ullong*, + unsigned long long*, + unsigned long long, memory_order, + memory_order); +unsigned long long atomic_fetch_add(volatile atomic_ullong*, + unsigned long long); +unsigned long long atomic_fetch_add(atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_add_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_fetch_add_explicit(atomic_ullong*, unsigned long long, + memory_order); +unsigned long long atomic_fetch_sub(volatile atomic_ullong*, + unsigned long long); +unsigned long long atomic_fetch_sub(atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_sub_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_fetch_sub_explicit(atomic_ullong*, unsigned long long, + memory_order); +unsigned long long atomic_fetch_and(volatile atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_and(atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_and_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_fetch_and_explicit(atomic_ullong*, unsigned long long, + memory_order); +unsigned long long atomic_fetch_or(volatile atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_or(atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_or_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_fetch_or_explicit(atomic_ullong*, unsigned long long, + memory_order); +unsigned long long atomic_fetch_xor(volatile atomic_ullong*, + unsigned long long); +unsigned long long atomic_fetch_xor(atomic_ullong*, unsigned long long); +unsigned long long atomic_fetch_xor_explicit(volatile atomic_ullong*, + unsigned long long, memory_order); +unsigned long long atomic_fetch_xor_explicit(atomic_ullong*, unsigned long long, + memory_order); + +typedef struct atomic_ullong +{ + unsigned long long __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(unsigned long long __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long load(memory_order __o = memory_order_seq_cst) const + volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator unsigned long long() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator unsigned long long() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + unsigned long long exchange(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long exchange(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e, + memory_order __s, memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e, + memory_order __s, memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_add(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_add(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_sub(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_sub(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_and(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_and(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_or(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_or(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_xor(unsigned long long __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + unsigned long long fetch_xor(unsigned long long __v, + memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_ullong() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_ullong() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_ullong(unsigned long long __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_ullong(const atomic_ullong&) = delete; + atomic_ullong& operator=(const atomic_ullong&) = delete; + atomic_ullong& operator=(const atomic_ullong&) volatile = delete; +#else +private: + atomic_ullong(const atomic_ullong&); + atomic_ullong& operator=(const atomic_ullong&); + atomic_ullong& operator=(const atomic_ullong&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + unsigned long long operator=(unsigned long long __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned long long operator=(unsigned long long __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + unsigned long long operator++(int) volatile + {typedef unsigned long long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++(int) + {typedef unsigned long long type; return fetch_add(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) volatile + {typedef unsigned long long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator--(int) + {typedef unsigned long long type; return fetch_sub(type(1));} + _LIBCPP_INLINE_VISIBILITY + long operator++() volatile + {typedef unsigned long long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator++() + {typedef unsigned long long type; return type(fetch_add(type(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() volatile + {typedef unsigned long long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator--() + {typedef unsigned long long type; return type(fetch_sub(type(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) volatile + {typedef unsigned long long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator+=(long __v) + {typedef unsigned long long type; return type(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) volatile + {typedef unsigned long long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator-=(long __v) + {typedef unsigned long long type; return type(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) volatile + {typedef unsigned long long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator&=(long __v) + {typedef unsigned long long type; return type(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) volatile + {typedef unsigned long long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator|=(long __v) + {typedef unsigned long long type; return type(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) volatile + {typedef unsigned long long type; return type(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + long operator^=(long __v) + {typedef unsigned long long type; return type(fetch_xor(__v) ^ __v);} +} atomic_ullong; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_ullong*) +{ + typedef unsigned long long type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_ullong* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_ullong* __obj, unsigned long long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_ullong* __obj, unsigned long long __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_ullong* __obj, unsigned long long __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_ullong* __obj, unsigned long long __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_ullong* __obj, unsigned long long __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_ullong* __obj, unsigned long long __desr, + memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_load(const volatile atomic_ullong* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_load(const atomic_ullong* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_load_explicit(const volatile atomic_ullong* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_load_explicit(const atomic_ullong* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_exchange(volatile atomic_ullong* __obj, unsigned long long __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_exchange(atomic_ullong* __obj, unsigned long long __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_exchange_explicit(volatile atomic_ullong* __obj, + unsigned long long __desr, memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_exchange_explicit(atomic_ullong* __obj, unsigned long long __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_ullong* __obj, unsigned long long* __exp, + unsigned long long __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_ullong* __obj, unsigned long long* __exp, + unsigned long long __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr, + memory_order __s, memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_ullong* __obj, + unsigned long long* __exp, + unsigned long long __desr, + memory_order __s, memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_add(volatile atomic_ullong* __obj, unsigned long long __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_add(atomic_ullong* __obj, unsigned long long __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_add_explicit(volatile atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_add_explicit(atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_sub(volatile atomic_ullong* __obj, unsigned long long __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_sub(atomic_ullong* __obj, unsigned long long __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_sub_explicit(volatile atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_sub_explicit(atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_and(volatile atomic_ullong* __obj, unsigned long long __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_and(atomic_ullong* __obj, unsigned long long __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_and_explicit(volatile atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_and_explicit(atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_or(volatile atomic_ullong* __obj, unsigned long long __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_or(atomic_ullong* __obj, unsigned long long __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_or_explicit(volatile atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_or_explicit(atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_xor(volatile atomic_ullong* __obj, unsigned long long __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_xor(atomic_ullong* __obj, unsigned long long __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_xor_explicit(volatile atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +unsigned long long +atomic_fetch_xor_explicit(atomic_ullong* __obj, unsigned long long __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + +// atomic_char16_t + +struct atomic_char16_t; + +bool atomic_is_lock_free(const volatile atomic_char16_t*); +bool atomic_is_lock_free(const atomic_char16_t*); +void atomic_init(volatile atomic_char16_t*, char16_t); +void atomic_init(atomic_char16_t*, char16_t); +void atomic_store(volatile atomic_char16_t*, char16_t); +void atomic_store(atomic_char16_t*, char16_t); +void atomic_store_explicit(volatile atomic_char16_t*, char16_t, memory_order); +void atomic_store_explicit(atomic_char16_t*, char16_t, memory_order); +char16_t atomic_load(const volatile atomic_char16_t*); +char16_t atomic_load(const atomic_char16_t*); +char16_t atomic_load_explicit(const volatile atomic_char16_t*, memory_order); +char16_t atomic_load_explicit(const atomic_char16_t*, memory_order); +char16_t atomic_exchange(volatile atomic_char16_t*, char16_t); +char16_t atomic_exchange(atomic_char16_t*, char16_t); +char16_t atomic_exchange_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_exchange_explicit(atomic_char16_t*, char16_t, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_char16_t*, char16_t*, + char16_t); +bool atomic_compare_exchange_weak(atomic_char16_t*, char16_t*, char16_t); +bool atomic_compare_exchange_strong(volatile atomic_char16_t*, char16_t*, + char16_t); +bool atomic_compare_exchange_strong(atomic_char16_t*, char16_t*, char16_t); +bool atomic_compare_exchange_weak_explicit(volatile atomic_char16_t*, char16_t*, + char16_t, memory_order, + memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_char16_t*, char16_t*, + char16_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_char16_t*, + char16_t*, char16_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_char16_t*, char16_t*, + char16_t, memory_order, + memory_order); +char16_t atomic_fetch_add(volatile atomic_char16_t*, char16_t); +char16_t atomic_fetch_add(atomic_char16_t*, char16_t); +char16_t atomic_fetch_add_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_fetch_add_explicit(atomic_char16_t*, char16_t, memory_order); +char16_t atomic_fetch_sub(volatile atomic_char16_t*, char16_t); +char16_t atomic_fetch_sub(atomic_char16_t*, char16_t); +char16_t atomic_fetch_sub_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_fetch_sub_explicit(atomic_char16_t*, char16_t, memory_order); +char16_t atomic_fetch_and(volatile atomic_char16_t*, char16_t); +char16_t atomic_fetch_and(atomic_char16_t*, char16_t); +char16_t atomic_fetch_and_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_fetch_and_explicit(atomic_char16_t*, char16_t, memory_order); +char16_t atomic_fetch_or(volatile atomic_char16_t*, char16_t); +char16_t atomic_fetch_or(atomic_char16_t*, char16_t); +char16_t atomic_fetch_or_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_fetch_or_explicit(atomic_char16_t*, char16_t, memory_order); +char16_t atomic_fetch_xor(volatile atomic_char16_t*, char16_t); +char16_t atomic_fetch_xor(atomic_char16_t*, char16_t); +char16_t atomic_fetch_xor_explicit(volatile atomic_char16_t*, char16_t, + memory_order); +char16_t atomic_fetch_xor_explicit(atomic_char16_t*, char16_t, memory_order); + +typedef struct atomic_char16_t +{ + char16_t __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(char16_t __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(char16_t __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator char16_t() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator char16_t() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + char16_t exchange(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t exchange(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char16_t& __v, char16_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char16_t& __v, char16_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char16_t& __v, char16_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char16_t& __v, char16_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char16_t& __v, char16_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char16_t& __v, char16_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char16_t& __v, char16_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char16_t& __v, char16_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_add(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_add(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_sub(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_sub(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_and(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_and(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_or(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_or(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_xor(char16_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char16_t fetch_xor(char16_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_char16_t() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_char16_t() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_char16_t(char16_t __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_char16_t(const atomic_char16_t&) = delete; + atomic_char16_t& operator=(const atomic_char16_t&) = delete; + atomic_char16_t& operator=(const atomic_char16_t&) volatile = delete; +#else +private: + atomic_char16_t(const atomic_char16_t&); + atomic_char16_t& operator=(const atomic_char16_t&); + atomic_char16_t& operator=(const atomic_char16_t&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + char16_t operator=(char16_t __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + char16_t operator=(char16_t __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + char16_t operator++(int) volatile + {return fetch_add(char16_t(1));} + _LIBCPP_INLINE_VISIBILITY + char16_t operator++(int) + {return fetch_add(char16_t(1));} + _LIBCPP_INLINE_VISIBILITY + char16_t operator--(int) volatile + {return fetch_sub(char16_t(1));} + _LIBCPP_INLINE_VISIBILITY + char16_t operator--(int) + {return fetch_sub(char16_t(1));} + _LIBCPP_INLINE_VISIBILITY + char16_t operator++() volatile + {return char16_t(fetch_add(char16_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator++() + {return char16_t(fetch_add(char16_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator--() volatile + {return char16_t(fetch_sub(char16_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator--() + {return char16_t(fetch_sub(char16_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator+=(char16_t __v) volatile + {return char16_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator+=(char16_t __v) + {return char16_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator-=(char16_t __v) volatile + {return char16_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator-=(char16_t __v) + {return char16_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator&=(char16_t __v) volatile + {return char16_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator&=(char16_t __v) + {return char16_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator|=(char16_t __v) volatile + {return char16_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator|=(char16_t __v) + {return char16_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator^=(char16_t __v) volatile + {return char16_t(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + char16_t operator^=(char16_t __v) + {return char16_t(fetch_xor(__v) ^ __v);} +} atomic_char16_t; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_char16_t*) +{ + typedef char16_t type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_char16_t* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_char16_t* __obj, char16_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_char16_t* __obj, char16_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_char16_t* __obj, char16_t __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_char16_t* __obj, char16_t __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_char16_t* __obj, char16_t __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_char16_t* __obj, char16_t __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_load(const volatile atomic_char16_t* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_load(const atomic_char16_t* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_load_explicit(const volatile atomic_char16_t* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_load_explicit(const atomic_char16_t* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_exchange(volatile atomic_char16_t* __obj, char16_t __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_exchange(atomic_char16_t* __obj, char16_t __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_exchange_explicit(volatile atomic_char16_t* __obj, char16_t __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_exchange_explicit(atomic_char16_t* __obj, char16_t __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_char16_t* __obj, + char16_t* __exp, char16_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_char16_t* __obj, + char16_t* __exp, char16_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_char16_t* __obj, char16_t* __exp, + char16_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_add(volatile atomic_char16_t* __obj, char16_t __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_add(atomic_char16_t* __obj, char16_t __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_add_explicit(volatile atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_add_explicit(atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_sub(volatile atomic_char16_t* __obj, char16_t __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_sub(atomic_char16_t* __obj, char16_t __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_sub_explicit(volatile atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_sub_explicit(atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_and(volatile atomic_char16_t* __obj, char16_t __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_and(atomic_char16_t* __obj, char16_t __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_and_explicit(volatile atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_and_explicit(atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_or(volatile atomic_char16_t* __obj, char16_t __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_or(atomic_char16_t* __obj, char16_t __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_or_explicit(volatile atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_or_explicit(atomic_char16_t* __obj, char16_t __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_xor(volatile atomic_char16_t* __obj, char16_t __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_xor(atomic_char16_t* __obj, char16_t __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_xor_explicit(volatile atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char16_t +atomic_fetch_xor_explicit(atomic_char16_t* __obj, char16_t __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +// atomic_char32_t + +struct atomic_char32_t; + +bool atomic_is_lock_free(const volatile atomic_char32_t*); +bool atomic_is_lock_free(const atomic_char32_t*); +void atomic_init(volatile atomic_char32_t*, char32_t); +void atomic_init(atomic_char32_t*, char32_t); +void atomic_store(volatile atomic_char32_t*, char32_t); +void atomic_store(atomic_char32_t*, char32_t); +void atomic_store_explicit(volatile atomic_char32_t*, char32_t, memory_order); +void atomic_store_explicit(atomic_char32_t*, char32_t, memory_order); +char32_t atomic_load(const volatile atomic_char32_t*); +char32_t atomic_load(const atomic_char32_t*); +char32_t atomic_load_explicit(const volatile atomic_char32_t*, memory_order); +char32_t atomic_load_explicit(const atomic_char32_t*, memory_order); +char32_t atomic_exchange(volatile atomic_char32_t*, char32_t); +char32_t atomic_exchange(atomic_char32_t*, char32_t); +char32_t atomic_exchange_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_exchange_explicit(atomic_char32_t*, char32_t, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_char32_t*, char32_t*, + char32_t); +bool atomic_compare_exchange_weak(atomic_char32_t*, char32_t*, char32_t); +bool atomic_compare_exchange_strong(volatile atomic_char32_t*, char32_t*, + char32_t); +bool atomic_compare_exchange_strong(atomic_char32_t*, char32_t*, char32_t); +bool atomic_compare_exchange_weak_explicit(volatile atomic_char32_t*, char32_t*, + char32_t, memory_order, + memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_char32_t*, char32_t*, + char32_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_char32_t*, + char32_t*, char32_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_char32_t*, char32_t*, + char32_t, memory_order, + memory_order); +char32_t atomic_fetch_add(volatile atomic_char32_t*, char32_t); +char32_t atomic_fetch_add(atomic_char32_t*, char32_t); +char32_t atomic_fetch_add_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_fetch_add_explicit(atomic_char32_t*, char32_t, memory_order); +char32_t atomic_fetch_sub(volatile atomic_char32_t*, char32_t); +char32_t atomic_fetch_sub(atomic_char32_t*, char32_t); +char32_t atomic_fetch_sub_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_fetch_sub_explicit(atomic_char32_t*, char32_t, memory_order); +char32_t atomic_fetch_and(volatile atomic_char32_t*, char32_t); +char32_t atomic_fetch_and(atomic_char32_t*, char32_t); +char32_t atomic_fetch_and_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_fetch_and_explicit(atomic_char32_t*, char32_t, memory_order); +char32_t atomic_fetch_or(volatile atomic_char32_t*, char32_t); +char32_t atomic_fetch_or(atomic_char32_t*, char32_t); +char32_t atomic_fetch_or_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_fetch_or_explicit(atomic_char32_t*, char32_t, memory_order); +char32_t atomic_fetch_xor(volatile atomic_char32_t*, char32_t); +char32_t atomic_fetch_xor(atomic_char32_t*, char32_t); +char32_t atomic_fetch_xor_explicit(volatile atomic_char32_t*, char32_t, + memory_order); +char32_t atomic_fetch_xor_explicit(atomic_char32_t*, char32_t, memory_order); + +typedef struct atomic_char32_t +{ + char32_t __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(char32_t __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(char32_t __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator char32_t() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator char32_t() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + char32_t exchange(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t exchange(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char32_t& __v, char32_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char32_t& __v, char32_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char32_t& __v, char32_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char32_t& __v, char32_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char32_t& __v, char32_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(char32_t& __v, char32_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char32_t& __v, char32_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(char32_t& __v, char32_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_add(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_add(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_sub(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_sub(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_and(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_and(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_or(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_or(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_xor(char32_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + char32_t fetch_xor(char32_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_char32_t() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_char32_t() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_char32_t(char32_t __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_char32_t(const atomic_char32_t&) = delete; + atomic_char32_t& operator=(const atomic_char32_t&) = delete; + atomic_char32_t& operator=(const atomic_char32_t&) volatile = delete; +#else +private: + atomic_char32_t(const atomic_char32_t&); + atomic_char32_t& operator=(const atomic_char32_t&); + atomic_char32_t& operator=(const atomic_char32_t&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + char32_t operator=(char32_t __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + char32_t operator=(char32_t __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + char32_t operator++(int) volatile + {return fetch_add(char32_t(1));} + _LIBCPP_INLINE_VISIBILITY + char32_t operator++(int) + {return fetch_add(char32_t(1));} + _LIBCPP_INLINE_VISIBILITY + char32_t operator--(int) volatile + {return fetch_sub(char32_t(1));} + _LIBCPP_INLINE_VISIBILITY + char32_t operator--(int) + {return fetch_sub(char32_t(1));} + _LIBCPP_INLINE_VISIBILITY + char32_t operator++() volatile + {return char32_t(fetch_add(char32_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator++() + {return char32_t(fetch_add(char32_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator--() volatile + {return char32_t(fetch_sub(char32_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator--() + {return char32_t(fetch_sub(char32_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator+=(char32_t __v) volatile + {return char32_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator+=(char32_t __v) + {return char32_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator-=(char32_t __v) volatile + {return char32_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator-=(char32_t __v) + {return char32_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator&=(char32_t __v) volatile + {return char32_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator&=(char32_t __v) + {return char32_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator|=(char32_t __v) volatile + {return char32_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator|=(char32_t __v) + {return char32_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator^=(char32_t __v) volatile + {return char32_t(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + char32_t operator^=(char32_t __v) + {return char32_t(fetch_xor(__v) ^ __v);} +} atomic_char32_t; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_char32_t*) +{ + typedef char32_t type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_char32_t* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_char32_t* __obj, char32_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_char32_t* __obj, char32_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_char32_t* __obj, char32_t __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_char32_t* __obj, char32_t __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_char32_t* __obj, char32_t __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_char32_t* __obj, char32_t __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_load(const volatile atomic_char32_t* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_load(const atomic_char32_t* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_load_explicit(const volatile atomic_char32_t* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_load_explicit(const atomic_char32_t* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_exchange(volatile atomic_char32_t* __obj, char32_t __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_exchange(atomic_char32_t* __obj, char32_t __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_exchange_explicit(volatile atomic_char32_t* __obj, char32_t __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_exchange_explicit(atomic_char32_t* __obj, char32_t __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_char32_t* __obj, + char32_t* __exp, char32_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_char32_t* __obj, + char32_t* __exp, char32_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_char32_t* __obj, char32_t* __exp, + char32_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_add(volatile atomic_char32_t* __obj, char32_t __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_add(atomic_char32_t* __obj, char32_t __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_add_explicit(volatile atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_add_explicit(atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_sub(volatile atomic_char32_t* __obj, char32_t __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_sub(atomic_char32_t* __obj, char32_t __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_sub_explicit(volatile atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_sub_explicit(atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_and(volatile atomic_char32_t* __obj, char32_t __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_and(atomic_char32_t* __obj, char32_t __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_and_explicit(volatile atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_and_explicit(atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_or(volatile atomic_char32_t* __obj, char32_t __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_or(atomic_char32_t* __obj, char32_t __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_or_explicit(volatile atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_or_explicit(atomic_char32_t* __obj, char32_t __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_xor(volatile atomic_char32_t* __obj, char32_t __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_xor(atomic_char32_t* __obj, char32_t __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_xor_explicit(volatile atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +char32_t +atomic_fetch_xor_explicit(atomic_char32_t* __obj, char32_t __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + +// atomic_wchar_t + +struct atomic_wchar_t; + +bool atomic_is_lock_free(const volatile atomic_wchar_t*); +bool atomic_is_lock_free(const atomic_wchar_t*); +void atomic_init(volatile atomic_wchar_t*, wchar_t); +void atomic_init(atomic_wchar_t*, wchar_t); +void atomic_store(volatile atomic_wchar_t*, wchar_t); +void atomic_store(atomic_wchar_t*, wchar_t); +void atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order); +void atomic_store_explicit(atomic_wchar_t*, wchar_t, memory_order); +wchar_t atomic_load(const volatile atomic_wchar_t*); +wchar_t atomic_load(const atomic_wchar_t*); +wchar_t atomic_load_explicit(const volatile atomic_wchar_t*, memory_order); +wchar_t atomic_load_explicit(const atomic_wchar_t*, memory_order); +wchar_t atomic_exchange(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_exchange(atomic_wchar_t*, wchar_t); +wchar_t atomic_exchange_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_exchange_explicit(atomic_wchar_t*, wchar_t, memory_order); +bool atomic_compare_exchange_weak(volatile atomic_wchar_t*, wchar_t*, + wchar_t); +bool atomic_compare_exchange_weak(atomic_wchar_t*, wchar_t*, wchar_t); +bool atomic_compare_exchange_strong(volatile atomic_wchar_t*, wchar_t*, + wchar_t); +bool atomic_compare_exchange_strong(atomic_wchar_t*, wchar_t*, wchar_t); +bool atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t*, wchar_t*, + wchar_t, memory_order, + memory_order); +bool atomic_compare_exchange_weak_explicit(atomic_wchar_t*, wchar_t*, + wchar_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t*, + wchar_t*, wchar_t, memory_order, + memory_order); +bool atomic_compare_exchange_strong_explicit(atomic_wchar_t*, wchar_t*, + wchar_t, memory_order, + memory_order); +wchar_t atomic_fetch_add(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_add(atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_fetch_add_explicit(atomic_wchar_t*, wchar_t, memory_order); +wchar_t atomic_fetch_sub(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_sub(atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_fetch_sub_explicit(atomic_wchar_t*, wchar_t, memory_order); +wchar_t atomic_fetch_and(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_and(atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_fetch_and_explicit(atomic_wchar_t*, wchar_t, memory_order); +wchar_t atomic_fetch_or(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_or(atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_fetch_or_explicit(atomic_wchar_t*, wchar_t, memory_order); +wchar_t atomic_fetch_xor(volatile atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_xor(atomic_wchar_t*, wchar_t); +wchar_t atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t, + memory_order); +wchar_t atomic_fetch_xor_explicit(atomic_wchar_t*, wchar_t, memory_order); + +typedef struct atomic_wchar_t +{ + wchar_t __v_; + + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const volatile + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + bool is_lock_free() const + {return atomic_is_lock_free(this);} + _LIBCPP_INLINE_VISIBILITY + void store(wchar_t __v, memory_order __o = memory_order_seq_cst) volatile + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + void store(wchar_t __v, memory_order __o = memory_order_seq_cst) + {atomic_store_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t load(memory_order __o = memory_order_seq_cst) const volatile + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t load(memory_order __o = memory_order_seq_cst) const + {return atomic_load_explicit(this, __o);} + _LIBCPP_INLINE_VISIBILITY + operator wchar_t() const volatile + {return load();} + _LIBCPP_INLINE_VISIBILITY + operator wchar_t() const + {return load();} + _LIBCPP_INLINE_VISIBILITY + wchar_t exchange(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t exchange(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_exchange_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(wchar_t& __v, wchar_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(wchar_t& __v, wchar_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(wchar_t& __v, wchar_t __e, memory_order __s, + memory_order __f) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(wchar_t& __v, wchar_t __e, memory_order __s, + memory_order __f) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __f);} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(wchar_t& __v, wchar_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_weak(wchar_t& __v, wchar_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(wchar_t& __v, wchar_t __e, + memory_order __s = memory_order_seq_cst) volatile + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + bool compare_exchange_strong(wchar_t& __v, wchar_t __e, + memory_order __s = memory_order_seq_cst) + {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s, + __translate_memory_order(__s));} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_add(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_add(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_add_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_sub(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_sub(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_sub_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_and(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_and(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_and_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_or(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_or(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_or_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_xor(wchar_t __v, + memory_order __o = memory_order_seq_cst) volatile + {return atomic_fetch_xor_explicit(this, __v, __o);} + _LIBCPP_INLINE_VISIBILITY + wchar_t fetch_xor(wchar_t __v, memory_order __o = memory_order_seq_cst) + {return atomic_fetch_xor_explicit(this, __v, __o);} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + atomic_wchar_t() = default; +#else + _LIBCPP_INLINE_VISIBILITY + atomic_wchar_t() {} +#endif + _LIBCPP_INLINE_VISIBILITY + /*constexpr*/ atomic_wchar_t(wchar_t __v) + : __v_(__v) {} +#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS + atomic_wchar_t(const atomic_wchar_t&) = delete; + atomic_wchar_t& operator=(const atomic_wchar_t&) = delete; + atomic_wchar_t& operator=(const atomic_wchar_t&) volatile = delete; +#else +private: + atomic_wchar_t(const atomic_wchar_t&); + atomic_wchar_t& operator=(const atomic_wchar_t&); + atomic_wchar_t& operator=(const atomic_wchar_t&) volatile; +public: +#endif + _LIBCPP_INLINE_VISIBILITY + wchar_t operator=(wchar_t __v) volatile + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator=(wchar_t __v) + {store(__v); return __v;} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator++(int) volatile + {return fetch_add(wchar_t(1));} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator++(int) + {return fetch_add(wchar_t(1));} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator--(int) volatile + {return fetch_sub(wchar_t(1));} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator--(int) + {return fetch_sub(wchar_t(1));} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator++() volatile + {return wchar_t(fetch_add(wchar_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator++() + {return wchar_t(fetch_add(wchar_t(1)) + 1);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator--() volatile + {return wchar_t(fetch_sub(wchar_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator--() + {return wchar_t(fetch_sub(wchar_t(1)) - 1);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator+=(wchar_t __v) volatile + {return wchar_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator+=(wchar_t __v) + {return wchar_t(fetch_add(__v) + __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator-=(wchar_t __v) volatile + {return wchar_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator-=(wchar_t __v) + {return wchar_t(fetch_sub(__v) - __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator&=(wchar_t __v) volatile + {return wchar_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator&=(wchar_t __v) + {return wchar_t(fetch_and(__v) & __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator|=(wchar_t __v) volatile + {return wchar_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator|=(wchar_t __v) + {return wchar_t(fetch_or(__v) | __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator^=(wchar_t __v) volatile + {return wchar_t(fetch_xor(__v) ^ __v);} + _LIBCPP_INLINE_VISIBILITY + wchar_t operator^=(wchar_t __v) + {return wchar_t(fetch_xor(__v) ^ __v);} +} atomic_wchar_t; + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const volatile atomic_wchar_t*) +{ + typedef wchar_t type; + return __atomic_is_lock_free(type); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_is_lock_free(const atomic_wchar_t* __obj) +{ + return atomic_is_lock_free(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(volatile atomic_wchar_t* __obj, wchar_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_init(atomic_wchar_t* __obj, wchar_t __desr) +{ + __obj->__v_ = __desr; +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(volatile atomic_wchar_t* __obj, wchar_t __desr) +{ + __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store(atomic_wchar_t* __obj, wchar_t __desr) +{ + atomic_store(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(volatile atomic_wchar_t* __obj, wchar_t __desr, + memory_order __o) +{ + __atomic_store(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +void +atomic_store_explicit(atomic_wchar_t* __obj, wchar_t __desr, memory_order __o) +{ + atomic_store_explicit(const_cast(__obj), __desr, + __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_load(const volatile atomic_wchar_t* __obj) +{ + return __atomic_load(&__obj->__v_, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_load(const atomic_wchar_t* __obj) +{ + return atomic_load(const_cast(__obj)); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_load_explicit(const volatile atomic_wchar_t* __obj, memory_order __o) +{ + return __atomic_load(&__obj->__v_, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_load_explicit(const atomic_wchar_t* __obj, memory_order __o) +{ + return atomic_load_explicit(const_cast + (__obj), __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_exchange(volatile atomic_wchar_t* __obj, wchar_t __desr) +{ + return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_exchange(atomic_wchar_t* __obj, wchar_t __desr) +{ + return atomic_exchange(const_cast(__obj), __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_exchange_explicit(volatile atomic_wchar_t* __obj, wchar_t __desr, + memory_order __o) +{ + return __atomic_exchange(&__obj->__v_, __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_exchange_explicit(atomic_wchar_t* __obj, wchar_t __desr, + memory_order __o) +{ + return atomic_exchange_explicit(const_cast + (__obj), __desr, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(volatile atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak(atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr) +{ + return atomic_compare_exchange_weak(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(volatile atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, + memory_order_seq_cst, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong(atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr) +{ + return atomic_compare_exchange_strong(const_cast + (__obj), __exp, __desr); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t* __obj, + wchar_t* __exp, wchar_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_weak_explicit(atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_weak_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t* __obj, + wchar_t* __exp, wchar_t __desr, + memory_order __s, memory_order __f) +{ + return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s, + __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +atomic_compare_exchange_strong_explicit(atomic_wchar_t* __obj, wchar_t* __exp, + wchar_t __desr, memory_order __s, + memory_order __f) +{ + return atomic_compare_exchange_strong_explicit( + const_cast(__obj), __exp, __desr, __s, __f); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_add(volatile atomic_wchar_t* __obj, wchar_t __v) +{ + return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_add(atomic_wchar_t* __obj, wchar_t __v) +{ + return atomic_fetch_add(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_add_explicit(volatile atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return __atomic_fetch_add(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_add_explicit(atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return atomic_fetch_add_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_sub(volatile atomic_wchar_t* __obj, wchar_t __v) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_sub(atomic_wchar_t* __obj, wchar_t __v) +{ + return atomic_fetch_sub(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_sub_explicit(volatile atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return __atomic_fetch_sub(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_sub_explicit(atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return atomic_fetch_sub_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_and(volatile atomic_wchar_t* __obj, wchar_t __v) +{ + return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_and(atomic_wchar_t* __obj, wchar_t __v) +{ + return atomic_fetch_and(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_and_explicit(volatile atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return __atomic_fetch_and(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_and_explicit(atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return atomic_fetch_and_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_or(volatile atomic_wchar_t* __obj, wchar_t __v) +{ + return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_or(atomic_wchar_t* __obj, wchar_t __v) +{ + return atomic_fetch_or(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_or_explicit(volatile atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return __atomic_fetch_or(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_or_explicit(atomic_wchar_t* __obj, wchar_t __v, memory_order __o) +{ + return atomic_fetch_or_explicit(const_cast(__obj), + __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_xor(volatile atomic_wchar_t* __obj, wchar_t __v) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_xor(atomic_wchar_t* __obj, wchar_t __v) +{ + return atomic_fetch_xor(const_cast(__obj), __v); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_xor_explicit(volatile atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return __atomic_fetch_xor(&__obj->__v_, __v, __o); +} + +inline _LIBCPP_INLINE_VISIBILITY +wchar_t +atomic_fetch_xor_explicit(atomic_wchar_t* __obj, wchar_t __v, + memory_order __o) +{ + return atomic_fetch_xor_explicit(const_cast(__obj), + __v, __o); +} + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_ATOMIC diff --git a/test/atomics/atomics.types/atomics.types.integral/integral.pass.cpp b/test/atomics/atomics.types/atomics.types.integral/integral.pass.cpp index a48ba8b0..fb7abc5a 100644 --- a/test/atomics/atomics.types/atomics.types.integral/integral.pass.cpp +++ b/test/atomics/atomics.types/atomics.types.integral/integral.pass.cpp @@ -126,7 +126,7 @@ template void -test() +do_test() { A obj(T(0)); assert(obj == T(0)); @@ -160,6 +160,25 @@ test() assert(x == T(1)); assert((obj = T(0)) == T(0)); assert(obj == T(0)); + assert(obj++ == T(0)); + assert(obj == T(1)); + assert(++obj == T(2)); + assert(obj == T(2)); + assert(--obj == T(1)); + assert(obj == T(1)); + assert(obj-- == T(1)); + assert(obj == T(0)); + obj = T(2); + assert((obj += T(3)) == T(5)); + assert(obj == T(5)); + assert((obj -= T(3)) == T(2)); + assert(obj == T(2)); + assert((obj |= T(5)) == T(7)); + assert(obj == T(7)); + assert((obj &= T(0xF)) == T(7)); + assert(obj == T(7)); + assert((obj ^= T(0xF)) == T(8)); + assert(obj == T(8)); std::atomic_init(&obj, T(1)); assert(obj == T(1)); @@ -205,10 +224,53 @@ test() assert(x == T(3)); assert((obj = T(1)) == T(1)); assert(obj == T(1)); + obj = T(2); + assert(std::atomic_fetch_add(&obj, T(3)) == T(2)); + assert(obj == T(5)); + assert(std::atomic_fetch_add_explicit(&obj, T(3), std::memory_order_seq_cst) == T(5)); + assert(obj == T(8)); + assert(std::atomic_fetch_sub(&obj, T(3)) == T(8)); + assert(obj == T(5)); + assert(std::atomic_fetch_sub_explicit(&obj, T(3), std::memory_order_seq_cst) == T(5)); + assert(obj == T(2)); + assert(std::atomic_fetch_or(&obj, T(5)) == T(2)); + assert(obj == T(7)); + assert(std::atomic_fetch_or_explicit(&obj, T(8), std::memory_order_seq_cst) == T(7)); + assert(obj == T(0xF)); + assert(std::atomic_fetch_and(&obj, T(7)) == T(0xF)); + assert(obj == T(7)); + assert(std::atomic_fetch_and_explicit(&obj, T(3), std::memory_order_seq_cst) == T(7)); + assert(obj == T(3)); + assert(std::atomic_fetch_xor(&obj, T(7)) == T(3)); + assert(obj == T(4)); + assert(std::atomic_fetch_xor_explicit(&obj, T(7), std::memory_order_seq_cst) == T(4)); + assert(obj == T(3)); } +template +void test() +{ + do_test(); + do_test(); +} + + int main() { test(); - test(); + test(); + test(); + test(); + test(); + test(); + test(); + test(); + test(); + test(); + test(); +#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS + test(); + test(); +#endif // _LIBCPP_HAS_NO_UNICODE_CHARS + test(); }