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