[cfe-commits] [libcxx] r121064 - in /libcxx/trunk: include/ test/atomics/atomics.types.operations/atomics.types.operations.req/
Howard Hinnant
hhinnant at apple.com
Mon Dec 6 15:10:09 PST 2010
Author: hhinnant
Date: Mon Dec 6 17:10:08 2010
New Revision: 121064
URL: http://llvm.org/viewvc/llvm-project?rev=121064&view=rev
Log:
Getting <atomic> warmed back up. We have a hopefully more stable spec now. And I believe the intrinsic spec at http://libcxx.llvm.org/atomic_design_a.html is still good.
Added:
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
Modified:
libcxx/trunk/include/atomic
Modified: libcxx/trunk/include/atomic
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?rev=121064&r1=121063&r2=121064&view=diff
==============================================================================
--- libcxx/trunk/include/atomic (original)
+++ libcxx/trunk/include/atomic Mon Dec 6 17:10:08 2010
@@ -41,2385 +41,859 @@
#define ATOMIC_INT_LOCK_FREE unspecified
#define ATOMIC_LONG_LOCK_FREE unspecified
#define ATOMIC_LLONG_LOCK_FREE unspecified
-#define ATOMIC_ADDRESS_LOCK_FREE unspecified
// flag type and operations
typedef struct atomic_flag
{
- bool test_and_set(memory_order = memory_order_seq_cst) volatile;
- bool test_and_set(memory_order = memory_order_seq_cst);
- void clear(memory_order = memory_order_seq_cst) volatile;
- void clear(memory_order = memory_order_seq_cst);
+ bool test_and_set(memory_order m = memory_order_seq_cst) volatile;
+ bool test_and_set(memory_order m = memory_order_seq_cst);
+ void clear(memory_order m = memory_order_seq_cst) volatile;
+ void clear(memory_order m = memory_order_seq_cst);
atomic_flag() = default;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
} atomic_flag;
-bool atomic_flag_test_and_set(volatile atomic_flag*);
-bool atomic_flag_test_and_set(atomic_flag*);
-bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
-bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);
-void atomic_flag_clear(volatile atomic_flag*);
-void atomic_flag_clear(atomic_flag*);
-void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
-void atomic_flag_clear_explicit(atomic_flag*, memory_order);
+bool
+ atomic_flag_test_and_set(volatile atomic_flag* obj);
+
+bool
+ atomic_flag_test_and_set(atomic_flag* obj);
+
+bool
+ atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
+ memory_order m);
+
+bool
+ atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m);
+
+void
+ atomic_flag_clear(volatile atomic_flag* obj);
+
+void
+ atomic_flag_clear(atomic_flag* obj);
+
+void
+ atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m);
+
+void
+ atomic_flag_clear_explicit(atomic_flag* obj, memory_order m);
#define ATOMIC_FLAG_INIT see below
#define ATOMIC_VAR_INIT(value) see below
-// atomic_bool
-
-typedef struct atomic_bool
+template <class T>
+struct atomic
{
bool is_lock_free() const volatile;
bool is_lock_free() const;
- void store(bool, memory_order = memory_order_seq_cst) volatile;
- void store(bool, memory_order = memory_order_seq_cst);
- bool load(memory_order = memory_order_seq_cst) const volatile;
- bool load(memory_order = memory_order_seq_cst) const;
- operator bool() const volatile;
- operator bool() const;
- bool exchange(bool, memory_order = memory_order_seq_cst) volatile;
- bool exchange(bool, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(bool&, bool, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(bool&, bool, memory_order, memory_order);
- bool compare_exchange_strong(bool&, bool, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(bool&, bool, memory_order, memory_order);
- bool compare_exchange_weak(bool&, bool,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(bool&, bool,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(bool&, bool,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(bool&, bool,
- memory_order = memory_order_seq_cst);
- atomic_bool() = default;
- constexpr atomic_bool(bool);
- atomic_bool(const atomic_bool&) = delete;
- atomic_bool& operator=(const atomic_bool&) = delete;
- atomic_bool& operator=(const atomic_bool&) volatile = delete;
- bool operator=(bool) volatile;
- bool operator=(bool);
-} atomic_bool;
-
-bool atomic_is_lock_free(const volatile atomic_bool*);
-bool atomic_is_lock_free(const atomic_bool*);
-void atomic_init(volatile atomic_bool*, bool);
-void atomic_init(atomic_bool*, bool);
-void atomic_store(volatile atomic_bool*, bool);
-void atomic_store(atomic_bool*, bool);
-void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
-void atomic_store_explicit(atomic_bool*, bool, memory_order);
-bool atomic_load(const volatile atomic_bool*);
-bool atomic_load(const atomic_bool*);
-bool atomic_load_explicit(const volatile atomic_bool*, memory_order);
-bool atomic_load_explicit(const atomic_bool*, memory_order);
-bool atomic_exchange(volatile atomic_bool*, bool);
-bool atomic_exchange(atomic_bool*, bool);
-bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
-bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);
-bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);
-bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);
-bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);
-bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);
-bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,
- memory_order, memory_order);
-bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,
- memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,
- memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,
- memory_order, memory_order);
+ void store(T desr, memory_order m = memory_order_seq_cst) volatile;
+ void store(T desr, memory_order m = memory_order_seq_cst);
+ T load(memory_order m = memory_order_seq_cst) const volatile;
+ T load(memory_order m = memory_order_seq_cst) const;
+ operator T() const volatile;
+ operator T() const;
+ T exchange(T desr, memory_order m = memory_order_seq_cst) volatile;
+ T exchange(T desr, memory_order m = memory_order_seq_cst);
+ bool compare_exchange_weak(T& expc, T desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f);
+ bool compare_exchange_strong(T& expc, T desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_strong(T& expc, T desr,
+ memory_order s, memory_order f);
+ bool compare_exchange_weak(T& expc, T desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_weak(T& expc, T desr,
+ memory_order m = memory_order_seq_cst);
+ bool compare_exchange_strong(T& expc, T desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_strong(T& expc, T desr,
+ memory_order m = memory_order_seq_cst);
-// atomic_char
+ atomic() = default;
+ constexpr atomic(T desr);
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+ T operator=(T) volatile;
+ T operator=(T);
+};
-typedef struct atomic_char
+template <>
+struct atomic<integral>
{
bool is_lock_free() const volatile;
bool is_lock_free() const;
- void store(char, memory_order = memory_order_seq_cst) volatile;
- void store(char, memory_order = memory_order_seq_cst);
- char load(memory_order = memory_order_seq_cst) const volatile;
- char load(memory_order = memory_order_seq_cst) const;
- operator char() const volatile;
- operator char() const;
- char exchange(char, memory_order = memory_order_seq_cst) volatile;
- char exchange(char, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(char&, char, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(char&, char, memory_order, memory_order);
- bool compare_exchange_strong(char&, char, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(char&, char, memory_order, memory_order);
- bool compare_exchange_weak(char&, char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(char&, char,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(char&, char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(char&, char,
- memory_order = memory_order_seq_cst);
- char fetch_add(char, memory_order = memory_order_seq_cst) volatile;
- char fetch_add(char, memory_order = memory_order_seq_cst);
- char fetch_sub(char, memory_order = memory_order_seq_cst) volatile;
- char fetch_sub(char, memory_order = memory_order_seq_cst);
- char fetch_and(char, memory_order = memory_order_seq_cst) volatile;
- char fetch_and(char, memory_order = memory_order_seq_cst);
- char fetch_or(char, memory_order = memory_order_seq_cst) volatile;
- char fetch_or(char, memory_order = memory_order_seq_cst);
- char fetch_xor(char, memory_order = memory_order_seq_cst) volatile;
- char fetch_xor(char, memory_order = memory_order_seq_cst);
- atomic_char() = default;
- constexpr atomic_char(char);
- atomic_char(const atomic_char&) = delete;
- atomic_char& operator=(const atomic_char&) = delete;
- atomic_char& operator=(const atomic_char&) volatile = delete;
- char operator=(char) volatile;
- char operator=(char);
- char operator++(int) volatile;
- char operator++(int);
- char operator--(int) volatile;
- char operator--(int);
- char operator++() volatile;
- char operator++();
- char operator--() volatile;
- char operator--();
- char operator+=(char) volatile;
- char operator+=(char);
- char operator-=(char) volatile;
- char operator-=(char);
- char operator&=(char) volatile;
- char operator&=(char);
- char operator|=(char) volatile;
- char operator|=(char);
- char operator^=(char) volatile;
- char operator^=(char);
-} atomic_char;
+ void store(integral desr, memory_order m = memory_order_seq_cst) volatile;
+ void store(integral desr, memory_order m = memory_order_seq_cst);
+ integral load(memory_order m = memory_order_seq_cst) const volatile;
+ integral load(memory_order m = memory_order_seq_cst) const;
+ operator integral() const volatile;
+ operator integral() const;
+ integral exchange(integral desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ integral exchange(integral desr, memory_order m = memory_order_seq_cst);
+ bool compare_exchange_weak(integral& expc, integral desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_weak(integral& expc, integral desr,
+ memory_order s, memory_order f);
+ bool compare_exchange_strong(integral& expc, integral desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_strong(integral& expc, integral desr,
+ memory_order s, memory_order f);
+ bool compare_exchange_weak(integral& expc, integral desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_weak(integral& expc, integral desr,
+ memory_order m = memory_order_seq_cst);
+ bool compare_exchange_strong(integral& expc, integral desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_strong(integral& expc, integral desr,
+ memory_order m = memory_order_seq_cst);
+
+ integral
+ fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile;
+ integral fetch_add(integral op, memory_order m = memory_order_seq_cst);
+ integral
+ fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile;
+ integral fetch_sub(integral op, memory_order m = memory_order_seq_cst);
+ integral
+ fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile;
+ integral fetch_and(integral op, memory_order m = memory_order_seq_cst);
+ integral
+ fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile;
+ integral fetch_or(integral op, memory_order m = memory_order_seq_cst);
+ integral
+ fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile;
+ integral fetch_xor(integral op, memory_order m = memory_order_seq_cst);
-bool atomic_is_lock_free(const volatile atomic_char*);
-bool atomic_is_lock_free(const atomic_char*);
-void atomic_init(volatile atomic_char*, char);
-void atomic_init(atomic_char*, char);
-void atomic_store(volatile atomic_char*, char);
-void atomic_store(atomic_char*, char);
-void atomic_store_explicit(volatile atomic_char*, char, memory_order);
-void atomic_store_explicit(atomic_char*, char, memory_order);
-char atomic_load(const volatile atomic_char*);
-char atomic_load(const atomic_char*);
-char atomic_load_explicit(const volatile atomic_char*, memory_order);
-char atomic_load_explicit(const atomic_char*, memory_order);
-char atomic_exchange(volatile atomic_char*, char);
-char atomic_exchange(atomic_char*, char);
-char atomic_exchange_explicit(volatile atomic_char*, char, memory_order);
-char atomic_exchange_explicit(atomic_char*, char, memory_order);
-bool atomic_compare_exchange_weak(volatile atomic_char*, char*, char);
-bool atomic_compare_exchange_weak(atomic_char*, char*, char);
-bool atomic_compare_exchange_strong(volatile atomic_char*, char*, char);
-bool atomic_compare_exchange_strong(atomic_char*, char*, char);
-bool atomic_compare_exchange_weak_explicit(volatile atomic_char*, char*, char,
- memory_order, memory_order);
-bool atomic_compare_exchange_weak_explicit(atomic_char*, char*, char,
- memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(volatile atomic_char*, char*, char,
- memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(atomic_char*, char*, char,
- memory_order, memory_order);
-char atomic_fetch_add(volatile atomic_char*, char);
-char atomic_fetch_add(atomic_char*, char);
-char atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);
-char atomic_fetch_add_explicit(atomic_char*, char, memory_order);
-char atomic_fetch_sub(volatile atomic_char*, char);
-char atomic_fetch_sub(atomic_char*, char);
-char atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);
-char atomic_fetch_sub_explicit(atomic_char*, char, memory_order);
-char atomic_fetch_and(volatile atomic_char*, char);
-char atomic_fetch_and(atomic_char*, char);
-char atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);
-char atomic_fetch_and_explicit(atomic_char*, char, memory_order);
-char atomic_fetch_or(volatile atomic_char*, char);
-char atomic_fetch_or(atomic_char*, char);
-char atomic_fetch_or_explicit(volatile atomic_char*, char, memory_order);
-char atomic_fetch_or_explicit(atomic_char*, char, memory_order);
-char atomic_fetch_xor(volatile atomic_char*, char);
-char atomic_fetch_xor(atomic_char*, char);
-char atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);
-char atomic_fetch_xor_explicit(atomic_char*, char, memory_order);
+ atomic() = default;
+ constexpr atomic(integral desr);
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+ integral operator=(integral desr) volatile;
+ integral operator=(integral desr);
-// atomic_schar
+ integral operator++(int) volatile;
+ integral operator++(int);
+ integral operator--(int) volatile;
+ integral operator--(int);
+ integral operator++() volatile;
+ integral operator++();
+ integral operator--() volatile;
+ integral operator--();
+ integral operator+=(integral op) volatile;
+ integral operator+=(integral op);
+ integral operator-=(integral op) volatile;
+ integral operator-=(integral op);
+ integral operator&=(integral op) volatile;
+ integral operator&=(integral op);
+ integral operator|=(integral op) volatile;
+ integral operator|=(integral op);
+ integral operatorË=(integral op) volatile;
+ integral operatorË=(integral op);
+};
-typedef struct atomic_schar
+template <class T>
+struct atomic<T*>
{
bool is_lock_free() const volatile;
bool is_lock_free() const;
- void store(signed char, memory_order = memory_order_seq_cst) volatile;
- void store(signed char, memory_order = memory_order_seq_cst);
- signed char load(memory_order = memory_order_seq_cst) const volatile;
- signed char load(memory_order = memory_order_seq_cst) const;
- operator signed char() const volatile;
- operator signed char() const;
- signed char exchange(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char exchange(signed char, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(signed char&, signed char, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(signed char&, signed char, memory_order,
- memory_order);
- bool compare_exchange_strong(signed char&, signed char, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(signed char&, signed char, memory_order,
- memory_order);
- bool compare_exchange_weak(signed char&, signed char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(signed char&, signed char,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(signed char&, signed char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(signed char&, signed char,
- memory_order = memory_order_seq_cst);
- signed char fetch_add(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char fetch_add(signed char, memory_order = memory_order_seq_cst);
- signed char fetch_sub(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char fetch_sub(signed char, memory_order = memory_order_seq_cst);
- signed char fetch_and(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char fetch_and(signed char, memory_order = memory_order_seq_cst);
- signed char fetch_or(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char fetch_or(signed char, memory_order = memory_order_seq_cst);
- signed char fetch_xor(signed char,
- memory_order = memory_order_seq_cst) volatile;
- signed char fetch_xor(signed char, memory_order = memory_order_seq_cst);
- atomic_schar() = default;
- constexpr atomic_schar(signed char);
- atomic_schar(const atomic_schar&) = delete;
- atomic_schar& operator=(const atomic_schar&) = delete;
- atomic_schar& operator=(const atomic_schar&) volatile = delete;
- signed char operator=(signed char) volatile;
- signed char operator=(signed char);
- signed char operator++(int) volatile;
- signed char operator++(int);
- signed char operator--(int) volatile;
- signed char operator--(int);
- signed char operator++() volatile;
- signed char operator++();
- signed char operator--() volatile;
- signed char operator--();
- signed char operator+=(signed char) volatile;
- signed char operator+=(signed char);
- signed char operator-=(signed char) volatile;
- signed char operator-=(signed char);
- signed char operator&=(signed char) volatile;
- signed char operator&=(signed char);
- signed char operator|=(signed char) volatile;
- signed char operator|=(signed char);
- signed char operator^=(signed char) volatile;
- signed char operator^=(signed char);
-} atomic_schar;
+ void store(T* desr, memory_order m = memory_order_seq_cst) volatile;
+ void store(T* desr, memory_order m = memory_order_seq_cst);
+ T* load(memory_order m = memory_order_seq_cst) const volatile;
+ T* load(memory_order m = memory_order_seq_cst) const;
+ operator T*() const volatile;
+ operator T*() const;
+ T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile;
+ T* exchange(T* desr, memory_order m = memory_order_seq_cst);
+ bool compare_exchange_weak(T*& expc, T* desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_weak(T*& expc, T* desr,
+ memory_order s, memory_order f);
+ bool compare_exchange_strong(T*& expc, T* desr,
+ memory_order s, memory_order f) volatile;
+ bool compare_exchange_strong(T*& expc, T* desr,
+ memory_order s, memory_order f);
+ bool compare_exchange_weak(T*& expc, T* desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_weak(T*& expc, T* desr,
+ memory_order m = memory_order_seq_cst);
+ bool compare_exchange_strong(T*& expc, T* desr,
+ memory_order m = memory_order_seq_cst) volatile;
+ bool compare_exchange_strong(T*& expc, T* desr,
+ memory_order m = memory_order_seq_cst);
+ T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile;
+ T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst);
+ T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile;
+ T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst);
-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);
+ atomic() = default;
+ constexpr atomic(T* desr);
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
-// atomic_uchar
+ T* operator=(T*) volatile;
+ T* operator=(T*);
+ T* operator++(int) volatile;
+ T* operator++(int);
+ T* operator--(int) volatile;
+ T* operator--(int);
+ T* operator++() volatile;
+ T* operator++();
+ T* operator--() volatile;
+ T* operator--();
+ T* operator+=(ptrdiff_t op) volatile;
+ T* operator+=(ptrdiff_t op);
+ T* operator-=(ptrdiff_t op) volatile;
+ T* operator-=(ptrdiff_t op);
+};
-typedef struct atomic_uchar
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(unsigned char, memory_order = memory_order_seq_cst) volatile;
- void store(unsigned char, memory_order = memory_order_seq_cst);
- unsigned char load(memory_order = memory_order_seq_cst) const volatile;
- unsigned char load(memory_order = memory_order_seq_cst) const;
- operator unsigned char() const volatile;
- operator unsigned char() const;
- unsigned char exchange(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char exchange(unsigned char, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
- memory_order);
- bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
- memory_order);
- bool compare_exchange_weak(unsigned char&, unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(unsigned char&, unsigned char,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(unsigned char&, unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(unsigned char&, unsigned char,
- memory_order = memory_order_seq_cst);
- unsigned char fetch_add(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char fetch_add(unsigned char, memory_order = memory_order_seq_cst);
- unsigned char fetch_sub(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char fetch_sub(unsigned char, memory_order = memory_order_seq_cst);
- unsigned char fetch_and(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char fetch_and(unsigned char, memory_order = memory_order_seq_cst);
- unsigned char fetch_or(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char fetch_or(unsigned char, memory_order = memory_order_seq_cst);
- unsigned char fetch_xor(unsigned char,
- memory_order = memory_order_seq_cst) volatile;
- unsigned char fetch_xor(unsigned char, memory_order = memory_order_seq_cst);
- atomic_uchar() = default;
- constexpr atomic_uchar(unsigned char);
- atomic_uchar(const atomic_uchar&) = delete;
- atomic_uchar& operator=(const atomic_uchar&) = delete;
- atomic_uchar& operator=(const atomic_uchar&) volatile = delete;
- unsigned char operator=(unsigned char) volatile;
- unsigned char operator=(unsigned char);
- unsigned char operator++(int) volatile;
- unsigned char operator++(int);
- unsigned char operator--(int) volatile;
- unsigned char operator--(int);
- unsigned char operator++() volatile;
- unsigned char operator++();
- unsigned char operator--() volatile;
- unsigned char operator--();
- unsigned char operator+=(unsigned char) volatile;
- unsigned char operator+=(unsigned char);
- unsigned char operator-=(unsigned char) volatile;
- unsigned char operator-=(unsigned char);
- unsigned char operator&=(unsigned char) volatile;
- unsigned char operator&=(unsigned char);
- unsigned char operator|=(unsigned char) volatile;
- unsigned char operator|=(unsigned char);
- unsigned char operator^=(unsigned char) volatile;
- unsigned char operator^=(unsigned char);
-} 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);
+template <class T>
+ bool
+ atomic_is_lock_free(const volatile atomic<T>* obj);
-// atomic_short
+template <class T>
+ bool
+ atomic_is_lock_free(const atomic<T>* obj);
-typedef struct atomic_short
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(short, memory_order = memory_order_seq_cst) volatile;
- void store(short, memory_order = memory_order_seq_cst);
- short load(memory_order = memory_order_seq_cst) const volatile;
- short load(memory_order = memory_order_seq_cst) const;
- operator short() const volatile;
- operator short() const;
- short exchange(short, memory_order = memory_order_seq_cst) volatile;
- short exchange(short, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(short&, short, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(short&, short, memory_order, memory_order);
- bool compare_exchange_strong(short&, short, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(short&, short, memory_order, memory_order);
- bool compare_exchange_weak(short&, short,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(short&, short,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(short&, short,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(short&, short,
- memory_order = memory_order_seq_cst);
- short fetch_add(short, memory_order = memory_order_seq_cst) volatile;
- short fetch_add(short, memory_order = memory_order_seq_cst);
- short fetch_sub(short, memory_order = memory_order_seq_cst) volatile;
- short fetch_sub(short, memory_order = memory_order_seq_cst);
- short fetch_and(short, memory_order = memory_order_seq_cst) volatile;
- short fetch_and(short, memory_order = memory_order_seq_cst);
- short fetch_or(short, memory_order = memory_order_seq_cst) volatile;
- short fetch_or(short, memory_order = memory_order_seq_cst);
- short fetch_xor(short, memory_order = memory_order_seq_cst) volatile;
- short fetch_xor(short, memory_order = memory_order_seq_cst);
- atomic_short() = default;
- constexpr atomic_short(short);
- atomic_short(const atomic_short&) = delete;
- atomic_short& operator=(const atomic_short&) = delete;
- atomic_short& operator=(const atomic_short&) volatile = delete;
- short operator=(short) volatile;
- short operator=(short);
- short operator++(int) volatile;
- short operator++(int);
- short operator--(int) volatile;
- short operator--(int);
- short operator++() volatile;
- short operator++();
- short operator--() volatile;
- short operator--();
- short operator+=(short) volatile;
- short operator+=(short);
- short operator-=(short) volatile;
- short operator-=(short);
- short operator&=(short) volatile;
- short operator&=(short);
- short operator|=(short) volatile;
- short operator|=(short);
- short operator^=(short) volatile;
- short operator^=(short);
-} atomic_short;
+template <class T>
+ void
+ atomic_init(volatile atomic<T>* obj, T desr);
-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);
+template <class T>
+ void
+ atomic_init(atomic<T>* obj, T desr);
-// atomic_ushort
+template <class T>
+ void
+ atomic_store(volatile atomic<T>* obj, T desr);
-typedef struct atomic_ushort
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(unsigned short, memory_order = memory_order_seq_cst) volatile;
- void store(unsigned short, memory_order = memory_order_seq_cst);
- unsigned short load(memory_order = memory_order_seq_cst) const volatile;
- unsigned short load(memory_order = memory_order_seq_cst) const;
- operator unsigned short() const volatile;
- operator unsigned short() const;
- unsigned short exchange(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short exchange(unsigned short,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
- memory_order);
- bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
- memory_order);
- bool compare_exchange_weak(unsigned short&, unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(unsigned short&, unsigned short,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(unsigned short&, unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(unsigned short&, unsigned short,
- memory_order = memory_order_seq_cst);
- unsigned short fetch_add(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short fetch_add(unsigned short,
- memory_order = memory_order_seq_cst);
- unsigned short fetch_sub(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short fetch_sub(unsigned short,
- memory_order = memory_order_seq_cst);
- unsigned short fetch_and(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short fetch_and(unsigned short,
- memory_order = memory_order_seq_cst);
- unsigned short fetch_or(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short fetch_or(unsigned short,
- memory_order = memory_order_seq_cst);
- unsigned short fetch_xor(unsigned short,
- memory_order = memory_order_seq_cst) volatile;
- unsigned short fetch_xor(unsigned short,
- memory_order = memory_order_seq_cst);
- atomic_ushort() = default;
- constexpr atomic_ushort(unsigned short);
- atomic_ushort(const atomic_ushort&) = delete;
- atomic_ushort& operator=(const atomic_ushort&) = delete;
- atomic_ushort& operator=(const atomic_ushort&) volatile = delete;
- unsigned short operator=(unsigned short) volatile;
- unsigned short operator=(unsigned short);
- unsigned short operator++(int) volatile;
- unsigned short operator++(int);
- unsigned short operator--(int) volatile;
- unsigned short operator--(int);
- unsigned short operator++() volatile;
- unsigned short operator++();
- unsigned short operator--() volatile;
- unsigned short operator--();
- unsigned short operator+=(unsigned short) volatile;
- unsigned short operator+=(unsigned short);
- unsigned short operator-=(unsigned short) volatile;
- unsigned short operator-=(unsigned short);
- unsigned short operator&=(unsigned short) volatile;
- unsigned short operator&=(unsigned short);
- unsigned short operator|=(unsigned short) volatile;
- unsigned short operator|=(unsigned short);
- unsigned short operator^=(unsigned short) volatile;
- unsigned short operator^=(unsigned short);
-} atomic_ushort;
+template <class T>
+ void
+ atomic_store(atomic<T>* obj, T desr);
-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);
+template <class T>
+ void
+ atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-// atomic_int
+template <class T>
+ void
+ atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);
-typedef struct atomic_int
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(int, memory_order = memory_order_seq_cst) volatile;
- void store(int, memory_order = memory_order_seq_cst);
- int load(memory_order = memory_order_seq_cst) const volatile;
- int load(memory_order = memory_order_seq_cst) const;
- operator int() const volatile;
- operator int() const;
- int exchange(int, memory_order = memory_order_seq_cst) volatile;
- int exchange(int, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(int&, int, memory_order, memory_order) volatile;
- bool compare_exchange_weak(int&, int, memory_order, memory_order);
- bool compare_exchange_strong(int&, int, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(int&, int, memory_order, memory_order);
- bool compare_exchange_weak(int&, int,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(int&, int, memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(int&, int,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(int&, int,
- memory_order = memory_order_seq_cst);
- int fetch_add(int, memory_order = memory_order_seq_cst) volatile;
- int fetch_add(int, memory_order = memory_order_seq_cst);
- int fetch_sub(int, memory_order = memory_order_seq_cst) volatile;
- int fetch_sub(int, memory_order = memory_order_seq_cst);
- int fetch_and(int, memory_order = memory_order_seq_cst) volatile;
- int fetch_and(int, memory_order = memory_order_seq_cst);
- int fetch_or(int, memory_order = memory_order_seq_cst) volatile;
- int fetch_or(int, memory_order = memory_order_seq_cst);
- int fetch_xor(int, memory_order = memory_order_seq_cst) volatile;
- int fetch_xor(int, memory_order = memory_order_seq_cst);
- atomic_int() = default;
- constexpr atomic_int(int);
- atomic_int(const atomic_int&) = delete;
- atomic_int& operator=(const atomic_int&) = delete;
- atomic_int& operator=(const atomic_int&) volatile = delete;
- int operator=(int) volatile;
- int operator=(int);
- int operator++(int) volatile;
- int operator++(int);
- int operator--(int) volatile;
- int operator--(int);
- int operator++() volatile;
- int operator++();
- int operator--() volatile;
- int operator--();
- int operator+=(int) volatile;
- int operator+=(int);
- int operator-=(int) volatile;
- int operator-=(int);
- int operator&=(int) volatile;
- int operator&=(int);
- int operator|=(int) volatile;
- int operator|=(int);
- int operator^=(int) volatile;
- int operator^=(int);
-} atomic_int;
+template <class T>
+ T
+ atomic_load(const volatile atomic<T>* obj);
-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);
+template <class T>
+ T
+ atomic_load(const atomic<T>* obj);
-// atomic_uint
+template <class T>
+ T
+ atomic_load_explicit(const volatile atomic<T>* obj, memory_order m);
-typedef struct atomic_uint
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(unsigned int, memory_order = memory_order_seq_cst) volatile;
- void store(unsigned int, memory_order = memory_order_seq_cst);
- unsigned int load(memory_order = memory_order_seq_cst) const volatile;
- unsigned int load(memory_order = memory_order_seq_cst) const;
- operator unsigned int() const volatile;
- operator unsigned int() const;
- unsigned int exchange(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int exchange(unsigned int, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
- memory_order);
- bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
- memory_order);
- bool compare_exchange_weak(unsigned int&, unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(unsigned int&, unsigned int,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(unsigned int&, unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(unsigned int&, unsigned int,
- memory_order = memory_order_seq_cst);
- unsigned int fetch_add(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int fetch_add(unsigned int, memory_order = memory_order_seq_cst);
- unsigned int fetch_sub(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int fetch_sub(unsigned int, memory_order = memory_order_seq_cst);
- unsigned int fetch_and(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int fetch_and(unsigned int, memory_order = memory_order_seq_cst);
- unsigned int fetch_or(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int fetch_or(unsigned int, memory_order = memory_order_seq_cst);
- unsigned int fetch_xor(unsigned int,
- memory_order = memory_order_seq_cst) volatile;
- unsigned int fetch_xor(unsigned int, memory_order = memory_order_seq_cst);
- atomic_uint() = default;
- constexpr atomic_uint(unsigned int);
- atomic_uint(const atomic_uint&) = delete;
- atomic_uint& operator=(const atomic_uint&) = delete;
- atomic_uint& operator=(const atomic_uint&) volatile = delete;
- unsigned int operator=(unsigned int) volatile;
- unsigned int operator=(unsigned int);
- unsigned int operator++(int) volatile;
- unsigned int operator++(int);
- unsigned int operator--(int) volatile;
- unsigned int operator--(int);
- unsigned int operator++() volatile;
- unsigned int operator++();
- unsigned int operator--() volatile;
- unsigned int operator--();
- unsigned int operator+=(unsigned int) volatile;
- unsigned int operator+=(unsigned int);
- unsigned int operator-=(unsigned int) volatile;
- unsigned int operator-=(unsigned int);
- unsigned int operator&=(unsigned int) volatile;
- unsigned int operator&=(unsigned int);
- unsigned int operator|=(unsigned int) volatile;
- unsigned int operator|=(unsigned int);
- unsigned int operator^=(unsigned int) volatile;
- unsigned int operator^=(unsigned int);
-} atomic_uint;
+template <class T>
+ T
+ atomic_load_explicit(const atomic<T>* obj, memory_order m);
-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);
-
-// atomic_long
-
-typedef struct atomic_long
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(long, memory_order = memory_order_seq_cst) volatile;
- void store(long, memory_order = memory_order_seq_cst);
- long load(memory_order = memory_order_seq_cst) const volatile;
- long load(memory_order = memory_order_seq_cst) const;
- operator long() const volatile;
- operator long() const;
- long exchange(long, memory_order = memory_order_seq_cst) volatile;
- long exchange(long, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(long&, long, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(long&, long, memory_order, memory_order);
- bool compare_exchange_strong(long&, long, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(long&, long, memory_order, memory_order);
- bool compare_exchange_weak(long&, long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(long&, long,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(long&, long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(long&, long,
- memory_order = memory_order_seq_cst);
- long fetch_add(long, memory_order = memory_order_seq_cst) volatile;
- long fetch_add(long, memory_order = memory_order_seq_cst);
- long fetch_sub(long, memory_order = memory_order_seq_cst) volatile;
- long fetch_sub(long, memory_order = memory_order_seq_cst);
- long fetch_and(long, memory_order = memory_order_seq_cst) volatile;
- long fetch_and(long, memory_order = memory_order_seq_cst);
- long fetch_or(long, memory_order = memory_order_seq_cst) volatile;
- long fetch_or(long, memory_order = memory_order_seq_cst);
- long fetch_xor(long, memory_order = memory_order_seq_cst) volatile;
- long fetch_xor(long, memory_order = memory_order_seq_cst);
- atomic_long() = default;
- constexpr atomic_long(long);
- atomic_long(const atomic_long&) = delete;
- atomic_long& operator=(const atomic_long&) = delete;
- atomic_long& operator=(const atomic_long&) volatile = delete;
- long operator=(long) volatile;
- long operator=(long);
- long operator++(int) volatile;
- long operator++(int);
- long operator--(int) volatile;
- long operator--(int);
- long operator++() volatile;
- long operator++();
- long operator--() volatile;
- long operator--();
- long operator+=(long) volatile;
- long operator+=(long);
- long operator-=(long) volatile;
- long operator-=(long);
- long operator&=(long) volatile;
- long operator&=(long);
- long operator|=(long) volatile;
- long operator|=(long);
- long operator^=(long) volatile;
- long operator^=(long);
-} 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);
-
-// atomic_ulong
-
-typedef struct atomic_ulong
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(unsigned long, memory_order = memory_order_seq_cst) volatile;
- void store(unsigned long, memory_order = memory_order_seq_cst);
- unsigned long load(memory_order = memory_order_seq_cst) const volatile;
- unsigned long load(memory_order = memory_order_seq_cst) const;
- operator unsigned long() const volatile;
- operator unsigned long() const;
- unsigned long exchange(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long exchange(unsigned long, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
- memory_order);
- bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
- memory_order);
- bool compare_exchange_weak(unsigned long&, unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(unsigned long&, unsigned long,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(unsigned long&, unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(unsigned long&, unsigned long,
- memory_order = memory_order_seq_cst);
- unsigned long fetch_add(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long fetch_add(unsigned long, memory_order = memory_order_seq_cst);
- unsigned long fetch_sub(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long fetch_sub(unsigned long, memory_order = memory_order_seq_cst);
- unsigned long fetch_and(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long fetch_and(unsigned long, memory_order = memory_order_seq_cst);
- unsigned long fetch_or(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long fetch_or(unsigned long, memory_order = memory_order_seq_cst);
- unsigned long fetch_xor(unsigned long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long fetch_xor(unsigned long, memory_order = memory_order_seq_cst);
- atomic_ulong() = default;
- constexpr atomic_ulong(unsigned long);
- atomic_ulong(const atomic_ulong&) = delete;
- atomic_ulong& operator=(const atomic_ulong&) = delete;
- atomic_ulong& operator=(const atomic_ulong&) volatile = delete;
- unsigned long operator=(unsigned long) volatile;
- unsigned long operator=(unsigned long);
- unsigned long operator++(int) volatile;
- unsigned long operator++(int);
- unsigned long operator--(int) volatile;
- unsigned long operator--(int);
- unsigned long operator++() volatile;
- unsigned long operator++();
- unsigned long operator--() volatile;
- unsigned long operator--();
- unsigned long operator+=(unsigned long) volatile;
- unsigned long operator+=(unsigned long);
- unsigned long operator-=(unsigned long) volatile;
- unsigned long operator-=(unsigned long);
- unsigned long operator&=(unsigned long) volatile;
- unsigned long operator&=(unsigned long);
- unsigned long operator|=(unsigned long) volatile;
- unsigned long operator|=(unsigned long);
- unsigned long operator^=(unsigned long) volatile;
- unsigned long operator^=(unsigned long);
-} 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);
+template <class T>
+ T
+ atomic_exchange(volatile atomic<T>* obj, T desr);
-// atomic_llong
+template <class T>
+ T
+ atomic_exchange(atomic<T>* obj, T desr);
-typedef struct atomic_llong
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(long long, memory_order = memory_order_seq_cst) volatile;
- void store(long long, memory_order = memory_order_seq_cst);
- long long load(memory_order = memory_order_seq_cst) const volatile;
- long long load(memory_order = memory_order_seq_cst) const;
- operator long long() const volatile;
- operator long long() const;
- long long exchange(long long, memory_order = memory_order_seq_cst) volatile;
- long long exchange(long long, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(long long&, long long, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(long long&, long long, memory_order,
- memory_order);
- bool compare_exchange_strong(long long&, long long, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(long long&, long long, memory_order,
- memory_order);
- bool compare_exchange_weak(long long&, long long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(long long&, long long,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(long long&, long long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(long long&, long long,
- memory_order = memory_order_seq_cst);
- long long fetch_add(long long,
- memory_order = memory_order_seq_cst) volatile;
- long long fetch_add(long long, memory_order = memory_order_seq_cst);
- long long fetch_sub(long long,
- memory_order = memory_order_seq_cst) volatile;
- long long fetch_sub(long long, memory_order = memory_order_seq_cst);
- long long fetch_and(long long,
- memory_order = memory_order_seq_cst) volatile;
- long long fetch_and(long long, memory_order = memory_order_seq_cst);
- long long fetch_or(long long, memory_order = memory_order_seq_cst) volatile;
- long long fetch_or(long long, memory_order = memory_order_seq_cst);
- long long fetch_xor(long long,
- memory_order = memory_order_seq_cst) volatile;
- long long fetch_xor(long long, memory_order = memory_order_seq_cst);
- atomic_llong() = default;
- constexpr atomic_llong(long long);
- atomic_llong(const atomic_llong&) = delete;
- atomic_llong& operator=(const atomic_llong&) = delete;
- atomic_llong& operator=(const atomic_llong&) volatile = delete;
- long long operator=(long long) volatile;
- long long operator=(long long);
- long long operator++(int) volatile;
- long long operator++(int);
- long long operator--(int) volatile;
- long long operator--(int);
- long long operator++() volatile;
- long long operator++();
- long long operator--() volatile;
- long long operator--();
- long long operator+=(long long) volatile;
- long long operator+=(long long);
- long long operator-=(long long) volatile;
- long long operator-=(long long);
- long long operator&=(long long) volatile;
- long long operator&=(long long);
- long long operator|=(long long) volatile;
- long long operator|=(long long);
- long long operator^=(long long) volatile;
- long long operator^=(long long);
-} atomic_llong;
+template <class T>
+ T
+ atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m);
-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);
+template <class T>
+ T
+ atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);
-// atomic_ullong
+template <class T>
+ bool
+ atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr);
-typedef struct atomic_ullong
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- void store(unsigned long long, memory_order = memory_order_seq_cst);
- unsigned long long load(memory_order = memory_order_seq_cst) const volatile;
- unsigned long long load(memory_order = memory_order_seq_cst) const;
- operator unsigned long long() const volatile;
- operator unsigned long long() const;
- unsigned long long exchange(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long exchange(unsigned long long,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(unsigned long long&, unsigned long long,
- memory_order, memory_order) volatile;
- bool compare_exchange_weak(unsigned long long&, unsigned long long,
- memory_order, memory_order);
- bool compare_exchange_strong(unsigned long long&, unsigned long long,
- memory_order, memory_order) volatile;
- bool compare_exchange_strong(unsigned long long&, unsigned long long,
- memory_order, memory_order);
- bool compare_exchange_weak(unsigned long long&, unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(unsigned long long&, unsigned long long,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(unsigned long long&, unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(unsigned long long&, unsigned long long,
- memory_order = memory_order_seq_cst);
- unsigned long long fetch_add(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long fetch_add(unsigned long long,
- memory_order = memory_order_seq_cst);
- unsigned long long fetch_sub(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long fetch_sub(unsigned long long,
- memory_order = memory_order_seq_cst);
- unsigned long long fetch_and(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long fetch_and(unsigned long long,
- memory_order = memory_order_seq_cst);
- unsigned long long fetch_or(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long fetch_or(unsigned long long,
- memory_order = memory_order_seq_cst);
- unsigned long long fetch_xor(unsigned long long,
- memory_order = memory_order_seq_cst) volatile;
- unsigned long long fetch_xor(unsigned long long,
- memory_order = memory_order_seq_cst);
- atomic_ullong() = default;
- constexpr atomic_ullong(unsigned long long);
- atomic_ullong(const atomic_ullong&) = delete;
- atomic_ullong& operator=(const atomic_ullong&) = delete;
- atomic_ullong& operator=(const atomic_ullong&) volatile = delete;
- unsigned long long operator=(unsigned long long) volatile;
- unsigned long long operator=(unsigned long long);
- unsigned long long operator++(int) volatile;
- unsigned long long operator++(int);
- unsigned long long operator--(int) volatile;
- unsigned long long operator--(int);
- unsigned long long operator++() volatile;
- unsigned long long operator++();
- unsigned long long operator--() volatile;
- unsigned long long operator--();
- unsigned long long operator+=(unsigned long long) volatile;
- unsigned long long operator+=(unsigned long long);
- unsigned long long operator-=(unsigned long long) volatile;
- unsigned long long operator-=(unsigned long long);
- unsigned long long operator&=(unsigned long long) volatile;
- unsigned long long operator&=(unsigned long long);
- unsigned long long operator|=(unsigned long long) volatile;
- unsigned long long operator|=(unsigned long long);
- unsigned long long operator^=(unsigned long long) volatile;
- unsigned long long operator^=(unsigned long long);
-} atomic_ullong;
+template <class T>
+ bool
+ atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);
-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);
+template <class T>
+ bool
+ atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr);
-// atomic_char16_t
+template <class T>
+ bool
+ atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);
-typedef struct atomic_char16_t
-{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(char16_t, memory_order = memory_order_seq_cst) volatile;
- void store(char16_t, memory_order = memory_order_seq_cst);
- char16_t load(memory_order = memory_order_seq_cst) const volatile;
- char16_t load(memory_order = memory_order_seq_cst) const;
- operator char16_t() const volatile;
- operator char16_t() const;
- char16_t exchange(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t exchange(char16_t, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(char16_t&, char16_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(char16_t&, char16_t, memory_order, memory_order);
- bool compare_exchange_strong(char16_t&, char16_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(char16_t&, char16_t,
- memory_order, memory_order);
- bool compare_exchange_weak(char16_t&, char16_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(char16_t&, char16_t,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(char16_t&, char16_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(char16_t&, char16_t,
- memory_order = memory_order_seq_cst);
- char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst);
- char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst);
- char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst);
- char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst);
- char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst) volatile;
- char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst);
- atomic_char16_t() = default;
- constexpr atomic_char16_t(char16_t);
- 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;
- char16_t operator=(char16_t) volatile;
- char16_t operator=(char16_t);
- char16_t operator++(int) volatile;
- char16_t operator++(int);
- char16_t operator--(int) volatile;
- char16_t operator--(int);
- char16_t operator++() volatile;
- char16_t operator++();
- char16_t operator--() volatile;
- char16_t operator--();
- char16_t operator+=(char16_t) volatile;
- char16_t operator+=(char16_t);
- char16_t operator-=(char16_t) volatile;
- char16_t operator-=(char16_t);
- char16_t operator&=(char16_t) volatile;
- char16_t operator&=(char16_t);
- char16_t operator|=(char16_t) volatile;
- char16_t operator|=(char16_t);
- char16_t operator^=(char16_t) volatile;
- char16_t operator^=(char16_t);
-} atomic_char16_t;
+template <class T>
+ bool
+ atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
+ T desr,
+ memory_order s, memory_order f);
-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);
+template <class T>
+ bool
+ atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
+ memory_order s, memory_order f);
-// atomic_char32_t
+template <class T>
+ bool
+ atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
+ T* expc, T desr,
+ memory_order s, memory_order f);
-typedef struct atomic_char32_t
+template <class T>
+ bool
+ atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
+ T desr,
+ memory_order s, memory_order f);
+
+template <class Integral>
+ Integral
+ atomic_fetch_add(volatile atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_add(atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_sub(atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_and(volatile atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_and(atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_or(volatile atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_or(atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_xor(atomic<Integral>* obj, Integral op);
+
+template <class Integral>
+ Integral
+ atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
+ memory_order m);
+template <class Integral>
+ Integral
+ atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
+ memory_order m);
+
+template <class T>
+ T*
+ atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op);
+
+template <class T>
+ T*
+ atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op);
+
+template <class T>
+ T*
+ atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
+ memory_order m);
+template <class T>
+ T*
+ atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
+
+template <class T>
+ T*
+ atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op);
+
+template <class T>
+ T*
+ atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op);
+
+template <class T>
+ T*
+ atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
+ memory_order m);
+template <class T>
+ T*
+ atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m);
+
+// Atomics for standard typedef types
+
+typedef atomic<char> atomic_char;
+typedef atomic<signed char> atomic_schar;
+typedef atomic<unsigned char> atomic_uchar;
+typedef atomic<short> atomic_short;
+typedef atomic<unsigned short> atomic_ushort;
+typedef atomic<int> atomic_int;
+typedef atomic<unsigned int> atomic_uint;
+typedef atomic<long> atomic_long;
+typedef atomic<unsigned long> atomic_ulong;
+typedef atomic<long long> atomic_llong;
+typedef atomic<unsigned long long> atomic_ullong;
+typedef atomic<char16_t> atomic_char16_t;
+typedef atomic<char32_t> atomic_char32_t;
+typedef atomic<wchar_t> atomic_wchar_t;
+
+typedef atomic<int_least8_t> atomic_int_least8_t;
+typedef atomic<uint_least8_t> atomic_uint_least8_t;
+typedef atomic<int_least16_t> atomic_int_least16_t;
+typedef atomic<uint_least16_t> atomic_uint_least16_t;
+typedef atomic<int_least32_t> atomic_int_least32_t;
+typedef atomic<uint_least32_t> atomic_uint_least32_t;
+typedef atomic<int_least64_t> atomic_int_least64_t;
+typedef atomic<uint_least64_t> atomic_uint_least64_t;
+
+typedef atomic<int_fast8_t> atomic_int_fast8_t;
+typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
+typedef atomic<int_fast16_t> atomic_int_fast16_t;
+typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
+typedef atomic<int_fast32_t> atomic_int_fast32_t;
+typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
+typedef atomic<int_fast64_t> atomic_int_fast64_t;
+typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
+
+typedef atomic<intptr_t> atomic_intptr_t;
+typedef atomic<uintptr_t> atomic_uintptr_t;
+typedef atomic<size_t> atomic_size_t;
+typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
+typedef atomic<intmax_t> atomic_intmax_t;
+typedef atomic<uintmax_t> atomic_uintmax_t;
+
+// fences
+
+void atomic_thread_fence(memory_order m);
+void atomic_signal_fence(memory_order m);
+
+} // std
+
+*/
+
+#include <__config>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#pragma GCC system_header
+
+//// Begin Temporary Intrinsics ////
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+__atomic_is_lock_free(_Tp)
{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(char32_t, memory_order = memory_order_seq_cst) volatile;
- void store(char32_t, memory_order = memory_order_seq_cst);
- char32_t load(memory_order = memory_order_seq_cst) const volatile;
- char32_t load(memory_order = memory_order_seq_cst) const;
- operator char32_t() const volatile;
- operator char32_t() const;
- char32_t exchange(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t exchange(char32_t, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(char32_t&, char32_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(char32_t&, char32_t, memory_order, memory_order);
- bool compare_exchange_strong(char32_t&, char32_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(char32_t&, char32_t,
- memory_order, memory_order);
- bool compare_exchange_weak(char32_t&, char32_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(char32_t&, char32_t,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(char32_t&, char32_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(char32_t&, char32_t,
- memory_order = memory_order_seq_cst);
- char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst);
- char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst);
- char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst);
- char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst);
- char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst) volatile;
- char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst);
- atomic_char32_t() = default;
- constexpr atomic_char32_t(char32_t);
- 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;
- char32_t operator=(char32_t) volatile;
- char32_t operator=(char32_t);
- char32_t operator++(int) volatile;
- char32_t operator++(int);
- char32_t operator--(int) volatile;
- char32_t operator--(int);
- char32_t operator++() volatile;
- char32_t operator++();
- char32_t operator--() volatile;
- char32_t operator--();
- char32_t operator+=(char32_t) volatile;
- char32_t operator+=(char32_t);
- char32_t operator-=(char32_t) volatile;
- char32_t operator-=(char32_t);
- char32_t operator&=(char32_t) volatile;
- char32_t operator&=(char32_t);
- char32_t operator|=(char32_t) volatile;
- char32_t operator|=(char32_t);
- char32_t operator^=(char32_t) volatile;
- char32_t operator^=(char32_t);
-} atomic_char32_t;
+ return false;
+}
-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);
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+__atomic_load(const volatile _Tp* __t, int)
+{
+ return *__t;
+}
-// atomic_wchar_t
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+__atomic_store(volatile _Tp* __t, _Tp __d, int)
+{
+ *__t = __d;
+}
-typedef struct atomic_wchar_t
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+__atomic_exchange(volatile _Tp* __t, _Tp __d, int)
{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(wchar_t, memory_order = memory_order_seq_cst) volatile;
- void store(wchar_t, memory_order = memory_order_seq_cst);
- wchar_t load(memory_order = memory_order_seq_cst) const volatile;
- wchar_t load(memory_order = memory_order_seq_cst) const;
- operator wchar_t() const volatile;
- operator wchar_t() const;
- wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(wchar_t&, wchar_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(wchar_t&, wchar_t, memory_order, memory_order);
- bool compare_exchange_strong(wchar_t&, wchar_t, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(wchar_t&, wchar_t, memory_order, memory_order);
- bool compare_exchange_weak(wchar_t&, wchar_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(wchar_t&, wchar_t,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(wchar_t&, wchar_t,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(wchar_t&, wchar_t,
- memory_order = memory_order_seq_cst);
- wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst);
- wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst);
- wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst);
- wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst);
- wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile;
- wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst);
- atomic_wchar_t() = default;
- constexpr atomic_wchar_t(wchar_t);
- 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;
- wchar_t operator=(wchar_t) volatile;
- wchar_t operator=(wchar_t);
- wchar_t operator++(int) volatile;
- wchar_t operator++(int);
- wchar_t operator--(int) volatile;
- wchar_t operator--(int);
- wchar_t operator++() volatile;
- wchar_t operator++();
- wchar_t operator--() volatile;
- wchar_t operator--();
- wchar_t operator+=(wchar_t) volatile;
- wchar_t operator+=(wchar_t);
- wchar_t operator-=(wchar_t) volatile;
- wchar_t operator-=(wchar_t);
- wchar_t operator&=(wchar_t) volatile;
- wchar_t operator&=(wchar_t);
- wchar_t operator|=(wchar_t) volatile;
- wchar_t operator|=(wchar_t);
- wchar_t operator^=(wchar_t) volatile;
- wchar_t operator^=(wchar_t);
-} atomic_wchar_t;
+ _Tp __tmp = *__t;
+ *__t = __d;
+ return __tmp;
+}
-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);
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+__atomic_compare_exchange_strong(volatile _Tp* __o, _Tp* __e, _Tp __d, int, int)
+{
+ if (const_cast<_Tp&>(*__o) == *__e)
+ {
+ *__o = __d;
+ return true;
+ }
+ *__e = __d;
+ return false;
+}
-// Atomics for standard typedef types
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+__atomic_compare_exchange_weak(volatile _Tp* __o, _Tp* __e, _Tp __d, int, int)
+{
+ if (const_cast<_Tp&>(*__o) == *__e)
+ {
+ *__o = __d;
+ return true;
+ }
+ *__e = __d;
+ return false;
+}
-typedef atomic_schar atomic_int_least8_t;
-typedef atomic_uchar atomic_uint_least8_t;
-typedef atomic_short atomic_int_least16_t;
-typedef atomic_ushort atomic_uint_least16_t;
-typedef atomic_int atomic_int_least32_t;
-typedef atomic_uint atomic_uint_least32_t;
-typedef atomic_llong atomic_int_least64_t;
-typedef atomic_ullong atomic_uint_least64_t;
-
-typedef atomic_schar atomic_int_fast8_t;
-typedef atomic_uchar atomic_uint_fast8_t;
-typedef atomic_short atomic_int_fast16_t;
-typedef atomic_ushort atomic_uint_fast16_t;
-typedef atomic_int atomic_int_fast32_t;
-typedef atomic_uint atomic_uint_fast32_t;
-typedef atomic_llong atomic_int_fast64_t;
-typedef atomic_ullong atomic_uint_fast64_t;
-
-typedef atomic_long atomic_intptr_t;
-typedef atomic_ulong atomic_uintptr_t;
-typedef atomic_ulong atomic_size_t;
-typedef atomic_long atomic_ptrdiff_t;
-typedef atomic_llong atomic_intmax_t;
-typedef atomic_ullong atomic_uintmax_t;
+//// End Temporary Intrinsics ////
-// address types
+_LIBCPP_BEGIN_NAMESPACE_STD
-typedef struct atomic_address
+typedef enum memory_order
{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(void*, memory_order = memory_order_seq_cst) volatile;
- void store(void*, memory_order = memory_order_seq_cst);
- void* load(memory_order = memory_order_seq_cst) const volatile;
- void* load(memory_order = memory_order_seq_cst) const;
- operator void*() const volatile;
- operator void*() const;
- void* exchange(void*, memory_order = memory_order_seq_cst) volatile;
- void* exchange(void*, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(void*&, void*, memory_order,
- memory_order) volatile;
- bool compare_exchange_weak(void*&, void*, memory_order, memory_order);
- bool compare_exchange_strong(void*&, void*, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(void*&, void*, memory_order, memory_order);
- bool compare_exchange_weak(void*&, void*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(void*&, void*,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(void*&, void*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(void*&, void*,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(const void*&, const void*,
- memory_order, memory_order) volatile;
- bool compare_exchange_weak(const void*&, const void*, memory_order,
- memory_order);
- bool compare_exchange_strong(const void*&, const void*, memory_order,
- memory_order) volatile;
- bool compare_exchange_strong(const void*&, const void*, memory_order,
- memory_order);
- bool compare_exchange_weak(const void*&, const void*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(const void*&, const void*,
- memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(const void*&, const void*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(const void*&, const void*,
- memory_order = memory_order_seq_cst);
- void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
- void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
- void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
- void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
- atomic_address() = default;
- constexpr atomic_address(void*);
- atomic_address(const atomic_address&) = delete;
- atomic_address& operator=(const atomic_address&) = delete;
- atomic_address& operator=(const atomic_address&) volatile = delete;
- void* operator=(const void*) volatile;
- void* operator=(const void*);
- void* operator+=(ptrdiff_t) volatile;
- void* operator+=(ptrdiff_t);
- void* operator-=(ptrdiff_t) volatile;
- void* operator-=(ptrdiff_t);
-} atomic_address;
+ memory_order_relaxed, memory_order_consume, memory_order_acquire,
+ memory_order_release, memory_order_acq_rel, memory_order_seq_cst
+} memory_order;
-bool atomic_is_lock_free(const volatile atomic_address*);
-bool atomic_is_lock_free(const atomic_address*);
-void atomic_init(volatile atomic_address*, void*);
-void atomic_init(atomic_address*, void*);
-void atomic_store(volatile atomic_address*, void*);
-void atomic_store(atomic_address*, void*);
-void atomic_store_explicit(volatile atomic_address*, void*, memory_order);
-void atomic_store_explicit(atomic_address*, void*, memory_order);
-void* atomic_load(const volatile atomic_address*);
-void* atomic_load(const atomic_address*);
-void* atomic_load_explicit(const volatile atomic_address*, memory_order);
-void* atomic_load_explicit(const atomic_address*, memory_order);
-void* atomic_exchange(volatile atomic_address*, void*);
-void* atomic_exchange(atomic_address*, void*);
-void* atomic_exchange_explicit(volatile atomic_address*, void*, memory_order);
-void* atomic_exchange_explicit(atomic_address*, void*, memory_order);
-bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*);
-bool atomic_compare_exchange_weak(atomic_address*, void**, void*);
-bool atomic_compare_exchange_strong(volatile atomic_address*, void**, void*);
-bool atomic_compare_exchange_strong(atomic_address*, void**, void*);
-bool atomic_compare_exchange_weak_explicit(volatile atomic_address*, void**,
- void*, memory_order, memory_order);
-bool atomic_compare_exchange_weak_explicit(atomic_address*, void**, void*,
- memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(volatile atomic_address*, void**,
- void*, memory_order, memory_order);
-bool atomic_compare_exchange_strong_explicit(atomic_address*, void**, void*,
- memory_order, memory_order);
-void* atomic_fetch_add(volatile atomic_address*, ptrdiff_t);
-void* atomic_fetch_add(atomic_address*, ptrdiff_t);
-void* atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t,
- memory_order);
-void* atomic_fetch_add_explicit(atomic_address*, ptrdiff_t, memory_order);
-void* atomic_fetch_sub(volatile atomic_address*, ptrdiff_t);
-void* atomic_fetch_sub(atomic_address*, ptrdiff_t);
-void* atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t,
- memory_order);
-void* atomic_fetch_sub_explicit(atomic_address*, ptrdiff_t, memory_order);
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+kill_dependency(_Tp __y)
+{
+ return __y;
+}
-// generic types
+template <class T> struct atomic;
-template <class T>
-struct atomic
+// atomic_is_lock_free
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_is_lock_free(const volatile atomic<_Tp>*)
+{
+ return __atomic_is_lock_free(_Tp());
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_is_lock_free(const atomic<_Tp>*)
{
- bool is_lock_free() const volatile;
- bool is_lock_free() const;
- void store(T, memory_order = memory_order_seq_cst) volatile;
- void store(T, memory_order = memory_order_seq_cst);
- T load(memory_order = memory_order_seq_cst) const volatile;
- T load(memory_order = memory_order_seq_cst) const;
- operator T() const volatile;
- operator T() const;
- T exchange(T, memory_order = memory_order_seq_cst) volatile;
- T exchange(T, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile;
- bool compare_exchange_weak(T&, T, memory_order, memory_order);
- bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile;
- bool compare_exchange_strong(T&, T, memory_order, memory_order);
- bool compare_exchange_weak(T&, T,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(T&, T,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst);
+ return __atomic_is_lock_free(_Tp());
+}
- atomic() = default;
- constexpr atomic(T);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- T operator=(T) volatile;
- T operator=(T);
-};
+// atomic_init
-template <>
-struct atomic<bool>
- : public atomic_bool
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_init(volatile atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(bool);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- bool operator=(bool) volatile;
- bool operator=(bool);
- operator bool() const volatile;
- operator bool() const;
-};
+ __o->__a_ = __d;
+}
-template <>
-struct atomic<char>
- : public atomic_char
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_init(atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(char);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- char operator=(char) volatile;
- char operator=(char);
- operator char() const volatile;
- operator char() const;
-};
+ __o->__a_ = __d;
+}
-template <>
-struct atomic<signed char>
- : public atomic_schar
+// atomic_store
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_store(volatile atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(signed char);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- signed char operator=(signed char) volatile;
- signed char operator=(signed char);
- operator signed char() const volatile;
- operator signed char() const;
-};
+ __atomic_store(&__o->__a_, __d, memory_order_seq_cst);
+}
-template <>
-struct atomic<unsigned char>
- : public atomic_uchar
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_store(atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(unsigned char);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- unsigned char operator=(unsigned char) volatile;
- unsigned char operator=(unsigned char);
- operator unsigned char() const volatile;
- operator unsigned char() const;
-};
+ __atomic_store(&__o->__a_, __d, memory_order_seq_cst);
+}
-template <>
-struct atomic<short>
- : public atomic_short
+// atomic_store_explicit
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m)
{
- atomic() = default;
- constexpr atomic(short);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- short operator=(short) volatile;
- short operator=(short);
- operator short() const volatile;
- operator short() const;
-};
+ __atomic_store(&__o->__a_, __d, __m);
+}
-template <>
-struct atomic<unsigned short>
- : public atomic_ushort
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m)
{
- atomic() = default;
- constexpr atomic(unsigned short);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- unsigned short operator=(unsigned short) volatile;
- unsigned short operator=(unsigned short);
- operator unsigned short() const volatile;
- operator unsigned short() const;
-};
+ __atomic_store(&__o->__a_, __d, __m);
+}
-template <>
-struct atomic<int>
- : public atomic_int
+// atomic_load
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_load(const volatile atomic<_Tp>* __o)
{
- atomic() = default;
- constexpr atomic(int);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- int operator=(int) volatile;
- int operator=(int);
- operator int() const volatile;
- operator int() const;
-};
+ return __atomic_load(&__o->__a_, memory_order_seq_cst);
+}
-template <>
-struct atomic<unsigned int>
- : public atomic_uint
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_load(const atomic<_Tp>* __o)
{
- atomic() = default;
- constexpr atomic(unsigned int);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- unsigned int operator=(unsigned int) volatile;
- unsigned int operator=(unsigned int);
- operator unsigned int() const volatile;
- operator unsigned int() const;
-};
+ return __atomic_load(&__o->__a_, memory_order_seq_cst);
+}
-template <>
-struct atomic<long>
- : public atomic_long
+// atomic_load_explicit
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m)
{
- atomic() = default;
- constexpr atomic(long);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- long operator=(long) volatile;
- long operator=(long);
- operator long() const volatile;
- operator long() const;
-};
+ return __atomic_load(&__o->__a_, __m);
+}
-template <>
-struct atomic<unsigned long>
- : public atomic_ulong
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m)
{
- atomic() = default;
- constexpr atomic(unsigned long);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- unsigned long operator=(unsigned long) volatile;
- unsigned long operator=(unsigned long);
- operator unsigned long() const volatile;
- operator unsigned long() const;
-};
+ return __atomic_load(&__o->__a_, __m);
+}
-template <>
-struct atomic<long long>
- : public atomic_llong
+// atomic_exchange
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(long long);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- long long operator=(long long) volatile;
- long long operator=(long long);
- operator long long() const volatile;
- operator long long() const;
-};
+ return __atomic_exchange(&__o->__a_, __d, memory_order_seq_cst);
+}
-template <>
-struct atomic<unsigned long long>
- : public atomic_ullong
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_exchange(atomic<_Tp>* __o, _Tp __d)
{
- atomic() = default;
- constexpr atomic(unsigned long long);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- unsigned long long operator=(unsigned long long) volatile;
- unsigned long long operator=(unsigned long long);
- operator unsigned long long() const volatile;
- operator unsigned long long() const;
-};
+ return __atomic_exchange(&__o->__a_, __d, memory_order_seq_cst);
+}
-template <>
-struct atomic<char16_t>
- : public atomic_char16_t
+// atomic_exchange_explicit
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m)
{
- atomic() = default;
- constexpr atomic(char16_t);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- char16_t operator=(char16_t) volatile;
- char16_t operator=(char16_t);
- operator char16_t() const volatile;
- operator char16_t() const;
-};
+ return __atomic_exchange(&__o->__a_, __d, __m);
+}
-template <>
-struct atomic<char32_t>
- : public atomic_char32_t
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp
+atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m)
{
- atomic() = default;
- constexpr atomic(char32_t);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- char32_t operator=(char32_t) volatile;
- char32_t operator=(char32_t);
- operator char32_t() const volatile;
- operator char32_t() const;
-};
+ return __atomic_exchange(&__o->__a_, __d, __m);
+}
-template <>
-struct atomic<wchar_t>
- : public atomic_wchar_t
+// atomic_compare_exchange_weak
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d)
{
- atomic() = default;
- constexpr atomic(wchar_t);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- wchar_t operator=(wchar_t) volatile;
- wchar_t operator=(wchar_t);
- operator wchar_t() const volatile;
- operator wchar_t() const;
-};
+ return __atomic_compare_exchange_weak(&__o->__a_, __e, __d,
+ memory_order_seq_cst,
+ memory_order_seq_cst);
+}
-template <class T>
-struct atomic<T*>
- : public atomic_address
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d)
{
- void store(T*, memory_order = memory_order_seq_cst) volatile;
- void store(T*, memory_order = memory_order_seq_cst);
- T* load(memory_order = memory_order_seq_cst) const volatile;
- T* load(memory_order = memory_order_seq_cst) const;
- operator T*() const volatile;
- operator T*() const;
- T* exchange(T*, memory_order = memory_order_seq_cst) volatile;
- T* exchange(T*, memory_order = memory_order_seq_cst);
- bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile;
- bool compare_exchange_weak(T*&, T*, memory_order, memory_order);
- bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile;
- bool compare_exchange_strong(T*&, T*, memory_order, memory_order);
- bool compare_exchange_weak(T*&, T*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);
- bool compare_exchange_strong(T*&, T*,
- memory_order = memory_order_seq_cst) volatile;
- bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);
- T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
- T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
- T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
- T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
- atomic() = default;
- constexpr atomic(T*);
- atomic(const atomic&) = delete;
- atomic& operator=(const atomic&) = delete;
- atomic& operator=(const atomic&) volatile = delete;
- T* operator=(T*) volatile;
- T* operator=(T*);
- T* operator++(int) volatile;
- T* operator++(int);
- T* operator--(int) volatile;
- T* operator--(int);
- T* operator++() volatile;
- T* operator++();
- T* operator--() volatile;
- T* operator--();
- T* operator+=(ptrdiff_t) volatile;
- T* operator+=(ptrdiff_t);
- T* operator-=(ptrdiff_t) volatile;
- T* operator-=(ptrdiff_t);
-};
+ return __atomic_compare_exchange_weak(&__o->__a_, __e, __d,
+ memory_order_seq_cst,
+ memory_order_seq_cst);
+}
-// fences
+// atomic_compare_exchange_strong
-void atomic_thread_fence(memory_order);
-void atomic_signal_fence(memory_order);
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d)
+{
+ return __atomic_compare_exchange_strong(&__o->__a_, __e, __d,
+ memory_order_seq_cst,
+ memory_order_seq_cst);
+}
-} // std
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d)
+{
+ return __atomic_compare_exchange_strong(&__o->__a_, __e, __d,
+ memory_order_seq_cst,
+ memory_order_seq_cst);
+}
-*/
+// atomic_compare_exchange_weak_explicit
-#include <__config>
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e,
+ _Tp __d,
+ memory_order __s, memory_order __f)
+{
+ return __atomic_compare_exchange_weak(&__o->__a_, __e, __d, __s, __f);
+}
-#pragma GCC system_header
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d,
+ memory_order __s, memory_order __f)
+{
+ return __atomic_compare_exchange_weak(&__o->__a_, __e, __d, __s, __f);
+}
-_LIBCPP_BEGIN_NAMESPACE_STD
+// atomic_compare_exchange_strong_explicit
-typedef enum memory_order
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o,
+ _Tp* __e, _Tp __d,
+ memory_order __s, memory_order __f)
{
- memory_order_relaxed, memory_order_consume, memory_order_acquire,
- memory_order_release, memory_order_acq_rel, memory_order_seq_cst
-} memory_order;
+ return __atomic_compare_exchange_strong(&__o->__a_, __e, __d, __s, __f);
+}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-kill_dependency(_Tp __y)
+bool
+atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,
+ _Tp __d,
+ memory_order __s, memory_order __f)
{
- return __y;
+ return __atomic_compare_exchange_strong(&__o->__a_, __e, __d, __s, __f);
}
+
+// atomic<T>
+
+template <class _Tp>
+struct atomic
+{
+ _Tp __a_;
+
+ bool is_lock_free() const volatile;
+ bool is_lock_free() const;
+ void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile;
+ void store(_Tp __d, memory_order __m = memory_order_seq_cst);
+ _LIBCPP_INLINE_VISIBILITY
+ _Tp load(memory_order __m = memory_order_seq_cst) const volatile
+ {return atomic_load_explicit(this, __m);}
+ _LIBCPP_INLINE_VISIBILITY
+ _Tp load(memory_order __m = memory_order_seq_cst) const
+ {return atomic_load_explicit(this, __m);}
+ _LIBCPP_INLINE_VISIBILITY
+ operator _Tp() const volatile {return load();}
+ _LIBCPP_INLINE_VISIBILITY
+ operator _Tp() const {return load();}
+ _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile;
+ _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst);
+ bool compare_exchange_weak(_Tp& __e, _Tp __d,
+ memory_order __s, memory_order __f) volatile;
+ bool compare_exchange_weak(_Tp& __e, _Tp __d,
+ memory_order __s, memory_order __f);
+ bool compare_exchange_strong(_Tp& __e, _Tp __d,
+ memory_order __s, memory_order __f) volatile;
+ bool compare_exchange_strong(_Tp& __e, _Tp __d,
+ memory_order __s, memory_order __f);
+ bool compare_exchange_weak(_Tp& __e, _Tp __d,
+ memory_order __m = memory_order_seq_cst) volatile;
+ bool compare_exchange_weak(_Tp& __e, _Tp __d,
+ memory_order __m = memory_order_seq_cst);
+ bool compare_exchange_strong(_Tp& __e, _Tp __d,
+ memory_order __m = memory_order_seq_cst) volatile;
+ bool compare_exchange_strong(_Tp& __e, _Tp __d,
+ memory_order __m = memory_order_seq_cst);
+
+ atomic() {} // = default;
+ constexpr atomic(_Tp __d);
+ atomic(const atomic&) = delete;
+ atomic& operator=(const atomic&) = delete;
+ atomic& operator=(const atomic&) volatile = delete;
+ _Tp operator=(_Tp) volatile;
+ _Tp operator=(_Tp);
+};
+
+/*
// flag type and operations
typedef bool __atomic_flag__;
@@ -2664,7 +1138,7 @@
atomic_bool() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_bool(bool __v)
+ constexpr atomic_bool(bool __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_bool(const atomic_bool&) = delete;
@@ -3018,7 +1492,7 @@
atomic_char() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_char(char __v)
+ constexpr atomic_char(char __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_char(const atomic_char&) = delete;
@@ -3624,7 +2098,7 @@
atomic_schar() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_schar(signed char __v)
+ constexpr atomic_schar(signed char __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_schar(const atomic_schar&) = delete;
@@ -4244,7 +2718,7 @@
atomic_uchar() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_uchar(unsigned char __v)
+ constexpr atomic_uchar(unsigned char __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_uchar(const atomic_uchar&) = delete;
@@ -4837,7 +3311,7 @@
atomic_short() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_short(short __v)
+ constexpr atomic_short(short __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_short(const atomic_short&) = delete;
@@ -5453,7 +3927,7 @@
atomic_ushort() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_ushort(unsigned short __v)
+ constexpr atomic_ushort(unsigned short __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_ushort(const atomic_ushort&) = delete;
@@ -6047,7 +4521,7 @@
atomic_int() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_int(int __v)
+ constexpr atomic_int(int __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_int(const atomic_int&) = delete;
@@ -6660,7 +5134,7 @@
atomic_uint() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_uint(unsigned int __v)
+ constexpr atomic_uint(unsigned int __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_uint(const atomic_uint&) = delete;
@@ -7253,7 +5727,7 @@
atomic_long() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_long(long __v)
+ constexpr atomic_long(long __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_long(const atomic_long&) = delete;
@@ -7866,7 +6340,7 @@
atomic_ulong() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_ulong(unsigned long __v)
+ constexpr atomic_ulong(unsigned long __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_ulong(const atomic_ulong&) = delete;
@@ -8491,7 +6965,7 @@
atomic_llong() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_llong(long long __v)
+ constexpr atomic_llong(long long __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_llong(const atomic_llong&) = delete;
@@ -9126,7 +7600,7 @@
atomic_ullong() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_ullong(unsigned long long __v)
+ constexpr atomic_ullong(unsigned long long __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_ullong(const atomic_ullong&) = delete;
@@ -9742,7 +8216,7 @@
atomic_char16_t() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_char16_t(char16_t __v)
+ constexpr atomic_char16_t(char16_t __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_char16_t(const atomic_char16_t&) = delete;
@@ -10348,7 +8822,7 @@
atomic_char32_t() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_char32_t(char32_t __v)
+ constexpr atomic_char32_t(char32_t __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_char32_t(const atomic_char32_t&) = delete;
@@ -10956,7 +9430,7 @@
atomic_wchar_t() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_wchar_t(wchar_t __v)
+ constexpr atomic_wchar_t(wchar_t __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_wchar_t(const atomic_wchar_t&) = delete;
@@ -11562,7 +10036,7 @@
atomic_address() {}
#endif
_LIBCPP_INLINE_VISIBILITY
- /*constexpr*/ atomic_address(void* __v)
+ constexpr atomic_address(void* __v)
: __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
atomic_address(const atomic_address&) = delete;
@@ -11849,7 +10323,7 @@
return atomic_fetch_sub_explicit(const_cast<volatile atomic_address*>(__obj),
__v, __o);
}
-
+*/
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_ATOMIC
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// bool
+// atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr);
+//
+// template <class T>
+// bool
+// atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ {
+ typedef std::atomic<T> A;
+ A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_strong(&a, &t, T(2)) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_strong(&a, &t, T(3)) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// bool
+// atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, T* expc,
+// T desr,
+// memory_order s, memory_order f);
+//
+// template <class T>
+// bool
+// atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,
+// memory_order s, memory_order f);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ {
+ typedef std::atomic<T> A;
+ A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// bool
+// atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr);
+//
+// template <class T>
+// bool
+// atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ {
+ typedef std::atomic<T> A;
+ A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_weak(&a, &t, T(2)) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_weak(&a, &t, T(2)) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_weak(&a, &t, T(3)) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// bool
+// atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
+// T desr,
+// memory_order s, memory_order f);
+//
+// template <class T>
+// bool
+// atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
+// memory_order s, memory_order f);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ {
+ typedef std::atomic<T> A;
+ A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(2),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+ {
+ typedef std::atomic<T> A;
+ volatile A a;
+ T t(T(1));
+ std::atomic_init(&a, t);
+ assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(2),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
+ assert(a == T(2));
+ assert(t == T(1));
+ assert(std::atomic_compare_exchange_weak_explicit(&a, &t, T(3),
+ std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
+ assert(a == T(2));
+ assert(t == T(3));
+ }
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// T
+// atomic_exchange(volatile atomic<T>* obj, T desr);
+//
+// template <class T>
+// T
+// atomic_exchange(atomic<T>* obj, T desr);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_init(&t, T(1));
+ assert(std::atomic_exchange(&t, T(2)) == T(1));
+ assert(t == T(2));
+ volatile A vt;
+ std::atomic_init(&vt, T(3));
+ assert(std::atomic_exchange(&vt, T(4)) == T(3));
+ assert(vt == T(4));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// T
+// atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m);
+//
+// template <class T>
+// T
+// atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_init(&t, T(1));
+ assert(std::atomic_exchange_explicit(&t, T(2), std::memory_order_seq_cst)
+ == T(1));
+ assert(t == T(2));
+ volatile A vt;
+ std::atomic_init(&vt, T(3));
+ assert(std::atomic_exchange_explicit(&vt, T(4), std::memory_order_seq_cst)
+ == T(3));
+ assert(vt == T(4));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// void
+// atomic_init(volatile atomic<T>* obj, T desr);
+//
+// template <class T>
+// void
+// atomic_init(atomic<T>* obj, T desr);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_init(&t, T(1));
+ assert(t == T(1));
+ volatile A vt;
+ std::atomic_init(&vt, T(2));
+ assert(vt == T(2));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_is_lock_free.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// bool
+// atomic_is_lock_free(const volatile atomic<T>* obj);
+//
+// template <class T>
+// bool
+// atomic_is_lock_free(const atomic<T>* obj);
+
+#include <atomic>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ const A ct;
+ bool b1 = std::atomic_is_lock_free(&ct);
+ const volatile A cvt;
+ bool b2 = std::atomic_is_lock_free(&cvt);
+}
+
+struct A
+{
+ char _[4];
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// T
+// atomic_load(const volatile atomic<T>* obj);
+//
+// template <class T>
+// T
+// atomic_load(const atomic<T>* obj);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_init(&t, T(1));
+ assert(std::atomic_load(&t) == T(1));
+ volatile A vt;
+ std::atomic_init(&vt, T(2));
+ assert(std::atomic_load(&vt) == T(2));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// T
+// atomic_load_explicit(const volatile atomic<T>* obj, memory_order m);
+//
+// template <class T>
+// T
+// atomic_load_explicit(const atomic<T>* obj, memory_order m);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_init(&t, T(1));
+ assert(std::atomic_load_explicit(&t, std::memory_order_seq_cst) == T(1));
+ volatile A vt;
+ std::atomic_init(&vt, T(2));
+ assert(std::atomic_load_explicit(&vt, std::memory_order_seq_cst) == T(2));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// void
+// atomic_store(volatile atomic<T>* obj, T desr);
+//
+// template <class T>
+// void
+// atomic_store(atomic<T>* obj, T desr);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_store(&t, T(1));
+ assert(t == T(1));
+ volatile A vt;
+ std::atomic_store(&vt, T(2));
+ assert(vt == T(2));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
Added: libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp?rev=121064&view=auto
==============================================================================
--- libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp (added)
+++ libcxx/trunk/test/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp Mon Dec 6 17:10:08 2010
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// template <class T>
+// void
+// atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m);
+//
+// template <class T>
+// void
+// atomic_store_explicit(atomic<T>* obj, T desr, memory_order m);
+
+#include <atomic>
+#include <cassert>
+
+template <class T>
+void
+test()
+{
+ typedef std::atomic<T> A;
+ A t;
+ std::atomic_store_explicit(&t, T(1), std::memory_order_seq_cst);
+ assert(t == T(1));
+ volatile A vt;
+ std::atomic_store_explicit(&vt, T(2), std::memory_order_seq_cst);
+ assert(vt == T(2));
+}
+
+struct A
+{
+ int i;
+
+ explicit A(int d = 0) : i(d) {}
+ A(const A& a) : i(a.i) {}
+ A(const volatile A& a) : i(a.i) {}
+
+ void operator=(const volatile A& a) volatile {i = a.i;}
+
+ friend bool operator==(const A& x, const A& y)
+ {return x.i == y.i;}
+};
+
+int main()
+{
+ test<A>();
+ test<char>();
+ test<signed char>();
+ test<unsigned char>();
+ test<short>();
+ test<unsigned short>();
+ test<int>();
+ test<unsigned int>();
+ test<long>();
+ test<unsigned long>();
+ test<long long>();
+ test<unsigned long long>();
+ test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<char16_t>();
+ test<char32_t>();
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
+ test<int*>();
+ test<const int*>();
+}
More information about the cfe-commits
mailing list