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) noexcept; 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 noexcept; 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 noexcept; 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 noexcept; 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) noexcept; 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 noexcept; 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 noexcept; 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 noexcept; 160 integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept; 161 integral 162 fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 163 integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept; 164 integral 165 fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 166 integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept; 167 integral 168 fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 169 integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept; 170 integral 171 fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept; 172 integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept; 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 noexcept; 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 noexcept; 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 noexcept; 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 noexcept; 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 noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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) noexcept; 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>::value> 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 _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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 _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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) _NOEXCEPT 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 _NOEXCEPT 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) _NOEXCEPT 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 1532
