1// -*- C++ -*- header.
2
3// Copyright (C) 2008-2021 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
43namespace std _GLIBCXX_VISIBILITY(default)
44{
45_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47 /**
48 * @addtogroup atomics
49 * @{
50 */
51
52#if __cplusplus >= 201703L
53# define __cpp_lib_atomic_is_always_lock_free 201603
54#endif
55
56 template<typename _Tp>
57 struct atomic;
58
59 /// atomic<bool>
60 // NB: No operators or fetch-operations for this type.
61 template<>
62 struct atomic<bool>
63 {
64 using value_type = bool;
65
66 private:
67 __atomic_base<bool> _M_base;
68
69 public:
70 atomic() noexcept = default;
71 ~atomic() noexcept = default;
72 atomic(const atomic&) = delete;
73 atomic& operator=(const atomic&) = delete;
74 atomic& operator=(const atomic&) volatile = delete;
75
76 constexpr atomic(bool __i) noexcept : _M_base(__i) { }
77
78 bool
79 operator=(bool __i) noexcept
80 { return _M_base.operator=(__i); }
81
82 bool
83 operator=(bool __i) volatile noexcept
84 { return _M_base.operator=(__i); }
85
86 operator bool() const noexcept
87 { return _M_base.load(); }
88
89 operator bool() const volatile noexcept
90 { return _M_base.load(); }
91
92 bool
93 is_lock_free() const noexcept { return _M_base.is_lock_free(); }
94
95 bool
96 is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
97
98#if __cplusplus >= 201703L
99 static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2;
100#endif
101
102 void
103 store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
104 { _M_base.store(__i, __m); }
105
106 void
107 store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
108 { _M_base.store(__i, __m); }
109
110 bool
111 load(memory_order __m = memory_order_seq_cst) const noexcept
112 { return _M_base.load(__m); }
113
114 bool
115 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
116 { return _M_base.load(__m); }
117
118 bool
119 exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
120 { return _M_base.exchange(__i, __m); }
121
122 bool
123 exchange(bool __i,
124 memory_order __m = memory_order_seq_cst) volatile noexcept
125 { return _M_base.exchange(__i, __m); }
126
127 bool
128 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
129 memory_order __m2) noexcept
130 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
131
132 bool
133 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
134 memory_order __m2) volatile noexcept
135 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
136
137 bool
138 compare_exchange_weak(bool& __i1, bool __i2,
139 memory_order __m = memory_order_seq_cst) noexcept
140 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
141
142 bool
143 compare_exchange_weak(bool& __i1, bool __i2,
144 memory_order __m = memory_order_seq_cst) volatile noexcept
145 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
146
147 bool
148 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
149 memory_order __m2) noexcept
150 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
151
152 bool
153 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
154 memory_order __m2) volatile noexcept
155 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
156
157 bool
158 compare_exchange_strong(bool& __i1, bool __i2,
159 memory_order __m = memory_order_seq_cst) noexcept
160 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
161
162 bool
163 compare_exchange_strong(bool& __i1, bool __i2,
164 memory_order __m = memory_order_seq_cst) volatile noexcept
165 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
166
167#if __cpp_lib_atomic_wait
168 void
169 wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept
170 { _M_base.wait(__old, __m); }
171
172 // TODO add const volatile overload
173
174 void
175 notify_one() noexcept
176 { _M_base.notify_one(); }
177
178 void
179 notify_all() noexcept
180 { _M_base.notify_all(); }
181#endif // __cpp_lib_atomic_wait
182 };
183
184#if __cplusplus <= 201703L
185# define _GLIBCXX20_INIT(I)
186#else
187# define _GLIBCXX20_INIT(I) = I
188#endif
189
190 /**
191 * @brief Generic atomic type, primary class template.
192 *
193 * @tparam _Tp Type to be made atomic, must be trivially copyable.
194 */
195 template<typename _Tp>
196 struct atomic
197 {
198 using value_type = _Tp;
199
200 private:
201 // Align 1/2/4/8/16-byte types to at least their size.
202 static constexpr int _S_min_alignment
203 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
204 ? 0 : sizeof(_Tp);
205
206 static constexpr int _S_alignment
207 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
208
209 alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
210
211 static_assert(__is_trivially_copyable(_Tp),
212 "std::atomic requires a trivially copyable type");
213
214 static_assert(sizeof(_Tp) > 0,
215 "Incomplete or zero-sized types are not supported");
216
217#if __cplusplus > 201703L
218 static_assert(is_copy_constructible_v<_Tp>);
219 static_assert(is_move_constructible_v<_Tp>);
220 static_assert(is_copy_assignable_v<_Tp>);
221 static_assert(is_move_assignable_v<_Tp>);
222#endif
223
224 public:
225 atomic() = default;
226 ~atomic() noexcept = default;
227 atomic(const atomic&) = delete;
228 atomic& operator=(const atomic&) = delete;
229 atomic& operator=(const atomic&) volatile = delete;
230
231 constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
232
233 operator _Tp() const noexcept
234 { return load(); }
235
236 operator _Tp() const volatile noexcept
237 { return load(); }
238
239 _Tp
240 operator=(_Tp __i) noexcept
241 { store(__i); return __i; }
242
243 _Tp
244 operator=(_Tp __i) volatile noexcept
245 { store(__i); return __i; }
246
247 bool
248 is_lock_free() const noexcept
249 {
250 // Produce a fake, minimally aligned pointer.
251 return __atomic_is_lock_free(sizeof(_M_i),
252 reinterpret_cast<void *>(-_S_alignment));
253 }
254
255 bool
256 is_lock_free() const volatile noexcept
257 {
258 // Produce a fake, minimally aligned pointer.
259 return __atomic_is_lock_free(sizeof(_M_i),
260 reinterpret_cast<void *>(-_S_alignment));
261 }
262
263#if __cplusplus >= 201703L
264 static constexpr bool is_always_lock_free
265 = __atomic_always_lock_free(sizeof(_M_i), 0);
266#endif
267
268 void
269 store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
270 {
271 __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m));
272 }
273
274 void
275 store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
276 {
277 __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m));
278 }
279
280 _Tp
281 load(memory_order __m = memory_order_seq_cst) const noexcept
282 {
283 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
284 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
285 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
286 return *__ptr;
287 }
288
289 _Tp
290 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
291 {
292 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
293 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
294 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
295 return *__ptr;
296 }
297
298 _Tp
299 exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
300 {
301 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
302 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
303 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
304 __ptr, int(__m));
305 return *__ptr;
306 }
307
308 _Tp
309 exchange(_Tp __i,
310 memory_order __m = memory_order_seq_cst) volatile noexcept
311 {
312 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
313 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
314 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
315 __ptr, int(__m));
316 return *__ptr;
317 }
318
319 bool
320 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
321 memory_order __f) noexcept
322 {
323 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
324
325 return __atomic_compare_exchange(std::__addressof(_M_i),
326 std::__addressof(__e),
327 std::__addressof(__i),
328 true, int(__s), int(__f));
329 }
330
331 bool
332 compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
333 memory_order __f) volatile noexcept
334 {
335 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
336
337 return __atomic_compare_exchange(std::__addressof(_M_i),
338 std::__addressof(__e),
339 std::__addressof(__i),
340 true, int(__s), int(__f));
341 }
342
343 bool
344 compare_exchange_weak(_Tp& __e, _Tp __i,
345 memory_order __m = memory_order_seq_cst) noexcept
346 { return compare_exchange_weak(__e, __i, __m,
347 __cmpexch_failure_order(__m)); }
348
349 bool
350 compare_exchange_weak(_Tp& __e, _Tp __i,
351 memory_order __m = memory_order_seq_cst) volatile noexcept
352 { return compare_exchange_weak(__e, __i, __m,
353 __cmpexch_failure_order(__m)); }
354
355 bool
356 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
357 memory_order __f) noexcept
358 {
359 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
360
361 return __atomic_compare_exchange(std::__addressof(_M_i),
362 std::__addressof(__e),
363 std::__addressof(__i),
364 false, int(__s), int(__f));
365 }
366
367 bool
368 compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
369 memory_order __f) volatile noexcept
370 {
371 __glibcxx_assert(__is_valid_cmpexch_failure_order(__f));
372
373 return __atomic_compare_exchange(std::__addressof(_M_i),
374 std::__addressof(__e),
375 std::__addressof(__i),
376 false, int(__s), int(__f));
377 }
378
379 bool
380 compare_exchange_strong(_Tp& __e, _Tp __i,
381 memory_order __m = memory_order_seq_cst) noexcept
382 { return compare_exchange_strong(__e, __i, __m,
383 __cmpexch_failure_order(__m)); }
384
385 bool
386 compare_exchange_strong(_Tp& __e, _Tp __i,
387 memory_order __m = memory_order_seq_cst) volatile noexcept
388 { return compare_exchange_strong(__e, __i, __m,
389 __cmpexch_failure_order(__m)); }
390
391#if __cpp_lib_atomic_wait
392 void
393 wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
394 {
395 std::__atomic_wait_address_v(&_M_i, __old,
396 [__m, this] { return this->load(__m); });
397 }
398
399 // TODO add const volatile overload
400
401 void
402 notify_one() noexcept
403 { std::__atomic_notify_address(&_M_i, false); }
404
405 void
406 notify_all() noexcept
407 { std::__atomic_notify_address(&_M_i, true); }
408#endif // __cpp_lib_atomic_wait
409
410 };
411#undef _GLIBCXX20_INIT
412
413 /// Partial specialization for pointer types.
414 template<typename _Tp>
415 struct atomic<_Tp*>
416 {
417 using value_type = _Tp*;
418 using difference_type = ptrdiff_t;
419
420 typedef _Tp* __pointer_type;
421 typedef __atomic_base<_Tp*> __base_type;
422 __base_type _M_b;
423
424 atomic() noexcept = default;
425 ~atomic() noexcept = default;
426 atomic(const atomic&) = delete;
427 atomic& operator=(const atomic&) = delete;
428 atomic& operator=(const atomic&) volatile = delete;
429
430 constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
431
432 operator __pointer_type() const noexcept
433 { return __pointer_type(_M_b); }
434
435 operator __pointer_type() const volatile noexcept
436 { return __pointer_type(_M_b); }
437
438 __pointer_type
439 operator=(__pointer_type __p) noexcept
440 { return _M_b.operator=(__p); }
441
442 __pointer_type
443 operator=(__pointer_type __p) volatile noexcept
444 { return _M_b.operator=(__p); }
445
446 __pointer_type
447 operator++(int) noexcept
448 {
449#if __cplusplus >= 201703L
450 static_assert( is_object<_Tp>::value, "pointer to object type" );
451#endif
452 return _M_b++;
453 }
454
455 __pointer_type
456 operator++(int) volatile noexcept
457 {
458#if __cplusplus >= 201703L
459 static_assert( is_object<_Tp>::value, "pointer to object type" );
460#endif
461 return _M_b++;
462 }
463
464 __pointer_type
465 operator--(int) noexcept
466 {
467#if __cplusplus >= 201703L
468 static_assert( is_object<_Tp>::value, "pointer to object type" );
469#endif
470 return _M_b--;
471 }
472
473 __pointer_type
474 operator--(int) volatile noexcept
475 {
476#if __cplusplus >= 201703L
477 static_assert( is_object<_Tp>::value, "pointer to object type" );
478#endif
479 return _M_b--;
480 }
481
482 __pointer_type
483 operator++() noexcept
484 {
485#if __cplusplus >= 201703L
486 static_assert( is_object<_Tp>::value, "pointer to object type" );
487#endif
488 return ++_M_b;
489 }
490
491 __pointer_type
492 operator++() volatile noexcept
493 {
494#if __cplusplus >= 201703L
495 static_assert( is_object<_Tp>::value, "pointer to object type" );
496#endif
497 return ++_M_b;
498 }
499
500 __pointer_type
501 operator--() noexcept
502 {
503#if __cplusplus >= 201703L
504 static_assert( is_object<_Tp>::value, "pointer to object type" );
505#endif
506 return --_M_b;
507 }
508
509 __pointer_type
510 operator--() volatile noexcept
511 {
512#if __cplusplus >= 201703L
513 static_assert( is_object<_Tp>::value, "pointer to object type" );
514#endif
515 return --_M_b;
516 }
517
518 __pointer_type
519 operator+=(ptrdiff_t __d) noexcept
520 {
521#if __cplusplus >= 201703L
522 static_assert( is_object<_Tp>::value, "pointer to object type" );
523#endif
524 return _M_b.operator+=(__d);
525 }
526
527 __pointer_type
528 operator+=(ptrdiff_t __d) volatile noexcept
529 {
530#if __cplusplus >= 201703L
531 static_assert( is_object<_Tp>::value, "pointer to object type" );
532#endif
533 return _M_b.operator+=(__d);
534 }
535
536 __pointer_type
537 operator-=(ptrdiff_t __d) noexcept
538 {
539#if __cplusplus >= 201703L
540 static_assert( is_object<_Tp>::value, "pointer to object type" );
541#endif
542 return _M_b.operator-=(__d);
543 }
544
545 __pointer_type
546 operator-=(ptrdiff_t __d) volatile noexcept
547 {
548#if __cplusplus >= 201703L
549 static_assert( is_object<_Tp>::value, "pointer to object type" );
550#endif
551 return _M_b.operator-=(__d);
552 }
553
554 bool
555 is_lock_free() const noexcept
556 { return _M_b.is_lock_free(); }
557
558 bool
559 is_lock_free() const volatile noexcept
560 { return _M_b.is_lock_free(); }
561
562#if __cplusplus >= 201703L
563 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
564#endif
565
566 void
567 store(__pointer_type __p,
568 memory_order __m = memory_order_seq_cst) noexcept
569 { return _M_b.store(__p, __m); }
570
571 void
572 store(__pointer_type __p,
573 memory_order __m = memory_order_seq_cst) volatile noexcept
574 { return _M_b.store(__p, __m); }
575
576 __pointer_type
577 load(memory_order __m = memory_order_seq_cst) const noexcept
578 { return _M_b.load(__m); }
579
580 __pointer_type
581 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
582 { return _M_b.load(__m); }
583
584 __pointer_type
585 exchange(__pointer_type __p,
586 memory_order __m = memory_order_seq_cst) noexcept
587 { return _M_b.exchange(__p, __m); }
588
589 __pointer_type
590 exchange(__pointer_type __p,
591 memory_order __m = memory_order_seq_cst) volatile noexcept
592 { return _M_b.exchange(__p, __m); }
593
594 bool
595 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
596 memory_order __m1, memory_order __m2) noexcept
597 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
598
599 bool
600 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
601 memory_order __m1,
602 memory_order __m2) volatile noexcept
603 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
604
605 bool
606 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
607 memory_order __m = memory_order_seq_cst) noexcept
608 {
609 return compare_exchange_weak(__p1, __p2, __m,
610 __cmpexch_failure_order(__m));
611 }
612
613 bool
614 compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
615 memory_order __m = memory_order_seq_cst) volatile noexcept
616 {
617 return compare_exchange_weak(__p1, __p2, __m,
618 __cmpexch_failure_order(__m));
619 }
620
621 bool
622 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
623 memory_order __m1, memory_order __m2) noexcept
624 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
625
626 bool
627 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
628 memory_order __m1,
629 memory_order __m2) volatile noexcept
630 { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
631
632 bool
633 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
634 memory_order __m = memory_order_seq_cst) noexcept
635 {
636 return _M_b.compare_exchange_strong(__p1, __p2, __m,
637 __cmpexch_failure_order(__m));
638 }
639
640 bool
641 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
642 memory_order __m = memory_order_seq_cst) volatile noexcept
643 {
644 return _M_b.compare_exchange_strong(__p1, __p2, __m,
645 __cmpexch_failure_order(__m));
646 }
647
648#if __cpp_lib_atomic_wait
649 void
650 wait(__pointer_type __old, memory_order __m = memory_order_seq_cst) const noexcept
651 { _M_b.wait(__old, __m); }
652
653 // TODO add const volatile overload
654
655 void
656 notify_one() noexcept
657 { _M_b.notify_one(); }
658
659 void
660 notify_all() noexcept
661 { _M_b.notify_all(); }
662#endif // __cpp_lib_atomic_wait
663 __pointer_type
664 fetch_add(ptrdiff_t __d,
665 memory_order __m = memory_order_seq_cst) noexcept
666 {
667#if __cplusplus >= 201703L
668 static_assert( is_object<_Tp>::value, "pointer to object type" );
669#endif
670 return _M_b.fetch_add(__d, __m);
671 }
672
673 __pointer_type
674 fetch_add(ptrdiff_t __d,
675 memory_order __m = memory_order_seq_cst) volatile noexcept
676 {
677#if __cplusplus >= 201703L
678 static_assert( is_object<_Tp>::value, "pointer to object type" );
679#endif
680 return _M_b.fetch_add(__d, __m);
681 }
682
683 __pointer_type
684 fetch_sub(ptrdiff_t __d,
685 memory_order __m = memory_order_seq_cst) noexcept
686 {
687#if __cplusplus >= 201703L
688 static_assert( is_object<_Tp>::value, "pointer to object type" );
689#endif
690 return _M_b.fetch_sub(__d, __m);
691 }
692
693 __pointer_type
694 fetch_sub(ptrdiff_t __d,
695 memory_order __m = memory_order_seq_cst) volatile noexcept
696 {
697#if __cplusplus >= 201703L
698 static_assert( is_object<_Tp>::value, "pointer to object type" );
699#endif
700 return _M_b.fetch_sub(__d, __m);
701 }
702 };
703
704
705 /// Explicit specialization for char.
706 template<>
707 struct atomic<char> : __atomic_base<char>
708 {
709 typedef char __integral_type;
710 typedef __atomic_base<char> __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 >= 201703L
724 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
725#endif
726 };
727
728 /// Explicit specialization for signed char.
729 template<>
730 struct atomic<signed char> : __atomic_base<signed char>
731 {
732 typedef signed char __integral_type;
733 typedef __atomic_base<signed char> __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 >= 201703L
747 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
748#endif
749 };
750
751 /// Explicit specialization for unsigned char.
752 template<>
753 struct atomic<unsigned char> : __atomic_base<unsigned char>
754 {
755 typedef unsigned char __integral_type;
756 typedef __atomic_base<unsigned char> __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 >= 201703L
770 static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
771#endif
772 };
773
774 /// Explicit specialization for short.
775 template<>
776 struct atomic<short> : __atomic_base<short>
777 {
778 typedef short __integral_type;
779 typedef __atomic_base<short> __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 >= 201703L
793 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
794#endif
795 };
796
797 /// Explicit specialization for unsigned short.
798 template<>
799 struct atomic<unsigned short> : __atomic_base<unsigned short>
800 {
801 typedef unsigned short __integral_type;
802 typedef __atomic_base<unsigned short> __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 >= 201703L
816 static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
817#endif
818 };
819
820 /// Explicit specialization for int.
821 template<>
822 struct atomic<int> : __atomic_base<int>
823 {
824 typedef int __integral_type;
825 typedef __atomic_base<int> __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 >= 201703L
839 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
840#endif
841 };
842
843 /// Explicit specialization for unsigned int.
844 template<>
845 struct atomic<unsigned int> : __atomic_base<unsigned int>
846 {
847 typedef unsigned int __integral_type;
848 typedef __atomic_base<unsigned int> __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 >= 201703L
862 static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
863#endif
864 };
865
866 /// Explicit specialization for long.
867 template<>
868 struct atomic<long> : __atomic_base<long>
869 {
870 typedef long __integral_type;
871 typedef __atomic_base<long> __base_type;
872
873 atomic() noexcept = default;
874 ~atomic() noexcept = default;
875 atomic(const atomic&) = delete;
876 atomic& operator=(const atomic&) = delete;
877 atomic& operator=(const atomic&) volatile = delete;
878
879 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
880
881 using __base_type::operator __integral_type;
882 using __base_type::operator=;
883
884#if __cplusplus >= 201703L
885 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
886#endif
887 };
888
889 /// Explicit specialization for unsigned long.
890 template<>
891 struct atomic<unsigned long> : __atomic_base<unsigned long>
892 {
893 typedef unsigned long __integral_type;
894 typedef __atomic_base<unsigned long> __base_type;
895
896 atomic() noexcept = default;
897 ~atomic() noexcept = default;
898 atomic(const atomic&) = delete;
899 atomic& operator=(const atomic&) = delete;
900 atomic& operator=(const atomic&) volatile = delete;
901
902 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
903
904 using __base_type::operator __integral_type;
905 using __base_type::operator=;
906
907#if __cplusplus >= 201703L
908 static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
909#endif
910 };
911
912 /// Explicit specialization for long long.
913 template<>
914 struct atomic<long long> : __atomic_base<long long>
915 {
916 typedef long long __integral_type;
917 typedef __atomic_base<long long> __base_type;
918
919 atomic() noexcept = default;
920 ~atomic() noexcept = default;
921 atomic(const atomic&) = delete;
922 atomic& operator=(const atomic&) = delete;
923 atomic& operator=(const atomic&) volatile = delete;
924
925 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
926
927 using __base_type::operator __integral_type;
928 using __base_type::operator=;
929
930#if __cplusplus >= 201703L
931 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
932#endif
933 };
934
935 /// Explicit specialization for unsigned long long.
936 template<>
937 struct atomic<unsigned long long> : __atomic_base<unsigned long long>
938 {
939 typedef unsigned long long __integral_type;
940 typedef __atomic_base<unsigned long long> __base_type;
941
942 atomic() noexcept = default;
943 ~atomic() noexcept = default;
944 atomic(const atomic&) = delete;
945 atomic& operator=(const atomic&) = delete;
946 atomic& operator=(const atomic&) volatile = delete;
947
948 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
949
950 using __base_type::operator __integral_type;
951 using __base_type::operator=;
952
953#if __cplusplus >= 201703L
954 static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
955#endif
956 };
957
958 /// Explicit specialization for wchar_t.
959 template<>
960 struct atomic<wchar_t> : __atomic_base<wchar_t>
961 {
962 typedef wchar_t __integral_type;
963 typedef __atomic_base<wchar_t> __base_type;
964
965 atomic() noexcept = default;
966 ~atomic() noexcept = default;
967 atomic(const atomic&) = delete;
968 atomic& operator=(const atomic&) = delete;
969 atomic& operator=(const atomic&) volatile = delete;
970
971 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
972
973 using __base_type::operator __integral_type;
974 using __base_type::operator=;
975
976#if __cplusplus >= 201703L
977 static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
978#endif
979 };
980
981#ifdef _GLIBCXX_USE_CHAR8_T
982 /// Explicit specialization for char8_t.
983 template<>
984 struct atomic<char8_t> : __atomic_base<char8_t>
985 {
986 typedef char8_t __integral_type;
987 typedef __atomic_base<char8_t> __base_type;
988
989 atomic() noexcept = default;
990 ~atomic() noexcept = default;
991 atomic(const atomic&) = delete;
992 atomic& operator=(const atomic&) = delete;
993 atomic& operator=(const atomic&) volatile = delete;
994
995 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
996
997 using __base_type::operator __integral_type;
998 using __base_type::operator=;
999
1000#if __cplusplus > 201402L
1001 static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
1002#endif
1003 };
1004#endif
1005
1006 /// Explicit specialization for char16_t.
1007 template<>
1008 struct atomic<char16_t> : __atomic_base<char16_t>
1009 {
1010 typedef char16_t __integral_type;
1011 typedef __atomic_base<char16_t> __base_type;
1012
1013 atomic() noexcept = default;
1014 ~atomic() noexcept = default;
1015 atomic(const atomic&) = delete;
1016 atomic& operator=(const atomic&) = delete;
1017 atomic& operator=(const atomic&) volatile = delete;
1018
1019 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1020
1021 using __base_type::operator __integral_type;
1022 using __base_type::operator=;
1023
1024#if __cplusplus >= 201703L
1025 static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
1026#endif
1027 };
1028
1029 /// Explicit specialization for char32_t.
1030 template<>
1031 struct atomic<char32_t> : __atomic_base<char32_t>
1032 {
1033 typedef char32_t __integral_type;
1034 typedef __atomic_base<char32_t> __base_type;
1035
1036 atomic() noexcept = default;
1037 ~atomic() noexcept = default;
1038 atomic(const atomic&) = delete;
1039 atomic& operator=(const atomic&) = delete;
1040 atomic& operator=(const atomic&) volatile = delete;
1041
1042 constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
1043
1044 using __base_type::operator __integral_type;
1045 using __base_type::operator=;
1046
1047#if __cplusplus >= 201703L
1048 static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
1049#endif
1050 };
1051
1052
1053 /// atomic_bool
1054 typedef atomic<bool> atomic_bool;
1055
1056 /// atomic_char
1057 typedef atomic<char> atomic_char;
1058
1059 /// atomic_schar
1060 typedef atomic<signed char> atomic_schar;
1061
1062 /// atomic_uchar
1063 typedef atomic<unsigned char> atomic_uchar;
1064
1065 /// atomic_short
1066 typedef atomic<short> atomic_short;
1067
1068 /// atomic_ushort
1069 typedef atomic<unsigned short> atomic_ushort;
1070
1071 /// atomic_int
1072 typedef atomic<int> atomic_int;
1073
1074 /// atomic_uint
1075 typedef atomic<unsigned int> atomic_uint;
1076
1077 /// atomic_long
1078 typedef atomic<long> atomic_long;
1079
1080 /// atomic_ulong
1081 typedef atomic<unsigned long> atomic_ulong;
1082
1083 /// atomic_llong
1084 typedef atomic<long long> atomic_llong;
1085
1086 /// atomic_ullong
1087 typedef atomic<unsigned long long> atomic_ullong;
1088
1089 /// atomic_wchar_t
1090 typedef atomic<wchar_t> atomic_wchar_t;
1091
1092#ifdef _GLIBCXX_USE_CHAR8_T
1093 /// atomic_char8_t
1094 typedef atomic<char8_t> atomic_char8_t;
1095#endif
1096
1097 /// atomic_char16_t
1098 typedef atomic<char16_t> atomic_char16_t;
1099
1100 /// atomic_char32_t
1101 typedef atomic<char32_t> atomic_char32_t;
1102
1103#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1104 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1105 // 2441. Exact-width atomic typedefs should be provided
1106
1107 /// atomic_int8_t
1108 typedef atomic<int8_t> atomic_int8_t;
1109
1110 /// atomic_uint8_t
1111 typedef atomic<uint8_t> atomic_uint8_t;
1112
1113 /// atomic_int16_t
1114 typedef atomic<int16_t> atomic_int16_t;
1115
1116 /// atomic_uint16_t
1117 typedef atomic<uint16_t> atomic_uint16_t;
1118
1119 /// atomic_int32_t
1120 typedef atomic<int32_t> atomic_int32_t;
1121
1122 /// atomic_uint32_t
1123 typedef atomic<uint32_t> atomic_uint32_t;
1124
1125 /// atomic_int64_t
1126 typedef atomic<int64_t> atomic_int64_t;
1127
1128 /// atomic_uint64_t
1129 typedef atomic<uint64_t> atomic_uint64_t;
1130
1131
1132 /// atomic_int_least8_t
1133 typedef atomic<int_least8_t> atomic_int_least8_t;
1134
1135 /// atomic_uint_least8_t
1136 typedef atomic<uint_least8_t> atomic_uint_least8_t;
1137
1138 /// atomic_int_least16_t
1139 typedef atomic<int_least16_t> atomic_int_least16_t;
1140
1141 /// atomic_uint_least16_t
1142 typedef atomic<uint_least16_t> atomic_uint_least16_t;
1143
1144 /// atomic_int_least32_t
1145 typedef atomic<int_least32_t> atomic_int_least32_t;
1146
1147 /// atomic_uint_least32_t
1148 typedef atomic<uint_least32_t> atomic_uint_least32_t;
1149
1150 /// atomic_int_least64_t
1151 typedef atomic<int_least64_t> atomic_int_least64_t;
1152
1153 /// atomic_uint_least64_t
1154 typedef atomic<uint_least64_t> atomic_uint_least64_t;
1155
1156
1157 /// atomic_int_fast8_t
1158 typedef atomic<int_fast8_t> atomic_int_fast8_t;
1159
1160 /// atomic_uint_fast8_t
1161 typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
1162
1163 /// atomic_int_fast16_t
1164 typedef atomic<int_fast16_t> atomic_int_fast16_t;
1165
1166 /// atomic_uint_fast16_t
1167 typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
1168
1169 /// atomic_int_fast32_t
1170 typedef atomic<int_fast32_t> atomic_int_fast32_t;
1171
1172 /// atomic_uint_fast32_t
1173 typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
1174
1175 /// atomic_int_fast64_t
1176 typedef atomic<int_fast64_t> atomic_int_fast64_t;
1177
1178 /// atomic_uint_fast64_t
1179 typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
1180#endif
1181
1182
1183 /// atomic_intptr_t
1184 typedef atomic<intptr_t> atomic_intptr_t;
1185
1186 /// atomic_uintptr_t
1187 typedef atomic<uintptr_t> atomic_uintptr_t;
1188
1189 /// atomic_size_t
1190 typedef atomic<size_t> atomic_size_t;
1191
1192 /// atomic_ptrdiff_t
1193 typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
1194
1195#ifdef _GLIBCXX_USE_C99_STDINT_TR1
1196 /// atomic_intmax_t
1197 typedef atomic<intmax_t> atomic_intmax_t;
1198
1199 /// atomic_uintmax_t
1200 typedef atomic<uintmax_t> atomic_uintmax_t;
1201#endif
1202
1203 // Function definitions, atomic_flag operations.
1204 inline bool
1205 atomic_flag_test_and_set_explicit(atomic_flag* __a,
1206 memory_order __m) noexcept
1207 { return __a->test_and_set(__m); }
1208
1209 inline bool
1210 atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
1211 memory_order __m) noexcept
1212 { return __a->test_and_set(__m); }
1213
1214#if __cpp_lib_atomic_flag_test
1215 inline bool
1216 atomic_flag_test(const atomic_flag* __a) noexcept
1217 { return __a->test(); }
1218
1219 inline bool
1220 atomic_flag_test(const volatile atomic_flag* __a) noexcept
1221 { return __a->test(); }
1222
1223 inline bool
1224 atomic_flag_test_explicit(const atomic_flag* __a,
1225 memory_order __m) noexcept
1226 { return __a->test(__m); }
1227
1228 inline bool
1229 atomic_flag_test_explicit(const volatile atomic_flag* __a,
1230 memory_order __m) noexcept
1231 { return __a->test(__m); }
1232#endif
1233
1234 inline void
1235 atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
1236 { __a->clear(__m); }
1237
1238 inline void
1239 atomic_flag_clear_explicit(volatile atomic_flag* __a,
1240 memory_order __m) noexcept
1241 { __a->clear(__m); }
1242
1243 inline bool
1244 atomic_flag_test_and_set(atomic_flag* __a) noexcept
1245 { return atomic_flag_test_and_set_explicit(__a, m: memory_order_seq_cst); }
1246
1247 inline bool
1248 atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
1249 { return atomic_flag_test_and_set_explicit(__a, m: memory_order_seq_cst); }
1250
1251 inline void
1252 atomic_flag_clear(atomic_flag* __a) noexcept
1253 { atomic_flag_clear_explicit(__a, m: memory_order_seq_cst); }
1254
1255 inline void
1256 atomic_flag_clear(volatile atomic_flag* __a) noexcept
1257 { atomic_flag_clear_explicit(__a, m: memory_order_seq_cst); }
1258
1259#if __cpp_lib_atomic_wait
1260 inline void
1261 atomic_flag_wait(atomic_flag* __a, bool __old) noexcept
1262 { __a->wait(__old); }
1263
1264 inline void
1265 atomic_flag_wait_explicit(atomic_flag* __a, bool __old,
1266 memory_order __m) noexcept
1267 { __a->wait(__old, __m); }
1268
1269 inline void
1270 atomic_flag_notify_one(atomic_flag* __a) noexcept
1271 { __a->notify_one(); }
1272
1273 inline void
1274 atomic_flag_notify_all(atomic_flag* __a) noexcept
1275 { __a->notify_all(); }
1276#endif // __cpp_lib_atomic_wait
1277
1278 /// @cond undocumented
1279 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1280 // 3220. P0558 broke conforming C++14 uses of atomic shared_ptr
1281 template<typename _Tp>
1282 using __atomic_val_t = __type_identity_t<_Tp>;
1283 template<typename _Tp>
1284 using __atomic_diff_t = typename atomic<_Tp>::difference_type;
1285 /// @endcond
1286
1287 // [atomics.nonmembers] Non-member functions.
1288 // Function templates generally applicable to atomic types.
1289 template<typename _ITp>
1290 inline bool
1291 atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
1292 { return __a->is_lock_free(); }
1293
1294 template<typename _ITp>
1295 inline bool
1296 atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
1297 { return __a->is_lock_free(); }
1298
1299 template<typename _ITp>
1300 inline void
1301 atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1302 { __a->store(__i, memory_order_relaxed); }
1303
1304 template<typename _ITp>
1305 inline void
1306 atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1307 { __a->store(__i, memory_order_relaxed); }
1308
1309 template<typename _ITp>
1310 inline void
1311 atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1312 memory_order __m) noexcept
1313 { __a->store(__i, __m); }
1314
1315 template<typename _ITp>
1316 inline void
1317 atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1318 memory_order __m) noexcept
1319 { __a->store(__i, __m); }
1320
1321 template<typename _ITp>
1322 inline _ITp
1323 atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
1324 { return __a->load(__m); }
1325
1326 template<typename _ITp>
1327 inline _ITp
1328 atomic_load_explicit(const volatile atomic<_ITp>* __a,
1329 memory_order __m) noexcept
1330 { return __a->load(__m); }
1331
1332 template<typename _ITp>
1333 inline _ITp
1334 atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1335 memory_order __m) noexcept
1336 { return __a->exchange(__i, __m); }
1337
1338 template<typename _ITp>
1339 inline _ITp
1340 atomic_exchange_explicit(volatile atomic<_ITp>* __a,
1341 __atomic_val_t<_ITp> __i,
1342 memory_order __m) noexcept
1343 { return __a->exchange(__i, __m); }
1344
1345 template<typename _ITp>
1346 inline bool
1347 atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1348 __atomic_val_t<_ITp>* __i1,
1349 __atomic_val_t<_ITp> __i2,
1350 memory_order __m1,
1351 memory_order __m2) noexcept
1352 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1353
1354 template<typename _ITp>
1355 inline bool
1356 atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
1357 __atomic_val_t<_ITp>* __i1,
1358 __atomic_val_t<_ITp> __i2,
1359 memory_order __m1,
1360 memory_order __m2) noexcept
1361 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1362
1363 template<typename _ITp>
1364 inline bool
1365 atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1366 __atomic_val_t<_ITp>* __i1,
1367 __atomic_val_t<_ITp> __i2,
1368 memory_order __m1,
1369 memory_order __m2) noexcept
1370 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1371
1372 template<typename _ITp>
1373 inline bool
1374 atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
1375 __atomic_val_t<_ITp>* __i1,
1376 __atomic_val_t<_ITp> __i2,
1377 memory_order __m1,
1378 memory_order __m2) noexcept
1379 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1380
1381
1382 template<typename _ITp>
1383 inline void
1384 atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1385 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1386
1387 template<typename _ITp>
1388 inline void
1389 atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1390 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1391
1392 template<typename _ITp>
1393 inline _ITp
1394 atomic_load(const atomic<_ITp>* __a) noexcept
1395 { return atomic_load_explicit(__a, memory_order_seq_cst); }
1396
1397 template<typename _ITp>
1398 inline _ITp
1399 atomic_load(const volatile atomic<_ITp>* __a) noexcept
1400 { return atomic_load_explicit(__a, memory_order_seq_cst); }
1401
1402 template<typename _ITp>
1403 inline _ITp
1404 atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1405 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1406
1407 template<typename _ITp>
1408 inline _ITp
1409 atomic_exchange(volatile atomic<_ITp>* __a,
1410 __atomic_val_t<_ITp> __i) noexcept
1411 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1412
1413 template<typename _ITp>
1414 inline bool
1415 atomic_compare_exchange_weak(atomic<_ITp>* __a,
1416 __atomic_val_t<_ITp>* __i1,
1417 __atomic_val_t<_ITp> __i2) noexcept
1418 {
1419 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1420 memory_order_seq_cst,
1421 memory_order_seq_cst);
1422 }
1423
1424 template<typename _ITp>
1425 inline bool
1426 atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
1427 __atomic_val_t<_ITp>* __i1,
1428 __atomic_val_t<_ITp> __i2) noexcept
1429 {
1430 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1431 memory_order_seq_cst,
1432 memory_order_seq_cst);
1433 }
1434
1435 template<typename _ITp>
1436 inline bool
1437 atomic_compare_exchange_strong(atomic<_ITp>* __a,
1438 __atomic_val_t<_ITp>* __i1,
1439 __atomic_val_t<_ITp> __i2) noexcept
1440 {
1441 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1442 memory_order_seq_cst,
1443 memory_order_seq_cst);
1444 }
1445
1446 template<typename _ITp>
1447 inline bool
1448 atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
1449 __atomic_val_t<_ITp>* __i1,
1450 __atomic_val_t<_ITp> __i2) noexcept
1451 {
1452 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1453 memory_order_seq_cst,
1454 memory_order_seq_cst);
1455 }
1456
1457
1458#if __cpp_lib_atomic_wait
1459 template<typename _Tp>
1460 inline void
1461 atomic_wait(const atomic<_Tp>* __a,
1462 typename std::atomic<_Tp>::value_type __old) noexcept
1463 { __a->wait(__old); }
1464
1465 template<typename _Tp>
1466 inline void
1467 atomic_wait_explicit(const atomic<_Tp>* __a,
1468 typename std::atomic<_Tp>::value_type __old,
1469 std::memory_order __m) noexcept
1470 { __a->wait(__old, __m); }
1471
1472 template<typename _Tp>
1473 inline void
1474 atomic_notify_one(atomic<_Tp>* __a) noexcept
1475 { __a->notify_one(); }
1476
1477 template<typename _Tp>
1478 inline void
1479 atomic_notify_all(atomic<_Tp>* __a) noexcept
1480 { __a->notify_all(); }
1481#endif // __cpp_lib_atomic_wait
1482
1483 // Function templates for atomic_integral and atomic_pointer operations only.
1484 // Some operations (and, or, xor) are only available for atomic integrals,
1485 // which is implemented by taking a parameter of type __atomic_base<_ITp>*.
1486
1487 template<typename _ITp>
1488 inline _ITp
1489 atomic_fetch_add_explicit(atomic<_ITp>* __a,
1490 __atomic_diff_t<_ITp> __i,
1491 memory_order __m) noexcept
1492 { return __a->fetch_add(__i, __m); }
1493
1494 template<typename _ITp>
1495 inline _ITp
1496 atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
1497 __atomic_diff_t<_ITp> __i,
1498 memory_order __m) noexcept
1499 { return __a->fetch_add(__i, __m); }
1500
1501 template<typename _ITp>
1502 inline _ITp
1503 atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1504 __atomic_diff_t<_ITp> __i,
1505 memory_order __m) noexcept
1506 { return __a->fetch_sub(__i, __m); }
1507
1508 template<typename _ITp>
1509 inline _ITp
1510 atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
1511 __atomic_diff_t<_ITp> __i,
1512 memory_order __m) noexcept
1513 { return __a->fetch_sub(__i, __m); }
1514
1515 template<typename _ITp>
1516 inline _ITp
1517 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1518 __atomic_val_t<_ITp> __i,
1519 memory_order __m) noexcept
1520 { return __a->fetch_and(__i, __m); }
1521
1522 template<typename _ITp>
1523 inline _ITp
1524 atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
1525 __atomic_val_t<_ITp> __i,
1526 memory_order __m) noexcept
1527 { return __a->fetch_and(__i, __m); }
1528
1529 template<typename _ITp>
1530 inline _ITp
1531 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1532 __atomic_val_t<_ITp> __i,
1533 memory_order __m) noexcept
1534 { return __a->fetch_or(__i, __m); }
1535
1536 template<typename _ITp>
1537 inline _ITp
1538 atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
1539 __atomic_val_t<_ITp> __i,
1540 memory_order __m) noexcept
1541 { return __a->fetch_or(__i, __m); }
1542
1543 template<typename _ITp>
1544 inline _ITp
1545 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1546 __atomic_val_t<_ITp> __i,
1547 memory_order __m) noexcept
1548 { return __a->fetch_xor(__i, __m); }
1549
1550 template<typename _ITp>
1551 inline _ITp
1552 atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
1553 __atomic_val_t<_ITp> __i,
1554 memory_order __m) noexcept
1555 { return __a->fetch_xor(__i, __m); }
1556
1557 template<typename _ITp>
1558 inline _ITp
1559 atomic_fetch_add(atomic<_ITp>* __a,
1560 __atomic_diff_t<_ITp> __i) noexcept
1561 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1562
1563 template<typename _ITp>
1564 inline _ITp
1565 atomic_fetch_add(volatile atomic<_ITp>* __a,
1566 __atomic_diff_t<_ITp> __i) noexcept
1567 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1568
1569 template<typename _ITp>
1570 inline _ITp
1571 atomic_fetch_sub(atomic<_ITp>* __a,
1572 __atomic_diff_t<_ITp> __i) noexcept
1573 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1574
1575 template<typename _ITp>
1576 inline _ITp
1577 atomic_fetch_sub(volatile atomic<_ITp>* __a,
1578 __atomic_diff_t<_ITp> __i) noexcept
1579 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1580
1581 template<typename _ITp>
1582 inline _ITp
1583 atomic_fetch_and(__atomic_base<_ITp>* __a,
1584 __atomic_val_t<_ITp> __i) noexcept
1585 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1586
1587 template<typename _ITp>
1588 inline _ITp
1589 atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
1590 __atomic_val_t<_ITp> __i) noexcept
1591 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1592
1593 template<typename _ITp>
1594 inline _ITp
1595 atomic_fetch_or(__atomic_base<_ITp>* __a,
1596 __atomic_val_t<_ITp> __i) noexcept
1597 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1598
1599 template<typename _ITp>
1600 inline _ITp
1601 atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
1602 __atomic_val_t<_ITp> __i) noexcept
1603 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1604
1605 template<typename _ITp>
1606 inline _ITp
1607 atomic_fetch_xor(__atomic_base<_ITp>* __a,
1608 __atomic_val_t<_ITp> __i) noexcept
1609 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1610
1611 template<typename _ITp>
1612 inline _ITp
1613 atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
1614 __atomic_val_t<_ITp> __i) noexcept
1615 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1616
1617#if __cplusplus > 201703L
1618#define __cpp_lib_atomic_float 201711L
1619 template<>
1620 struct atomic<float> : __atomic_float<float>
1621 {
1622 atomic() noexcept = default;
1623
1624 constexpr
1625 atomic(float __fp) noexcept : __atomic_float<float>(__fp)
1626 { }
1627
1628 atomic& operator=(const atomic&) volatile = delete;
1629 atomic& operator=(const atomic&) = delete;
1630
1631 using __atomic_float<float>::operator=;
1632 };
1633
1634 template<>
1635 struct atomic<double> : __atomic_float<double>
1636 {
1637 atomic() noexcept = default;
1638
1639 constexpr
1640 atomic(double __fp) noexcept : __atomic_float<double>(__fp)
1641 { }
1642
1643 atomic& operator=(const atomic&) volatile = delete;
1644 atomic& operator=(const atomic&) = delete;
1645
1646 using __atomic_float<double>::operator=;
1647 };
1648
1649 template<>
1650 struct atomic<long double> : __atomic_float<long double>
1651 {
1652 atomic() noexcept = default;
1653
1654 constexpr
1655 atomic(long double __fp) noexcept : __atomic_float<long double>(__fp)
1656 { }
1657
1658 atomic& operator=(const atomic&) volatile = delete;
1659 atomic& operator=(const atomic&) = delete;
1660
1661 using __atomic_float<long double>::operator=;
1662 };
1663
1664#define __cpp_lib_atomic_ref 201806L
1665
1666 /// Class template to provide atomic operations on a non-atomic variable.
1667 template<typename _Tp>
1668 struct atomic_ref : __atomic_ref<_Tp>
1669 {
1670 explicit
1671 atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1672 { }
1673
1674 atomic_ref& operator=(const atomic_ref&) = delete;
1675
1676 atomic_ref(const atomic_ref&) = default;
1677
1678 using __atomic_ref<_Tp>::operator=;
1679 };
1680
1681#endif // C++2a
1682
1683 /// @} group atomics
1684
1685_GLIBCXX_END_NAMESPACE_VERSION
1686} // namespace
1687
1688#endif // C++11
1689
1690#endif // _GLIBCXX_ATOMIC
1691

source code of include/c++/11/atomic