libstdc++
atomic
Go to the documentation of this file.
1 // -*- C++ -*- header.
2 
3 // Copyright (C) 2008-2020 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 
43 namespace 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 
168 #if __cplusplus <= 201703L
169 # define _GLIBCXX20_INIT(I)
170 #else
171 # define _GLIBCXX20_INIT(I) = I
172 #endif
173 
174  /**
175  * @brief Generic atomic type, primary class template.
176  *
177  * @tparam _Tp Type to be made atomic, must be trivially copyable.
178  */
179  template<typename _Tp>
180  struct atomic
181  {
182  using value_type = _Tp;
183 
184  private:
185  // Align 1/2/4/8/16-byte types to at least their size.
186  static constexpr int _S_min_alignment
187  = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
188  ? 0 : sizeof(_Tp);
189 
190  static constexpr int _S_alignment
191  = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
192 
193  alignas(_S_alignment) _Tp _M_i _GLIBCXX20_INIT(_Tp());
194 
195  static_assert(__is_trivially_copyable(_Tp),
196  "std::atomic requires a trivially copyable type");
197 
198  static_assert(sizeof(_Tp) > 0,
199  "Incomplete or zero-sized types are not supported");
200 
201  public:
202  atomic() = default;
203  ~atomic() noexcept = default;
204  atomic(const atomic&) = delete;
205  atomic& operator=(const atomic&) = delete;
206  atomic& operator=(const atomic&) volatile = delete;
207 
208  constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
209 
210  operator _Tp() const noexcept
211  { return load(); }
212 
213  operator _Tp() const volatile noexcept
214  { return load(); }
215 
216  _Tp
217  operator=(_Tp __i) noexcept
218  { store(__i); return __i; }
219 
220  _Tp
221  operator=(_Tp __i) volatile noexcept
222  { store(__i); return __i; }
223 
224  bool
225  is_lock_free() const noexcept
226  {
227  // Produce a fake, minimally aligned pointer.
228  return __atomic_is_lock_free(sizeof(_M_i),
229  reinterpret_cast<void *>(-_S_alignment));
230  }
231 
232  bool
233  is_lock_free() const volatile noexcept
234  {
235  // Produce a fake, minimally aligned pointer.
236  return __atomic_is_lock_free(sizeof(_M_i),
237  reinterpret_cast<void *>(-_S_alignment));
238  }
239 
240 #if __cplusplus >= 201703L
241  static constexpr bool is_always_lock_free
242  = __atomic_always_lock_free(sizeof(_M_i), 0);
243 #endif
244 
245  void
246  store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
247  { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
248 
249  void
250  store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
251  { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
252 
253  _Tp
254  load(memory_order __m = memory_order_seq_cst) const noexcept
255  {
256  alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
257  _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
258  __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
259  return *__ptr;
260  }
261 
262  _Tp
263  load(memory_order __m = memory_order_seq_cst) const volatile noexcept
264  {
265  alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
266  _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
267  __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
268  return *__ptr;
269  }
270 
271  _Tp
272  exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
273  {
274  alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
275  _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
276  __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
277  __ptr, int(__m));
278  return *__ptr;
279  }
280 
281  _Tp
282  exchange(_Tp __i,
283  memory_order __m = memory_order_seq_cst) volatile noexcept
284  {
285  alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
286  _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
287  __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
288  __ptr, int(__m));
289  return *__ptr;
290  }
291 
292  bool
293  compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
294  memory_order __f) noexcept
295  {
296  return __atomic_compare_exchange(std::__addressof(_M_i),
297  std::__addressof(__e),
298  std::__addressof(__i),
299  true, int(__s), int(__f));
300  }
301 
302  bool
303  compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
304  memory_order __f) volatile noexcept
305  {
306  return __atomic_compare_exchange(std::__addressof(_M_i),
307  std::__addressof(__e),
308  std::__addressof(__i),
309  true, int(__s), int(__f));
310  }
311 
312  bool
313  compare_exchange_weak(_Tp& __e, _Tp __i,
314  memory_order __m = memory_order_seq_cst) noexcept
315  { return compare_exchange_weak(__e, __i, __m,
316  __cmpexch_failure_order(__m)); }
317 
318  bool
319  compare_exchange_weak(_Tp& __e, _Tp __i,
320  memory_order __m = memory_order_seq_cst) volatile noexcept
321  { return compare_exchange_weak(__e, __i, __m,
322  __cmpexch_failure_order(__m)); }
323 
324  bool
325  compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
326  memory_order __f) noexcept
327  {
328  return __atomic_compare_exchange(std::__addressof(_M_i),
329  std::__addressof(__e),
330  std::__addressof(__i),
331  false, int(__s), int(__f));
332  }
333 
334  bool
335  compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
336  memory_order __f) volatile noexcept
337  {
338  return __atomic_compare_exchange(std::__addressof(_M_i),
339  std::__addressof(__e),
340  std::__addressof(__i),
341  false, int(__s), int(__f));
342  }
343 
344  bool
345  compare_exchange_strong(_Tp& __e, _Tp __i,
346  memory_order __m = memory_order_seq_cst) noexcept
347  { return compare_exchange_strong(__e, __i, __m,
348  __cmpexch_failure_order(__m)); }
349 
350  bool
351  compare_exchange_strong(_Tp& __e, _Tp __i,
352  memory_order __m = memory_order_seq_cst) volatile noexcept
353  { return compare_exchange_strong(__e, __i, __m,
354  __cmpexch_failure_order(__m)); }
355  };
356 #undef _GLIBCXX20_INIT
357 
358  /// Partial specialization for pointer types.
359  template<typename _Tp>
360  struct atomic<_Tp*>
361  {
362  using value_type = _Tp*;
363  using difference_type = ptrdiff_t;
364 
365  typedef _Tp* __pointer_type;
367  __base_type _M_b;
368 
369  atomic() noexcept = default;
370  ~atomic() noexcept = default;
371  atomic(const atomic&) = delete;
372  atomic& operator=(const atomic&) = delete;
373  atomic& operator=(const atomic&) volatile = delete;
374 
375  constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
376 
377  operator __pointer_type() const noexcept
378  { return __pointer_type(_M_b); }
379 
380  operator __pointer_type() const volatile noexcept
381  { return __pointer_type(_M_b); }
382 
383  __pointer_type
384  operator=(__pointer_type __p) noexcept
385  { return _M_b.operator=(__p); }
386 
387  __pointer_type
388  operator=(__pointer_type __p) volatile noexcept
389  { return _M_b.operator=(__p); }
390 
391  __pointer_type
392  operator++(int) noexcept
393  {
394 #if __cplusplus >= 201703L
395  static_assert( is_object<_Tp>::value, "pointer to object type" );
396 #endif
397  return _M_b++;
398  }
399 
400  __pointer_type
401  operator++(int) volatile noexcept
402  {
403 #if __cplusplus >= 201703L
404  static_assert( is_object<_Tp>::value, "pointer to object type" );
405 #endif
406  return _M_b++;
407  }
408 
409  __pointer_type
410  operator--(int) noexcept
411  {
412 #if __cplusplus >= 201703L
413  static_assert( is_object<_Tp>::value, "pointer to object type" );
414 #endif
415  return _M_b--;
416  }
417 
418  __pointer_type
419  operator--(int) volatile noexcept
420  {
421 #if __cplusplus >= 201703L
422  static_assert( is_object<_Tp>::value, "pointer to object type" );
423 #endif
424  return _M_b--;
425  }
426 
427  __pointer_type
428  operator++() noexcept
429  {
430 #if __cplusplus >= 201703L
431  static_assert( is_object<_Tp>::value, "pointer to object type" );
432 #endif
433  return ++_M_b;
434  }
435 
436  __pointer_type
437  operator++() volatile noexcept
438  {
439 #if __cplusplus >= 201703L
440  static_assert( is_object<_Tp>::value, "pointer to object type" );
441 #endif
442  return ++_M_b;
443  }
444 
445  __pointer_type
446  operator--() noexcept
447  {
448 #if __cplusplus >= 201703L
449  static_assert( is_object<_Tp>::value, "pointer to object type" );
450 #endif
451  return --_M_b;
452  }
453 
454  __pointer_type
455  operator--() volatile noexcept
456  {
457 #if __cplusplus >= 201703L
458  static_assert( is_object<_Tp>::value, "pointer to object type" );
459 #endif
460  return --_M_b;
461  }
462 
463  __pointer_type
464  operator+=(ptrdiff_t __d) noexcept
465  {
466 #if __cplusplus >= 201703L
467  static_assert( is_object<_Tp>::value, "pointer to object type" );
468 #endif
469  return _M_b.operator+=(__d);
470  }
471 
472  __pointer_type
473  operator+=(ptrdiff_t __d) volatile noexcept
474  {
475 #if __cplusplus >= 201703L
476  static_assert( is_object<_Tp>::value, "pointer to object type" );
477 #endif
478  return _M_b.operator+=(__d);
479  }
480 
481  __pointer_type
482  operator-=(ptrdiff_t __d) noexcept
483  {
484 #if __cplusplus >= 201703L
485  static_assert( is_object<_Tp>::value, "pointer to object type" );
486 #endif
487  return _M_b.operator-=(__d);
488  }
489 
490  __pointer_type
491  operator-=(ptrdiff_t __d) volatile noexcept
492  {
493 #if __cplusplus >= 201703L
494  static_assert( is_object<_Tp>::value, "pointer to object type" );
495 #endif
496  return _M_b.operator-=(__d);
497  }
498 
499  bool
500  is_lock_free() const noexcept
501  { return _M_b.is_lock_free(); }
502 
503  bool
504  is_lock_free() const volatile noexcept
505  { return _M_b.is_lock_free(); }
506 
507 #if __cplusplus >= 201703L
508  static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
509 #endif
510 
511  void
512  store(__pointer_type __p,
513  memory_order __m = memory_order_seq_cst) noexcept
514  { return _M_b.store(__p, __m); }
515 
516  void
517  store(__pointer_type __p,
518  memory_order __m = memory_order_seq_cst) volatile noexcept
519  { return _M_b.store(__p, __m); }
520 
521  __pointer_type
522  load(memory_order __m = memory_order_seq_cst) const noexcept
523  { return _M_b.load(__m); }
524 
525  __pointer_type
526  load(memory_order __m = memory_order_seq_cst) const volatile noexcept
527  { return _M_b.load(__m); }
528 
529  __pointer_type
530  exchange(__pointer_type __p,
531  memory_order __m = memory_order_seq_cst) noexcept
532  { return _M_b.exchange(__p, __m); }
533 
534  __pointer_type
535  exchange(__pointer_type __p,
536  memory_order __m = memory_order_seq_cst) volatile noexcept
537  { return _M_b.exchange(__p, __m); }
538 
539  bool
540  compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
541  memory_order __m1, memory_order __m2) noexcept
542  { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
543 
544  bool
545  compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
546  memory_order __m1,
547  memory_order __m2) volatile noexcept
548  { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
549 
550  bool
551  compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
552  memory_order __m = memory_order_seq_cst) noexcept
553  {
554  return compare_exchange_weak(__p1, __p2, __m,
555  __cmpexch_failure_order(__m));
556  }
557 
558  bool
559  compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
560  memory_order __m = memory_order_seq_cst) volatile noexcept
561  {
562  return compare_exchange_weak(__p1, __p2, __m,
563  __cmpexch_failure_order(__m));
564  }
565 
566  bool
567  compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
568  memory_order __m1, memory_order __m2) noexcept
569  { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
570 
571  bool
572  compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
573  memory_order __m1,
574  memory_order __m2) volatile noexcept
575  { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
576 
577  bool
578  compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
579  memory_order __m = memory_order_seq_cst) noexcept
580  {
581  return _M_b.compare_exchange_strong(__p1, __p2, __m,
582  __cmpexch_failure_order(__m));
583  }
584 
585  bool
586  compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
587  memory_order __m = memory_order_seq_cst) volatile noexcept
588  {
589  return _M_b.compare_exchange_strong(__p1, __p2, __m,
590  __cmpexch_failure_order(__m));
591  }
592 
593  __pointer_type
594  fetch_add(ptrdiff_t __d,
595  memory_order __m = memory_order_seq_cst) noexcept
596  {
597 #if __cplusplus >= 201703L
598  static_assert( is_object<_Tp>::value, "pointer to object type" );
599 #endif
600  return _M_b.fetch_add(__d, __m);
601  }
602 
603  __pointer_type
604  fetch_add(ptrdiff_t __d,
605  memory_order __m = memory_order_seq_cst) volatile noexcept
606  {
607 #if __cplusplus >= 201703L
608  static_assert( is_object<_Tp>::value, "pointer to object type" );
609 #endif
610  return _M_b.fetch_add(__d, __m);
611  }
612 
613  __pointer_type
614  fetch_sub(ptrdiff_t __d,
615  memory_order __m = memory_order_seq_cst) noexcept
616  {
617 #if __cplusplus >= 201703L
618  static_assert( is_object<_Tp>::value, "pointer to object type" );
619 #endif
620  return _M_b.fetch_sub(__d, __m);
621  }
622 
623  __pointer_type
624  fetch_sub(ptrdiff_t __d,
625  memory_order __m = memory_order_seq_cst) volatile noexcept
626  {
627 #if __cplusplus >= 201703L
628  static_assert( is_object<_Tp>::value, "pointer to object type" );
629 #endif
630  return _M_b.fetch_sub(__d, __m);
631  }
632  };
633 
634 
635  /// Explicit specialization for char.
636  template<>
637  struct atomic<char> : __atomic_base<char>
638  {
639  typedef char __integral_type;
641 
642  atomic() noexcept = default;
643  ~atomic() noexcept = default;
644  atomic(const atomic&) = delete;
645  atomic& operator=(const atomic&) = delete;
646  atomic& operator=(const atomic&) volatile = delete;
647 
648  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
649 
650  using __base_type::operator __integral_type;
651  using __base_type::operator=;
652 
653 #if __cplusplus >= 201703L
654  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
655 #endif
656  };
657 
658  /// Explicit specialization for signed char.
659  template<>
660  struct atomic<signed char> : __atomic_base<signed char>
661  {
662  typedef signed char __integral_type;
664 
665  atomic() noexcept= default;
666  ~atomic() noexcept = default;
667  atomic(const atomic&) = delete;
668  atomic& operator=(const atomic&) = delete;
669  atomic& operator=(const atomic&) volatile = delete;
670 
671  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
672 
673  using __base_type::operator __integral_type;
674  using __base_type::operator=;
675 
676 #if __cplusplus >= 201703L
677  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
678 #endif
679  };
680 
681  /// Explicit specialization for unsigned char.
682  template<>
683  struct atomic<unsigned char> : __atomic_base<unsigned char>
684  {
685  typedef unsigned char __integral_type;
687 
688  atomic() noexcept= default;
689  ~atomic() noexcept = default;
690  atomic(const atomic&) = delete;
691  atomic& operator=(const atomic&) = delete;
692  atomic& operator=(const atomic&) volatile = delete;
693 
694  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
695 
696  using __base_type::operator __integral_type;
697  using __base_type::operator=;
698 
699 #if __cplusplus >= 201703L
700  static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
701 #endif
702  };
703 
704  /// Explicit specialization for short.
705  template<>
706  struct atomic<short> : __atomic_base<short>
707  {
708  typedef short __integral_type;
710 
711  atomic() noexcept = default;
712  ~atomic() noexcept = default;
713  atomic(const atomic&) = delete;
714  atomic& operator=(const atomic&) = delete;
715  atomic& operator=(const atomic&) volatile = delete;
716 
717  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
718 
719  using __base_type::operator __integral_type;
720  using __base_type::operator=;
721 
722 #if __cplusplus >= 201703L
723  static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
724 #endif
725  };
726 
727  /// Explicit specialization for unsigned short.
728  template<>
729  struct atomic<unsigned short> : __atomic_base<unsigned short>
730  {
731  typedef unsigned short __integral_type;
733 
734  atomic() noexcept = default;
735  ~atomic() noexcept = default;
736  atomic(const atomic&) = delete;
737  atomic& operator=(const atomic&) = delete;
738  atomic& operator=(const atomic&) volatile = delete;
739 
740  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
741 
742  using __base_type::operator __integral_type;
743  using __base_type::operator=;
744 
745 #if __cplusplus >= 201703L
746  static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
747 #endif
748  };
749 
750  /// Explicit specialization for int.
751  template<>
752  struct atomic<int> : __atomic_base<int>
753  {
754  typedef int __integral_type;
756 
757  atomic() noexcept = default;
758  ~atomic() noexcept = default;
759  atomic(const atomic&) = delete;
760  atomic& operator=(const atomic&) = delete;
761  atomic& operator=(const atomic&) volatile = delete;
762 
763  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
764 
765  using __base_type::operator __integral_type;
766  using __base_type::operator=;
767 
768 #if __cplusplus >= 201703L
769  static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
770 #endif
771  };
772 
773  /// Explicit specialization for unsigned int.
774  template<>
775  struct atomic<unsigned int> : __atomic_base<unsigned int>
776  {
777  typedef unsigned int __integral_type;
779 
780  atomic() noexcept = default;
781  ~atomic() noexcept = default;
782  atomic(const atomic&) = delete;
783  atomic& operator=(const atomic&) = delete;
784  atomic& operator=(const atomic&) volatile = delete;
785 
786  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
787 
788  using __base_type::operator __integral_type;
789  using __base_type::operator=;
790 
791 #if __cplusplus >= 201703L
792  static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
793 #endif
794  };
795 
796  /// Explicit specialization for long.
797  template<>
798  struct atomic<long> : __atomic_base<long>
799  {
800  typedef long __integral_type;
802 
803  atomic() noexcept = default;
804  ~atomic() noexcept = default;
805  atomic(const atomic&) = delete;
806  atomic& operator=(const atomic&) = delete;
807  atomic& operator=(const atomic&) volatile = delete;
808 
809  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
810 
811  using __base_type::operator __integral_type;
812  using __base_type::operator=;
813 
814 #if __cplusplus >= 201703L
815  static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
816 #endif
817  };
818 
819  /// Explicit specialization for unsigned long.
820  template<>
821  struct atomic<unsigned long> : __atomic_base<unsigned long>
822  {
823  typedef unsigned long __integral_type;
825 
826  atomic() noexcept = default;
827  ~atomic() noexcept = default;
828  atomic(const atomic&) = delete;
829  atomic& operator=(const atomic&) = delete;
830  atomic& operator=(const atomic&) volatile = delete;
831 
832  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
833 
834  using __base_type::operator __integral_type;
835  using __base_type::operator=;
836 
837 #if __cplusplus >= 201703L
838  static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
839 #endif
840  };
841 
842  /// Explicit specialization for long long.
843  template<>
844  struct atomic<long long> : __atomic_base<long long>
845  {
846  typedef long long __integral_type;
848 
849  atomic() noexcept = default;
850  ~atomic() noexcept = default;
851  atomic(const atomic&) = delete;
852  atomic& operator=(const atomic&) = delete;
853  atomic& operator=(const atomic&) volatile = delete;
854 
855  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
856 
857  using __base_type::operator __integral_type;
858  using __base_type::operator=;
859 
860 #if __cplusplus >= 201703L
861  static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
862 #endif
863  };
864 
865  /// Explicit specialization for unsigned long long.
866  template<>
867  struct atomic<unsigned long long> : __atomic_base<unsigned long long>
868  {
869  typedef unsigned long long __integral_type;
871 
872  atomic() noexcept = default;
873  ~atomic() noexcept = default;
874  atomic(const atomic&) = delete;
875  atomic& operator=(const atomic&) = delete;
876  atomic& operator=(const atomic&) volatile = delete;
877 
878  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
879 
880  using __base_type::operator __integral_type;
881  using __base_type::operator=;
882 
883 #if __cplusplus >= 201703L
884  static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
885 #endif
886  };
887 
888  /// Explicit specialization for wchar_t.
889  template<>
890  struct atomic<wchar_t> : __atomic_base<wchar_t>
891  {
892  typedef wchar_t __integral_type;
894 
895  atomic() noexcept = default;
896  ~atomic() noexcept = default;
897  atomic(const atomic&) = delete;
898  atomic& operator=(const atomic&) = delete;
899  atomic& operator=(const atomic&) volatile = delete;
900 
901  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
902 
903  using __base_type::operator __integral_type;
904  using __base_type::operator=;
905 
906 #if __cplusplus >= 201703L
907  static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
908 #endif
909  };
910 
911 #ifdef _GLIBCXX_USE_CHAR8_T
912  /// Explicit specialization for char8_t.
913  template<>
914  struct atomic<char8_t> : __atomic_base<char8_t>
915  {
916  typedef char8_t __integral_type;
917  typedef __atomic_base<char8_t> __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 > 201402L
931  static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
932 #endif
933  };
934 #endif
935 
936  /// Explicit specialization for char16_t.
937  template<>
938  struct atomic<char16_t> : __atomic_base<char16_t>
939  {
940  typedef char16_t __integral_type;
942 
943  atomic() noexcept = default;
944  ~atomic() noexcept = default;
945  atomic(const atomic&) = delete;
946  atomic& operator=(const atomic&) = delete;
947  atomic& operator=(const atomic&) volatile = delete;
948 
949  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
950 
951  using __base_type::operator __integral_type;
952  using __base_type::operator=;
953 
954 #if __cplusplus >= 201703L
955  static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
956 #endif
957  };
958 
959  /// Explicit specialization for char32_t.
960  template<>
961  struct atomic<char32_t> : __atomic_base<char32_t>
962  {
963  typedef char32_t __integral_type;
965 
966  atomic() noexcept = default;
967  ~atomic() noexcept = default;
968  atomic(const atomic&) = delete;
969  atomic& operator=(const atomic&) = delete;
970  atomic& operator=(const atomic&) volatile = delete;
971 
972  constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
973 
974  using __base_type::operator __integral_type;
975  using __base_type::operator=;
976 
977 #if __cplusplus >= 201703L
978  static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
979 #endif
980  };
981 
982 
983  /// atomic_bool
985 
986  /// atomic_char
988 
989  /// atomic_schar
991 
992  /// atomic_uchar
994 
995  /// atomic_short
997 
998  /// atomic_ushort
1000 
1001  /// atomic_int
1003 
1004  /// atomic_uint
1006 
1007  /// atomic_long
1009 
1010  /// atomic_ulong
1012 
1013  /// atomic_llong
1015 
1016  /// atomic_ullong
1018 
1019  /// atomic_wchar_t
1021 
1022 #ifdef _GLIBCXX_USE_CHAR8_T
1023  /// atomic_char8_t
1024  typedef atomic<char8_t> atomic_char8_t;
1025 #endif
1026 
1027  /// atomic_char16_t
1029 
1030  /// atomic_char32_t
1032 
1033 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1034  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1035  // 2441. Exact-width atomic typedefs should be provided
1036 
1037  /// atomic_int8_t
1039 
1040  /// atomic_uint8_t
1042 
1043  /// atomic_int16_t
1045 
1046  /// atomic_uint16_t
1048 
1049  /// atomic_int32_t
1051 
1052  /// atomic_uint32_t
1054 
1055  /// atomic_int64_t
1057 
1058  /// atomic_uint64_t
1060 
1061 
1062  /// atomic_int_least8_t
1064 
1065  /// atomic_uint_least8_t
1067 
1068  /// atomic_int_least16_t
1070 
1071  /// atomic_uint_least16_t
1073 
1074  /// atomic_int_least32_t
1076 
1077  /// atomic_uint_least32_t
1079 
1080  /// atomic_int_least64_t
1082 
1083  /// atomic_uint_least64_t
1085 
1086 
1087  /// atomic_int_fast8_t
1089 
1090  /// atomic_uint_fast8_t
1092 
1093  /// atomic_int_fast16_t
1095 
1096  /// atomic_uint_fast16_t
1098 
1099  /// atomic_int_fast32_t
1101 
1102  /// atomic_uint_fast32_t
1104 
1105  /// atomic_int_fast64_t
1107 
1108  /// atomic_uint_fast64_t
1110 #endif
1111 
1112 
1113  /// atomic_intptr_t
1115 
1116  /// atomic_uintptr_t
1118 
1119  /// atomic_size_t
1121 
1122  /// atomic_ptrdiff_t
1124 
1125 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
1126  /// atomic_intmax_t
1128 
1129  /// atomic_uintmax_t
1131 #endif
1132 
1133  // Function definitions, atomic_flag operations.
1134  inline bool
1135  atomic_flag_test_and_set_explicit(atomic_flag* __a,
1136  memory_order __m) noexcept
1137  { return __a->test_and_set(__m); }
1138 
1139  inline bool
1140  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
1141  memory_order __m) noexcept
1142  { return __a->test_and_set(__m); }
1143 
1144  inline void
1145  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
1146  { __a->clear(__m); }
1147 
1148  inline void
1149  atomic_flag_clear_explicit(volatile atomic_flag* __a,
1150  memory_order __m) noexcept
1151  { __a->clear(__m); }
1152 
1153  inline bool
1154  atomic_flag_test_and_set(atomic_flag* __a) noexcept
1155  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1156 
1157  inline bool
1158  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
1159  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
1160 
1161  inline void
1162  atomic_flag_clear(atomic_flag* __a) noexcept
1163  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1164 
1165  inline void
1166  atomic_flag_clear(volatile atomic_flag* __a) noexcept
1167  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
1168 
1169 
1170  template<typename _Tp>
1171  using __atomic_val_t = typename atomic<_Tp>::value_type;
1172  template<typename _Tp>
1173  using __atomic_diff_t = typename atomic<_Tp>::difference_type;
1174 
1175  // [atomics.nonmembers] Non-member functions.
1176  // Function templates generally applicable to atomic types.
1177  template<typename _ITp>
1178  inline bool
1179  atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
1180  { return __a->is_lock_free(); }
1181 
1182  template<typename _ITp>
1183  inline bool
1184  atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
1185  { return __a->is_lock_free(); }
1186 
1187  template<typename _ITp>
1188  inline void
1189  atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1190  { __a->store(__i, memory_order_relaxed); }
1191 
1192  template<typename _ITp>
1193  inline void
1194  atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1195  { __a->store(__i, memory_order_relaxed); }
1196 
1197  template<typename _ITp>
1198  inline void
1199  atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1200  memory_order __m) noexcept
1201  { __a->store(__i, __m); }
1202 
1203  template<typename _ITp>
1204  inline void
1205  atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1206  memory_order __m) noexcept
1207  { __a->store(__i, __m); }
1208 
1209  template<typename _ITp>
1210  inline _ITp
1211  atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
1212  { return __a->load(__m); }
1213 
1214  template<typename _ITp>
1215  inline _ITp
1216  atomic_load_explicit(const volatile atomic<_ITp>* __a,
1217  memory_order __m) noexcept
1218  { return __a->load(__m); }
1219 
1220  template<typename _ITp>
1221  inline _ITp
1222  atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
1223  memory_order __m) noexcept
1224  { return __a->exchange(__i, __m); }
1225 
1226  template<typename _ITp>
1227  inline _ITp
1228  atomic_exchange_explicit(volatile atomic<_ITp>* __a,
1229  __atomic_val_t<_ITp> __i,
1230  memory_order __m) noexcept
1231  { return __a->exchange(__i, __m); }
1232 
1233  template<typename _ITp>
1234  inline bool
1235  atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
1236  __atomic_val_t<_ITp>* __i1,
1237  __atomic_val_t<_ITp> __i2,
1238  memory_order __m1,
1239  memory_order __m2) noexcept
1240  { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1241 
1242  template<typename _ITp>
1243  inline bool
1244  atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
1245  __atomic_val_t<_ITp>* __i1,
1246  __atomic_val_t<_ITp> __i2,
1247  memory_order __m1,
1248  memory_order __m2) noexcept
1249  { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
1250 
1251  template<typename _ITp>
1252  inline bool
1253  atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
1254  __atomic_val_t<_ITp>* __i1,
1255  __atomic_val_t<_ITp> __i2,
1256  memory_order __m1,
1257  memory_order __m2) noexcept
1258  { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1259 
1260  template<typename _ITp>
1261  inline bool
1262  atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
1263  __atomic_val_t<_ITp>* __i1,
1264  __atomic_val_t<_ITp> __i2,
1265  memory_order __m1,
1266  memory_order __m2) noexcept
1267  { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
1268 
1269 
1270  template<typename _ITp>
1271  inline void
1272  atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1273  { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1274 
1275  template<typename _ITp>
1276  inline void
1277  atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1278  { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
1279 
1280  template<typename _ITp>
1281  inline _ITp
1282  atomic_load(const atomic<_ITp>* __a) noexcept
1283  { return atomic_load_explicit(__a, memory_order_seq_cst); }
1284 
1285  template<typename _ITp>
1286  inline _ITp
1287  atomic_load(const volatile atomic<_ITp>* __a) noexcept
1288  { return atomic_load_explicit(__a, memory_order_seq_cst); }
1289 
1290  template<typename _ITp>
1291  inline _ITp
1292  atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
1293  { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1294 
1295  template<typename _ITp>
1296  inline _ITp
1297  atomic_exchange(volatile atomic<_ITp>* __a,
1298  __atomic_val_t<_ITp> __i) noexcept
1299  { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
1300 
1301  template<typename _ITp>
1302  inline bool
1303  atomic_compare_exchange_weak(atomic<_ITp>* __a,
1304  __atomic_val_t<_ITp>* __i1,
1305  __atomic_val_t<_ITp> __i2) noexcept
1306  {
1307  return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1308  memory_order_seq_cst,
1309  memory_order_seq_cst);
1310  }
1311 
1312  template<typename _ITp>
1313  inline bool
1314  atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
1315  __atomic_val_t<_ITp>* __i1,
1316  __atomic_val_t<_ITp> __i2) noexcept
1317  {
1318  return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
1319  memory_order_seq_cst,
1320  memory_order_seq_cst);
1321  }
1322 
1323  template<typename _ITp>
1324  inline bool
1325  atomic_compare_exchange_strong(atomic<_ITp>* __a,
1326  __atomic_val_t<_ITp>* __i1,
1327  __atomic_val_t<_ITp> __i2) noexcept
1328  {
1329  return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1330  memory_order_seq_cst,
1331  memory_order_seq_cst);
1332  }
1333 
1334  template<typename _ITp>
1335  inline bool
1336  atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
1337  __atomic_val_t<_ITp>* __i1,
1338  __atomic_val_t<_ITp> __i2) noexcept
1339  {
1340  return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
1341  memory_order_seq_cst,
1342  memory_order_seq_cst);
1343  }
1344 
1345  // Function templates for atomic_integral and atomic_pointer operations only.
1346  // Some operations (and, or, xor) are only available for atomic integrals,
1347  // which is implemented by taking a parameter of type __atomic_base<_ITp>*.
1348 
1349  template<typename _ITp>
1350  inline _ITp
1351  atomic_fetch_add_explicit(atomic<_ITp>* __a,
1352  __atomic_diff_t<_ITp> __i,
1353  memory_order __m) noexcept
1354  { return __a->fetch_add(__i, __m); }
1355 
1356  template<typename _ITp>
1357  inline _ITp
1358  atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
1359  __atomic_diff_t<_ITp> __i,
1360  memory_order __m) noexcept
1361  { return __a->fetch_add(__i, __m); }
1362 
1363  template<typename _ITp>
1364  inline _ITp
1365  atomic_fetch_sub_explicit(atomic<_ITp>* __a,
1366  __atomic_diff_t<_ITp> __i,
1367  memory_order __m) noexcept
1368  { return __a->fetch_sub(__i, __m); }
1369 
1370  template<typename _ITp>
1371  inline _ITp
1372  atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
1373  __atomic_diff_t<_ITp> __i,
1374  memory_order __m) noexcept
1375  { return __a->fetch_sub(__i, __m); }
1376 
1377  template<typename _ITp>
1378  inline _ITp
1379  atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
1380  __atomic_val_t<_ITp> __i,
1381  memory_order __m) noexcept
1382  { return __a->fetch_and(__i, __m); }
1383 
1384  template<typename _ITp>
1385  inline _ITp
1386  atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
1387  __atomic_val_t<_ITp> __i,
1388  memory_order __m) noexcept
1389  { return __a->fetch_and(__i, __m); }
1390 
1391  template<typename _ITp>
1392  inline _ITp
1393  atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
1394  __atomic_val_t<_ITp> __i,
1395  memory_order __m) noexcept
1396  { return __a->fetch_or(__i, __m); }
1397 
1398  template<typename _ITp>
1399  inline _ITp
1400  atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
1401  __atomic_val_t<_ITp> __i,
1402  memory_order __m) noexcept
1403  { return __a->fetch_or(__i, __m); }
1404 
1405  template<typename _ITp>
1406  inline _ITp
1407  atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
1408  __atomic_val_t<_ITp> __i,
1409  memory_order __m) noexcept
1410  { return __a->fetch_xor(__i, __m); }
1411 
1412  template<typename _ITp>
1413  inline _ITp
1414  atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
1415  __atomic_val_t<_ITp> __i,
1416  memory_order __m) noexcept
1417  { return __a->fetch_xor(__i, __m); }
1418 
1419  template<typename _ITp>
1420  inline _ITp
1421  atomic_fetch_add(atomic<_ITp>* __a,
1422  __atomic_diff_t<_ITp> __i) noexcept
1423  { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1424 
1425  template<typename _ITp>
1426  inline _ITp
1427  atomic_fetch_add(volatile atomic<_ITp>* __a,
1428  __atomic_diff_t<_ITp> __i) noexcept
1429  { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
1430 
1431  template<typename _ITp>
1432  inline _ITp
1433  atomic_fetch_sub(atomic<_ITp>* __a,
1434  __atomic_diff_t<_ITp> __i) noexcept
1435  { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1436 
1437  template<typename _ITp>
1438  inline _ITp
1439  atomic_fetch_sub(volatile atomic<_ITp>* __a,
1440  __atomic_diff_t<_ITp> __i) noexcept
1441  { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
1442 
1443  template<typename _ITp>
1444  inline _ITp
1445  atomic_fetch_and(__atomic_base<_ITp>* __a,
1446  __atomic_val_t<_ITp> __i) noexcept
1447  { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1448 
1449  template<typename _ITp>
1450  inline _ITp
1451  atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
1452  __atomic_val_t<_ITp> __i) noexcept
1453  { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
1454 
1455  template<typename _ITp>
1456  inline _ITp
1457  atomic_fetch_or(__atomic_base<_ITp>* __a,
1458  __atomic_val_t<_ITp> __i) noexcept
1459  { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1460 
1461  template<typename _ITp>
1462  inline _ITp
1463  atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
1464  __atomic_val_t<_ITp> __i) noexcept
1465  { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
1466 
1467  template<typename _ITp>
1468  inline _ITp
1469  atomic_fetch_xor(__atomic_base<_ITp>* __a,
1470  __atomic_val_t<_ITp> __i) noexcept
1471  { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1472 
1473  template<typename _ITp>
1474  inline _ITp
1475  atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
1476  __atomic_val_t<_ITp> __i) noexcept
1477  { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
1478 
1479 #if __cplusplus > 201703L
1480 #define __cpp_lib_atomic_float 201711L
1481  template<>
1482  struct atomic<float> : __atomic_float<float>
1483  {
1484  atomic() noexcept = default;
1485 
1486  constexpr
1487  atomic(float __fp) noexcept : __atomic_float<float>(__fp)
1488  { }
1489 
1490  atomic& operator=(const atomic&) volatile = delete;
1491  atomic& operator=(const atomic&) = delete;
1492 
1493  using __atomic_float<float>::operator=;
1494  };
1495 
1496  template<>
1497  struct atomic<double> : __atomic_float<double>
1498  {
1499  atomic() noexcept = default;
1500 
1501  constexpr
1502  atomic(double __fp) noexcept : __atomic_float<double>(__fp)
1503  { }
1504 
1505  atomic& operator=(const atomic&) volatile = delete;
1506  atomic& operator=(const atomic&) = delete;
1507 
1508  using __atomic_float<double>::operator=;
1509  };
1510 
1511  template<>
1512  struct atomic<long double> : __atomic_float<long double>
1513  {
1514  atomic() noexcept = default;
1515 
1516  constexpr
1517  atomic(long double __fp) noexcept : __atomic_float<long double>(__fp)
1518  { }
1519 
1520  atomic& operator=(const atomic&) volatile = delete;
1521  atomic& operator=(const atomic&) = delete;
1522 
1523  using __atomic_float<long double>::operator=;
1524  };
1525 
1526 #define __cpp_lib_atomic_ref 201806L
1527 
1528  /// Class template to provide atomic operations on a non-atomic variable.
1529  template<typename _Tp>
1530  struct atomic_ref : __atomic_ref<_Tp>
1531  {
1532  explicit
1533  atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t)
1534  { }
1535 
1536  atomic_ref& operator=(const atomic_ref&) = delete;
1537 
1538  atomic_ref(const atomic_ref&) = default;
1539 
1540  using __atomic_ref<_Tp>::operator=;
1541  };
1542 
1543 #endif // C++2a
1544 
1545  // @} group atomics
1546 
1547 _GLIBCXX_END_NAMESPACE_VERSION
1548 } // namespace
1549 
1550 #endif // C++11
1551 
1552 #endif // _GLIBCXX_ATOMIC
atomic< wchar_t > atomic_wchar_t
atomic_wchar_t
Definition: atomic:1020
atomic< ptrdiff_t > atomic_ptrdiff_t
atomic_ptrdiff_t
Definition: atomic:1123
atomic< int_least32_t > atomic_int_least32_t
atomic_int_least32_t
Definition: atomic:1075
Explicit specialization for unsigned char.
Definition: atomic:683
atomic< intptr_t > atomic_intptr_t
atomic_intptr_t
Definition: atomic:1114
is_object
Definition: type_traits:547
atomic< int_least16_t > atomic_int_least16_t
atomic_int_least16_t
Definition: atomic:1069
atomic< uint_fast16_t > atomic_uint_fast16_t
atomic_uint_fast16_t
Definition: atomic:1097
atomic&lt;bool&gt;
Definition: atomic:62
atomic< uint_fast64_t > atomic_uint_fast64_t
atomic_uint_fast64_t
Definition: atomic:1109
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition: move.h:49
atomic< uint8_t > atomic_uint8_t
atomic_uint8_t
Definition: atomic:1041
atomic< int64_t > atomic_int64_t
atomic_int64_t
Definition: atomic:1056
Explicit specialization for long.
Definition: atomic:798
atomic< size_t > atomic_size_t
atomic_size_t
Definition: atomic:1120
memory_order
Enumeration for memory_order.
Definition: atomic_base.h:74
atomic< unsigned long > atomic_ulong
atomic_ulong
Definition: atomic:1011
Explicit specialization for char32_t.
Definition: atomic:961
Explicit specialization for signed char.
Definition: atomic:660
atomic< char > atomic_char
atomic_char
Definition: atomic:987
atomic< bool > atomic_bool
atomic_bool
Definition: atomic:984
atomic< signed char > atomic_schar
atomic_schar
Definition: atomic:990
atomic< uintptr_t > atomic_uintptr_t
atomic_uintptr_t
Definition: atomic:1117
Explicit specialization for unsigned long.
Definition: atomic:821
atomic< unsigned char > atomic_uchar
atomic_uchar
Definition: atomic:993
atomic< uint64_t > atomic_uint64_t
atomic_uint64_t
Definition: atomic:1059
atomic< long long > atomic_llong
atomic_llong
Definition: atomic:1014
Explicit specialization for int.
Definition: atomic:752
atomic< char32_t > atomic_char32_t
atomic_char32_t
Definition: atomic:1031
Explicit specialization for char16_t.
Definition: atomic:938
atomic< uint_fast32_t > atomic_uint_fast32_t
atomic_uint_fast32_t
Definition: atomic:1103
atomic< int_fast32_t > atomic_int_fast32_t
atomic_int_fast32_t
Definition: atomic:1100
atomic< int > atomic_int
atomic_int
Definition: atomic:1002
atomic< int16_t > atomic_int16_t
atomic_int16_t
Definition: atomic:1044
atomic< int_least8_t > atomic_int_least8_t
atomic_int_least8_t
Definition: atomic:1063
#define ATOMIC_BOOL_LOCK_FREE
atomic< unsigned int > atomic_uint
atomic_uint
Definition: atomic:1005
atomic< int_fast64_t > atomic_int_fast64_t
atomic_int_fast64_t
Definition: atomic:1106
atomic< unsigned long long > atomic_ullong
atomic_ullong
Definition: atomic:1017
atomic< int_fast16_t > atomic_int_fast16_t
atomic_int_fast16_t
Definition: atomic:1094
Explicit specialization for short.
Definition: atomic:706
atomic< uint16_t > atomic_uint16_t
atomic_uint16_t
Definition: atomic:1047
atomic< unsigned short > atomic_ushort
atomic_ushort
Definition: atomic:999
atomic< int_least64_t > atomic_int_least64_t
atomic_int_least64_t
Definition: atomic:1081
atomic< uint_fast8_t > atomic_uint_fast8_t
atomic_uint_fast8_t
Definition: atomic:1091
Explicit specialization for unsigned int.
Definition: atomic:775
Generic atomic type, primary class template.
Definition: atomic:57
atomic< char16_t > atomic_char16_t
atomic_char16_t
Definition: atomic:1028
atomic_flag
Definition: atomic_base.h:186
Explicit specialization for unsigned short.
Definition: atomic:729
atomic< uint_least8_t > atomic_uint_least8_t
atomic_uint_least8_t
Definition: atomic:1066
atomic< intmax_t > atomic_intmax_t
atomic_intmax_t
Definition: atomic:1127
Explicit specialization for char.
Definition: atomic:637
atomic< long > atomic_long
atomic_long
Definition: atomic:1008
atomic< int32_t > atomic_int32_t
atomic_int32_t
Definition: atomic:1050
atomic< uint_least16_t > atomic_uint_least16_t
atomic_uint_least16_t
Definition: atomic:1072
atomic< int8_t > atomic_int8_t
atomic_int8_t
Definition: atomic:1038
Explicit specialization for long long.
Definition: atomic:844
constexpr _Tp exchange(_Tp &__obj, _Up &&__new_val)
Assign __new_val to __obj and return its previous value.
Definition: utility:291
atomic< uintmax_t > atomic_uintmax_t
atomic_uintmax_t
Definition: atomic:1130
atomic< uint32_t > atomic_uint32_t
atomic_uint32_t
Definition: atomic:1053
Explicit specialization for wchar_t.
Definition: atomic:890
atomic< short > atomic_short
atomic_short
Definition: atomic:996
atomic< int_fast8_t > atomic_int_fast8_t
atomic_int_fast8_t
Definition: atomic:1088
Explicit specialization for unsigned long long.
Definition: atomic:867
atomic< uint_least64_t > atomic_uint_least64_t
atomic_uint_least64_t
Definition: atomic:1084
atomic< uint_least32_t > atomic_uint_least32_t
atomic_uint_least32_t
Definition: atomic:1078