| OLD | NEW |
|---|
| (Empty) | |
| 1 // -*- C++ -*- |
| 2 //===--------------------------- atomic -----------------------------------===// |
| 3 // |
| 4 // The LLVM Compiler Infrastructure |
| 5 // |
| 6 // This file is distributed under the University of Illinois Open Source |
| 7 // License. See LICENSE.TXT for details. |
| 8 // |
| 9 //===----------------------------------------------------------------------===// |
| 10 |
| 11 #ifndef _LIBCPP_ATOMIC |
| 12 #define _LIBCPP_ATOMIC |
| 13 |
| 14 /* |
| 15 atomic synopsis |
| 16 |
| 17 namespace std |
| 18 { |
| 19 |
| 20 // order and consistency |
| 21 |
| 22 typedef enum memory_order |
| 23 { |
| 24 memory_order_relaxed, |
| 25 memory_order_consume, // load-consume |
| 26 memory_order_acquire, // load-acquire |
| 27 memory_order_release, // store-release |
| 28 memory_order_acq_rel, // store-release load-acquire |
| 29 memory_order_seq_cst // store-release load-acquire |
| 30 } memory_order; |
| 31 |
| 32 template <class T> T kill_dependency(T y) noexcept; |
| 33 |
| 34 // lock-free property |
| 35 |
| 36 #define ATOMIC_BOOL_LOCK_FREE unspecified |
| 37 #define ATOMIC_CHAR_LOCK_FREE unspecified |
| 38 #define ATOMIC_CHAR16_T_LOCK_FREE unspecified |
| 39 #define ATOMIC_CHAR32_T_LOCK_FREE unspecified |
| 40 #define ATOMIC_WCHAR_T_LOCK_FREE unspecified |
| 41 #define ATOMIC_SHORT_LOCK_FREE unspecified |
| 42 #define ATOMIC_INT_LOCK_FREE unspecified |
| 43 #define ATOMIC_LONG_LOCK_FREE unspecified |
| 44 #define ATOMIC_LLONG_LOCK_FREE unspecified |
| 45 #define ATOMIC_POINTER_LOCK_FREE unspecified |
| 46 |
| 47 // flag type and operations |
| 48 |
| 49 typedef struct atomic_flag |
| 50 { |
| 51 bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept; |
| 52 bool test_and_set(memory_order m = memory_order_seq_cst) noexcept; |
| 53 void clear(memory_order m = memory_order_seq_cst) volatile noexcept; |
| 54 void clear(memory_order m = memory_order_seq_cst) noexcept; |
| 55 atomic_flag() noexcept = default; |
| 56 atomic_flag(const atomic_flag&) = delete; |
| 57 atomic_flag& operator=(const atomic_flag&) = delete; |
| 58 atomic_flag& operator=(const atomic_flag&) volatile = delete; |
| 59 } atomic_flag; |
| 60 |
| 61 bool |
| 62 atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept; |
| 63 |
| 64 bool |
| 65 atomic_flag_test_and_set(atomic_flag* obj) noexcept; |
| 66 |
| 67 bool |
| 68 atomic_flag_test_and_set_explicit(volatile atomic_flag* obj, |
| 69 memory_order m) noexcept; |
| 70 |
| 71 bool |
| 72 atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept
; |
| 73 |
| 74 void |
| 75 atomic_flag_clear(volatile atomic_flag* obj) noexcept; |
| 76 |
| 77 void |
| 78 atomic_flag_clear(atomic_flag* obj) noexcept; |
| 79 |
| 80 void |
| 81 atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexce
pt; |
| 82 |
| 83 void |
| 84 atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept; |
| 85 |
| 86 #define ATOMIC_FLAG_INIT see below |
| 87 #define ATOMIC_VAR_INIT(value) see below |
| 88 |
| 89 template <class T> |
| 90 struct atomic |
| 91 { |
| 92 bool is_lock_free() const volatile noexcept; |
| 93 bool is_lock_free() const noexcept; |
| 94 void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept; |
| 95 void store(T desr, memory_order m = memory_order_seq_cst) noexcept; |
| 96 T load(memory_order m = memory_order_seq_cst) const volatile noexcept; |
| 97 T load(memory_order m = memory_order_seq_cst) const noexcept; |
| 98 operator T() const volatile noexcept; |
| 99 operator T() const noexcept; |
| 100 T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept; |
| 101 T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept; |
| 102 bool compare_exchange_weak(T& expc, T desr, |
| 103 memory_order s, memory_order f) volatile noexcept
; |
| 104 bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f)
noexcept; |
| 105 bool compare_exchange_strong(T& expc, T desr, |
| 106 memory_order s, memory_order f) volatile noexce
pt; |
| 107 bool compare_exchange_strong(T& expc, T desr, |
| 108 memory_order s, memory_order f) noexcept; |
| 109 bool compare_exchange_weak(T& expc, T desr, |
| 110 memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 111 bool compare_exchange_weak(T& expc, T desr, |
| 112 memory_order m = memory_order_seq_cst) noexcept; |
| 113 bool compare_exchange_strong(T& expc, T desr, |
| 114 memory_order m = memory_order_seq_cst) volatile
noexcept; |
| 115 bool compare_exchange_strong(T& expc, T desr, |
| 116 memory_order m = memory_order_seq_cst) noexcept
; |
| 117 |
| 118 atomic() noexcept = default; |
| 119 constexpr atomic(T desr) noexcept; |
| 120 atomic(const atomic&) = delete; |
| 121 atomic& operator=(const atomic&) = delete; |
| 122 atomic& operator=(const atomic&) volatile = delete; |
| 123 T operator=(T) volatile noexcept; |
| 124 T operator=(T) noexcept; |
| 125 }; |
| 126 |
| 127 template <> |
| 128 struct atomic<integral> |
| 129 { |
| 130 bool is_lock_free() const volatile noexcept; |
| 131 bool is_lock_free() const noexcept; |
| 132 void store(integral desr, memory_order m = memory_order_seq_cst) volatile no
except; |
| 133 void store(integral desr, memory_order m = memory_order_seq_cst) noexcept; |
| 134 integral load(memory_order m = memory_order_seq_cst) const volatile noexcept
; |
| 135 integral load(memory_order m = memory_order_seq_cst) const noexcept; |
| 136 operator integral() const volatile noexcept; |
| 137 operator integral() const noexcept; |
| 138 integral exchange(integral desr, |
| 139 memory_order m = memory_order_seq_cst) volatile noexcept; |
| 140 integral exchange(integral desr, memory_order m = memory_order_seq_cst) noex
cept; |
| 141 bool compare_exchange_weak(integral& expc, integral desr, |
| 142 memory_order s, memory_order f) volatile noexcept
; |
| 143 bool compare_exchange_weak(integral& expc, integral desr, |
| 144 memory_order s, memory_order f) noexcept; |
| 145 bool compare_exchange_strong(integral& expc, integral desr, |
| 146 memory_order s, memory_order f) volatile noexce
pt; |
| 147 bool compare_exchange_strong(integral& expc, integral desr, |
| 148 memory_order s, memory_order f) noexcept; |
| 149 bool compare_exchange_weak(integral& expc, integral desr, |
| 150 memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 151 bool compare_exchange_weak(integral& expc, integral desr, |
| 152 memory_order m = memory_order_seq_cst) noexcept; |
| 153 bool compare_exchange_strong(integral& expc, integral desr, |
| 154 memory_order m = memory_order_seq_cst) volatile
noexcept; |
| 155 bool compare_exchange_strong(integral& expc, integral desr, |
| 156 memory_order m = memory_order_seq_cst) noexcept
; |
| 157 |
| 158 integral |
| 159 fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 160 integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexc
ept; |
| 161 integral |
| 162 fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 163 integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexc
ept; |
| 164 integral |
| 165 fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 166 integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexc
ept; |
| 167 integral |
| 168 fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile no
except; |
| 169 integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexce
pt; |
| 170 integral |
| 171 fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 172 integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexc
ept; |
| 173 |
| 174 atomic() noexcept = default; |
| 175 constexpr atomic(integral desr) noexcept; |
| 176 atomic(const atomic&) = delete; |
| 177 atomic& operator=(const atomic&) = delete; |
| 178 atomic& operator=(const atomic&) volatile = delete; |
| 179 integral operator=(integral desr) volatile noexcept; |
| 180 integral operator=(integral desr) noexcept; |
| 181 |
| 182 integral operator++(int) volatile noexcept; |
| 183 integral operator++(int) noexcept; |
| 184 integral operator--(int) volatile noexcept; |
| 185 integral operator--(int) noexcept; |
| 186 integral operator++() volatile noexcept; |
| 187 integral operator++() noexcept; |
| 188 integral operator--() volatile noexcept; |
| 189 integral operator--() noexcept; |
| 190 integral operator+=(integral op) volatile noexcept; |
| 191 integral operator+=(integral op) noexcept; |
| 192 integral operator-=(integral op) volatile noexcept; |
| 193 integral operator-=(integral op) noexcept; |
| 194 integral operator&=(integral op) volatile noexcept; |
| 195 integral operator&=(integral op) noexcept; |
| 196 integral operator|=(integral op) volatile noexcept; |
| 197 integral operator|=(integral op) noexcept; |
| 198 integral operator^=(integral op) volatile noexcept; |
| 199 integral operator^=(integral op) noexcept; |
| 200 }; |
| 201 |
| 202 template <class T> |
| 203 struct atomic<T*> |
| 204 { |
| 205 bool is_lock_free() const volatile noexcept; |
| 206 bool is_lock_free() const noexcept; |
| 207 void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept
; |
| 208 void store(T* desr, memory_order m = memory_order_seq_cst) noexcept; |
| 209 T* load(memory_order m = memory_order_seq_cst) const volatile noexcept; |
| 210 T* load(memory_order m = memory_order_seq_cst) const noexcept; |
| 211 operator T*() const volatile noexcept; |
| 212 operator T*() const noexcept; |
| 213 T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcep
t; |
| 214 T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept; |
| 215 bool compare_exchange_weak(T*& expc, T* desr, |
| 216 memory_order s, memory_order f) volatile noexcept
; |
| 217 bool compare_exchange_weak(T*& expc, T* desr, |
| 218 memory_order s, memory_order f) noexcept; |
| 219 bool compare_exchange_strong(T*& expc, T* desr, |
| 220 memory_order s, memory_order f) volatile noexce
pt; |
| 221 bool compare_exchange_strong(T*& expc, T* desr, |
| 222 memory_order s, memory_order f) noexcept; |
| 223 bool compare_exchange_weak(T*& expc, T* desr, |
| 224 memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 225 bool compare_exchange_weak(T*& expc, T* desr, |
| 226 memory_order m = memory_order_seq_cst) noexcept; |
| 227 bool compare_exchange_strong(T*& expc, T* desr, |
| 228 memory_order m = memory_order_seq_cst) volatile
noexcept; |
| 229 bool compare_exchange_strong(T*& expc, T* desr, |
| 230 memory_order m = memory_order_seq_cst) noexcept
; |
| 231 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 232 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept; |
| 233 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile n
oexcept; |
| 234 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept; |
| 235 |
| 236 atomic() noexcept = default; |
| 237 constexpr atomic(T* desr) noexcept; |
| 238 atomic(const atomic&) = delete; |
| 239 atomic& operator=(const atomic&) = delete; |
| 240 atomic& operator=(const atomic&) volatile = delete; |
| 241 |
| 242 T* operator=(T*) volatile noexcept; |
| 243 T* operator=(T*) noexcept; |
| 244 T* operator++(int) volatile noexcept; |
| 245 T* operator++(int) noexcept; |
| 246 T* operator--(int) volatile noexcept; |
| 247 T* operator--(int) noexcept; |
| 248 T* operator++() volatile noexcept; |
| 249 T* operator++() noexcept; |
| 250 T* operator--() volatile noexcept; |
| 251 T* operator--() noexcept; |
| 252 T* operator+=(ptrdiff_t op) volatile noexcept; |
| 253 T* operator+=(ptrdiff_t op) noexcept; |
| 254 T* operator-=(ptrdiff_t op) volatile noexcept; |
| 255 T* operator-=(ptrdiff_t op) noexcept; |
| 256 }; |
| 257 |
| 258 |
| 259 template <class T> |
| 260 bool |
| 261 atomic_is_lock_free(const volatile atomic<T>* obj) noexcept; |
| 262 |
| 263 template <class T> |
| 264 bool |
| 265 atomic_is_lock_free(const atomic<T>* obj) noexcept; |
| 266 |
| 267 template <class T> |
| 268 void |
| 269 atomic_init(volatile atomic<T>* obj, T desr) noexcept; |
| 270 |
| 271 template <class T> |
| 272 void |
| 273 atomic_init(atomic<T>* obj, T desr) noexcept; |
| 274 |
| 275 template <class T> |
| 276 void |
| 277 atomic_store(volatile atomic<T>* obj, T desr) noexcept; |
| 278 |
| 279 template <class T> |
| 280 void |
| 281 atomic_store(atomic<T>* obj, T desr) noexcept; |
| 282 |
| 283 template <class T> |
| 284 void |
| 285 atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexc
ept; |
| 286 |
| 287 template <class T> |
| 288 void |
| 289 atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept; |
| 290 |
| 291 template <class T> |
| 292 T |
| 293 atomic_load(const volatile atomic<T>* obj) noexcept; |
| 294 |
| 295 template <class T> |
| 296 T |
| 297 atomic_load(const atomic<T>* obj) noexcept; |
| 298 |
| 299 template <class T> |
| 300 T |
| 301 atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept
; |
| 302 |
| 303 template <class T> |
| 304 T |
| 305 atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept; |
| 306 |
| 307 template <class T> |
| 308 T |
| 309 atomic_exchange(volatile atomic<T>* obj, T desr) noexcept; |
| 310 |
| 311 template <class T> |
| 312 T |
| 313 atomic_exchange(atomic<T>* obj, T desr) noexcept; |
| 314 |
| 315 template <class T> |
| 316 T |
| 317 atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) no
except; |
| 318 |
| 319 template <class T> |
| 320 T |
| 321 atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept; |
| 322 |
| 323 template <class T> |
| 324 bool |
| 325 atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexc
ept; |
| 326 |
| 327 template <class T> |
| 328 bool |
| 329 atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept; |
| 330 |
| 331 template <class T> |
| 332 bool |
| 333 atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noe
xcept; |
| 334 |
| 335 template <class T> |
| 336 bool |
| 337 atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept; |
| 338 |
| 339 template <class T> |
| 340 bool |
| 341 atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc, |
| 342 T desr, |
| 343 memory_order s, memory_order f) noexce
pt; |
| 344 |
| 345 template <class T> |
| 346 bool |
| 347 atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr, |
| 348 memory_order s, memory_order f) noexce
pt; |
| 349 |
| 350 template <class T> |
| 351 bool |
| 352 atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, |
| 353 T* expc, T desr, |
| 354 memory_order s, memory_order f) noex
cept; |
| 355 |
| 356 template <class T> |
| 357 bool |
| 358 atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, |
| 359 T desr, |
| 360 memory_order s, memory_order f) noex
cept; |
| 361 |
| 362 template <class Integral> |
| 363 Integral |
| 364 atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept; |
| 365 |
| 366 template <class Integral> |
| 367 Integral |
| 368 atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept; |
| 369 |
| 370 template <class Integral> |
| 371 Integral |
| 372 atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op, |
| 373 memory_order m) noexcept; |
| 374 template <class Integral> |
| 375 Integral |
| 376 atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op, |
| 377 memory_order m) noexcept; |
| 378 template <class Integral> |
| 379 Integral |
| 380 atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept; |
| 381 |
| 382 template <class Integral> |
| 383 Integral |
| 384 atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept; |
| 385 |
| 386 template <class Integral> |
| 387 Integral |
| 388 atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op, |
| 389 memory_order m) noexcept; |
| 390 template <class Integral> |
| 391 Integral |
| 392 atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op, |
| 393 memory_order m) noexcept; |
| 394 template <class Integral> |
| 395 Integral |
| 396 atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept; |
| 397 |
| 398 template <class Integral> |
| 399 Integral |
| 400 atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept; |
| 401 |
| 402 template <class Integral> |
| 403 Integral |
| 404 atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op, |
| 405 memory_order m) noexcept; |
| 406 template <class Integral> |
| 407 Integral |
| 408 atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op, |
| 409 memory_order m) noexcept; |
| 410 template <class Integral> |
| 411 Integral |
| 412 atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept; |
| 413 |
| 414 template <class Integral> |
| 415 Integral |
| 416 atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept; |
| 417 |
| 418 template <class Integral> |
| 419 Integral |
| 420 atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op, |
| 421 memory_order m) noexcept; |
| 422 template <class Integral> |
| 423 Integral |
| 424 atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op, |
| 425 memory_order m) noexcept; |
| 426 template <class Integral> |
| 427 Integral |
| 428 atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept; |
| 429 |
| 430 template <class Integral> |
| 431 Integral |
| 432 atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept; |
| 433 |
| 434 template <class Integral> |
| 435 Integral |
| 436 atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op, |
| 437 memory_order m) noexcept; |
| 438 template <class Integral> |
| 439 Integral |
| 440 atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op, |
| 441 memory_order m) noexcept; |
| 442 |
| 443 template <class T> |
| 444 T* |
| 445 atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op) noexcept; |
| 446 |
| 447 template <class T> |
| 448 T* |
| 449 atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op) noexcept; |
| 450 |
| 451 template <class T> |
| 452 T* |
| 453 atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op, |
| 454 memory_order m) noexcept; |
| 455 template <class T> |
| 456 T* |
| 457 atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noe
xcept; |
| 458 |
| 459 template <class T> |
| 460 T* |
| 461 atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op) noexcept; |
| 462 |
| 463 template <class T> |
| 464 T* |
| 465 atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op) noexcept; |
| 466 |
| 467 template <class T> |
| 468 T* |
| 469 atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op, |
| 470 memory_order m) noexcept; |
| 471 template <class T> |
| 472 T* |
| 473 atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noe
xcept; |
| 474 |
| 475 // Atomics for standard typedef types |
| 476 |
| 477 typedef atomic<bool> atomic_bool; |
| 478 typedef atomic<char> atomic_char; |
| 479 typedef atomic<signed char> atomic_schar; |
| 480 typedef atomic<unsigned char> atomic_uchar; |
| 481 typedef atomic<short> atomic_short; |
| 482 typedef atomic<unsigned short> atomic_ushort; |
| 483 typedef atomic<int> atomic_int; |
| 484 typedef atomic<unsigned int> atomic_uint; |
| 485 typedef atomic<long> atomic_long; |
| 486 typedef atomic<unsigned long> atomic_ulong; |
| 487 typedef atomic<long long> atomic_llong; |
| 488 typedef atomic<unsigned long long> atomic_ullong; |
| 489 typedef atomic<char16_t> atomic_char16_t; |
| 490 typedef atomic<char32_t> atomic_char32_t; |
| 491 typedef atomic<wchar_t> atomic_wchar_t; |
| 492 |
| 493 typedef atomic<int_least8_t> atomic_int_least8_t; |
| 494 typedef atomic<uint_least8_t> atomic_uint_least8_t; |
| 495 typedef atomic<int_least16_t> atomic_int_least16_t; |
| 496 typedef atomic<uint_least16_t> atomic_uint_least16_t; |
| 497 typedef atomic<int_least32_t> atomic_int_least32_t; |
| 498 typedef atomic<uint_least32_t> atomic_uint_least32_t; |
| 499 typedef atomic<int_least64_t> atomic_int_least64_t; |
| 500 typedef atomic<uint_least64_t> atomic_uint_least64_t; |
| 501 |
| 502 typedef atomic<int_fast8_t> atomic_int_fast8_t; |
| 503 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; |
| 504 typedef atomic<int_fast16_t> atomic_int_fast16_t; |
| 505 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; |
| 506 typedef atomic<int_fast32_t> atomic_int_fast32_t; |
| 507 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; |
| 508 typedef atomic<int_fast64_t> atomic_int_fast64_t; |
| 509 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; |
| 510 |
| 511 typedef atomic<intptr_t> atomic_intptr_t; |
| 512 typedef atomic<uintptr_t> atomic_uintptr_t; |
| 513 typedef atomic<size_t> atomic_size_t; |
| 514 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; |
| 515 typedef atomic<intmax_t> atomic_intmax_t; |
| 516 typedef atomic<uintmax_t> atomic_uintmax_t; |
| 517 |
| 518 // fences |
| 519 |
| 520 void atomic_thread_fence(memory_order m) noexcept; |
| 521 void atomic_signal_fence(memory_order m) noexcept; |
| 522 |
| 523 } // std |
| 524 |
| 525 */ |
| 526 |
| 527 #include <__config> |
| 528 #include <cstddef> |
| 529 #include <cstdint> |
| 530 #include <type_traits> |
| 531 |
| 532 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| 533 #pragma GCC system_header |
| 534 #endif |
| 535 |
| 536 _LIBCPP_BEGIN_NAMESPACE_STD |
| 537 |
| 538 #if !__has_feature(cxx_atomic) |
| 539 #error <atomic> is not implemented |
| 540 #else |
| 541 |
| 542 typedef enum memory_order |
| 543 { |
| 544 memory_order_relaxed, memory_order_consume, memory_order_acquire, |
| 545 memory_order_release, memory_order_acq_rel, memory_order_seq_cst |
| 546 } memory_order; |
| 547 |
| 548 template <class _Tp> |
| 549 inline _LIBCPP_INLINE_VISIBILITY |
| 550 _Tp |
| 551 kill_dependency(_Tp __y) _NOEXCEPT |
| 552 { |
| 553 return __y; |
| 554 } |
| 555 |
| 556 // general atomic<T> |
| 557 |
| 558 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::valu
e> |
| 559 struct __atomic_base // false |
| 560 { |
| 561 mutable _Atomic(_Tp) __a_; |
| 562 |
| 563 _LIBCPP_INLINE_VISIBILITY |
| 564 bool is_lock_free() const volatile _NOEXCEPT |
| 565 {return __c11_atomic_is_lock_free(sizeof(_Tp));} |
| 566 _LIBCPP_INLINE_VISIBILITY |
| 567 bool is_lock_free() const _NOEXCEPT |
| 568 {return __c11_atomic_is_lock_free(sizeof(_Tp));} |
| 569 _LIBCPP_INLINE_VISIBILITY |
| 570 void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXC
EPT |
| 571 {__c11_atomic_store(&__a_, __d, __m);} |
| 572 _LIBCPP_INLINE_VISIBILITY |
| 573 void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 574 {__c11_atomic_store(&__a_, __d, __m);} |
| 575 _LIBCPP_INLINE_VISIBILITY |
| 576 _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT |
| 577 {return __c11_atomic_load(&__a_, __m);} |
| 578 _LIBCPP_INLINE_VISIBILITY |
| 579 _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT |
| 580 {return __c11_atomic_load(&__a_, __m);} |
| 581 _LIBCPP_INLINE_VISIBILITY |
| 582 operator _Tp() const volatile _NOEXCEPT {return load();} |
| 583 _LIBCPP_INLINE_VISIBILITY |
| 584 operator _Tp() const _NOEXCEPT {return load();} |
| 585 _LIBCPP_INLINE_VISIBILITY |
| 586 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOE
XCEPT |
| 587 {return __c11_atomic_exchange(&__a_, __d, __m);} |
| 588 _LIBCPP_INLINE_VISIBILITY |
| 589 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 590 {return __c11_atomic_exchange(&__a_, __d, __m);} |
| 591 _LIBCPP_INLINE_VISIBILITY |
| 592 bool compare_exchange_weak(_Tp& __e, _Tp __d, |
| 593 memory_order __s, memory_order __f) volatile _NOE
XCEPT |
| 594 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);} |
| 595 _LIBCPP_INLINE_VISIBILITY |
| 596 bool compare_exchange_weak(_Tp& __e, _Tp __d, |
| 597 memory_order __s, memory_order __f) _NOEXCEPT |
| 598 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);} |
| 599 _LIBCPP_INLINE_VISIBILITY |
| 600 bool compare_exchange_strong(_Tp& __e, _Tp __d, |
| 601 memory_order __s, memory_order __f) volatile _N
OEXCEPT |
| 602 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f)
;} |
| 603 _LIBCPP_INLINE_VISIBILITY |
| 604 bool compare_exchange_strong(_Tp& __e, _Tp __d, |
| 605 memory_order __s, memory_order __f) _NOEXCEPT |
| 606 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f)
;} |
| 607 _LIBCPP_INLINE_VISIBILITY |
| 608 bool compare_exchange_weak(_Tp& __e, _Tp __d, |
| 609 memory_order __m = memory_order_seq_cst) volatile
_NOEXCEPT |
| 610 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);} |
| 611 _LIBCPP_INLINE_VISIBILITY |
| 612 bool compare_exchange_weak(_Tp& __e, _Tp __d, |
| 613 memory_order __m = memory_order_seq_cst) _NOEXCEP
T |
| 614 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);} |
| 615 _LIBCPP_INLINE_VISIBILITY |
| 616 bool compare_exchange_strong(_Tp& __e, _Tp __d, |
| 617 memory_order __m = memory_order_seq_cst) volatile
_NOEXCEPT |
| 618 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m)
;} |
| 619 _LIBCPP_INLINE_VISIBILITY |
| 620 bool compare_exchange_strong(_Tp& __e, _Tp __d, |
| 621 memory_order __m = memory_order_seq_cst) _NOEXC
EPT |
| 622 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m)
;} |
| 623 |
| 624 _LIBCPP_INLINE_VISIBILITY |
| 625 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS |
| 626 __atomic_base() _NOEXCEPT = default; |
| 627 #else |
| 628 __atomic_base() _NOEXCEPT : __a_() {} |
| 629 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS |
| 630 |
| 631 _LIBCPP_INLINE_VISIBILITY |
| 632 _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {} |
| 633 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 634 __atomic_base(const __atomic_base&) = delete; |
| 635 __atomic_base& operator=(const __atomic_base&) = delete; |
| 636 __atomic_base& operator=(const __atomic_base&) volatile = delete; |
| 637 #else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 638 private: |
| 639 __atomic_base(const __atomic_base&); |
| 640 __atomic_base& operator=(const __atomic_base&); |
| 641 __atomic_base& operator=(const __atomic_base&) volatile; |
| 642 #endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 643 }; |
| 644 |
| 645 // atomic<Integral> |
| 646 |
| 647 template <class _Tp> |
| 648 struct __atomic_base<_Tp, true> |
| 649 : public __atomic_base<_Tp, false> |
| 650 { |
| 651 typedef __atomic_base<_Tp, false> __base; |
| 652 _LIBCPP_INLINE_VISIBILITY |
| 653 __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT |
| 654 _LIBCPP_INLINE_VISIBILITY |
| 655 _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {} |
| 656 |
| 657 _LIBCPP_INLINE_VISIBILITY |
| 658 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _N
OEXCEPT |
| 659 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} |
| 660 _LIBCPP_INLINE_VISIBILITY |
| 661 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 662 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} |
| 663 _LIBCPP_INLINE_VISIBILITY |
| 664 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _N
OEXCEPT |
| 665 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} |
| 666 _LIBCPP_INLINE_VISIBILITY |
| 667 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 668 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} |
| 669 _LIBCPP_INLINE_VISIBILITY |
| 670 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _N
OEXCEPT |
| 671 {return __c11_atomic_fetch_and(&this->__a_, __op, __m);} |
| 672 _LIBCPP_INLINE_VISIBILITY |
| 673 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 674 {return __c11_atomic_fetch_and(&this->__a_, __op, __m);} |
| 675 _LIBCPP_INLINE_VISIBILITY |
| 676 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NO
EXCEPT |
| 677 {return __c11_atomic_fetch_or(&this->__a_, __op, __m);} |
| 678 _LIBCPP_INLINE_VISIBILITY |
| 679 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 680 {return __c11_atomic_fetch_or(&this->__a_, __op, __m);} |
| 681 _LIBCPP_INLINE_VISIBILITY |
| 682 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _N
OEXCEPT |
| 683 {return __c11_atomic_fetch_xor(&this->__a_, __op, __m);} |
| 684 _LIBCPP_INLINE_VISIBILITY |
| 685 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 686 {return __c11_atomic_fetch_xor(&this->__a_, __op, __m);} |
| 687 |
| 688 _LIBCPP_INLINE_VISIBILITY |
| 689 _Tp operator++(int) volatile _NOEXCEPT {return fetch_add(_Tp(1));} |
| 690 _LIBCPP_INLINE_VISIBILITY |
| 691 _Tp operator++(int) _NOEXCEPT {return fetch_add(_Tp(1));} |
| 692 _LIBCPP_INLINE_VISIBILITY |
| 693 _Tp operator--(int) volatile _NOEXCEPT {return fetch_sub(_Tp(1));} |
| 694 _LIBCPP_INLINE_VISIBILITY |
| 695 _Tp operator--(int) _NOEXCEPT {return fetch_sub(_Tp(1));} |
| 696 _LIBCPP_INLINE_VISIBILITY |
| 697 _Tp operator++() volatile _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(
1);} |
| 698 _LIBCPP_INLINE_VISIBILITY |
| 699 _Tp operator++() _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(
1);} |
| 700 _LIBCPP_INLINE_VISIBILITY |
| 701 _Tp operator--() volatile _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(
1);} |
| 702 _LIBCPP_INLINE_VISIBILITY |
| 703 _Tp operator--() _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(
1);} |
| 704 _LIBCPP_INLINE_VISIBILITY |
| 705 _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;} |
| 706 _LIBCPP_INLINE_VISIBILITY |
| 707 _Tp operator+=(_Tp __op) _NOEXCEPT {return fetch_add(__op) + __op;} |
| 708 _LIBCPP_INLINE_VISIBILITY |
| 709 _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;} |
| 710 _LIBCPP_INLINE_VISIBILITY |
| 711 _Tp operator-=(_Tp __op) _NOEXCEPT {return fetch_sub(__op) - __op;} |
| 712 _LIBCPP_INLINE_VISIBILITY |
| 713 _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;} |
| 714 _LIBCPP_INLINE_VISIBILITY |
| 715 _Tp operator&=(_Tp __op) _NOEXCEPT {return fetch_and(__op) & __op;} |
| 716 _LIBCPP_INLINE_VISIBILITY |
| 717 _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;} |
| 718 _LIBCPP_INLINE_VISIBILITY |
| 719 _Tp operator|=(_Tp __op) _NOEXCEPT {return fetch_or(__op) | __op;} |
| 720 _LIBCPP_INLINE_VISIBILITY |
| 721 _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;} |
| 722 _LIBCPP_INLINE_VISIBILITY |
| 723 _Tp operator^=(_Tp __op) _NOEXCEPT {return fetch_xor(__op) ^ __op;} |
| 724 }; |
| 725 |
| 726 // atomic<T> |
| 727 |
| 728 template <class _Tp> |
| 729 struct atomic |
| 730 : public __atomic_base<_Tp> |
| 731 { |
| 732 typedef __atomic_base<_Tp> __base; |
| 733 _LIBCPP_INLINE_VISIBILITY |
| 734 atomic() _NOEXCEPT _LIBCPP_DEFAULT |
| 735 _LIBCPP_INLINE_VISIBILITY |
| 736 _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {} |
| 737 |
| 738 _LIBCPP_INLINE_VISIBILITY |
| 739 _Tp operator=(_Tp __d) volatile _NOEXCEPT |
| 740 {__base::store(__d); return __d;} |
| 741 _LIBCPP_INLINE_VISIBILITY |
| 742 _Tp operator=(_Tp __d) _NOEXCEPT |
| 743 {__base::store(__d); return __d;} |
| 744 }; |
| 745 |
| 746 // atomic<T*> |
| 747 |
| 748 template <class _Tp> |
| 749 struct atomic<_Tp*> |
| 750 : public __atomic_base<_Tp*> |
| 751 { |
| 752 typedef __atomic_base<_Tp*> __base; |
| 753 _LIBCPP_INLINE_VISIBILITY |
| 754 atomic() _NOEXCEPT _LIBCPP_DEFAULT |
| 755 _LIBCPP_INLINE_VISIBILITY |
| 756 _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {} |
| 757 |
| 758 _LIBCPP_INLINE_VISIBILITY |
| 759 _Tp* operator=(_Tp* __d) volatile _NOEXCEPT |
| 760 {__base::store(__d); return __d;} |
| 761 _LIBCPP_INLINE_VISIBILITY |
| 762 _Tp* operator=(_Tp* __d) _NOEXCEPT |
| 763 {__base::store(__d); return __d;} |
| 764 |
| 765 _LIBCPP_INLINE_VISIBILITY |
| 766 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) |
| 767 volatile
_NOEXCEPT |
| 768 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} |
| 769 _LIBCPP_INLINE_VISIBILITY |
| 770 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOE
XCEPT |
| 771 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} |
| 772 _LIBCPP_INLINE_VISIBILITY |
| 773 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) |
| 774 volatile
_NOEXCEPT |
| 775 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} |
| 776 _LIBCPP_INLINE_VISIBILITY |
| 777 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOE
XCEPT |
| 778 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} |
| 779 |
| 780 _LIBCPP_INLINE_VISIBILITY |
| 781 _Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);} |
| 782 _LIBCPP_INLINE_VISIBILITY |
| 783 _Tp* operator++(int) _NOEXCEPT {return fetch_add(1);} |
| 784 _LIBCPP_INLINE_VISIBILITY |
| 785 _Tp* operator--(int) volatile _NOEXCEPT {return fetch_sub(1);} |
| 786 _LIBCPP_INLINE_VISIBILITY |
| 787 _Tp* operator--(int) _NOEXCEPT {return fetch_sub(1);} |
| 788 _LIBCPP_INLINE_VISIBILITY |
| 789 _Tp* operator++() volatile _NOEXCEPT {return fetch_add(1) + 1;
} |
| 790 _LIBCPP_INLINE_VISIBILITY |
| 791 _Tp* operator++() _NOEXCEPT {return fetch_add(1) + 1;
} |
| 792 _LIBCPP_INLINE_VISIBILITY |
| 793 _Tp* operator--() volatile _NOEXCEPT {return fetch_sub(1) - 1;
} |
| 794 _LIBCPP_INLINE_VISIBILITY |
| 795 _Tp* operator--() _NOEXCEPT {return fetch_sub(1) - 1;
} |
| 796 _LIBCPP_INLINE_VISIBILITY |
| 797 _Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_add(__op) +
__op;} |
| 798 _LIBCPP_INLINE_VISIBILITY |
| 799 _Tp* operator+=(ptrdiff_t __op) _NOEXCEPT {return fetch_add(__op) +
__op;} |
| 800 _LIBCPP_INLINE_VISIBILITY |
| 801 _Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_sub(__op) -
__op;} |
| 802 _LIBCPP_INLINE_VISIBILITY |
| 803 _Tp* operator-=(ptrdiff_t __op) _NOEXCEPT {return fetch_sub(__op) -
__op;} |
| 804 }; |
| 805 |
| 806 // atomic_is_lock_free |
| 807 |
| 808 template <class _Tp> |
| 809 inline _LIBCPP_INLINE_VISIBILITY |
| 810 bool |
| 811 atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT |
| 812 { |
| 813 return __o->is_lock_free(); |
| 814 } |
| 815 |
| 816 template <class _Tp> |
| 817 inline _LIBCPP_INLINE_VISIBILITY |
| 818 bool |
| 819 atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT |
| 820 { |
| 821 return __o->is_lock_free(); |
| 822 } |
| 823 |
| 824 // atomic_init |
| 825 |
| 826 template <class _Tp> |
| 827 inline _LIBCPP_INLINE_VISIBILITY |
| 828 void |
| 829 atomic_init(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 830 { |
| 831 __c11_atomic_init(&__o->__a_, __d); |
| 832 } |
| 833 |
| 834 template <class _Tp> |
| 835 inline _LIBCPP_INLINE_VISIBILITY |
| 836 void |
| 837 atomic_init(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 838 { |
| 839 __c11_atomic_init(&__o->__a_, __d); |
| 840 } |
| 841 |
| 842 // atomic_store |
| 843 |
| 844 template <class _Tp> |
| 845 inline _LIBCPP_INLINE_VISIBILITY |
| 846 void |
| 847 atomic_store(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 848 { |
| 849 __o->store(__d); |
| 850 } |
| 851 |
| 852 template <class _Tp> |
| 853 inline _LIBCPP_INLINE_VISIBILITY |
| 854 void |
| 855 atomic_store(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 856 { |
| 857 __o->store(__d); |
| 858 } |
| 859 |
| 860 // atomic_store_explicit |
| 861 |
| 862 template <class _Tp> |
| 863 inline _LIBCPP_INLINE_VISIBILITY |
| 864 void |
| 865 atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOE
XCEPT |
| 866 { |
| 867 __o->store(__d, __m); |
| 868 } |
| 869 |
| 870 template <class _Tp> |
| 871 inline _LIBCPP_INLINE_VISIBILITY |
| 872 void |
| 873 atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT |
| 874 { |
| 875 __o->store(__d, __m); |
| 876 } |
| 877 |
| 878 // atomic_load |
| 879 |
| 880 template <class _Tp> |
| 881 inline _LIBCPP_INLINE_VISIBILITY |
| 882 _Tp |
| 883 atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT |
| 884 { |
| 885 return __o->load(); |
| 886 } |
| 887 |
| 888 template <class _Tp> |
| 889 inline _LIBCPP_INLINE_VISIBILITY |
| 890 _Tp |
| 891 atomic_load(const atomic<_Tp>* __o) _NOEXCEPT |
| 892 { |
| 893 return __o->load(); |
| 894 } |
| 895 |
| 896 // atomic_load_explicit |
| 897 |
| 898 template <class _Tp> |
| 899 inline _LIBCPP_INLINE_VISIBILITY |
| 900 _Tp |
| 901 atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEP
T |
| 902 { |
| 903 return __o->load(__m); |
| 904 } |
| 905 |
| 906 template <class _Tp> |
| 907 inline _LIBCPP_INLINE_VISIBILITY |
| 908 _Tp |
| 909 atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT |
| 910 { |
| 911 return __o->load(__m); |
| 912 } |
| 913 |
| 914 // atomic_exchange |
| 915 |
| 916 template <class _Tp> |
| 917 inline _LIBCPP_INLINE_VISIBILITY |
| 918 _Tp |
| 919 atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 920 { |
| 921 return __o->exchange(__d); |
| 922 } |
| 923 |
| 924 template <class _Tp> |
| 925 inline _LIBCPP_INLINE_VISIBILITY |
| 926 _Tp |
| 927 atomic_exchange(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT |
| 928 { |
| 929 return __o->exchange(__d); |
| 930 } |
| 931 |
| 932 // atomic_exchange_explicit |
| 933 |
| 934 template <class _Tp> |
| 935 inline _LIBCPP_INLINE_VISIBILITY |
| 936 _Tp |
| 937 atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _
NOEXCEPT |
| 938 { |
| 939 return __o->exchange(__d, __m); |
| 940 } |
| 941 |
| 942 template <class _Tp> |
| 943 inline _LIBCPP_INLINE_VISIBILITY |
| 944 _Tp |
| 945 atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT |
| 946 { |
| 947 return __o->exchange(__d, __m); |
| 948 } |
| 949 |
| 950 // atomic_compare_exchange_weak |
| 951 |
| 952 template <class _Tp> |
| 953 inline _LIBCPP_INLINE_VISIBILITY |
| 954 bool |
| 955 atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEX
CEPT |
| 956 { |
| 957 return __o->compare_exchange_weak(*__e, __d); |
| 958 } |
| 959 |
| 960 template <class _Tp> |
| 961 inline _LIBCPP_INLINE_VISIBILITY |
| 962 bool |
| 963 atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT |
| 964 { |
| 965 return __o->compare_exchange_weak(*__e, __d); |
| 966 } |
| 967 |
| 968 // atomic_compare_exchange_strong |
| 969 |
| 970 template <class _Tp> |
| 971 inline _LIBCPP_INLINE_VISIBILITY |
| 972 bool |
| 973 atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NO
EXCEPT |
| 974 { |
| 975 return __o->compare_exchange_strong(*__e, __d); |
| 976 } |
| 977 |
| 978 template <class _Tp> |
| 979 inline _LIBCPP_INLINE_VISIBILITY |
| 980 bool |
| 981 atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT |
| 982 { |
| 983 return __o->compare_exchange_strong(*__e, __d); |
| 984 } |
| 985 |
| 986 // atomic_compare_exchange_weak_explicit |
| 987 |
| 988 template <class _Tp> |
| 989 inline _LIBCPP_INLINE_VISIBILITY |
| 990 bool |
| 991 atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e, |
| 992 _Tp __d, |
| 993 memory_order __s, memory_order __f) _NOEXC
EPT |
| 994 { |
| 995 return __o->compare_exchange_weak(*__e, __d, __s, __f); |
| 996 } |
| 997 |
| 998 template <class _Tp> |
| 999 inline _LIBCPP_INLINE_VISIBILITY |
| 1000 bool |
| 1001 atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d, |
| 1002 memory_order __s, memory_order __f) _NOEXC
EPT |
| 1003 { |
| 1004 return __o->compare_exchange_weak(*__e, __d, __s, __f); |
| 1005 } |
| 1006 |
| 1007 // atomic_compare_exchange_strong_explicit |
| 1008 |
| 1009 template <class _Tp> |
| 1010 inline _LIBCPP_INLINE_VISIBILITY |
| 1011 bool |
| 1012 atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o, |
| 1013 _Tp* __e, _Tp __d, |
| 1014 memory_order __s, memory_order __f) _NOE
XCEPT |
| 1015 { |
| 1016 return __o->compare_exchange_strong(*__e, __d, __s, __f); |
| 1017 } |
| 1018 |
| 1019 template <class _Tp> |
| 1020 inline _LIBCPP_INLINE_VISIBILITY |
| 1021 bool |
| 1022 atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e, |
| 1023 _Tp __d, |
| 1024 memory_order __s, memory_order __f) _NOE
XCEPT |
| 1025 { |
| 1026 return __o->compare_exchange_strong(*__e, __d, __s, __f); |
| 1027 } |
| 1028 |
| 1029 // atomic_fetch_add |
| 1030 |
| 1031 template <class _Tp> |
| 1032 inline _LIBCPP_INLINE_VISIBILITY |
| 1033 typename enable_if |
| 1034 < |
| 1035 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1036 _Tp |
| 1037 >::type |
| 1038 atomic_fetch_add(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1039 { |
| 1040 return __o->fetch_add(__op); |
| 1041 } |
| 1042 |
| 1043 template <class _Tp> |
| 1044 inline _LIBCPP_INLINE_VISIBILITY |
| 1045 typename enable_if |
| 1046 < |
| 1047 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1048 _Tp |
| 1049 >::type |
| 1050 atomic_fetch_add(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1051 { |
| 1052 return __o->fetch_add(__op); |
| 1053 } |
| 1054 |
| 1055 template <class _Tp> |
| 1056 inline _LIBCPP_INLINE_VISIBILITY |
| 1057 _Tp* |
| 1058 atomic_fetch_add(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT |
| 1059 { |
| 1060 return __o->fetch_add(__op); |
| 1061 } |
| 1062 |
| 1063 template <class _Tp> |
| 1064 inline _LIBCPP_INLINE_VISIBILITY |
| 1065 _Tp* |
| 1066 atomic_fetch_add(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT |
| 1067 { |
| 1068 return __o->fetch_add(__op); |
| 1069 } |
| 1070 |
| 1071 // atomic_fetch_add_explicit |
| 1072 |
| 1073 template <class _Tp> |
| 1074 inline _LIBCPP_INLINE_VISIBILITY |
| 1075 typename enable_if |
| 1076 < |
| 1077 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1078 _Tp |
| 1079 >::type |
| 1080 atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m)
_NOEXCEPT |
| 1081 { |
| 1082 return __o->fetch_add(__op, __m); |
| 1083 } |
| 1084 |
| 1085 template <class _Tp> |
| 1086 inline _LIBCPP_INLINE_VISIBILITY |
| 1087 typename enable_if |
| 1088 < |
| 1089 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1090 _Tp |
| 1091 >::type |
| 1092 atomic_fetch_add_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEP
T |
| 1093 { |
| 1094 return __o->fetch_add(__op, __m); |
| 1095 } |
| 1096 |
| 1097 template <class _Tp> |
| 1098 inline _LIBCPP_INLINE_VISIBILITY |
| 1099 _Tp* |
| 1100 atomic_fetch_add_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op, |
| 1101 memory_order __m) _NOEXCEPT |
| 1102 { |
| 1103 return __o->fetch_add(__op, __m); |
| 1104 } |
| 1105 |
| 1106 template <class _Tp> |
| 1107 inline _LIBCPP_INLINE_VISIBILITY |
| 1108 _Tp* |
| 1109 atomic_fetch_add_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _
NOEXCEPT |
| 1110 { |
| 1111 return __o->fetch_add(__op, __m); |
| 1112 } |
| 1113 |
| 1114 // atomic_fetch_sub |
| 1115 |
| 1116 template <class _Tp> |
| 1117 inline _LIBCPP_INLINE_VISIBILITY |
| 1118 typename enable_if |
| 1119 < |
| 1120 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1121 _Tp |
| 1122 >::type |
| 1123 atomic_fetch_sub(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1124 { |
| 1125 return __o->fetch_sub(__op); |
| 1126 } |
| 1127 |
| 1128 template <class _Tp> |
| 1129 inline _LIBCPP_INLINE_VISIBILITY |
| 1130 typename enable_if |
| 1131 < |
| 1132 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1133 _Tp |
| 1134 >::type |
| 1135 atomic_fetch_sub(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1136 { |
| 1137 return __o->fetch_sub(__op); |
| 1138 } |
| 1139 |
| 1140 template <class _Tp> |
| 1141 inline _LIBCPP_INLINE_VISIBILITY |
| 1142 _Tp* |
| 1143 atomic_fetch_sub(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT |
| 1144 { |
| 1145 return __o->fetch_sub(__op); |
| 1146 } |
| 1147 |
| 1148 template <class _Tp> |
| 1149 inline _LIBCPP_INLINE_VISIBILITY |
| 1150 _Tp* |
| 1151 atomic_fetch_sub(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT |
| 1152 { |
| 1153 return __o->fetch_sub(__op); |
| 1154 } |
| 1155 |
| 1156 // atomic_fetch_sub_explicit |
| 1157 |
| 1158 template <class _Tp> |
| 1159 inline _LIBCPP_INLINE_VISIBILITY |
| 1160 typename enable_if |
| 1161 < |
| 1162 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1163 _Tp |
| 1164 >::type |
| 1165 atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m)
_NOEXCEPT |
| 1166 { |
| 1167 return __o->fetch_sub(__op, __m); |
| 1168 } |
| 1169 |
| 1170 template <class _Tp> |
| 1171 inline _LIBCPP_INLINE_VISIBILITY |
| 1172 typename enable_if |
| 1173 < |
| 1174 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1175 _Tp |
| 1176 >::type |
| 1177 atomic_fetch_sub_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEP
T |
| 1178 { |
| 1179 return __o->fetch_sub(__op, __m); |
| 1180 } |
| 1181 |
| 1182 template <class _Tp> |
| 1183 inline _LIBCPP_INLINE_VISIBILITY |
| 1184 _Tp* |
| 1185 atomic_fetch_sub_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op, |
| 1186 memory_order __m) _NOEXCEPT |
| 1187 { |
| 1188 return __o->fetch_sub(__op, __m); |
| 1189 } |
| 1190 |
| 1191 template <class _Tp> |
| 1192 inline _LIBCPP_INLINE_VISIBILITY |
| 1193 _Tp* |
| 1194 atomic_fetch_sub_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _
NOEXCEPT |
| 1195 { |
| 1196 return __o->fetch_sub(__op, __m); |
| 1197 } |
| 1198 |
| 1199 // atomic_fetch_and |
| 1200 |
| 1201 template <class _Tp> |
| 1202 inline _LIBCPP_INLINE_VISIBILITY |
| 1203 typename enable_if |
| 1204 < |
| 1205 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1206 _Tp |
| 1207 >::type |
| 1208 atomic_fetch_and(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1209 { |
| 1210 return __o->fetch_and(__op); |
| 1211 } |
| 1212 |
| 1213 template <class _Tp> |
| 1214 inline _LIBCPP_INLINE_VISIBILITY |
| 1215 typename enable_if |
| 1216 < |
| 1217 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1218 _Tp |
| 1219 >::type |
| 1220 atomic_fetch_and(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1221 { |
| 1222 return __o->fetch_and(__op); |
| 1223 } |
| 1224 |
| 1225 // atomic_fetch_and_explicit |
| 1226 |
| 1227 template <class _Tp> |
| 1228 inline _LIBCPP_INLINE_VISIBILITY |
| 1229 typename enable_if |
| 1230 < |
| 1231 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1232 _Tp |
| 1233 >::type |
| 1234 atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m)
_NOEXCEPT |
| 1235 { |
| 1236 return __o->fetch_and(__op, __m); |
| 1237 } |
| 1238 |
| 1239 template <class _Tp> |
| 1240 inline _LIBCPP_INLINE_VISIBILITY |
| 1241 typename enable_if |
| 1242 < |
| 1243 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1244 _Tp |
| 1245 >::type |
| 1246 atomic_fetch_and_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEP
T |
| 1247 { |
| 1248 return __o->fetch_and(__op, __m); |
| 1249 } |
| 1250 |
| 1251 // atomic_fetch_or |
| 1252 |
| 1253 template <class _Tp> |
| 1254 inline _LIBCPP_INLINE_VISIBILITY |
| 1255 typename enable_if |
| 1256 < |
| 1257 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1258 _Tp |
| 1259 >::type |
| 1260 atomic_fetch_or(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1261 { |
| 1262 return __o->fetch_or(__op); |
| 1263 } |
| 1264 |
| 1265 template <class _Tp> |
| 1266 inline _LIBCPP_INLINE_VISIBILITY |
| 1267 typename enable_if |
| 1268 < |
| 1269 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1270 _Tp |
| 1271 >::type |
| 1272 atomic_fetch_or(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1273 { |
| 1274 return __o->fetch_or(__op); |
| 1275 } |
| 1276 |
| 1277 // atomic_fetch_or_explicit |
| 1278 |
| 1279 template <class _Tp> |
| 1280 inline _LIBCPP_INLINE_VISIBILITY |
| 1281 typename enable_if |
| 1282 < |
| 1283 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1284 _Tp |
| 1285 >::type |
| 1286 atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m)
_NOEXCEPT |
| 1287 { |
| 1288 return __o->fetch_or(__op, __m); |
| 1289 } |
| 1290 |
| 1291 template <class _Tp> |
| 1292 inline _LIBCPP_INLINE_VISIBILITY |
| 1293 typename enable_if |
| 1294 < |
| 1295 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1296 _Tp |
| 1297 >::type |
| 1298 atomic_fetch_or_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT |
| 1299 { |
| 1300 return __o->fetch_or(__op, __m); |
| 1301 } |
| 1302 |
| 1303 // atomic_fetch_xor |
| 1304 |
| 1305 template <class _Tp> |
| 1306 inline _LIBCPP_INLINE_VISIBILITY |
| 1307 typename enable_if |
| 1308 < |
| 1309 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1310 _Tp |
| 1311 >::type |
| 1312 atomic_fetch_xor(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1313 { |
| 1314 return __o->fetch_xor(__op); |
| 1315 } |
| 1316 |
| 1317 template <class _Tp> |
| 1318 inline _LIBCPP_INLINE_VISIBILITY |
| 1319 typename enable_if |
| 1320 < |
| 1321 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1322 _Tp |
| 1323 >::type |
| 1324 atomic_fetch_xor(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT |
| 1325 { |
| 1326 return __o->fetch_xor(__op); |
| 1327 } |
| 1328 |
| 1329 // atomic_fetch_xor_explicit |
| 1330 |
| 1331 template <class _Tp> |
| 1332 inline _LIBCPP_INLINE_VISIBILITY |
| 1333 typename enable_if |
| 1334 < |
| 1335 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1336 _Tp |
| 1337 >::type |
| 1338 atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m)
_NOEXCEPT |
| 1339 { |
| 1340 return __o->fetch_xor(__op, __m); |
| 1341 } |
| 1342 |
| 1343 template <class _Tp> |
| 1344 inline _LIBCPP_INLINE_VISIBILITY |
| 1345 typename enable_if |
| 1346 < |
| 1347 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, |
| 1348 _Tp |
| 1349 >::type |
| 1350 atomic_fetch_xor_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEP
T |
| 1351 { |
| 1352 return __o->fetch_xor(__op, __m); |
| 1353 } |
| 1354 |
| 1355 // flag type and operations |
| 1356 |
| 1357 typedef struct atomic_flag |
| 1358 { |
| 1359 _Atomic(bool) __a_; |
| 1360 |
| 1361 _LIBCPP_INLINE_VISIBILITY |
| 1362 bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEP
T |
| 1363 {return __c11_atomic_exchange(&__a_, true, __m);} |
| 1364 _LIBCPP_INLINE_VISIBILITY |
| 1365 bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 1366 {return __c11_atomic_exchange(&__a_, true, __m);} |
| 1367 _LIBCPP_INLINE_VISIBILITY |
| 1368 void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT |
| 1369 {__c11_atomic_store(&__a_, false, __m);} |
| 1370 _LIBCPP_INLINE_VISIBILITY |
| 1371 void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT |
| 1372 {__c11_atomic_store(&__a_, false, __m);} |
| 1373 |
| 1374 _LIBCPP_INLINE_VISIBILITY |
| 1375 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS |
| 1376 atomic_flag() _NOEXCEPT = default; |
| 1377 #else |
| 1378 atomic_flag() _NOEXCEPT : __a_() {} |
| 1379 #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS |
| 1380 |
| 1381 _LIBCPP_INLINE_VISIBILITY |
| 1382 atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} |
| 1383 |
| 1384 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 1385 atomic_flag(const atomic_flag&) = delete; |
| 1386 atomic_flag& operator=(const atomic_flag&) = delete; |
| 1387 atomic_flag& operator=(const atomic_flag&) volatile = delete; |
| 1388 #else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 1389 private: |
| 1390 atomic_flag(const atomic_flag&); |
| 1391 atomic_flag& operator=(const atomic_flag&); |
| 1392 atomic_flag& operator=(const atomic_flag&) volatile; |
| 1393 #endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS |
| 1394 } atomic_flag; |
| 1395 |
| 1396 inline _LIBCPP_INLINE_VISIBILITY |
| 1397 bool |
| 1398 atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT |
| 1399 { |
| 1400 return __o->test_and_set(); |
| 1401 } |
| 1402 |
| 1403 inline _LIBCPP_INLINE_VISIBILITY |
| 1404 bool |
| 1405 atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT |
| 1406 { |
| 1407 return __o->test_and_set(); |
| 1408 } |
| 1409 |
| 1410 inline _LIBCPP_INLINE_VISIBILITY |
| 1411 bool |
| 1412 atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _
NOEXCEPT |
| 1413 { |
| 1414 return __o->test_and_set(__m); |
| 1415 } |
| 1416 |
| 1417 inline _LIBCPP_INLINE_VISIBILITY |
| 1418 bool |
| 1419 atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT |
| 1420 { |
| 1421 return __o->test_and_set(__m); |
| 1422 } |
| 1423 |
| 1424 inline _LIBCPP_INLINE_VISIBILITY |
| 1425 void |
| 1426 atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT |
| 1427 { |
| 1428 __o->clear(); |
| 1429 } |
| 1430 |
| 1431 inline _LIBCPP_INLINE_VISIBILITY |
| 1432 void |
| 1433 atomic_flag_clear(atomic_flag* __o) _NOEXCEPT |
| 1434 { |
| 1435 __o->clear(); |
| 1436 } |
| 1437 |
| 1438 inline _LIBCPP_INLINE_VISIBILITY |
| 1439 void |
| 1440 atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEP
T |
| 1441 { |
| 1442 __o->clear(__m); |
| 1443 } |
| 1444 |
| 1445 inline _LIBCPP_INLINE_VISIBILITY |
| 1446 void |
| 1447 atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT |
| 1448 { |
| 1449 __o->clear(__m); |
| 1450 } |
| 1451 |
| 1452 // fences |
| 1453 |
| 1454 inline _LIBCPP_INLINE_VISIBILITY |
| 1455 void |
| 1456 atomic_thread_fence(memory_order __m) _NOEXCEPT |
| 1457 { |
| 1458 __c11_atomic_thread_fence(__m); |
| 1459 } |
| 1460 |
| 1461 inline _LIBCPP_INLINE_VISIBILITY |
| 1462 void |
| 1463 atomic_signal_fence(memory_order __m) _NOEXCEPT |
| 1464 { |
| 1465 __c11_atomic_signal_fence(__m); |
| 1466 } |
| 1467 |
| 1468 // Atomics for standard typedef types |
| 1469 |
| 1470 typedef atomic<bool> atomic_bool; |
| 1471 typedef atomic<char> atomic_char; |
| 1472 typedef atomic<signed char> atomic_schar; |
| 1473 typedef atomic<unsigned char> atomic_uchar; |
| 1474 typedef atomic<short> atomic_short; |
| 1475 typedef atomic<unsigned short> atomic_ushort; |
| 1476 typedef atomic<int> atomic_int; |
| 1477 typedef atomic<unsigned int> atomic_uint; |
| 1478 typedef atomic<long> atomic_long; |
| 1479 typedef atomic<unsigned long> atomic_ulong; |
| 1480 typedef atomic<long long> atomic_llong; |
| 1481 typedef atomic<unsigned long long> atomic_ullong; |
| 1482 typedef atomic<char16_t> atomic_char16_t; |
| 1483 typedef atomic<char32_t> atomic_char32_t; |
| 1484 typedef atomic<wchar_t> atomic_wchar_t; |
| 1485 |
| 1486 typedef atomic<int_least8_t> atomic_int_least8_t; |
| 1487 typedef atomic<uint_least8_t> atomic_uint_least8_t; |
| 1488 typedef atomic<int_least16_t> atomic_int_least16_t; |
| 1489 typedef atomic<uint_least16_t> atomic_uint_least16_t; |
| 1490 typedef atomic<int_least32_t> atomic_int_least32_t; |
| 1491 typedef atomic<uint_least32_t> atomic_uint_least32_t; |
| 1492 typedef atomic<int_least64_t> atomic_int_least64_t; |
| 1493 typedef atomic<uint_least64_t> atomic_uint_least64_t; |
| 1494 |
| 1495 typedef atomic<int_fast8_t> atomic_int_fast8_t; |
| 1496 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; |
| 1497 typedef atomic<int_fast16_t> atomic_int_fast16_t; |
| 1498 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; |
| 1499 typedef atomic<int_fast32_t> atomic_int_fast32_t; |
| 1500 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; |
| 1501 typedef atomic<int_fast64_t> atomic_int_fast64_t; |
| 1502 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; |
| 1503 |
| 1504 typedef atomic<intptr_t> atomic_intptr_t; |
| 1505 typedef atomic<uintptr_t> atomic_uintptr_t; |
| 1506 typedef atomic<size_t> atomic_size_t; |
| 1507 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; |
| 1508 typedef atomic<intmax_t> atomic_intmax_t; |
| 1509 typedef atomic<uintmax_t> atomic_uintmax_t; |
| 1510 |
| 1511 #define ATOMIC_FLAG_INIT {false} |
| 1512 #define ATOMIC_VAR_INIT(__v) {__v} |
| 1513 |
| 1514 // lock-free property |
| 1515 |
| 1516 #define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE |
| 1517 #define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE |
| 1518 #define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE |
| 1519 #define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE |
| 1520 #define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE |
| 1521 #define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE |
| 1522 #define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE |
| 1523 #define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE |
| 1524 #define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE |
| 1525 #define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE |
| 1526 |
| 1527 #endif // !__has_feature(cxx_atomic) |
| 1528 |
| 1529 _LIBCPP_END_NAMESPACE_STD |
| 1530 |
| 1531 #endif // _LIBCPP_ATOMIC |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 75213003:
Add libc++ and libc++abi to third-party. (Closed)
Base URL: https://src.chromium.org/chrome/trunk/src/