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