From cd39d413b47fbc509787355aed69ad8ebf15e80e Mon Sep 17 00:00:00 2001 From: Howard Hinnant Date: Mon, 27 Sep 2010 21:17:38 +0000 Subject: [PATCH] Getting started on llvm-svn: 114887 --- libcxx/include/atomic | 2418 ++++++++++++++++++++++++++ libcxx/test/atomics/version.pass.cpp | 20 + 2 files changed, 2438 insertions(+) create mode 100644 libcxx/include/atomic create mode 100644 libcxx/test/atomics/version.pass.cpp diff --git a/libcxx/include/atomic b/libcxx/include/atomic new file mode 100644 index 000000000000..b36aee2328cc --- /dev/null +++ b/libcxx/include/atomic @@ -0,0 +1,2418 @@ +// -*- C++ -*- +//===--------------------------- atomic -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_ATOMIC +#define _LIBCPP_ATOMIC + +/* + atomic synopsis + +namespace std +{ + +// order and consistency + +typedef enum memory_order +{ + memory_order_relaxed, memory_order_consume, memory_order_acquire, + memory_order_release, memory_order_acq_rel, memory_order_seq_cst +} memory_order; + +template T kill_dependency(T y); + +// lock-free property + +#define ATOMIC_CHAR_LOCK_FREE unspecified +#define ATOMIC_CHAR16_T_LOCK_FREE unspecified +#define ATOMIC_CHAR32_T_LOCK_FREE unspecified +#define ATOMIC_WCHAR_T_LOCK_FREE unspecified +#define ATOMIC_SHORT_LOCK_FREE unspecified +#define ATOMIC_INT_LOCK_FREE unspecified +#define ATOMIC_LONG_LOCK_FREE unspecified +#define ATOMIC_LLONG_LOCK_FREE unspecified +#define ATOMIC_ADDRESS_LOCK_FREE unspecified + +// operations on atomic types + +#define ATOMIC_VAR_INIT(value) see below + +// 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); + 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); + +#define ATOMIC_FLAG_INIT see below + +// atomic_bool + +typedef struct atomic_bool +{ + 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; +} 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); + +// atomic_char + +typedef struct atomic_char +{ + 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; + +bool atomic_is_lock_free(const volatile atomic_char*); +bool atomic_is_lock_free(const atomic_char*); +void atomic_init(volatile atomic_char*, itype); +void atomic_init(atomic_char*, itype); +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_schar + +typedef struct atomic_schar +{ + 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; + +bool atomic_is_lock_free(const volatile atomic_schar*); +bool atomic_is_lock_free(const atomic_schar*); +void atomic_init(volatile atomic_schar*, itype); +void atomic_init(atomic_schar*, itype); +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_uchar + +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*, itype); +void atomic_init(atomic_uchar*, itype); +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); + +// atomic_short + +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; + +bool atomic_is_lock_free(const volatile atomic_short*); +bool atomic_is_lock_free(const atomic_short*); +void atomic_init(volatile atomic_short*, itype); +void atomic_init(atomic_short*, itype); +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); + +// atomic_ushort + +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; + +bool atomic_is_lock_free(const volatile atomic_ushort*); +bool atomic_is_lock_free(const atomic_ushort*); +void atomic_init(volatile atomic_ushort*, itype); +void atomic_init(atomic_ushort*, itype); +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); + +// atomic_int + +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; + +bool atomic_is_lock_free(const volatile atomic_int*); +bool atomic_is_lock_free(const atomic_int*); +void atomic_init(volatile atomic_int*, itype); +void atomic_init(atomic_int*, itype); +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); + +// atomic_uint + +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; + +bool atomic_is_lock_free(const volatile atomic_uint*); +bool atomic_is_lock_free(const atomic_uint*); +void atomic_init(volatile atomic_uint*, itype); +void atomic_init(atomic_uint*, itype); +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*, itype); +void atomic_init(atomic_long*, itype); +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*, itype); +void atomic_init(atomic_ulong*, itype); +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); + +// atomic_llong + +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; + +bool atomic_is_lock_free(const volatile atomic_llong*); +bool atomic_is_lock_free(const atomic_llong*); +void atomic_init(volatile atomic_llong*, itype); +void atomic_init(atomic_llong*, itype); +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); + +// atomic_ullong + +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; + +bool atomic_is_lock_free(const volatile atomic_ullong*); +bool atomic_is_lock_free(const atomic_ullong*); +void atomic_init(volatile atomic_ullong*, itype); +void atomic_init(atomic_ullong*, itype); +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); + +// atomic_char16_t + +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; + +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*, itype); +void atomic_init(atomic_char16_t*, itype); +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); + +// atomic_char32_t + +typedef struct atomic_char32_t +{ + 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; + +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*, itype); +void atomic_init(atomic_char32_t*, itype); +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); + +// atomic_wchar_t + +typedef struct atomic_wchar_t +{ + 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; + +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*, itype); +void atomic_init(atomic_wchar_t*, itype); +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); + +// Atomics for standard typedef types + +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; + +// address types + +typedef struct atomic_address +{ + 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; + +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); + +// generic types + +template +struct atomic +{ + 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); + + 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); +}; + +template <> +struct atomic + : public atomic_bool +{ + 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; +}; + +template <> +struct atomic + : public atomic_char +{ + 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; +}; + +template <> +struct atomic + : public atomic_schar +{ + 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; +}; + +template <> +struct atomic + : public atomic_uchar +{ + 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; +}; + +template <> +struct atomic + : public atomic_short +{ + 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; +}; + +template <> +struct atomic + : public atomic_ushort +{ + 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; +}; + +template <> +struct atomic + : public atomic_int +{ + 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; +}; + +template <> +struct atomic + : public atomic_uint +{ + 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; +}; + +template <> +struct atomic + : public atomic_long +{ + 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; +}; + +template <> +struct atomic + : public atomic_ulong +{ + 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; +}; + +template <> +struct atomic + : public atomic_llong +{ + 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; +}; + +template <> +struct atomic + : public atomic_ullong +{ + 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; +}; + +template <> +struct atomic + : public atomic_char16_t +{ + 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; +}; + +template <> +struct atomic + : public atomic_char32_t +{ + 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; +}; + +template <> +struct atomic + : public atomic_wchar_t +{ + 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; +}; + +template +struct atomic + : public atomic_address +{ + 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); +}; + +// fences + +void atomic_thread_fence(memory_order); +void atomic_signal_fence(memory_order); + +} // std + +*/ + +#include <__config> + +#pragma GCC system_header + +_LIBCPP_BEGIN_NAMESPACE_STD + + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_ATOMIC diff --git a/libcxx/test/atomics/version.pass.cpp b/libcxx/test/atomics/version.pass.cpp new file mode 100644 index 000000000000..283b5df305a9 --- /dev/null +++ b/libcxx/test/atomics/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// + +#include + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +}