1 // -*- C++ -*- header. 2 3 // Copyright (C) 2008-2019 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/atomic 26 * This is a Standard C++ Library header. 27 */ 28 29 // Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. 30 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html 31 32 #ifndef _GLIBCXX_ATOMIC 33 #define _GLIBCXX_ATOMIC 1 34 35 #pragma GCC system_header 36 37 #if __cplusplus < 201103L 38 # include <bits/c++0x_warning.h> 39 #else 40 41 #include <bits/atomic_base.h> 42 #include <bits/move.h> 43 44 namespace std _GLIBCXX_VISIBILITY(default) 45 { 46 _GLIBCXX_BEGIN_NAMESPACE_VERSION 47 48 /** 49 * @addtogroup atomics 50 * @{ 51 */ 52 53 #if __cplusplus >= 201703L 54 # define __cpp_lib_atomic_is_always_lock_free 201603 55 #endif 56 57 template<typename _Tp> 58 struct atomic; 59 60 /// atomic<bool> 61 // NB: No operators or fetch-operations for this type. 62 template<> 63 struct atomic<bool> 64 { 65 using value_type = bool; 66 67 private: 68 __atomic_base<bool> _M_base; 69 70 public: 71 atomic() noexcept = default; 72 ~atomic() noexcept = default; 73 atomic(const atomic&) = delete; 74 atomic& operator=(const atomic&) = delete; 75 atomic& operator=(const atomic&) volatile = delete; 76 77 constexpr atomic(bool __i) noexcept : _M_base(__i) { } 78 79 bool 80 operator=(bool __i) noexcept 81 { return _M_base.operator=(__i); } 82 83 bool 84 operator=(bool __i) volatile noexcept 85 { return _M_base.operator=(__i); } 86 87 operator bool() const noexcept 88 { return _M_base.load(); } 89 90 operator bool() const volatile noexcept 91 { return _M_base.load(); } 92 93 bool 94 is_lock_free() const noexcept { return _M_base.is_lock_free(); } 95 96 bool 97 is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } 98 99 #if __cplusplus >= 201703L 100 static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2; 101 #endif 102 103 void 104 store(bool __i, memory_order __m = memory_order_seq_cst) noexcept 105 { _M_base.store(__i, __m); } 106 107 void 108 store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept 109 { _M_base.store(__i, __m); } 110 111 bool 112 load(memory_order __m = memory_order_seq_cst) const noexcept 113 { return _M_base.load(__m); } 114 115 bool 116 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 117 { return _M_base.load(__m); } 118 119 bool 120 exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept 121 { return _M_base.exchange(__i, __m); } 122 123 bool 124 exchange(bool __i, 125 memory_order __m = memory_order_seq_cst) volatile noexcept 126 { return _M_base.exchange(__i, __m); } 127 128 bool 129 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, 130 memory_order __m2) noexcept 131 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } 132 133 bool 134 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, 135 memory_order __m2) volatile noexcept 136 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } 137 138 bool 139 compare_exchange_weak(bool& __i1, bool __i2, 140 memory_order __m = memory_order_seq_cst) noexcept 141 { return _M_base.compare_exchange_weak(__i1, __i2, __m); } 142 143 bool 144 compare_exchange_weak(bool& __i1, bool __i2, 145 memory_order __m = memory_order_seq_cst) volatile noexcept 146 { return _M_base.compare_exchange_weak(__i1, __i2, __m); } 147 148 bool 149 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, 150 memory_order __m2) noexcept 151 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } 152 153 bool 154 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, 155 memory_order __m2) volatile noexcept 156 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } 157 158 bool 159 compare_exchange_strong(bool& __i1, bool __i2, 160 memory_order __m = memory_order_seq_cst) noexcept 161 { return _M_base.compare_exchange_strong(__i1, __i2, __m); } 162 163 bool 164 compare_exchange_strong(bool& __i1, bool __i2, 165 memory_order __m = memory_order_seq_cst) volatile noexcept 166 { return _M_base.compare_exchange_strong(__i1, __i2, __m); } 167 }; 168 169 170 /** 171 * @brief Generic atomic type, primary class template. 172 * 173 * @tparam _Tp Type to be made atomic, must be trivally copyable. 174 */ 175 template<typename _Tp> 176 struct atomic 177 { 178 using value_type = _Tp; 179 180 private: 181 // Align 1/2/4/8/16-byte types to at least their size. 182 static constexpr int _S_min_alignment 183 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 184 ? 0 : sizeof(_Tp); 185 186 static constexpr int _S_alignment 187 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); 188 189 alignas(_S_alignment) _Tp _M_i; 190 191 static_assert(__is_trivially_copyable(_Tp), 192 "std::atomic requires a trivially copyable type"); 193 194 static_assert(sizeof(_Tp) > 0, 195 "Incomplete or zero-sized types are not supported"); 196 197 public: 198 atomic() noexcept = default; 199 ~atomic() noexcept = default; 200 atomic(const atomic&) = delete; 201 atomic& operator=(const atomic&) = delete; 202 atomic& operator=(const atomic&) volatile = delete; 203 204 constexpr atomic(_Tp __i) noexcept : _M_i(__i) { } 205 206 operator _Tp() const noexcept 207 { return load(); } 208 209 operator _Tp() const volatile noexcept 210 { return load(); } 211 212 _Tp 213 operator=(_Tp __i) noexcept 214 { store(__i); return __i; } 215 216 _Tp 217 operator=(_Tp __i) volatile noexcept 218 { store(__i); return __i; } 219 220 bool 221 is_lock_free() const noexcept 222 { 223 // Produce a fake, minimally aligned pointer. 224 return __atomic_is_lock_free(sizeof(_M_i), 225 reinterpret_cast<void *>(-_S_alignment)); 226 } 227 228 bool 229 is_lock_free() const volatile noexcept 230 { 231 // Produce a fake, minimally aligned pointer. 232 return __atomic_is_lock_free(sizeof(_M_i), 233 reinterpret_cast<void *>(-_S_alignment)); 234 } 235 236 #if __cplusplus >= 201703L 237 static constexpr bool is_always_lock_free 238 = __atomic_always_lock_free(sizeof(_M_i), 0); 239 #endif 240 241 void 242 store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept 243 { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } 244 245 void 246 store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept 247 { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } 248 249 _Tp 250 load(memory_order __m = memory_order_seq_cst) const noexcept 251 { 252 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 253 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 254 __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); 255 return *__ptr; 256 } 257 258 _Tp 259 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 260 { 261 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 262 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 263 __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); 264 return *__ptr; 265 } 266 267 _Tp 268 exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept 269 { 270 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 271 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 272 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), 273 __ptr, int(__m)); 274 return *__ptr; 275 } 276 277 _Tp 278 exchange(_Tp __i, 279 memory_order __m = memory_order_seq_cst) volatile noexcept 280 { 281 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 282 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); 283 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), 284 __ptr, int(__m)); 285 return *__ptr; 286 } 287 288 bool 289 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 290 memory_order __f) noexcept 291 { 292 return __atomic_compare_exchange(std::__addressof(_M_i), 293 std::__addressof(__e), 294 std::__addressof(__i), 295 true, int(__s), int(__f)); 296 } 297 298 bool 299 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, 300 memory_order __f) volatile noexcept 301 { 302 return __atomic_compare_exchange(std::__addressof(_M_i), 303 std::__addressof(__e), 304 std::__addressof(__i), 305 true, int(__s), int(__f)); 306 } 307 308 bool 309 compare_exchange_weak(_Tp& __e, _Tp __i, 310 memory_order __m = memory_order_seq_cst) noexcept 311 { return compare_exchange_weak(__e, __i, __m, 312 __cmpexch_failure_order(__m)); } 313 314 bool 315 compare_exchange_weak(_Tp& __e, _Tp __i, 316 memory_order __m = memory_order_seq_cst) volatile noexcept 317 { return compare_exchange_weak(__e, __i, __m, 318 __cmpexch_failure_order(__m)); } 319 320 bool 321 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 322 memory_order __f) noexcept 323 { 324 return __atomic_compare_exchange(std::__addressof(_M_i), 325 std::__addressof(__e), 326 std::__addressof(__i), 327 false, int(__s), int(__f)); 328 } 329 330 bool 331 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, 332 memory_order __f) volatile noexcept 333 { 334 return __atomic_compare_exchange(std::__addressof(_M_i), 335 std::__addressof(__e), 336 std::__addressof(__i), 337 false, int(__s), int(__f)); 338 } 339 340 bool 341 compare_exchange_strong(_Tp& __e, _Tp __i, 342 memory_order __m = memory_order_seq_cst) noexcept 343 { return compare_exchange_strong(__e, __i, __m, 344 __cmpexch_failure_order(__m)); } 345 346 bool 347 compare_exchange_strong(_Tp& __e, _Tp __i, 348 memory_order __m = memory_order_seq_cst) volatile noexcept 349 { return compare_exchange_strong(__e, __i, __m, 350 __cmpexch_failure_order(__m)); } 351 }; 352 353 354 /// Partial specialization for pointer types. 355 template<typename _Tp> 356 struct atomic<_Tp*> 357 { 358 using value_type = _Tp*; 359 using difference_type = ptrdiff_t; 360 361 typedef _Tp* __pointer_type; 362 typedef __atomic_base<_Tp*> __base_type; 363 __base_type _M_b; 364 365 atomic() noexcept = default; 366 ~atomic() noexcept = default; 367 atomic(const atomic&) = delete; 368 atomic& operator=(const atomic&) = delete; 369 atomic& operator=(const atomic&) volatile = delete; 370 371 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } 372 373 operator __pointer_type() const noexcept 374 { return __pointer_type(_M_b); } 375 376 operator __pointer_type() const volatile noexcept 377 { return __pointer_type(_M_b); } 378 379 __pointer_type 380 operator=(__pointer_type __p) noexcept 381 { return _M_b.operator=(__p); } 382 383 __pointer_type 384 operator=(__pointer_type __p) volatile noexcept 385 { return _M_b.operator=(__p); } 386 387 __pointer_type 388 operator++(int) noexcept 389 { 390 #if __cplusplus >= 201703L 391 static_assert( is_object<_Tp>::value, "pointer to object type" ); 392 #endif 393 return _M_b++; 394 } 395 396 __pointer_type 397 operator++(int) volatile noexcept 398 { 399 #if __cplusplus >= 201703L 400 static_assert( is_object<_Tp>::value, "pointer to object type" ); 401 #endif 402 return _M_b++; 403 } 404 405 __pointer_type 406 operator--(int) noexcept 407 { 408 #if __cplusplus >= 201703L 409 static_assert( is_object<_Tp>::value, "pointer to object type" ); 410 #endif 411 return _M_b--; 412 } 413 414 __pointer_type 415 operator--(int) volatile noexcept 416 { 417 #if __cplusplus >= 201703L 418 static_assert( is_object<_Tp>::value, "pointer to object type" ); 419 #endif 420 return _M_b--; 421 } 422 423 __pointer_type 424 operator++() noexcept 425 { 426 #if __cplusplus >= 201703L 427 static_assert( is_object<_Tp>::value, "pointer to object type" ); 428 #endif 429 return ++_M_b; 430 } 431 432 __pointer_type 433 operator++() volatile noexcept 434 { 435 #if __cplusplus >= 201703L 436 static_assert( is_object<_Tp>::value, "pointer to object type" ); 437 #endif 438 return ++_M_b; 439 } 440 441 __pointer_type 442 operator--() noexcept 443 { 444 #if __cplusplus >= 201703L 445 static_assert( is_object<_Tp>::value, "pointer to object type" ); 446 #endif 447 return --_M_b; 448 } 449 450 __pointer_type 451 operator--() volatile noexcept 452 { 453 #if __cplusplus >= 201703L 454 static_assert( is_object<_Tp>::value, "pointer to object type" ); 455 #endif 456 return --_M_b; 457 } 458 459 __pointer_type 460 operator+=(ptrdiff_t __d) noexcept 461 { 462 #if __cplusplus >= 201703L 463 static_assert( is_object<_Tp>::value, "pointer to object type" ); 464 #endif 465 return _M_b.operator+=(__d); 466 } 467 468 __pointer_type 469 operator+=(ptrdiff_t __d) volatile noexcept 470 { 471 #if __cplusplus >= 201703L 472 static_assert( is_object<_Tp>::value, "pointer to object type" ); 473 #endif 474 return _M_b.operator+=(__d); 475 } 476 477 __pointer_type 478 operator-=(ptrdiff_t __d) noexcept 479 { 480 #if __cplusplus >= 201703L 481 static_assert( is_object<_Tp>::value, "pointer to object type" ); 482 #endif 483 return _M_b.operator-=(__d); 484 } 485 486 __pointer_type 487 operator-=(ptrdiff_t __d) volatile noexcept 488 { 489 #if __cplusplus >= 201703L 490 static_assert( is_object<_Tp>::value, "pointer to object type" ); 491 #endif 492 return _M_b.operator-=(__d); 493 } 494 495 bool 496 is_lock_free() const noexcept 497 { return _M_b.is_lock_free(); } 498 499 bool 500 is_lock_free() const volatile noexcept 501 { return _M_b.is_lock_free(); } 502 503 #if __cplusplus >= 201703L 504 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2; 505 #endif 506 507 void 508 store(__pointer_type __p, 509 memory_order __m = memory_order_seq_cst) noexcept 510 { return _M_b.store(__p, __m); } 511 512 void 513 store(__pointer_type __p, 514 memory_order __m = memory_order_seq_cst) volatile noexcept 515 { return _M_b.store(__p, __m); } 516 517 __pointer_type 518 load(memory_order __m = memory_order_seq_cst) const noexcept 519 { return _M_b.load(__m); } 520 521 __pointer_type 522 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 523 { return _M_b.load(__m); } 524 525 __pointer_type 526 exchange(__pointer_type __p, 527 memory_order __m = memory_order_seq_cst) noexcept 528 { return _M_b.exchange(__p, __m); } 529 530 __pointer_type 531 exchange(__pointer_type __p, 532 memory_order __m = memory_order_seq_cst) volatile noexcept 533 { return _M_b.exchange(__p, __m); } 534 535 bool 536 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 537 memory_order __m1, memory_order __m2) noexcept 538 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 539 540 bool 541 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 542 memory_order __m1, 543 memory_order __m2) volatile noexcept 544 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 545 546 bool 547 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 548 memory_order __m = memory_order_seq_cst) noexcept 549 { 550 return compare_exchange_weak(__p1, __p2, __m, 551 __cmpexch_failure_order(__m)); 552 } 553 554 bool 555 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, 556 memory_order __m = memory_order_seq_cst) volatile noexcept 557 { 558 return compare_exchange_weak(__p1, __p2, __m, 559 __cmpexch_failure_order(__m)); 560 } 561 562 bool 563 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 564 memory_order __m1, memory_order __m2) noexcept 565 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 566 567 bool 568 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 569 memory_order __m1, 570 memory_order __m2) volatile noexcept 571 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } 572 573 bool 574 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 575 memory_order __m = memory_order_seq_cst) noexcept 576 { 577 return _M_b.compare_exchange_strong(__p1, __p2, __m, 578 __cmpexch_failure_order(__m)); 579 } 580 581 bool 582 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 583 memory_order __m = memory_order_seq_cst) volatile noexcept 584 { 585 return _M_b.compare_exchange_strong(__p1, __p2, __m, 586 __cmpexch_failure_order(__m)); 587 } 588 589 __pointer_type 590 fetch_add(ptrdiff_t __d, 591 memory_order __m = memory_order_seq_cst) noexcept 592 { 593 #if __cplusplus >= 201703L 594 static_assert( is_object<_Tp>::value, "pointer to object type" ); 595 #endif 596 return _M_b.fetch_add(__d, __m); 597 } 598 599 __pointer_type 600 fetch_add(ptrdiff_t __d, 601 memory_order __m = memory_order_seq_cst) volatile noexcept 602 { 603 #if __cplusplus >= 201703L 604 static_assert( is_object<_Tp>::value, "pointer to object type" ); 605 #endif 606 return _M_b.fetch_add(__d, __m); 607 } 608 609 __pointer_type 610 fetch_sub(ptrdiff_t __d, 611 memory_order __m = memory_order_seq_cst) noexcept 612 { 613 #if __cplusplus >= 201703L 614 static_assert( is_object<_Tp>::value, "pointer to object type" ); 615 #endif 616 return _M_b.fetch_sub(__d, __m); 617 } 618 619 __pointer_type 620 fetch_sub(ptrdiff_t __d, 621 memory_order __m = memory_order_seq_cst) volatile noexcept 622 { 623 #if __cplusplus >= 201703L 624 static_assert( is_object<_Tp>::value, "pointer to object type" ); 625 #endif 626 return _M_b.fetch_sub(__d, __m); 627 } 628 }; 629 630 631 /// Explicit specialization for char. 632 template<> 633 struct atomic<char> : __atomic_base<char> 634 { 635 typedef char __integral_type; 636 typedef __atomic_base<char> __base_type; 637 638 atomic() noexcept = default; 639 ~atomic() noexcept = default; 640 atomic(const atomic&) = delete; 641 atomic& operator=(const atomic&) = delete; 642 atomic& operator=(const atomic&) volatile = delete; 643 644 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 645 646 using __base_type::operator __integral_type; 647 using __base_type::operator=; 648 649 #if __cplusplus >= 201703L 650 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 651 #endif 652 }; 653 654 /// Explicit specialization for signed char. 655 template<> 656 struct atomic<signed char> : __atomic_base<signed char> 657 { 658 typedef signed char __integral_type; 659 typedef __atomic_base<signed char> __base_type; 660 661 atomic() noexcept= default; 662 ~atomic() noexcept = default; 663 atomic(const atomic&) = delete; 664 atomic& operator=(const atomic&) = delete; 665 atomic& operator=(const atomic&) volatile = delete; 666 667 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 668 669 using __base_type::operator __integral_type; 670 using __base_type::operator=; 671 672 #if __cplusplus >= 201703L 673 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 674 #endif 675 }; 676 677 /// Explicit specialization for unsigned char. 678 template<> 679 struct atomic<unsigned char> : __atomic_base<unsigned char> 680 { 681 typedef unsigned char __integral_type; 682 typedef __atomic_base<unsigned char> __base_type; 683 684 atomic() noexcept= default; 685 ~atomic() noexcept = default; 686 atomic(const atomic&) = delete; 687 atomic& operator=(const atomic&) = delete; 688 atomic& operator=(const atomic&) volatile = delete; 689 690 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 691 692 using __base_type::operator __integral_type; 693 using __base_type::operator=; 694 695 #if __cplusplus >= 201703L 696 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2; 697 #endif 698 }; 699 700 /// Explicit specialization for short. 701 template<> 702 struct atomic<short> : __atomic_base<short> 703 { 704 typedef short __integral_type; 705 typedef __atomic_base<short> __base_type; 706 707 atomic() noexcept = default; 708 ~atomic() noexcept = default; 709 atomic(const atomic&) = delete; 710 atomic& operator=(const atomic&) = delete; 711 atomic& operator=(const atomic&) volatile = delete; 712 713 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 714 715 using __base_type::operator __integral_type; 716 using __base_type::operator=; 717 718 #if __cplusplus >= 201703L 719 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; 720 #endif 721 }; 722 723 /// Explicit specialization for unsigned short. 724 template<> 725 struct atomic<unsigned short> : __atomic_base<unsigned short> 726 { 727 typedef unsigned short __integral_type; 728 typedef __atomic_base<unsigned short> __base_type; 729 730 atomic() noexcept = default; 731 ~atomic() noexcept = default; 732 atomic(const atomic&) = delete; 733 atomic& operator=(const atomic&) = delete; 734 atomic& operator=(const atomic&) volatile = delete; 735 736 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 737 738 using __base_type::operator __integral_type; 739 using __base_type::operator=; 740 741 #if __cplusplus >= 201703L 742 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2; 743 #endif 744 }; 745 746 /// Explicit specialization for int. 747 template<> 748 struct atomic<int> : __atomic_base<int> 749 { 750 typedef int __integral_type; 751 typedef __atomic_base<int> __base_type; 752 753 atomic() noexcept = default; 754 ~atomic() noexcept = default; 755 atomic(const atomic&) = delete; 756 atomic& operator=(const atomic&) = delete; 757 atomic& operator=(const atomic&) volatile = delete; 758 759 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 760 761 using __base_type::operator __integral_type; 762 using __base_type::operator=; 763 764 #if __cplusplus >= 201703L 765 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; 766 #endif 767 }; 768 769 /// Explicit specialization for unsigned int. 770 template<> 771 struct atomic<unsigned int> : __atomic_base<unsigned int> 772 { 773 typedef unsigned int __integral_type; 774 typedef __atomic_base<unsigned int> __base_type; 775 776 atomic() noexcept = default; 777 ~atomic() noexcept = default; 778 atomic(const atomic&) = delete; 779 atomic& operator=(const atomic&) = delete; 780 atomic& operator=(const atomic&) volatile = delete; 781 782 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 783 784 using __base_type::operator __integral_type; 785 using __base_type::operator=; 786 787 #if __cplusplus >= 201703L 788 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2; 789 #endif 790 }; 791 792 /// Explicit specialization for long. 793 template<> 794 struct atomic<long> : __atomic_base<long> 795 { 796 typedef long __integral_type; 797 typedef __atomic_base<long> __base_type; 798 799 atomic() noexcept = default; 800 ~atomic() noexcept = default; 801 atomic(const atomic&) = delete; 802 atomic& operator=(const atomic&) = delete; 803 atomic& operator=(const atomic&) volatile = delete; 804 805 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 806 807 using __base_type::operator __integral_type; 808 using __base_type::operator=; 809 810 #if __cplusplus >= 201703L 811 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; 812 #endif 813 }; 814 815 /// Explicit specialization for unsigned long. 816 template<> 817 struct atomic<unsigned long> : __atomic_base<unsigned long> 818 { 819 typedef unsigned long __integral_type; 820 typedef __atomic_base<unsigned long> __base_type; 821 822 atomic() noexcept = default; 823 ~atomic() noexcept = default; 824 atomic(const atomic&) = delete; 825 atomic& operator=(const atomic&) = delete; 826 atomic& operator=(const atomic&) volatile = delete; 827 828 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 829 830 using __base_type::operator __integral_type; 831 using __base_type::operator=; 832 833 #if __cplusplus >= 201703L 834 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2; 835 #endif 836 }; 837 838 /// Explicit specialization for long long. 839 template<> 840 struct atomic<long long> : __atomic_base<long long> 841 { 842 typedef long long __integral_type; 843 typedef __atomic_base<long long> __base_type; 844 845 atomic() noexcept = default; 846 ~atomic() noexcept = default; 847 atomic(const atomic&) = delete; 848 atomic& operator=(const atomic&) = delete; 849 atomic& operator=(const atomic&) volatile = delete; 850 851 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 852 853 using __base_type::operator __integral_type; 854 using __base_type::operator=; 855 856 #if __cplusplus >= 201703L 857 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; 858 #endif 859 }; 860 861 /// Explicit specialization for unsigned long long. 862 template<> 863 struct atomic<unsigned long long> : __atomic_base<unsigned long long> 864 { 865 typedef unsigned long long __integral_type; 866 typedef __atomic_base<unsigned long long> __base_type; 867 868 atomic() noexcept = default; 869 ~atomic() noexcept = default; 870 atomic(const atomic&) = delete; 871 atomic& operator=(const atomic&) = delete; 872 atomic& operator=(const atomic&) volatile = delete; 873 874 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 875 876 using __base_type::operator __integral_type; 877 using __base_type::operator=; 878 879 #if __cplusplus >= 201703L 880 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2; 881 #endif 882 }; 883 884 /// Explicit specialization for wchar_t. 885 template<> 886 struct atomic<wchar_t> : __atomic_base<wchar_t> 887 { 888 typedef wchar_t __integral_type; 889 typedef __atomic_base<wchar_t> __base_type; 890 891 atomic() noexcept = default; 892 ~atomic() noexcept = default; 893 atomic(const atomic&) = delete; 894 atomic& operator=(const atomic&) = delete; 895 atomic& operator=(const atomic&) volatile = delete; 896 897 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 898 899 using __base_type::operator __integral_type; 900 using __base_type::operator=; 901 902 #if __cplusplus >= 201703L 903 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2; 904 #endif 905 }; 906 907 #ifdef _GLIBCXX_USE_CHAR8_T 908 /// Explicit specialization for char8_t. 909 template<> 910 struct atomic<char8_t> : __atomic_base<char8_t> 911 { 912 typedef char8_t __integral_type; 913 typedef __atomic_base<char8_t> __base_type; 914 915 atomic() noexcept = default; 916 ~atomic() noexcept = default; 917 atomic(const atomic&) = delete; 918 atomic& operator=(const atomic&) = delete; 919 atomic& operator=(const atomic&) volatile = delete; 920 921 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 922 923 using __base_type::operator __integral_type; 924 using __base_type::operator=; 925 926 #if __cplusplus > 201402L 927 static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2; 928 #endif 929 }; 930 #endif 931 932 /// Explicit specialization for char16_t. 933 template<> 934 struct atomic<char16_t> : __atomic_base<char16_t> 935 { 936 typedef char16_t __integral_type; 937 typedef __atomic_base<char16_t> __base_type; 938 939 atomic() noexcept = default; 940 ~atomic() noexcept = default; 941 atomic(const atomic&) = delete; 942 atomic& operator=(const atomic&) = delete; 943 atomic& operator=(const atomic&) volatile = delete; 944 945 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 946 947 using __base_type::operator __integral_type; 948 using __base_type::operator=; 949 950 #if __cplusplus >= 201703L 951 static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2; 952 #endif 953 }; 954 955 /// Explicit specialization for char32_t. 956 template<> 957 struct atomic<char32_t> : __atomic_base<char32_t> 958 { 959 typedef char32_t __integral_type; 960 typedef __atomic_base<char32_t> __base_type; 961 962 atomic() noexcept = default; 963 ~atomic() noexcept = default; 964 atomic(const atomic&) = delete; 965 atomic& operator=(const atomic&) = delete; 966 atomic& operator=(const atomic&) volatile = delete; 967 968 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } 969 970 using __base_type::operator __integral_type; 971 using __base_type::operator=; 972 973 #if __cplusplus >= 201703L 974 static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2; 975 #endif 976 }; 977 978 979 /// atomic_bool 980 typedef atomic<bool> atomic_bool; 981 982 /// atomic_char 983 typedef atomic<char> atomic_char; 984 985 /// atomic_schar 986 typedef atomic<signed char> atomic_schar; 987 988 /// atomic_uchar 989 typedef atomic<unsigned char> atomic_uchar; 990 991 /// atomic_short 992 typedef atomic<short> atomic_short; 993 994 /// atomic_ushort 995 typedef atomic<unsigned short> atomic_ushort; 996 997 /// atomic_int 998 typedef atomic<int> atomic_int; 999 1000 /// atomic_uint 1001 typedef atomic<unsigned int> atomic_uint; 1002 1003 /// atomic_long 1004 typedef atomic<long> atomic_long; 1005 1006 /// atomic_ulong 1007 typedef atomic<unsigned long> atomic_ulong; 1008 1009 /// atomic_llong 1010 typedef atomic<long long> atomic_llong; 1011 1012 /// atomic_ullong 1013 typedef atomic<unsigned long long> atomic_ullong; 1014 1015 /// atomic_wchar_t 1016 typedef atomic<wchar_t> atomic_wchar_t; 1017 1018 #ifdef _GLIBCXX_USE_CHAR8_T 1019 /// atomic_char8_t 1020 typedef atomic<char8_t> atomic_char8_t; 1021 #endif 1022 1023 /// atomic_char16_t 1024 typedef atomic<char16_t> atomic_char16_t; 1025 1026 /// atomic_char32_t 1027 typedef atomic<char32_t> atomic_char32_t; 1028 1029 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 1030 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1031 // 2441. Exact-width atomic typedefs should be provided 1032 1033 /// atomic_int8_t 1034 typedef atomic<int8_t> atomic_int8_t; 1035 1036 /// atomic_uint8_t 1037 typedef atomic<uint8_t> atomic_uint8_t; 1038 1039 /// atomic_int16_t 1040 typedef atomic<int16_t> atomic_int16_t; 1041 1042 /// atomic_uint16_t 1043 typedef atomic<uint16_t> atomic_uint16_t; 1044 1045 /// atomic_int32_t 1046 typedef atomic<int32_t> atomic_int32_t; 1047 1048 /// atomic_uint32_t 1049 typedef atomic<uint32_t> atomic_uint32_t; 1050 1051 /// atomic_int64_t 1052 typedef atomic<int64_t> atomic_int64_t; 1053 1054 /// atomic_uint64_t 1055 typedef atomic<uint64_t> atomic_uint64_t; 1056 1057 1058 /// atomic_int_least8_t 1059 typedef atomic<int_least8_t> atomic_int_least8_t; 1060 1061 /// atomic_uint_least8_t 1062 typedef atomic<uint_least8_t> atomic_uint_least8_t; 1063 1064 /// atomic_int_least16_t 1065 typedef atomic<int_least16_t> atomic_int_least16_t; 1066 1067 /// atomic_uint_least16_t 1068 typedef atomic<uint_least16_t> atomic_uint_least16_t; 1069 1070 /// atomic_int_least32_t 1071 typedef atomic<int_least32_t> atomic_int_least32_t; 1072 1073 /// atomic_uint_least32_t 1074 typedef atomic<uint_least32_t> atomic_uint_least32_t; 1075 1076 /// atomic_int_least64_t 1077 typedef atomic<int_least64_t> atomic_int_least64_t; 1078 1079 /// atomic_uint_least64_t 1080 typedef atomic<uint_least64_t> atomic_uint_least64_t; 1081 1082 1083 /// atomic_int_fast8_t 1084 typedef atomic<int_fast8_t> atomic_int_fast8_t; 1085 1086 /// atomic_uint_fast8_t 1087 typedef atomic<uint_fast8_t> atomic_uint_fast8_t; 1088 1089 /// atomic_int_fast16_t 1090 typedef atomic<int_fast16_t> atomic_int_fast16_t; 1091 1092 /// atomic_uint_fast16_t 1093 typedef atomic<uint_fast16_t> atomic_uint_fast16_t; 1094 1095 /// atomic_int_fast32_t 1096 typedef atomic<int_fast32_t> atomic_int_fast32_t; 1097 1098 /// atomic_uint_fast32_t 1099 typedef atomic<uint_fast32_t> atomic_uint_fast32_t; 1100 1101 /// atomic_int_fast64_t 1102 typedef atomic<int_fast64_t> atomic_int_fast64_t; 1103 1104 /// atomic_uint_fast64_t 1105 typedef atomic<uint_fast64_t> atomic_uint_fast64_t; 1106 #endif 1107 1108 1109 /// atomic_intptr_t 1110 typedef atomic<intptr_t> atomic_intptr_t; 1111 1112 /// atomic_uintptr_t 1113 typedef atomic<uintptr_t> atomic_uintptr_t; 1114 1115 /// atomic_size_t 1116 typedef atomic<size_t> atomic_size_t; 1117 1118 /// atomic_ptrdiff_t 1119 typedef atomic<ptrdiff_t> atomic_ptrdiff_t; 1120 1121 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 1122 /// atomic_intmax_t 1123 typedef atomic<intmax_t> atomic_intmax_t; 1124 1125 /// atomic_uintmax_t 1126 typedef atomic<uintmax_t> atomic_uintmax_t; 1127 #endif 1128 1129 // Function definitions, atomic_flag operations. 1130 inline bool 1131 atomic_flag_test_and_set_explicit(atomic_flag* __a, 1132 memory_order __m) noexcept 1133 { return __a->test_and_set(__m); } 1134 1135 inline bool 1136 atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, 1137 memory_order __m) noexcept 1138 { return __a->test_and_set(__m); } 1139 1140 inline void 1141 atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept 1142 { __a->clear(__m); } 1143 1144 inline void 1145 atomic_flag_clear_explicit(volatile atomic_flag* __a, 1146 memory_order __m) noexcept 1147 { __a->clear(__m); } 1148 1149 inline bool 1150 atomic_flag_test_and_set(atomic_flag* __a) noexcept 1151 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } 1152 1153 inline bool 1154 atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept 1155 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } 1156 1157 inline void 1158 atomic_flag_clear(atomic_flag* __a) noexcept 1159 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } 1160 1161 inline void 1162 atomic_flag_clear(volatile atomic_flag* __a) noexcept 1163 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } 1164 1165 1166 template<typename _Tp> 1167 using __atomic_val_t = typename atomic<_Tp>::value_type; 1168 template<typename _Tp> 1169 using __atomic_diff_t = typename atomic<_Tp>::difference_type; 1170 1171 // [atomics.nonmembers] Non-member functions. 1172 // Function templates generally applicable to atomic types. 1173 template<typename _ITp> 1174 inline bool 1175 atomic_is_lock_free(const atomic<_ITp>* __a) noexcept 1176 { return __a->is_lock_free(); } 1177 1178 template<typename _ITp> 1179 inline bool 1180 atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept 1181 { return __a->is_lock_free(); } 1182 1183 template<typename _ITp> 1184 inline void 1185 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1186 { __a->store(__i, memory_order_relaxed); } 1187 1188 template<typename _ITp> 1189 inline void 1190 atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1191 { __a->store(__i, memory_order_relaxed); } 1192 1193 template<typename _ITp> 1194 inline void 1195 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1196 memory_order __m) noexcept 1197 { __a->store(__i, __m); } 1198 1199 template<typename _ITp> 1200 inline void 1201 atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1202 memory_order __m) noexcept 1203 { __a->store(__i, __m); } 1204 1205 template<typename _ITp> 1206 inline _ITp 1207 atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept 1208 { return __a->load(__m); } 1209 1210 template<typename _ITp> 1211 inline _ITp 1212 atomic_load_explicit(const volatile atomic<_ITp>* __a, 1213 memory_order __m) noexcept 1214 { return __a->load(__m); } 1215 1216 template<typename _ITp> 1217 inline _ITp 1218 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, 1219 memory_order __m) noexcept 1220 { return __a->exchange(__i, __m); } 1221 1222 template<typename _ITp> 1223 inline _ITp 1224 atomic_exchange_explicit(volatile atomic<_ITp>* __a, 1225 __atomic_val_t<_ITp> __i, 1226 memory_order __m) noexcept 1227 { return __a->exchange(__i, __m); } 1228 1229 template<typename _ITp> 1230 inline bool 1231 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, 1232 __atomic_val_t<_ITp>* __i1, 1233 __atomic_val_t<_ITp> __i2, 1234 memory_order __m1, 1235 memory_order __m2) noexcept 1236 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } 1237 1238 template<typename _ITp> 1239 inline bool 1240 atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, 1241 __atomic_val_t<_ITp>* __i1, 1242 __atomic_val_t<_ITp> __i2, 1243 memory_order __m1, 1244 memory_order __m2) noexcept 1245 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } 1246 1247 template<typename _ITp> 1248 inline bool 1249 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, 1250 __atomic_val_t<_ITp>* __i1, 1251 __atomic_val_t<_ITp> __i2, 1252 memory_order __m1, 1253 memory_order __m2) noexcept 1254 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } 1255 1256 template<typename _ITp> 1257 inline bool 1258 atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, 1259 __atomic_val_t<_ITp>* __i1, 1260 __atomic_val_t<_ITp> __i2, 1261 memory_order __m1, 1262 memory_order __m2) noexcept 1263 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } 1264 1265 1266 template<typename _ITp> 1267 inline void 1268 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1269 { atomic_store_explicit(__a, __i, memory_order_seq_cst); } 1270 1271 template<typename _ITp> 1272 inline void 1273 atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1274 { atomic_store_explicit(__a, __i, memory_order_seq_cst); } 1275 1276 template<typename _ITp> 1277 inline _ITp 1278 atomic_load(const atomic<_ITp>* __a) noexcept 1279 { return atomic_load_explicit(__a, memory_order_seq_cst); } 1280 1281 template<typename _ITp> 1282 inline _ITp 1283 atomic_load(const volatile atomic<_ITp>* __a) noexcept 1284 { return atomic_load_explicit(__a, memory_order_seq_cst); } 1285 1286 template<typename _ITp> 1287 inline _ITp 1288 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept 1289 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } 1290 1291 template<typename _ITp> 1292 inline _ITp 1293 atomic_exchange(volatile atomic<_ITp>* __a, 1294 __atomic_val_t<_ITp> __i) noexcept 1295 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } 1296 1297 template<typename _ITp> 1298 inline bool 1299 atomic_compare_exchange_weak(atomic<_ITp>* __a, 1300 __atomic_val_t<_ITp>* __i1, 1301 __atomic_val_t<_ITp> __i2) noexcept 1302 { 1303 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, 1304 memory_order_seq_cst, 1305 memory_order_seq_cst); 1306 } 1307 1308 template<typename _ITp> 1309 inline bool 1310 atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, 1311 __atomic_val_t<_ITp>* __i1, 1312 __atomic_val_t<_ITp> __i2) noexcept 1313 { 1314 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, 1315 memory_order_seq_cst, 1316 memory_order_seq_cst); 1317 } 1318 1319 template<typename _ITp> 1320 inline bool 1321 atomic_compare_exchange_strong(atomic<_ITp>* __a, 1322 __atomic_val_t<_ITp>* __i1, 1323 __atomic_val_t<_ITp> __i2) noexcept 1324 { 1325 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, 1326 memory_order_seq_cst, 1327 memory_order_seq_cst); 1328 } 1329 1330 template<typename _ITp> 1331 inline bool 1332 atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, 1333 __atomic_val_t<_ITp>* __i1, 1334 __atomic_val_t<_ITp> __i2) noexcept 1335 { 1336 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, 1337 memory_order_seq_cst, 1338 memory_order_seq_cst); 1339 } 1340 1341 // Function templates for atomic_integral and atomic_pointer operations only. 1342 // Some operations (and, or, xor) are only available for atomic integrals, 1343 // which is implemented by taking a parameter of type __atomic_base<_ITp>*. 1344 1345 template<typename _ITp> 1346 inline _ITp 1347 atomic_fetch_add_explicit(atomic<_ITp>* __a, 1348 __atomic_diff_t<_ITp> __i, 1349 memory_order __m) noexcept 1350 { return __a->fetch_add(__i, __m); } 1351 1352 template<typename _ITp> 1353 inline _ITp 1354 atomic_fetch_add_explicit(volatile atomic<_ITp>* __a, 1355 __atomic_diff_t<_ITp> __i, 1356 memory_order __m) noexcept 1357 { return __a->fetch_add(__i, __m); } 1358 1359 template<typename _ITp> 1360 inline _ITp 1361 atomic_fetch_sub_explicit(atomic<_ITp>* __a, 1362 __atomic_diff_t<_ITp> __i, 1363 memory_order __m) noexcept 1364 { return __a->fetch_sub(__i, __m); } 1365 1366 template<typename _ITp> 1367 inline _ITp 1368 atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a, 1369 __atomic_diff_t<_ITp> __i, 1370 memory_order __m) noexcept 1371 { return __a->fetch_sub(__i, __m); } 1372 1373 template<typename _ITp> 1374 inline _ITp 1375 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, 1376 __atomic_val_t<_ITp> __i, 1377 memory_order __m) noexcept 1378 { return __a->fetch_and(__i, __m); } 1379 1380 template<typename _ITp> 1381 inline _ITp 1382 atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, 1383 __atomic_val_t<_ITp> __i, 1384 memory_order __m) noexcept 1385 { return __a->fetch_and(__i, __m); } 1386 1387 template<typename _ITp> 1388 inline _ITp 1389 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, 1390 __atomic_val_t<_ITp> __i, 1391 memory_order __m) noexcept 1392 { return __a->fetch_or(__i, __m); } 1393 1394 template<typename _ITp> 1395 inline _ITp 1396 atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, 1397 __atomic_val_t<_ITp> __i, 1398 memory_order __m) noexcept 1399 { return __a->fetch_or(__i, __m); } 1400 1401 template<typename _ITp> 1402 inline _ITp 1403 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, 1404 __atomic_val_t<_ITp> __i, 1405 memory_order __m) noexcept 1406 { return __a->fetch_xor(__i, __m); } 1407 1408 template<typename _ITp> 1409 inline _ITp 1410 atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, 1411 __atomic_val_t<_ITp> __i, 1412 memory_order __m) noexcept 1413 { return __a->fetch_xor(__i, __m); } 1414 1415 template<typename _ITp> 1416 inline _ITp 1417 atomic_fetch_add(atomic<_ITp>* __a, 1418 __atomic_diff_t<_ITp> __i) noexcept 1419 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } 1420 1421 template<typename _ITp> 1422 inline _ITp 1423 atomic_fetch_add(volatile atomic<_ITp>* __a, 1424 __atomic_diff_t<_ITp> __i) noexcept 1425 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } 1426 1427 template<typename _ITp> 1428 inline _ITp 1429 atomic_fetch_sub(atomic<_ITp>* __a, 1430 __atomic_diff_t<_ITp> __i) noexcept 1431 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } 1432 1433 template<typename _ITp> 1434 inline _ITp 1435 atomic_fetch_sub(volatile atomic<_ITp>* __a, 1436 __atomic_diff_t<_ITp> __i) noexcept 1437 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } 1438 1439 template<typename _ITp> 1440 inline _ITp 1441 atomic_fetch_and(__atomic_base<_ITp>* __a, 1442 __atomic_val_t<_ITp> __i) noexcept 1443 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } 1444 1445 template<typename _ITp> 1446 inline _ITp 1447 atomic_fetch_and(volatile __atomic_base<_ITp>* __a, 1448 __atomic_val_t<_ITp> __i) noexcept 1449 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } 1450 1451 template<typename _ITp> 1452 inline _ITp 1453 atomic_fetch_or(__atomic_base<_ITp>* __a, 1454 __atomic_val_t<_ITp> __i) noexcept 1455 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } 1456 1457 template<typename _ITp> 1458 inline _ITp 1459 atomic_fetch_or(volatile __atomic_base<_ITp>* __a, 1460 __atomic_val_t<_ITp> __i) noexcept 1461 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } 1462 1463 template<typename _ITp> 1464 inline _ITp 1465 atomic_fetch_xor(__atomic_base<_ITp>* __a, 1466 __atomic_val_t<_ITp> __i) noexcept 1467 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } 1468 1469 template<typename _ITp> 1470 inline _ITp 1471 atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, 1472 __atomic_val_t<_ITp> __i) noexcept 1473 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } 1474 1475 /// @} group atomics 1476 1477 _GLIBCXX_END_NAMESPACE_VERSION 1478 } // namespace 1479 1480 #endif // C++11 1481 1482 #endif // _GLIBCXX_ATOMIC 1483