1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP_STDATOMIC_H 11 #define _LIBCPP_STDATOMIC_H 12 13 /* 14 stdatomic.h synopsis 15 16 template<class T> 17 using std-atomic = std::atomic<T>; // exposition only 18 19 #define _Atomic(T) std-atomic<T> 20 21 #define ATOMIC_BOOL_LOCK_FREE see below 22 #define ATOMIC_CHAR_LOCK_FREE see below 23 #define ATOMIC_CHAR16_T_LOCK_FREE see below 24 #define ATOMIC_CHAR32_T_LOCK_FREE see below 25 #define ATOMIC_WCHAR_T_LOCK_FREE see below 26 #define ATOMIC_SHORT_LOCK_FREE see below 27 #define ATOMIC_INT_LOCK_FREE see below 28 #define ATOMIC_LONG_LOCK_FREE see below 29 #define ATOMIC_LLONG_LOCK_FREE see below 30 #define ATOMIC_POINTER_LOCK_FREE see below 31 32 using std::memory_order // see below 33 using std::memory_order_relaxed // see below 34 using std::memory_order_consume // see below 35 using std::memory_order_acquire // see below 36 using std::memory_order_release // see below 37 using std::memory_order_acq_rel // see below 38 using std::memory_order_seq_cst // see below 39 40 using std::atomic_flag // see below 41 42 using std::atomic_bool // see below 43 using std::atomic_char // see below 44 using std::atomic_schar // see below 45 using std::atomic_uchar // see below 46 using std::atomic_short // see below 47 using std::atomic_ushort // see below 48 using std::atomic_int // see below 49 using std::atomic_uint // see below 50 using std::atomic_long // see below 51 using std::atomic_ulong // see below 52 using std::atomic_llong // see below 53 using std::atomic_ullong // see below 54 using std::atomic_char8_t // see below 55 using std::atomic_char16_t // see below 56 using std::atomic_char32_t // see below 57 using std::atomic_wchar_t // see below 58 using std::atomic_int8_t // see below 59 using std::atomic_uint8_t // see below 60 using std::atomic_int16_t // see below 61 using std::atomic_uint16_t // see below 62 using std::atomic_int32_t // see below 63 using std::atomic_uint32_t // see below 64 using std::atomic_int64_t // see below 65 using std::atomic_uint64_t // see below 66 using std::atomic_int_least8_t // see below 67 using std::atomic_uint_least8_t // see below 68 using std::atomic_int_least16_t // see below 69 using std::atomic_uint_least16_t // see below 70 using std::atomic_int_least32_t // see below 71 using std::atomic_uint_least32_t // see below 72 using std::atomic_int_least64_t // see below 73 using std::atomic_uint_least64_t // see below 74 using std::atomic_int_fast8_t // see below 75 using std::atomic_uint_fast8_t // see below 76 using std::atomic_int_fast16_t // see below 77 using std::atomic_uint_fast16_t // see below 78 using std::atomic_int_fast32_t // see below 79 using std::atomic_uint_fast32_t // see below 80 using std::atomic_int_fast64_t // see below 81 using std::atomic_uint_fast64_t // see below 82 using std::atomic_intptr_t // see below 83 using std::atomic_uintptr_t // see below 84 using std::atomic_size_t // see below 85 using std::atomic_ptrdiff_t // see below 86 using std::atomic_intmax_t // see below 87 using std::atomic_uintmax_t // see below 88 89 using std::atomic_is_lock_free // see below 90 using std::atomic_load // see below 91 using std::atomic_load_explicit // see below 92 using std::atomic_store // see below 93 using std::atomic_store_explicit // see below 94 using std::atomic_exchange // see below 95 using std::atomic_exchange_explicit // see below 96 using std::atomic_compare_exchange_strong // see below 97 using std::atomic_compare_exchange_strong_explicit // see below 98 using std::atomic_compare_exchange_weak // see below 99 using std::atomic_compare_exchange_weak_explicit // see below 100 using std::atomic_fetch_add // see below 101 using std::atomic_fetch_add_explicit // see below 102 using std::atomic_fetch_sub // see below 103 using std::atomic_fetch_sub_explicit // see below 104 using std::atomic_fetch_or // see below 105 using std::atomic_fetch_or_explicit // see below 106 using std::atomic_fetch_and // see below 107 using std::atomic_fetch_and_explicit // see below 108 using std::atomic_flag_test_and_set // see below 109 using std::atomic_flag_test_and_set_explicit // see below 110 using std::atomic_flag_clear // see below 111 using std::atomic_flag_clear_explicit // see below 112 113 using std::atomic_thread_fence // see below 114 using std::atomic_signal_fence // see below 115 116 */ 117 118 #include <__config> 119 120 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 121 # pragma GCC system_header 122 #endif 123 124 #if defined(__cplusplus) && _LIBCPP_STD_VER >= 23 125 126 # include <atomic> 127 # include <version> 128 129 # ifdef _Atomic 130 # undef _Atomic 131 # endif 132 133 # define _Atomic(_Tp) ::std::atomic<_Tp> 134 135 using std::memory_order _LIBCPP_USING_IF_EXISTS; 136 using std::memory_order_relaxed _LIBCPP_USING_IF_EXISTS; 137 using std::memory_order_consume _LIBCPP_USING_IF_EXISTS; 138 using std::memory_order_acquire _LIBCPP_USING_IF_EXISTS; 139 using std::memory_order_release _LIBCPP_USING_IF_EXISTS; 140 using std::memory_order_acq_rel _LIBCPP_USING_IF_EXISTS; 141 using std::memory_order_seq_cst _LIBCPP_USING_IF_EXISTS; 142 143 using std::atomic_flag _LIBCPP_USING_IF_EXISTS; 144 145 using std::atomic_bool _LIBCPP_USING_IF_EXISTS; 146 using std::atomic_char _LIBCPP_USING_IF_EXISTS; 147 using std::atomic_schar _LIBCPP_USING_IF_EXISTS; 148 using std::atomic_uchar _LIBCPP_USING_IF_EXISTS; 149 using std::atomic_short _LIBCPP_USING_IF_EXISTS; 150 using std::atomic_ushort _LIBCPP_USING_IF_EXISTS; 151 using std::atomic_int _LIBCPP_USING_IF_EXISTS; 152 using std::atomic_uint _LIBCPP_USING_IF_EXISTS; 153 using std::atomic_long _LIBCPP_USING_IF_EXISTS; 154 using std::atomic_ulong _LIBCPP_USING_IF_EXISTS; 155 using std::atomic_llong _LIBCPP_USING_IF_EXISTS; 156 using std::atomic_ullong _LIBCPP_USING_IF_EXISTS; 157 using std::atomic_char8_t _LIBCPP_USING_IF_EXISTS; 158 using std::atomic_char16_t _LIBCPP_USING_IF_EXISTS; 159 using std::atomic_char32_t _LIBCPP_USING_IF_EXISTS; 160 using std::atomic_wchar_t _LIBCPP_USING_IF_EXISTS; 161 162 using std::atomic_int8_t _LIBCPP_USING_IF_EXISTS; 163 using std::atomic_uint8_t _LIBCPP_USING_IF_EXISTS; 164 using std::atomic_int16_t _LIBCPP_USING_IF_EXISTS; 165 using std::atomic_uint16_t _LIBCPP_USING_IF_EXISTS; 166 using std::atomic_int32_t _LIBCPP_USING_IF_EXISTS; 167 using std::atomic_uint32_t _LIBCPP_USING_IF_EXISTS; 168 using std::atomic_int64_t _LIBCPP_USING_IF_EXISTS; 169 using std::atomic_uint64_t _LIBCPP_USING_IF_EXISTS; 170 171 using std::atomic_int_least8_t _LIBCPP_USING_IF_EXISTS; 172 using std::atomic_uint_least8_t _LIBCPP_USING_IF_EXISTS; 173 using std::atomic_int_least16_t _LIBCPP_USING_IF_EXISTS; 174 using std::atomic_uint_least16_t _LIBCPP_USING_IF_EXISTS; 175 using std::atomic_int_least32_t _LIBCPP_USING_IF_EXISTS; 176 using std::atomic_uint_least32_t _LIBCPP_USING_IF_EXISTS; 177 using std::atomic_int_least64_t _LIBCPP_USING_IF_EXISTS; 178 using std::atomic_uint_least64_t _LIBCPP_USING_IF_EXISTS; 179 180 using std::atomic_int_fast8_t _LIBCPP_USING_IF_EXISTS; 181 using std::atomic_uint_fast8_t _LIBCPP_USING_IF_EXISTS; 182 using std::atomic_int_fast16_t _LIBCPP_USING_IF_EXISTS; 183 using std::atomic_uint_fast16_t _LIBCPP_USING_IF_EXISTS; 184 using std::atomic_int_fast32_t _LIBCPP_USING_IF_EXISTS; 185 using std::atomic_uint_fast32_t _LIBCPP_USING_IF_EXISTS; 186 using std::atomic_int_fast64_t _LIBCPP_USING_IF_EXISTS; 187 using std::atomic_uint_fast64_t _LIBCPP_USING_IF_EXISTS; 188 189 using std::atomic_intptr_t _LIBCPP_USING_IF_EXISTS; 190 using std::atomic_uintptr_t _LIBCPP_USING_IF_EXISTS; 191 using std::atomic_size_t _LIBCPP_USING_IF_EXISTS; 192 using std::atomic_ptrdiff_t _LIBCPP_USING_IF_EXISTS; 193 using std::atomic_intmax_t _LIBCPP_USING_IF_EXISTS; 194 using std::atomic_uintmax_t _LIBCPP_USING_IF_EXISTS; 195 196 using std::atomic_compare_exchange_strong _LIBCPP_USING_IF_EXISTS; 197 using std::atomic_compare_exchange_strong_explicit _LIBCPP_USING_IF_EXISTS; 198 using std::atomic_compare_exchange_weak _LIBCPP_USING_IF_EXISTS; 199 using std::atomic_compare_exchange_weak_explicit _LIBCPP_USING_IF_EXISTS; 200 using std::atomic_exchange _LIBCPP_USING_IF_EXISTS; 201 using std::atomic_exchange_explicit _LIBCPP_USING_IF_EXISTS; 202 using std::atomic_fetch_add _LIBCPP_USING_IF_EXISTS; 203 using std::atomic_fetch_add_explicit _LIBCPP_USING_IF_EXISTS; 204 using std::atomic_fetch_and _LIBCPP_USING_IF_EXISTS; 205 using std::atomic_fetch_and_explicit _LIBCPP_USING_IF_EXISTS; 206 using std::atomic_fetch_or _LIBCPP_USING_IF_EXISTS; 207 using std::atomic_fetch_or_explicit _LIBCPP_USING_IF_EXISTS; 208 using std::atomic_fetch_sub _LIBCPP_USING_IF_EXISTS; 209 using std::atomic_fetch_sub_explicit _LIBCPP_USING_IF_EXISTS; 210 using std::atomic_flag_clear _LIBCPP_USING_IF_EXISTS; 211 using std::atomic_flag_clear_explicit _LIBCPP_USING_IF_EXISTS; 212 using std::atomic_flag_test_and_set _LIBCPP_USING_IF_EXISTS; 213 using std::atomic_flag_test_and_set_explicit _LIBCPP_USING_IF_EXISTS; 214 using std::atomic_is_lock_free _LIBCPP_USING_IF_EXISTS; 215 using std::atomic_load _LIBCPP_USING_IF_EXISTS; 216 using std::atomic_load_explicit _LIBCPP_USING_IF_EXISTS; 217 using std::atomic_store _LIBCPP_USING_IF_EXISTS; 218 using std::atomic_store_explicit _LIBCPP_USING_IF_EXISTS; 219 220 using std::atomic_signal_fence _LIBCPP_USING_IF_EXISTS; 221 using std::atomic_thread_fence _LIBCPP_USING_IF_EXISTS; 222 223 #elif defined(_LIBCPP_COMPILER_CLANG_BASED) 224 225 // Before C++23, we include the next <stdatomic.h> on the path to avoid hijacking 226 // the header. We do this because Clang has historically shipped a <stdatomic.h> 227 // header that would be available in all Standard modes, and we don't want to 228 // break that use case. 229 # if __has_include_next(<stdatomic.h>) 230 # include_next <stdatomic.h> 231 # endif 232 233 #endif // defined(__cplusplus) && _LIBCPP_STD_VER >= 23 234 235 #endif // _LIBCPP_STDATOMIC_H 236