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 // feature test macro 21 22 #define __cpp_lib_atomic_is_always_lock_free // as specified by SG10 23 24 // order and consistency 25 26 typedef enum memory_order 27 { 28 memory_order_relaxed, 29 memory_order_consume, // load-consume 30 memory_order_acquire, // load-acquire 31 memory_order_release, // store-release 32 memory_order_acq_rel, // store-release load-acquire 33 memory_order_seq_cst // store-release load-acquire 34 } memory_order; 35 36 template <class T> T kill_dependency(T y) noexcept; 37 38 // lock-free property 39 40 #define ATOMIC_BOOL_LOCK_FREE unspecified 41 #define ATOMIC_CHAR_LOCK_FREE unspecified 42 #define ATOMIC_CHAR16_T_LOCK_FREE unspecified 43 #define ATOMIC_CHAR32_T_LOCK_FREE unspecified 44 #define ATOMIC_WCHAR_T_LOCK_FREE unspecified 45 #define ATOMIC_SHORT_LOCK_FREE unspecified 46 #define ATOMIC_INT_LOCK_FREE unspecified 47 #define ATOMIC_LONG_LOCK_FREE unspecified 48 #define ATOMIC_LLONG_LOCK_FREE unspecified 49 #define ATOMIC_POINTER_LOCK_FREE unspecified 50 51 // flag type and operations 52 53 typedef struct atomic_flag 54 { 55 bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept; 56 bool test_and_set(memory_order m = memory_order_seq_cst) noexcept; 57 void clear(memory_order m = memory_order_seq_cst) volatile noexcept; 58 void clear(memory_order m = memory_order_seq_cst) noexcept; 59 atomic_flag() noexcept = default; 60 atomic_flag(const atomic_flag&) = delete; 61 atomic_flag& operator=(const atomic_flag&) = delete; 62 atomic_flag& operator=(const atomic_flag&) volatile = delete; 63 } atomic_flag; 64 65 bool 66 atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept; 67 68 bool 69 atomic_flag_test_and_set(atomic_flag* obj) noexcept; 70 71 bool 72 atomic_flag_test_and_set_explicit(volatile atomic_flag* obj, 73 memory_order m) noexcept; 74 75 bool 76 atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept; 77 78 void 79 atomic_flag_clear(volatile atomic_flag* obj) noexcept; 80 81 void 82 atomic_flag_clear(atomic_flag* obj) noexcept; 83 84 void 85 atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept; 86 87 void 88 atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept; 89 90 #define ATOMIC_FLAG_INIT see below 91 #define ATOMIC_VAR_INIT(value) see below 92 93 template <class T> 94 struct atomic 95 { 96 static constexpr bool is_always_lock_free; 97 bool is_lock_free() const volatile noexcept; 98 bool is_lock_free() const noexcept; 99 void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept; 100 void store(T desr, memory_order m = memory_order_seq_cst) noexcept; 101 T load(memory_order m = memory_order_seq_cst) const volatile noexcept; 102 T load(memory_order m = memory_order_seq_cst) const noexcept; 103 operator T() const volatile noexcept; 104 operator T() const noexcept; 105 T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept; 106 T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept; 107 bool compare_exchange_weak(T& expc, T desr, 108 memory_order s, memory_order f) volatile noexcept; 109 bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept; 110 bool compare_exchange_strong(T& expc, T desr, 111 memory_order s, memory_order f) volatile noexcept; 112 bool compare_exchange_strong(T& expc, T desr, 113 memory_order s, memory_order f) noexcept; 114 bool compare_exchange_weak(T& expc, T desr, 115 memory_order m = memory_order_seq_cst) volatile noexcept; 116 bool compare_exchange_weak(T& expc, T desr, 117 memory_order m = memory_order_seq_cst) noexcept; 118 bool compare_exchange_strong(T& expc, T desr, 119 memory_order m = memory_order_seq_cst) volatile noexcept; 120 bool compare_exchange_strong(T& expc, T desr, 121 memory_order m = memory_order_seq_cst) noexcept; 122 123 atomic() noexcept = default; 124 constexpr atomic(T desr) noexcept; 125 atomic(const atomic&) = delete; 126 atomic& operator=(const atomic&) = delete; 127 atomic& operator=(const atomic&) volatile = delete; 128 T operator=(T) volatile noexcept; 129 T operator=(T) noexcept; 130 }; 131 132 template <> 133 struct atomic<integral> 134 { 135 static constexpr bool is_always_lock_free; 136 bool is_lock_free() const volatile noexcept; 137 bool is_lock_free() const noexcept; 138 void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept; 139 void store(integral desr, memory_order m = memory_order_seq_cst) noexcept; 140 integral load(memory_order m = memory_order_seq_cst) const volatile noexcept; 141 integral load(memory_order m = memory_order_seq_cst) const noexcept; 142 operator integral() const volatile noexcept; 143 operator integral() const noexcept; 144 integral exchange(integral desr, 145 memory_order m = memory_order_seq_cst) volatile noexcept; 146 integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept; 147 bool compare_exchange_weak(integral& expc, integral desr, 148 memory_order s, memory_order f) volatile noexcept; 149 bool compare_exchange_weak(integral& expc, integral desr, 150 memory_order s, memory_order f) noexcept; 151 bool compare_exchange_strong(integral& expc, integral desr, 152 memory_order s, memory_order f) volatile noexcept; 153 bool compare_exchange_strong(integral& expc, integral desr, 154 memory_order s, memory_order f) noexcept; 155 bool compare_exchange_weak(integral& expc, integral desr, 156 memory_order m = memory_order_seq_cst) volatile noexcept; 157 bool compare_exchange_weak(integral& expc, integral desr, 158 memory_order m = memory_order_seq_cst) noexcept; 159 bool compare_exchange_strong(integral& expc, integral desr, 160 memory_order m = memory_order_seq_cst) volatile noexcept; 161 bool compare_exchange_strong(integral& expc, integral desr, 162 memory_order m = memory_order_seq_cst) noexcept; 163 164 integral 165 fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 166 integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept; 167 integral 168 fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 169 integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept; 170 integral 171 fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 172 integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept; 173 integral 174 fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 175 integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept; 176 integral 177 fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 178 integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept; 179 180 atomic() noexcept = default; 181 constexpr atomic(integral desr) noexcept; 182 atomic(const atomic&) = delete; 183 atomic& operator=(const atomic&) = delete; 184 atomic& operator=(const atomic&) volatile = delete; 185 integral operator=(integral desr) volatile noexcept; 186 integral operator=(integral desr) noexcept; 187 188 integral operator++(int) volatile noexcept; 189 integral operator++(int) noexcept; 190 integral operator--(int) volatile noexcept; 191 integral operator--(int) noexcept; 192 integral operator++() volatile noexcept; 193 integral operator++() noexcept; 194 integral operator--() volatile noexcept; 195 integral operator--() 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 integral operator&=(integral op) volatile noexcept; 201 integral operator&=(integral op) noexcept; 202 integral operator|=(integral op) volatile noexcept; 203 integral operator|=(integral op) noexcept; 204 integral operator^=(integral op) volatile noexcept; 205 integral operator^=(integral op) noexcept; 206 }; 207 208 template <class T> 209 struct atomic<T*> 210 { 211 static constexpr bool is_always_lock_free; 212 bool is_lock_free() const volatile noexcept; 213 bool is_lock_free() const noexcept; 214 void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept; 215 void store(T* desr, memory_order m = memory_order_seq_cst) noexcept; 216 T* load(memory_order m = memory_order_seq_cst) const volatile noexcept; 217 T* load(memory_order m = memory_order_seq_cst) const noexcept; 218 operator T*() const volatile noexcept; 219 operator T*() const noexcept; 220 T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept; 221 T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept; 222 bool compare_exchange_weak(T*& expc, T* desr, 223 memory_order s, memory_order f) volatile noexcept; 224 bool compare_exchange_weak(T*& expc, T* desr, 225 memory_order s, memory_order f) noexcept; 226 bool compare_exchange_strong(T*& expc, T* desr, 227 memory_order s, memory_order f) volatile noexcept; 228 bool compare_exchange_strong(T*& expc, T* desr, 229 memory_order s, memory_order f) noexcept; 230 bool compare_exchange_weak(T*& expc, T* desr, 231 memory_order m = memory_order_seq_cst) volatile noexcept; 232 bool compare_exchange_weak(T*& expc, T* desr, 233 memory_order m = memory_order_seq_cst) noexcept; 234 bool compare_exchange_strong(T*& expc, T* desr, 235 memory_order m = memory_order_seq_cst) volatile noexcept; 236 bool compare_exchange_strong(T*& expc, T* desr, 237 memory_order m = memory_order_seq_cst) noexcept; 238 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept; 239 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept; 240 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept; 241 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept; 242 243 atomic() noexcept = default; 244 constexpr atomic(T* desr) noexcept; 245 atomic(const atomic&) = delete; 246 atomic& operator=(const atomic&) = delete; 247 atomic& operator=(const atomic&) volatile = delete; 248 249 T* operator=(T*) volatile noexcept; 250 T* operator=(T*) noexcept; 251 T* operator++(int) volatile noexcept; 252 T* operator++(int) noexcept; 253 T* operator--(int) volatile noexcept; 254 T* operator--(int) noexcept; 255 T* operator++() volatile noexcept; 256 T* operator++() noexcept; 257 T* operator--() volatile noexcept; 258 T* operator--() noexcept; 259 T* operator+=(ptrdiff_t op) volatile noexcept; 260 T* operator+=(ptrdiff_t op) noexcept; 261 T* operator-=(ptrdiff_t op) volatile noexcept; 262 T* operator-=(ptrdiff_t op) noexcept; 263 }; 264 265 266 template <class T> 267 bool 268 atomic_is_lock_free(const volatile atomic<T>* obj) noexcept; 269 270 template <class T> 271 bool 272 atomic_is_lock_free(const atomic<T>* obj) noexcept; 273 274 template <class T> 275 void 276 atomic_init(volatile atomic<T>* obj, T desr) noexcept; 277 278 template <class T> 279 void 280 atomic_init(atomic<T>* obj, T desr) noexcept; 281 282 template <class T> 283 void 284 atomic_store(volatile atomic<T>* obj, T desr) noexcept; 285 286 template <class T> 287 void 288 atomic_store(atomic<T>* obj, T desr) noexcept; 289 290 template <class T> 291 void 292 atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept; 293 294 template <class T> 295 void 296 atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept; 297 298 template <class T> 299 T 300 atomic_load(const volatile atomic<T>* obj) noexcept; 301 302 template <class T> 303 T 304 atomic_load(const atomic<T>* obj) noexcept; 305 306 template <class T> 307 T 308 atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept; 309 310 template <class T> 311 T 312 atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept; 313 314 template <class T> 315 T 316 atomic_exchange(volatile atomic<T>* obj, T desr) noexcept; 317 318 template <class T> 319 T 320 atomic_exchange(atomic<T>* obj, T desr) noexcept; 321 322 template <class T> 323 T 324 atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept; 325 326 template <class T> 327 T 328 atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept; 329 330 template <class T> 331 bool 332 atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept; 333 334 template <class T> 335 bool 336 atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept; 337 338 template <class T> 339 bool 340 atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept; 341 342 template <class T> 343 bool 344 atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept; 345 346 template <class T> 347 bool 348 atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc, 349 T desr, 350 memory_order s, memory_order f) noexcept; 351 352 template <class T> 353 bool 354 atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr, 355 memory_order s, memory_order f) noexcept; 356 357 template <class T> 358 bool 359 atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, 360 T* expc, T desr, 361 memory_order s, memory_order f) noexcept; 362 363 template <class T> 364 bool 365 atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, 366 T desr, 367 memory_order s, memory_order f) noexcept; 368 369 template <class Integral> 370 Integral 371 atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept; 372 373 template <class Integral> 374 Integral 375 atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept; 376 377 template <class Integral> 378 Integral 379 atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op, 380 memory_order m) noexcept; 381 template <class Integral> 382 Integral 383 atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op, 384 memory_order m) noexcept; 385 template <class Integral> 386 Integral 387 atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept; 388 389 template <class Integral> 390 Integral 391 atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept; 392 393 template <class Integral> 394 Integral 395 atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op, 396 memory_order m) noexcept; 397 template <class Integral> 398 Integral 399 atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op, 400 memory_order m) noexcept; 401 template <class Integral> 402 Integral 403 atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept; 404 405 template <class Integral> 406 Integral 407 atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept; 408 409 template <class Integral> 410 Integral 411 atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op, 412 memory_order m) noexcept; 413 template <class Integral> 414 Integral 415 atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op, 416 memory_order m) noexcept; 417 template <class Integral> 418 Integral 419 atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept; 420 421 template <class Integral> 422 Integral 423 atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept; 424 425 template <class Integral> 426 Integral 427 atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op, 428 memory_order m) noexcept; 429 template <class Integral> 430 Integral 431 atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op, 432 memory_order m) noexcept; 433 template <class Integral> 434 Integral 435 atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept; 436 437 template <class Integral> 438 Integral 439 atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept; 440 441 template <class Integral> 442 Integral 443 atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op, 444 memory_order m) noexcept; 445 template <class Integral> 446 Integral 447 atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op, 448 memory_order m) noexcept; 449 450 template <class T> 451 T* 452 atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op) noexcept; 453 454 template <class T> 455 T* 456 atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op) noexcept; 457 458 template <class T> 459 T* 460 atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op, 461 memory_order m) noexcept; 462 template <class T> 463 T* 464 atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept; 465 466 template <class T> 467 T* 468 atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op) noexcept; 469 470 template <class T> 471 T* 472 atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op) noexcept; 473 474 template <class T> 475 T* 476 atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op, 477 memory_order m) noexcept; 478 template <class T> 479 T* 480 atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept; 481 482 // Atomics for standard typedef types 483 484 typedef atomic<bool> atomic_bool; 485 typedef atomic<char> atomic_char; 486 typedef atomic<signed char> atomic_schar; 487 typedef atomic<unsigned char> atomic_uchar; 488 typedef atomic<short> atomic_short; 489 typedef atomic<unsigned short> atomic_ushort; 490 typedef atomic<int> atomic_int; 491 typedef atomic<unsigned int> atomic_uint; 492 typedef atomic<long> atomic_long; 493 typedef atomic<unsigned long> atomic_ulong; 494 typedef atomic<long long> atomic_llong; 495 typedef atomic<unsigned long long> atomic_ullong; 496 typedef atomic<char16_t> atomic_char16_t; 497 typedef atomic<char32_t> atomic_char32_t; 498 typedef atomic<wchar_t> atomic_wchar_t; 499 500 typedef atomic<int_least8_t> atomic_int_least8_t; 501 typedef atomic<uint_least8_t> atomic_uint_least8_t; 502 typedef atomic<int_least16_t> atomic_int_least16_t; 503 typedef atomic<uint_least16_t> atomic_uint_least16_t; 504 typedef atomic<int_least32_t> atomic_int_least32_t; 505 typedef atomic<uint_least32_t> atomic_uint_least32_t; 506 typedef atomic<int_least64_t> atomic_int_least64_t; 507 typedef atomic<uint_least64_t> atomic_uint_least64_t; 508 509 typedef atomic<int_fast8_t> atomic_int_fast8_t; 510 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; 511 typedef atomic<int_fast16_t> atomic_int_fast16_t; 512 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; 513 typedef atomic<int_fast32_t> atomic_int_fast32_t; 514 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; 515 typedef atomic<int_fast64_t> atomic_int_fast64_t; 516 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; 517 518 typedef atomic<int8_t> atomic_int8_t; 519 typedef atomic<uint8_t> atomic_uint8_t; 520 typedef atomic<int16_t> atomic_int16_t; 521 typedef atomic<uint16_t> atomic_uint16_t; 522 typedef atomic<int32_t> atomic_int32_t; 523 typedef atomic<uint32_t> atomic_uint32_t; 524 typedef atomic<int64_t> atomic_int64_t; 525 typedef atomic<uint64_t> atomic_uint64_t; 526 527 typedef atomic<intptr_t> atomic_intptr_t; 528 typedef atomic<uintptr_t> atomic_uintptr_t; 529 typedef atomic<size_t> atomic_size_t; 530 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; 531 typedef atomic<intmax_t> atomic_intmax_t; 532 typedef atomic<uintmax_t> atomic_uintmax_t; 533 534 // fences 535 536 void atomic_thread_fence(memory_order m) noexcept; 537 void atomic_signal_fence(memory_order m) noexcept; 538 539 } // std 540 541 */ 542 543 #include <__config> 544 #include <cstddef> 545 #include <cstdint> 546 #include <type_traits> 547 548 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 549 #pragma GCC system_header 550 #endif 551 552 #ifdef _LIBCPP_HAS_NO_THREADS 553 #error <atomic> is not supported on this single threaded system 554 #endif 555 #if !defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) 556 #error <atomic> is not implemented 557 #endif 558 559 #if _LIBCPP_STD_VER > 14 560 # define __cpp_lib_atomic_is_always_lock_free 201603L 561 #endif 562 563 #define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \ 564 _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume || \ 565 __m == memory_order_acquire || \ 566 __m == memory_order_acq_rel, \ 567 "memory order argument to atomic operation is invalid") 568 569 #define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) \ 570 _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || \ 571 __m == memory_order_acq_rel, \ 572 "memory order argument to atomic operation is invalid") 573 574 #define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__m, __f) \ 575 _LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release || \ 576 __f == memory_order_acq_rel, \ 577 "memory order argument to atomic operation is invalid") 578 579 _LIBCPP_BEGIN_NAMESPACE_STD 580 581 typedef enum memory_order 582 { 583 memory_order_relaxed, memory_order_consume, memory_order_acquire, 584 memory_order_release, memory_order_acq_rel, memory_order_seq_cst 585 } memory_order; 586 587 #if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) 588 namespace __gcc_atomic { 589 template <typename _Tp> 590 struct __gcc_atomic_t { 591 592 #if _GNUC_VER >= 501 593 static_assert(is_trivially_copyable<_Tp>::value, 594 "std::atomic<Tp> requires that 'Tp' be a trivially copyable type"); 595 #endif 596 597 _LIBCPP_INLINE_VISIBILITY 598 #ifndef _LIBCPP_CXX03_LANG 599 __gcc_atomic_t() _NOEXCEPT = default; 600 #else 601 __gcc_atomic_t() _NOEXCEPT : __a_value() {} 602 #endif // _LIBCPP_CXX03_LANG 603 _LIBCPP_CONSTEXPR explicit __gcc_atomic_t(_Tp value) _NOEXCEPT 604 : __a_value(value) {} 605 _Tp __a_value; 606 }; 607 #define _Atomic(x) __gcc_atomic::__gcc_atomic_t<x> 608 609 template <typename _Tp> _Tp __create(); 610 611 template <typename _Tp, typename _Td> 612 typename enable_if<sizeof(_Tp()->__a_value = __create<_Td>()), char>::type 613 __test_atomic_assignable(int); 614 template <typename _Tp, typename _Up> 615 __two __test_atomic_assignable(...); 616 617 template <typename _Tp, typename _Td> 618 struct __can_assign { 619 static const bool value = 620 sizeof(__test_atomic_assignable<_Tp, _Td>(1)) == sizeof(char); 621 }; 622 623 static inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) { 624 // Avoid switch statement to make this a constexpr. 625 return __order == memory_order_relaxed ? __ATOMIC_RELAXED: 626 (__order == memory_order_acquire ? __ATOMIC_ACQUIRE: 627 (__order == memory_order_release ? __ATOMIC_RELEASE: 628 (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST: 629 (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL: 630 __ATOMIC_CONSUME)))); 631 } 632 633 static inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) { 634 // Avoid switch statement to make this a constexpr. 635 return __order == memory_order_relaxed ? __ATOMIC_RELAXED: 636 (__order == memory_order_acquire ? __ATOMIC_ACQUIRE: 637 (__order == memory_order_release ? __ATOMIC_RELAXED: 638 (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST: 639 (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE: 640 __ATOMIC_CONSUME)))); 641 } 642 643 } // namespace __gcc_atomic 644 645 template <typename _Tp> 646 static inline 647 typename enable_if< 648 __gcc_atomic::__can_assign<volatile _Atomic(_Tp)*, _Tp>::value>::type 649 __c11_atomic_init(volatile _Atomic(_Tp)* __a, _Tp __val) { 650 __a->__a_value = __val; 651 } 652 653 template <typename _Tp> 654 static inline 655 typename enable_if< 656 !__gcc_atomic::__can_assign<volatile _Atomic(_Tp)*, _Tp>::value && 657 __gcc_atomic::__can_assign< _Atomic(_Tp)*, _Tp>::value>::type 658 __c11_atomic_init(volatile _Atomic(_Tp)* __a, _Tp __val) { 659 // [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because 660 // the default operator= in an object is not volatile, a byte-by-byte copy 661 // is required. 662 volatile char* to = reinterpret_cast<volatile char*>(&__a->__a_value); 663 volatile char* end = to + sizeof(_Tp); 664 char* from = reinterpret_cast<char*>(&__val); 665 while (to != end) { 666 *to++ = *from++; 667 } 668 } 669 670 template <typename _Tp> 671 static inline void __c11_atomic_init(_Atomic(_Tp)* __a, _Tp __val) { 672 __a->__a_value = __val; 673 } 674 675 static inline void __c11_atomic_thread_fence(memory_order __order) { 676 __atomic_thread_fence(__gcc_atomic::__to_gcc_order(__order)); 677 } 678 679 static inline void __c11_atomic_signal_fence(memory_order __order) { 680 __atomic_signal_fence(__gcc_atomic::__to_gcc_order(__order)); 681 } 682 683 template <typename _Tp> 684 static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a, _Tp __val, 685 memory_order __order) { 686 return __atomic_store(&__a->__a_value, &__val, 687 __gcc_atomic::__to_gcc_order(__order)); 688 } 689 690 template <typename _Tp> 691 static inline void __c11_atomic_store(_Atomic(_Tp)* __a, _Tp __val, 692 memory_order __order) { 693 __atomic_store(&__a->__a_value, &__val, 694 __gcc_atomic::__to_gcc_order(__order)); 695 } 696 697 template <typename _Tp> 698 static inline _Tp __c11_atomic_load(volatile _Atomic(_Tp)* __a, 699 memory_order __order) { 700 _Tp __ret; 701 __atomic_load(&__a->__a_value, &__ret, 702 __gcc_atomic::__to_gcc_order(__order)); 703 return __ret; 704 } 705 706 template <typename _Tp> 707 static inline _Tp __c11_atomic_load(_Atomic(_Tp)* __a, memory_order __order) { 708 _Tp __ret; 709 __atomic_load(&__a->__a_value, &__ret, 710 __gcc_atomic::__to_gcc_order(__order)); 711 return __ret; 712 } 713 714 template <typename _Tp> 715 static inline _Tp __c11_atomic_exchange(volatile _Atomic(_Tp)* __a, 716 _Tp __value, memory_order __order) { 717 _Tp __ret; 718 __atomic_exchange(&__a->__a_value, &__value, &__ret, 719 __gcc_atomic::__to_gcc_order(__order)); 720 return __ret; 721 } 722 723 template <typename _Tp> 724 static inline _Tp __c11_atomic_exchange(_Atomic(_Tp)* __a, _Tp __value, 725 memory_order __order) { 726 _Tp __ret; 727 __atomic_exchange(&__a->__a_value, &__value, &__ret, 728 __gcc_atomic::__to_gcc_order(__order)); 729 return __ret; 730 } 731 732 template <typename _Tp> 733 static inline bool __c11_atomic_compare_exchange_strong( 734 volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, 735 memory_order __success, memory_order __failure) { 736 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, 737 false, 738 __gcc_atomic::__to_gcc_order(__success), 739 __gcc_atomic::__to_gcc_failure_order(__failure)); 740 } 741 742 template <typename _Tp> 743 static inline bool __c11_atomic_compare_exchange_strong( 744 _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success, 745 memory_order __failure) { 746 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, 747 false, 748 __gcc_atomic::__to_gcc_order(__success), 749 __gcc_atomic::__to_gcc_failure_order(__failure)); 750 } 751 752 template <typename _Tp> 753 static inline bool __c11_atomic_compare_exchange_weak( 754 volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, 755 memory_order __success, memory_order __failure) { 756 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, 757 true, 758 __gcc_atomic::__to_gcc_order(__success), 759 __gcc_atomic::__to_gcc_failure_order(__failure)); 760 } 761 762 template <typename _Tp> 763 static inline bool __c11_atomic_compare_exchange_weak( 764 _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success, 765 memory_order __failure) { 766 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value, 767 true, 768 __gcc_atomic::__to_gcc_order(__success), 769 __gcc_atomic::__to_gcc_failure_order(__failure)); 770 } 771 772 template <typename _Tp> 773 struct __skip_amt { enum {value = 1}; }; 774 775 template <typename _Tp> 776 struct __skip_amt<_Tp*> { enum {value = sizeof(_Tp)}; }; 777 778 // FIXME: Haven't figured out what the spec says about using arrays with 779 // atomic_fetch_add. Force a failure rather than creating bad behavior. 780 template <typename _Tp> 781 struct __skip_amt<_Tp[]> { }; 782 template <typename _Tp, int n> 783 struct __skip_amt<_Tp[n]> { }; 784 785 template <typename _Tp, typename _Td> 786 static inline _Tp __c11_atomic_fetch_add(volatile _Atomic(_Tp)* __a, 787 _Td __delta, memory_order __order) { 788 return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value, 789 __gcc_atomic::__to_gcc_order(__order)); 790 } 791 792 template <typename _Tp, typename _Td> 793 static inline _Tp __c11_atomic_fetch_add(_Atomic(_Tp)* __a, _Td __delta, 794 memory_order __order) { 795 return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value, 796 __gcc_atomic::__to_gcc_order(__order)); 797 } 798 799 template <typename _Tp, typename _Td> 800 static inline _Tp __c11_atomic_fetch_sub(volatile _Atomic(_Tp)* __a, 801 _Td __delta, memory_order __order) { 802 return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value, 803 __gcc_atomic::__to_gcc_order(__order)); 804 } 805 806 template <typename _Tp, typename _Td> 807 static inline _Tp __c11_atomic_fetch_sub(_Atomic(_Tp)* __a, _Td __delta, 808 memory_order __order) { 809 return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value, 810 __gcc_atomic::__to_gcc_order(__order)); 811 } 812 813 template <typename _Tp> 814 static inline _Tp __c11_atomic_fetch_and(volatile _Atomic(_Tp)* __a, 815 _Tp __pattern, memory_order __order) { 816 return __atomic_fetch_and(&__a->__a_value, __pattern, 817 __gcc_atomic::__to_gcc_order(__order)); 818 } 819 820 template <typename _Tp> 821 static inline _Tp __c11_atomic_fetch_and(_Atomic(_Tp)* __a, 822 _Tp __pattern, memory_order __order) { 823 return __atomic_fetch_and(&__a->__a_value, __pattern, 824 __gcc_atomic::__to_gcc_order(__order)); 825 } 826 827 template <typename _Tp> 828 static inline _Tp __c11_atomic_fetch_or(volatile _Atomic(_Tp)* __a, 829 _Tp __pattern, memory_order __order) { 830 return __atomic_fetch_or(&__a->__a_value, __pattern, 831 __gcc_atomic::__to_gcc_order(__order)); 832 } 833 834 template <typename _Tp> 835 static inline _Tp __c11_atomic_fetch_or(_Atomic(_Tp)* __a, _Tp __pattern, 836 memory_order __order) { 837 return __atomic_fetch_or(&__a->__a_value, __pattern, 838 __gcc_atomic::__to_gcc_order(__order)); 839 } 840 841 template <typename _Tp> 842 static inline _Tp __c11_atomic_fetch_xor(volatile _Atomic(_Tp)* __a, 843 _Tp __pattern, memory_order __order) { 844 return __atomic_fetch_xor(&__a->__a_value, __pattern, 845 __gcc_atomic::__to_gcc_order(__order)); 846 } 847 848 template <typename _Tp> 849 static inline _Tp __c11_atomic_fetch_xor(_Atomic(_Tp)* __a, _Tp __pattern, 850 memory_order __order) { 851 return __atomic_fetch_xor(&__a->__a_value, __pattern, 852 __gcc_atomic::__to_gcc_order(__order)); 853 } 854 #endif // _LIBCPP_HAS_GCC_ATOMIC_IMP 855 856 template <class _Tp> 857 inline _LIBCPP_INLINE_VISIBILITY 858 _Tp 859 kill_dependency(_Tp __y) _NOEXCEPT 860 { 861 return __y; 862 } 863 864 #if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE) 865 # define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE 866 # define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE 867 # define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 868 # define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 869 # define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 870 # define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE 871 # define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE 872 # define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE 873 # define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE 874 # define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE 875 #else 876 # define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE 877 # define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE 878 # define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE 879 # define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE 880 # define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE 881 # define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE 882 # define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE 883 # define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE 884 # define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE 885 # define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE 886 #endif 887 888 // general atomic<T> 889 890 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value> 891 struct __atomic_base // false 892 { 893 mutable _Atomic(_Tp) __a_; 894 895 #if defined(__cpp_lib_atomic_is_always_lock_free) 896 static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0); 897 #endif 898 899 _LIBCPP_INLINE_VISIBILITY 900 bool is_lock_free() const volatile _NOEXCEPT 901 { 902 #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) 903 return __c11_atomic_is_lock_free(sizeof(_Tp)); 904 #else 905 return __atomic_is_lock_free(sizeof(_Tp), 0); 906 #endif 907 } 908 _LIBCPP_INLINE_VISIBILITY 909 bool is_lock_free() const _NOEXCEPT 910 {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();} 911 _LIBCPP_INLINE_VISIBILITY 912 void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 913 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) 914 {__c11_atomic_store(&__a_, __d, __m);} 915 _LIBCPP_INLINE_VISIBILITY 916 void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT 917 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) 918 {__c11_atomic_store(&__a_, __d, __m);} 919 _LIBCPP_INLINE_VISIBILITY 920 _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT 921 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) 922 {return __c11_atomic_load(&__a_, __m);} 923 _LIBCPP_INLINE_VISIBILITY 924 _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT 925 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) 926 {return __c11_atomic_load(&__a_, __m);} 927 _LIBCPP_INLINE_VISIBILITY 928 operator _Tp() const volatile _NOEXCEPT {return load();} 929 _LIBCPP_INLINE_VISIBILITY 930 operator _Tp() const _NOEXCEPT {return load();} 931 _LIBCPP_INLINE_VISIBILITY 932 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 933 {return __c11_atomic_exchange(&__a_, __d, __m);} 934 _LIBCPP_INLINE_VISIBILITY 935 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT 936 {return __c11_atomic_exchange(&__a_, __d, __m);} 937 _LIBCPP_INLINE_VISIBILITY 938 bool compare_exchange_weak(_Tp& __e, _Tp __d, 939 memory_order __s, memory_order __f) volatile _NOEXCEPT 940 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 941 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);} 942 _LIBCPP_INLINE_VISIBILITY 943 bool compare_exchange_weak(_Tp& __e, _Tp __d, 944 memory_order __s, memory_order __f) _NOEXCEPT 945 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 946 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);} 947 _LIBCPP_INLINE_VISIBILITY 948 bool compare_exchange_strong(_Tp& __e, _Tp __d, 949 memory_order __s, memory_order __f) volatile _NOEXCEPT 950 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 951 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);} 952 _LIBCPP_INLINE_VISIBILITY 953 bool compare_exchange_strong(_Tp& __e, _Tp __d, 954 memory_order __s, memory_order __f) _NOEXCEPT 955 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 956 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);} 957 _LIBCPP_INLINE_VISIBILITY 958 bool compare_exchange_weak(_Tp& __e, _Tp __d, 959 memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 960 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);} 961 _LIBCPP_INLINE_VISIBILITY 962 bool compare_exchange_weak(_Tp& __e, _Tp __d, 963 memory_order __m = memory_order_seq_cst) _NOEXCEPT 964 {return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);} 965 _LIBCPP_INLINE_VISIBILITY 966 bool compare_exchange_strong(_Tp& __e, _Tp __d, 967 memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 968 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);} 969 _LIBCPP_INLINE_VISIBILITY 970 bool compare_exchange_strong(_Tp& __e, _Tp __d, 971 memory_order __m = memory_order_seq_cst) _NOEXCEPT 972 {return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);} 973 974 _LIBCPP_INLINE_VISIBILITY 975 #ifndef _LIBCPP_CXX03_LANG 976 __atomic_base() _NOEXCEPT = default; 977 #else 978 __atomic_base() _NOEXCEPT : __a_() {} 979 #endif // _LIBCPP_CXX03_LANG 980 981 _LIBCPP_INLINE_VISIBILITY 982 _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {} 983 #ifndef _LIBCPP_CXX03_LANG 984 __atomic_base(const __atomic_base&) = delete; 985 __atomic_base& operator=(const __atomic_base&) = delete; 986 __atomic_base& operator=(const __atomic_base&) volatile = delete; 987 #else 988 private: 989 __atomic_base(const __atomic_base&); 990 __atomic_base& operator=(const __atomic_base&); 991 __atomic_base& operator=(const __atomic_base&) volatile; 992 #endif 993 }; 994 995 #if defined(__cpp_lib_atomic_is_always_lock_free) 996 template <class _Tp, bool __b> 997 _LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free; 998 #endif 999 1000 // atomic<Integral> 1001 1002 template <class _Tp> 1003 struct __atomic_base<_Tp, true> 1004 : public __atomic_base<_Tp, false> 1005 { 1006 typedef __atomic_base<_Tp, false> __base; 1007 _LIBCPP_INLINE_VISIBILITY 1008 __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT 1009 _LIBCPP_INLINE_VISIBILITY 1010 _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {} 1011 1012 _LIBCPP_INLINE_VISIBILITY 1013 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1014 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} 1015 _LIBCPP_INLINE_VISIBILITY 1016 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1017 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} 1018 _LIBCPP_INLINE_VISIBILITY 1019 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1020 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} 1021 _LIBCPP_INLINE_VISIBILITY 1022 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1023 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} 1024 _LIBCPP_INLINE_VISIBILITY 1025 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1026 {return __c11_atomic_fetch_and(&this->__a_, __op, __m);} 1027 _LIBCPP_INLINE_VISIBILITY 1028 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1029 {return __c11_atomic_fetch_and(&this->__a_, __op, __m);} 1030 _LIBCPP_INLINE_VISIBILITY 1031 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1032 {return __c11_atomic_fetch_or(&this->__a_, __op, __m);} 1033 _LIBCPP_INLINE_VISIBILITY 1034 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1035 {return __c11_atomic_fetch_or(&this->__a_, __op, __m);} 1036 _LIBCPP_INLINE_VISIBILITY 1037 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1038 {return __c11_atomic_fetch_xor(&this->__a_, __op, __m);} 1039 _LIBCPP_INLINE_VISIBILITY 1040 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1041 {return __c11_atomic_fetch_xor(&this->__a_, __op, __m);} 1042 1043 _LIBCPP_INLINE_VISIBILITY 1044 _Tp operator++(int) volatile _NOEXCEPT {return fetch_add(_Tp(1));} 1045 _LIBCPP_INLINE_VISIBILITY 1046 _Tp operator++(int) _NOEXCEPT {return fetch_add(_Tp(1));} 1047 _LIBCPP_INLINE_VISIBILITY 1048 _Tp operator--(int) volatile _NOEXCEPT {return fetch_sub(_Tp(1));} 1049 _LIBCPP_INLINE_VISIBILITY 1050 _Tp operator--(int) _NOEXCEPT {return fetch_sub(_Tp(1));} 1051 _LIBCPP_INLINE_VISIBILITY 1052 _Tp operator++() volatile _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);} 1053 _LIBCPP_INLINE_VISIBILITY 1054 _Tp operator++() _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);} 1055 _LIBCPP_INLINE_VISIBILITY 1056 _Tp operator--() volatile _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);} 1057 _LIBCPP_INLINE_VISIBILITY 1058 _Tp operator--() _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);} 1059 _LIBCPP_INLINE_VISIBILITY 1060 _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;} 1061 _LIBCPP_INLINE_VISIBILITY 1062 _Tp operator+=(_Tp __op) _NOEXCEPT {return fetch_add(__op) + __op;} 1063 _LIBCPP_INLINE_VISIBILITY 1064 _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;} 1065 _LIBCPP_INLINE_VISIBILITY 1066 _Tp operator-=(_Tp __op) _NOEXCEPT {return fetch_sub(__op) - __op;} 1067 _LIBCPP_INLINE_VISIBILITY 1068 _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;} 1069 _LIBCPP_INLINE_VISIBILITY 1070 _Tp operator&=(_Tp __op) _NOEXCEPT {return fetch_and(__op) & __op;} 1071 _LIBCPP_INLINE_VISIBILITY 1072 _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;} 1073 _LIBCPP_INLINE_VISIBILITY 1074 _Tp operator|=(_Tp __op) _NOEXCEPT {return fetch_or(__op) | __op;} 1075 _LIBCPP_INLINE_VISIBILITY 1076 _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;} 1077 _LIBCPP_INLINE_VISIBILITY 1078 _Tp operator^=(_Tp __op) _NOEXCEPT {return fetch_xor(__op) ^ __op;} 1079 }; 1080 1081 // atomic<T> 1082 1083 template <class _Tp> 1084 struct atomic 1085 : public __atomic_base<_Tp> 1086 { 1087 typedef __atomic_base<_Tp> __base; 1088 _LIBCPP_INLINE_VISIBILITY 1089 atomic() _NOEXCEPT _LIBCPP_DEFAULT 1090 _LIBCPP_INLINE_VISIBILITY 1091 _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {} 1092 1093 _LIBCPP_INLINE_VISIBILITY 1094 _Tp operator=(_Tp __d) volatile _NOEXCEPT 1095 {__base::store(__d); return __d;} 1096 _LIBCPP_INLINE_VISIBILITY 1097 _Tp operator=(_Tp __d) _NOEXCEPT 1098 {__base::store(__d); return __d;} 1099 }; 1100 1101 // atomic<T*> 1102 1103 template <class _Tp> 1104 struct atomic<_Tp*> 1105 : public __atomic_base<_Tp*> 1106 { 1107 typedef __atomic_base<_Tp*> __base; 1108 _LIBCPP_INLINE_VISIBILITY 1109 atomic() _NOEXCEPT _LIBCPP_DEFAULT 1110 _LIBCPP_INLINE_VISIBILITY 1111 _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {} 1112 1113 _LIBCPP_INLINE_VISIBILITY 1114 _Tp* operator=(_Tp* __d) volatile _NOEXCEPT 1115 {__base::store(__d); return __d;} 1116 _LIBCPP_INLINE_VISIBILITY 1117 _Tp* operator=(_Tp* __d) _NOEXCEPT 1118 {__base::store(__d); return __d;} 1119 1120 _LIBCPP_INLINE_VISIBILITY 1121 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) 1122 volatile _NOEXCEPT 1123 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} 1124 _LIBCPP_INLINE_VISIBILITY 1125 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1126 {return __c11_atomic_fetch_add(&this->__a_, __op, __m);} 1127 _LIBCPP_INLINE_VISIBILITY 1128 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) 1129 volatile _NOEXCEPT 1130 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} 1131 _LIBCPP_INLINE_VISIBILITY 1132 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT 1133 {return __c11_atomic_fetch_sub(&this->__a_, __op, __m);} 1134 1135 _LIBCPP_INLINE_VISIBILITY 1136 _Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);} 1137 _LIBCPP_INLINE_VISIBILITY 1138 _Tp* operator++(int) _NOEXCEPT {return fetch_add(1);} 1139 _LIBCPP_INLINE_VISIBILITY 1140 _Tp* operator--(int) volatile _NOEXCEPT {return fetch_sub(1);} 1141 _LIBCPP_INLINE_VISIBILITY 1142 _Tp* operator--(int) _NOEXCEPT {return fetch_sub(1);} 1143 _LIBCPP_INLINE_VISIBILITY 1144 _Tp* operator++() volatile _NOEXCEPT {return fetch_add(1) + 1;} 1145 _LIBCPP_INLINE_VISIBILITY 1146 _Tp* operator++() _NOEXCEPT {return fetch_add(1) + 1;} 1147 _LIBCPP_INLINE_VISIBILITY 1148 _Tp* operator--() volatile _NOEXCEPT {return fetch_sub(1) - 1;} 1149 _LIBCPP_INLINE_VISIBILITY 1150 _Tp* operator--() _NOEXCEPT {return fetch_sub(1) - 1;} 1151 _LIBCPP_INLINE_VISIBILITY 1152 _Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;} 1153 _LIBCPP_INLINE_VISIBILITY 1154 _Tp* operator+=(ptrdiff_t __op) _NOEXCEPT {return fetch_add(__op) + __op;} 1155 _LIBCPP_INLINE_VISIBILITY 1156 _Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;} 1157 _LIBCPP_INLINE_VISIBILITY 1158 _Tp* operator-=(ptrdiff_t __op) _NOEXCEPT {return fetch_sub(__op) - __op;} 1159 }; 1160 1161 // atomic_is_lock_free 1162 1163 template <class _Tp> 1164 inline _LIBCPP_INLINE_VISIBILITY 1165 bool 1166 atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT 1167 { 1168 return __o->is_lock_free(); 1169 } 1170 1171 template <class _Tp> 1172 inline _LIBCPP_INLINE_VISIBILITY 1173 bool 1174 atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT 1175 { 1176 return __o->is_lock_free(); 1177 } 1178 1179 // atomic_init 1180 1181 template <class _Tp> 1182 inline _LIBCPP_INLINE_VISIBILITY 1183 void 1184 atomic_init(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1185 { 1186 __c11_atomic_init(&__o->__a_, __d); 1187 } 1188 1189 template <class _Tp> 1190 inline _LIBCPP_INLINE_VISIBILITY 1191 void 1192 atomic_init(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1193 { 1194 __c11_atomic_init(&__o->__a_, __d); 1195 } 1196 1197 // atomic_store 1198 1199 template <class _Tp> 1200 inline _LIBCPP_INLINE_VISIBILITY 1201 void 1202 atomic_store(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1203 { 1204 __o->store(__d); 1205 } 1206 1207 template <class _Tp> 1208 inline _LIBCPP_INLINE_VISIBILITY 1209 void 1210 atomic_store(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1211 { 1212 __o->store(__d); 1213 } 1214 1215 // atomic_store_explicit 1216 1217 template <class _Tp> 1218 inline _LIBCPP_INLINE_VISIBILITY 1219 void 1220 atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT 1221 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) 1222 { 1223 __o->store(__d, __m); 1224 } 1225 1226 template <class _Tp> 1227 inline _LIBCPP_INLINE_VISIBILITY 1228 void 1229 atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT 1230 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) 1231 { 1232 __o->store(__d, __m); 1233 } 1234 1235 // atomic_load 1236 1237 template <class _Tp> 1238 inline _LIBCPP_INLINE_VISIBILITY 1239 _Tp 1240 atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT 1241 { 1242 return __o->load(); 1243 } 1244 1245 template <class _Tp> 1246 inline _LIBCPP_INLINE_VISIBILITY 1247 _Tp 1248 atomic_load(const atomic<_Tp>* __o) _NOEXCEPT 1249 { 1250 return __o->load(); 1251 } 1252 1253 // atomic_load_explicit 1254 1255 template <class _Tp> 1256 inline _LIBCPP_INLINE_VISIBILITY 1257 _Tp 1258 atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT 1259 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) 1260 { 1261 return __o->load(__m); 1262 } 1263 1264 template <class _Tp> 1265 inline _LIBCPP_INLINE_VISIBILITY 1266 _Tp 1267 atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT 1268 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) 1269 { 1270 return __o->load(__m); 1271 } 1272 1273 // atomic_exchange 1274 1275 template <class _Tp> 1276 inline _LIBCPP_INLINE_VISIBILITY 1277 _Tp 1278 atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1279 { 1280 return __o->exchange(__d); 1281 } 1282 1283 template <class _Tp> 1284 inline _LIBCPP_INLINE_VISIBILITY 1285 _Tp 1286 atomic_exchange(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT 1287 { 1288 return __o->exchange(__d); 1289 } 1290 1291 // atomic_exchange_explicit 1292 1293 template <class _Tp> 1294 inline _LIBCPP_INLINE_VISIBILITY 1295 _Tp 1296 atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT 1297 { 1298 return __o->exchange(__d, __m); 1299 } 1300 1301 template <class _Tp> 1302 inline _LIBCPP_INLINE_VISIBILITY 1303 _Tp 1304 atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT 1305 { 1306 return __o->exchange(__d, __m); 1307 } 1308 1309 // atomic_compare_exchange_weak 1310 1311 template <class _Tp> 1312 inline _LIBCPP_INLINE_VISIBILITY 1313 bool 1314 atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT 1315 { 1316 return __o->compare_exchange_weak(*__e, __d); 1317 } 1318 1319 template <class _Tp> 1320 inline _LIBCPP_INLINE_VISIBILITY 1321 bool 1322 atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT 1323 { 1324 return __o->compare_exchange_weak(*__e, __d); 1325 } 1326 1327 // atomic_compare_exchange_strong 1328 1329 template <class _Tp> 1330 inline _LIBCPP_INLINE_VISIBILITY 1331 bool 1332 atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT 1333 { 1334 return __o->compare_exchange_strong(*__e, __d); 1335 } 1336 1337 template <class _Tp> 1338 inline _LIBCPP_INLINE_VISIBILITY 1339 bool 1340 atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT 1341 { 1342 return __o->compare_exchange_strong(*__e, __d); 1343 } 1344 1345 // atomic_compare_exchange_weak_explicit 1346 1347 template <class _Tp> 1348 inline _LIBCPP_INLINE_VISIBILITY 1349 bool 1350 atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e, 1351 _Tp __d, 1352 memory_order __s, memory_order __f) _NOEXCEPT 1353 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 1354 { 1355 return __o->compare_exchange_weak(*__e, __d, __s, __f); 1356 } 1357 1358 template <class _Tp> 1359 inline _LIBCPP_INLINE_VISIBILITY 1360 bool 1361 atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d, 1362 memory_order __s, memory_order __f) _NOEXCEPT 1363 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 1364 { 1365 return __o->compare_exchange_weak(*__e, __d, __s, __f); 1366 } 1367 1368 // atomic_compare_exchange_strong_explicit 1369 1370 template <class _Tp> 1371 inline _LIBCPP_INLINE_VISIBILITY 1372 bool 1373 atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o, 1374 _Tp* __e, _Tp __d, 1375 memory_order __s, memory_order __f) _NOEXCEPT 1376 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 1377 { 1378 return __o->compare_exchange_strong(*__e, __d, __s, __f); 1379 } 1380 1381 template <class _Tp> 1382 inline _LIBCPP_INLINE_VISIBILITY 1383 bool 1384 atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e, 1385 _Tp __d, 1386 memory_order __s, memory_order __f) _NOEXCEPT 1387 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) 1388 { 1389 return __o->compare_exchange_strong(*__e, __d, __s, __f); 1390 } 1391 1392 // atomic_fetch_add 1393 1394 template <class _Tp> 1395 inline _LIBCPP_INLINE_VISIBILITY 1396 typename enable_if 1397 < 1398 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1399 _Tp 1400 >::type 1401 atomic_fetch_add(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1402 { 1403 return __o->fetch_add(__op); 1404 } 1405 1406 template <class _Tp> 1407 inline _LIBCPP_INLINE_VISIBILITY 1408 typename enable_if 1409 < 1410 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1411 _Tp 1412 >::type 1413 atomic_fetch_add(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1414 { 1415 return __o->fetch_add(__op); 1416 } 1417 1418 template <class _Tp> 1419 inline _LIBCPP_INLINE_VISIBILITY 1420 _Tp* 1421 atomic_fetch_add(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT 1422 { 1423 return __o->fetch_add(__op); 1424 } 1425 1426 template <class _Tp> 1427 inline _LIBCPP_INLINE_VISIBILITY 1428 _Tp* 1429 atomic_fetch_add(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT 1430 { 1431 return __o->fetch_add(__op); 1432 } 1433 1434 // atomic_fetch_add_explicit 1435 1436 template <class _Tp> 1437 inline _LIBCPP_INLINE_VISIBILITY 1438 typename enable_if 1439 < 1440 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1441 _Tp 1442 >::type 1443 atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1444 { 1445 return __o->fetch_add(__op, __m); 1446 } 1447 1448 template <class _Tp> 1449 inline _LIBCPP_INLINE_VISIBILITY 1450 typename enable_if 1451 < 1452 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1453 _Tp 1454 >::type 1455 atomic_fetch_add_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1456 { 1457 return __o->fetch_add(__op, __m); 1458 } 1459 1460 template <class _Tp> 1461 inline _LIBCPP_INLINE_VISIBILITY 1462 _Tp* 1463 atomic_fetch_add_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op, 1464 memory_order __m) _NOEXCEPT 1465 { 1466 return __o->fetch_add(__op, __m); 1467 } 1468 1469 template <class _Tp> 1470 inline _LIBCPP_INLINE_VISIBILITY 1471 _Tp* 1472 atomic_fetch_add_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT 1473 { 1474 return __o->fetch_add(__op, __m); 1475 } 1476 1477 // atomic_fetch_sub 1478 1479 template <class _Tp> 1480 inline _LIBCPP_INLINE_VISIBILITY 1481 typename enable_if 1482 < 1483 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1484 _Tp 1485 >::type 1486 atomic_fetch_sub(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1487 { 1488 return __o->fetch_sub(__op); 1489 } 1490 1491 template <class _Tp> 1492 inline _LIBCPP_INLINE_VISIBILITY 1493 typename enable_if 1494 < 1495 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1496 _Tp 1497 >::type 1498 atomic_fetch_sub(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1499 { 1500 return __o->fetch_sub(__op); 1501 } 1502 1503 template <class _Tp> 1504 inline _LIBCPP_INLINE_VISIBILITY 1505 _Tp* 1506 atomic_fetch_sub(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT 1507 { 1508 return __o->fetch_sub(__op); 1509 } 1510 1511 template <class _Tp> 1512 inline _LIBCPP_INLINE_VISIBILITY 1513 _Tp* 1514 atomic_fetch_sub(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT 1515 { 1516 return __o->fetch_sub(__op); 1517 } 1518 1519 // atomic_fetch_sub_explicit 1520 1521 template <class _Tp> 1522 inline _LIBCPP_INLINE_VISIBILITY 1523 typename enable_if 1524 < 1525 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1526 _Tp 1527 >::type 1528 atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1529 { 1530 return __o->fetch_sub(__op, __m); 1531 } 1532 1533 template <class _Tp> 1534 inline _LIBCPP_INLINE_VISIBILITY 1535 typename enable_if 1536 < 1537 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1538 _Tp 1539 >::type 1540 atomic_fetch_sub_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1541 { 1542 return __o->fetch_sub(__op, __m); 1543 } 1544 1545 template <class _Tp> 1546 inline _LIBCPP_INLINE_VISIBILITY 1547 _Tp* 1548 atomic_fetch_sub_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op, 1549 memory_order __m) _NOEXCEPT 1550 { 1551 return __o->fetch_sub(__op, __m); 1552 } 1553 1554 template <class _Tp> 1555 inline _LIBCPP_INLINE_VISIBILITY 1556 _Tp* 1557 atomic_fetch_sub_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT 1558 { 1559 return __o->fetch_sub(__op, __m); 1560 } 1561 1562 // atomic_fetch_and 1563 1564 template <class _Tp> 1565 inline _LIBCPP_INLINE_VISIBILITY 1566 typename enable_if 1567 < 1568 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1569 _Tp 1570 >::type 1571 atomic_fetch_and(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1572 { 1573 return __o->fetch_and(__op); 1574 } 1575 1576 template <class _Tp> 1577 inline _LIBCPP_INLINE_VISIBILITY 1578 typename enable_if 1579 < 1580 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1581 _Tp 1582 >::type 1583 atomic_fetch_and(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1584 { 1585 return __o->fetch_and(__op); 1586 } 1587 1588 // atomic_fetch_and_explicit 1589 1590 template <class _Tp> 1591 inline _LIBCPP_INLINE_VISIBILITY 1592 typename enable_if 1593 < 1594 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1595 _Tp 1596 >::type 1597 atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1598 { 1599 return __o->fetch_and(__op, __m); 1600 } 1601 1602 template <class _Tp> 1603 inline _LIBCPP_INLINE_VISIBILITY 1604 typename enable_if 1605 < 1606 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1607 _Tp 1608 >::type 1609 atomic_fetch_and_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1610 { 1611 return __o->fetch_and(__op, __m); 1612 } 1613 1614 // atomic_fetch_or 1615 1616 template <class _Tp> 1617 inline _LIBCPP_INLINE_VISIBILITY 1618 typename enable_if 1619 < 1620 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1621 _Tp 1622 >::type 1623 atomic_fetch_or(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1624 { 1625 return __o->fetch_or(__op); 1626 } 1627 1628 template <class _Tp> 1629 inline _LIBCPP_INLINE_VISIBILITY 1630 typename enable_if 1631 < 1632 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1633 _Tp 1634 >::type 1635 atomic_fetch_or(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1636 { 1637 return __o->fetch_or(__op); 1638 } 1639 1640 // atomic_fetch_or_explicit 1641 1642 template <class _Tp> 1643 inline _LIBCPP_INLINE_VISIBILITY 1644 typename enable_if 1645 < 1646 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1647 _Tp 1648 >::type 1649 atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1650 { 1651 return __o->fetch_or(__op, __m); 1652 } 1653 1654 template <class _Tp> 1655 inline _LIBCPP_INLINE_VISIBILITY 1656 typename enable_if 1657 < 1658 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1659 _Tp 1660 >::type 1661 atomic_fetch_or_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1662 { 1663 return __o->fetch_or(__op, __m); 1664 } 1665 1666 // atomic_fetch_xor 1667 1668 template <class _Tp> 1669 inline _LIBCPP_INLINE_VISIBILITY 1670 typename enable_if 1671 < 1672 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1673 _Tp 1674 >::type 1675 atomic_fetch_xor(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1676 { 1677 return __o->fetch_xor(__op); 1678 } 1679 1680 template <class _Tp> 1681 inline _LIBCPP_INLINE_VISIBILITY 1682 typename enable_if 1683 < 1684 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1685 _Tp 1686 >::type 1687 atomic_fetch_xor(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT 1688 { 1689 return __o->fetch_xor(__op); 1690 } 1691 1692 // atomic_fetch_xor_explicit 1693 1694 template <class _Tp> 1695 inline _LIBCPP_INLINE_VISIBILITY 1696 typename enable_if 1697 < 1698 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1699 _Tp 1700 >::type 1701 atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1702 { 1703 return __o->fetch_xor(__op, __m); 1704 } 1705 1706 template <class _Tp> 1707 inline _LIBCPP_INLINE_VISIBILITY 1708 typename enable_if 1709 < 1710 is_integral<_Tp>::value && !is_same<_Tp, bool>::value, 1711 _Tp 1712 >::type 1713 atomic_fetch_xor_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT 1714 { 1715 return __o->fetch_xor(__op, __m); 1716 } 1717 1718 // flag type and operations 1719 1720 typedef struct atomic_flag 1721 { 1722 _Atomic(bool) __a_; 1723 1724 _LIBCPP_INLINE_VISIBILITY 1725 bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1726 {return __c11_atomic_exchange(&__a_, true, __m);} 1727 _LIBCPP_INLINE_VISIBILITY 1728 bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT 1729 {return __c11_atomic_exchange(&__a_, true, __m);} 1730 _LIBCPP_INLINE_VISIBILITY 1731 void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT 1732 {__c11_atomic_store(&__a_, false, __m);} 1733 _LIBCPP_INLINE_VISIBILITY 1734 void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT 1735 {__c11_atomic_store(&__a_, false, __m);} 1736 1737 _LIBCPP_INLINE_VISIBILITY 1738 #ifndef _LIBCPP_CXX03_LANG 1739 atomic_flag() _NOEXCEPT = default; 1740 #else 1741 atomic_flag() _NOEXCEPT : __a_() {} 1742 #endif // _LIBCPP_CXX03_LANG 1743 1744 _LIBCPP_INLINE_VISIBILITY 1745 atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION 1746 1747 #ifndef _LIBCPP_CXX03_LANG 1748 atomic_flag(const atomic_flag&) = delete; 1749 atomic_flag& operator=(const atomic_flag&) = delete; 1750 atomic_flag& operator=(const atomic_flag&) volatile = delete; 1751 #else 1752 private: 1753 atomic_flag(const atomic_flag&); 1754 atomic_flag& operator=(const atomic_flag&); 1755 atomic_flag& operator=(const atomic_flag&) volatile; 1756 #endif 1757 } atomic_flag; 1758 1759 inline _LIBCPP_INLINE_VISIBILITY 1760 bool 1761 atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT 1762 { 1763 return __o->test_and_set(); 1764 } 1765 1766 inline _LIBCPP_INLINE_VISIBILITY 1767 bool 1768 atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT 1769 { 1770 return __o->test_and_set(); 1771 } 1772 1773 inline _LIBCPP_INLINE_VISIBILITY 1774 bool 1775 atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT 1776 { 1777 return __o->test_and_set(__m); 1778 } 1779 1780 inline _LIBCPP_INLINE_VISIBILITY 1781 bool 1782 atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT 1783 { 1784 return __o->test_and_set(__m); 1785 } 1786 1787 inline _LIBCPP_INLINE_VISIBILITY 1788 void 1789 atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT 1790 { 1791 __o->clear(); 1792 } 1793 1794 inline _LIBCPP_INLINE_VISIBILITY 1795 void 1796 atomic_flag_clear(atomic_flag* __o) _NOEXCEPT 1797 { 1798 __o->clear(); 1799 } 1800 1801 inline _LIBCPP_INLINE_VISIBILITY 1802 void 1803 atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT 1804 { 1805 __o->clear(__m); 1806 } 1807 1808 inline _LIBCPP_INLINE_VISIBILITY 1809 void 1810 atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT 1811 { 1812 __o->clear(__m); 1813 } 1814 1815 // fences 1816 1817 inline _LIBCPP_INLINE_VISIBILITY 1818 void 1819 atomic_thread_fence(memory_order __m) _NOEXCEPT 1820 { 1821 __c11_atomic_thread_fence(__m); 1822 } 1823 1824 inline _LIBCPP_INLINE_VISIBILITY 1825 void 1826 atomic_signal_fence(memory_order __m) _NOEXCEPT 1827 { 1828 __c11_atomic_signal_fence(__m); 1829 } 1830 1831 // Atomics for standard typedef types 1832 1833 typedef atomic<bool> atomic_bool; 1834 typedef atomic<char> atomic_char; 1835 typedef atomic<signed char> atomic_schar; 1836 typedef atomic<unsigned char> atomic_uchar; 1837 typedef atomic<short> atomic_short; 1838 typedef atomic<unsigned short> atomic_ushort; 1839 typedef atomic<int> atomic_int; 1840 typedef atomic<unsigned int> atomic_uint; 1841 typedef atomic<long> atomic_long; 1842 typedef atomic<unsigned long> atomic_ulong; 1843 typedef atomic<long long> atomic_llong; 1844 typedef atomic<unsigned long long> atomic_ullong; 1845 typedef atomic<char16_t> atomic_char16_t; 1846 typedef atomic<char32_t> atomic_char32_t; 1847 typedef atomic<wchar_t> atomic_wchar_t; 1848 1849 typedef atomic<int_least8_t> atomic_int_least8_t; 1850 typedef atomic<uint_least8_t> atomic_uint_least8_t; 1851 typedef atomic<int_least16_t> atomic_int_least16_t; 1852 typedef atomic<uint_least16_t> atomic_uint_least16_t; 1853 typedef atomic<int_least32_t> atomic_int_least32_t; 1854 typedef atomic<uint_least32_t> atomic_uint_least32_t; 1855 typedef atomic<int_least64_t> atomic_int_least64_t; 1856 typedef atomic<uint_least64_t> atomic_uint_least64_t; 1857 1858 typedef atomic<int_fast8_t> atomic_int_fast8_t; 1859 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; 1860 typedef atomic<int_fast16_t> atomic_int_fast16_t; 1861 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; 1862 typedef atomic<int_fast32_t> atomic_int_fast32_t; 1863 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; 1864 typedef atomic<int_fast64_t> atomic_int_fast64_t; 1865 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; 1866 1867 typedef atomic< int8_t> atomic_int8_t; 1868 typedef atomic<uint8_t> atomic_uint8_t; 1869 typedef atomic< int16_t> atomic_int16_t; 1870 typedef atomic<uint16_t> atomic_uint16_t; 1871 typedef atomic< int32_t> atomic_int32_t; 1872 typedef atomic<uint32_t> atomic_uint32_t; 1873 typedef atomic< int64_t> atomic_int64_t; 1874 typedef atomic<uint64_t> atomic_uint64_t; 1875 1876 typedef atomic<intptr_t> atomic_intptr_t; 1877 typedef atomic<uintptr_t> atomic_uintptr_t; 1878 typedef atomic<size_t> atomic_size_t; 1879 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; 1880 typedef atomic<intmax_t> atomic_intmax_t; 1881 typedef atomic<uintmax_t> atomic_uintmax_t; 1882 1883 #define ATOMIC_FLAG_INIT {false} 1884 #define ATOMIC_VAR_INIT(__v) {__v} 1885 1886 _LIBCPP_END_NAMESPACE_STD 1887 1888 #endif // _LIBCPP_ATOMIC 1889
