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 bits/atomic_base.h 
26 * This is an internal header file, included by other library headers. 
27 * Do not attempt to use it directly. @headername{atomic} 
28 */ 
29 
30#ifndef _GLIBCXX_ATOMIC_BASE_H 
31#define _GLIBCXX_ATOMIC_BASE_H 1 
32 
33#pragma GCC system_header 
34 
35#include <bits/c++config.h> 
36#include <stdint.h> 
37#include <bits/atomic_lockfree_defines.h> 
38#include <bits/move.h> 
39 
40#if __cplusplus > 201703L && _GLIBCXX_HOSTED 
41#include <bits/atomic_wait.h> 
42#endif 
43 
44#ifndef _GLIBCXX_ALWAYS_INLINE 
45#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__)) 
46#endif 
47 
48namespace std _GLIBCXX_VISIBILITY(default) 
49{ 
50_GLIBCXX_BEGIN_NAMESPACE_VERSION 
51 
52 /** 
53 * @defgroup atomics Atomics 
54 * 
55 * Components for performing atomic operations. 
56 * @{ 
57 */ 
58 
59 /// Enumeration for memory_order 
60#if __cplusplus > 201703L 
61 enum class memory_order : int 
62 { 
63 relaxed, 
64 consume, 
65 acquire, 
66 release, 
67 acq_rel, 
68 seq_cst 
69 }; 
70 
71 inline constexpr memory_order memory_order_relaxed = memory_order::relaxed; 
72 inline constexpr memory_order memory_order_consume = memory_order::consume; 
73 inline constexpr memory_order memory_order_acquire = memory_order::acquire; 
74 inline constexpr memory_order memory_order_release = memory_order::release; 
75 inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel; 
76 inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst; 
77#else 
78 typedef enum memory_order 
79 { 
80 memory_order_relaxed, 
81 memory_order_consume, 
82 memory_order_acquire, 
83 memory_order_release, 
84 memory_order_acq_rel, 
85 memory_order_seq_cst 
86 } memory_order; 
87#endif 
88 
89 enum __memory_order_modifier 
90 { 
91 __memory_order_mask = 0x0ffff, 
92 __memory_order_modifier_mask = 0xffff0000, 
93 __memory_order_hle_acquire = 0x10000, 
94 __memory_order_hle_release = 0x20000 
95 }; 
96 
97 constexpr memory_order 
98 operator|(memory_order __m, __memory_order_modifier __mod) 
99 { 
100 return memory_order(int(__m) | int(__mod)); 
101 } 
102 
103 constexpr memory_order 
104 operator&(memory_order __m, __memory_order_modifier __mod) 
105 { 
106 return memory_order(int(__m) & int(__mod)); 
107 } 
108 
109 // Drop release ordering as per [atomics.types.operations.req]/21 
110 constexpr memory_order 
111 __cmpexch_failure_order2(memory_order __m) noexcept 
112 { 
113 return __m == memory_order_acq_rel ? memory_order_acquire 
114 : __m == memory_order_release ? memory_order_relaxed : __m; 
115 } 
116 
117 constexpr memory_order 
118 __cmpexch_failure_order(memory_order __m) noexcept 
119 { 
120 return memory_order(__cmpexch_failure_order2(m: __m & __memory_order_mask) 
121 | __memory_order_modifier(__m & __memory_order_modifier_mask)); 
122 } 
123 
124 constexpr bool 
125 __is_valid_cmpexch_failure_order(memory_order __m) noexcept 
126 { 
127 return (__m & __memory_order_mask) != memory_order_release 
128 && (__m & __memory_order_mask) != memory_order_acq_rel; 
129 } 
130 
131 _GLIBCXX_ALWAYS_INLINE void 
132 atomic_thread_fence(memory_order __m) noexcept 
133 { __atomic_thread_fence(int(__m)); } 
134 
135 _GLIBCXX_ALWAYS_INLINE void 
136 atomic_signal_fence(memory_order __m) noexcept 
137 { __atomic_signal_fence(int(__m)); } 
138 
139 /// kill_dependency 
140 template<typename _Tp> 
141 inline _Tp 
142 kill_dependency(_Tp __y) noexcept 
143 { 
144 _Tp __ret(__y); 
145 return __ret; 
146 } 
147 
148 // Base types for atomics. 
149 template<typename _IntTp> 
150 struct __atomic_base; 
151 
152#if __cplusplus <= 201703L 
153# define _GLIBCXX20_INIT(I) 
154#else 
155# define __cpp_lib_atomic_value_initialization 201911L 
156# define _GLIBCXX20_INIT(I) = I 
157#endif 
158 
159#define ATOMIC_VAR_INIT(_VI) { _VI } 
160 
161 template<typename _Tp> 
162 struct atomic; 
163 
164 template<typename _Tp> 
165 struct atomic<_Tp*>; 
166 
167 /* The target's "set" value for test-and-set may not be exactly 1. */ 
168#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1 
169 typedef bool __atomic_flag_data_type; 
170#else 
171 typedef unsigned char __atomic_flag_data_type; 
172#endif 
173 
174 /** 
175 * @brief Base type for atomic_flag. 
176 * 
177 * Base type is POD with data, allowing atomic_flag to derive from 
178 * it and meet the standard layout type requirement. In addition to 
179 * compatibility with a C interface, this allows different 
180 * implementations of atomic_flag to use the same atomic operation 
181 * functions, via a standard conversion to the __atomic_flag_base 
182 * argument. 
183 */ 
184 _GLIBCXX_BEGIN_EXTERN_C 
185 
186 struct __atomic_flag_base 
187 { 
188 __atomic_flag_data_type _M_i _GLIBCXX20_INIT({}); 
189 }; 
190 
191 _GLIBCXX_END_EXTERN_C 
192 
193#define ATOMIC_FLAG_INIT { 0 } 
194 
195 /// atomic_flag 
196 struct atomic_flag : public __atomic_flag_base 
197 { 
198 atomic_flag() noexcept = default; 
199 ~atomic_flag() noexcept = default; 
200 atomic_flag(const atomic_flag&) = delete; 
201 atomic_flag& operator=(const atomic_flag&) = delete; 
202 atomic_flag& operator=(const atomic_flag&) volatile = delete; 
203 
204 // Conversion to ATOMIC_FLAG_INIT. 
205 constexpr atomic_flag(bool __i) noexcept 
206 : __atomic_flag_base{ ._M_i: _S_init(__i) } 
207 { } 
208 
209 _GLIBCXX_ALWAYS_INLINE bool 
210 test_and_set(memory_order __m = memory_order_seq_cst) noexcept 
211 { 
212 return __atomic_test_and_set (&_M_i, int(__m)); 
213 } 
214 
215 _GLIBCXX_ALWAYS_INLINE bool 
216 test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept 
217 { 
218 return __atomic_test_and_set (&_M_i, int(__m)); 
219 } 
220 
221#if __cplusplus > 201703L 
222#define __cpp_lib_atomic_flag_test 201907L 
223 
224 _GLIBCXX_ALWAYS_INLINE bool 
225 test(memory_order __m = memory_order_seq_cst) const noexcept 
226 { 
227 __atomic_flag_data_type __v; 
228 __atomic_load(&_M_i, &__v, int(__m)); 
229 return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL; 
230 } 
231 
232 _GLIBCXX_ALWAYS_INLINE bool 
233 test(memory_order __m = memory_order_seq_cst) const volatile noexcept 
234 { 
235 __atomic_flag_data_type __v; 
236 __atomic_load(&_M_i, &__v, int(__m)); 
237 return __v == __GCC_ATOMIC_TEST_AND_SET_TRUEVAL; 
238 } 
239 
240#if __cpp_lib_atomic_wait 
241 _GLIBCXX_ALWAYS_INLINE void 
242 wait(bool __old, 
243 memory_order __m = memory_order_seq_cst) const noexcept 
244 { 
245 const __atomic_flag_data_type __v 
246 = __old ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; 
247 
248 std::__atomic_wait_address_v(addr: &_M_i, old: __v, 
249 vfn: [__m, this] { return __atomic_load_n(&_M_i, int(__m)); }); 
250 } 
251 
252 // TODO add const volatile overload 
253 
254 _GLIBCXX_ALWAYS_INLINE void 
255 notify_one() noexcept 
256 { std::__atomic_notify_address(addr: &_M_i, all: false); } 
257 
258 // TODO add const volatile overload 
259 
260 _GLIBCXX_ALWAYS_INLINE void 
261 notify_all() noexcept 
262 { std::__atomic_notify_address(addr: &_M_i, all: true); } 
263 
264 // TODO add const volatile overload 
265#endif // __cpp_lib_atomic_wait 
266#endif // C++20 
267 
268 _GLIBCXX_ALWAYS_INLINE void 
269 clear(memory_order __m = memory_order_seq_cst) noexcept 
270 { 
271 memory_order __b __attribute__ ((__unused__)) 
272 = __m & __memory_order_mask; 
273 __glibcxx_assert(__b != memory_order_consume); 
274 __glibcxx_assert(__b != memory_order_acquire); 
275 __glibcxx_assert(__b != memory_order_acq_rel); 
276 
277 __atomic_clear (&_M_i, int(__m)); 
278 } 
279 
280 _GLIBCXX_ALWAYS_INLINE void 
281 clear(memory_order __m = memory_order_seq_cst) volatile noexcept 
282 { 
283 memory_order __b __attribute__ ((__unused__)) 
284 = __m & __memory_order_mask; 
285 __glibcxx_assert(__b != memory_order_consume); 
286 __glibcxx_assert(__b != memory_order_acquire); 
287 __glibcxx_assert(__b != memory_order_acq_rel); 
288 
289 __atomic_clear (&_M_i, int(__m)); 
290 } 
291 
292 private: 
293 static constexpr __atomic_flag_data_type 
294 _S_init(bool __i) 
295 { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; } 
296 }; 
297 
298 
299 /// Base class for atomic integrals. 
300 // 
301 // For each of the integral types, define atomic_[integral type] struct 
302 // 
303 // atomic_bool bool 
304 // atomic_char char 
305 // atomic_schar signed char 
306 // atomic_uchar unsigned char 
307 // atomic_short short 
308 // atomic_ushort unsigned short 
309 // atomic_int int 
310 // atomic_uint unsigned int 
311 // atomic_long long 
312 // atomic_ulong unsigned long 
313 // atomic_llong long long 
314 // atomic_ullong unsigned long long 
315 // atomic_char8_t char8_t 
316 // atomic_char16_t char16_t 
317 // atomic_char32_t char32_t 
318 // atomic_wchar_t wchar_t 
319 // 
320 // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or 
321 // 8 bytes, since that is what GCC built-in functions for atomic 
322 // memory access expect. 
323 template<typename _ITp> 
324 struct __atomic_base 
325 { 
326 using value_type = _ITp; 
327 using difference_type = value_type; 
328 
329 private: 
330 typedef _ITp __int_type; 
331 
332 static constexpr int _S_alignment = 
333 sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); 
334 
335 alignas(_S_alignment) __int_type _M_i _GLIBCXX20_INIT(0); 
336 
337 public: 
338 __atomic_base() noexcept = default; 
339 ~__atomic_base() noexcept = default; 
340 __atomic_base(const __atomic_base&) = delete; 
341 __atomic_base& operator=(const __atomic_base&) = delete; 
342 __atomic_base& operator=(const __atomic_base&) volatile = delete; 
343 
344 // Requires __int_type convertible to _M_i. 
345 constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } 
346 
347 operator __int_type() const noexcept 
348 { return load(); } 
349 
350 operator __int_type() const volatile noexcept 
351 { return load(); } 
352 
353 __int_type 
354 operator=(__int_type __i) noexcept 
355 { 
356 store(__i); 
357 return __i; 
358 } 
359 
360 __int_type 
361 operator=(__int_type __i) volatile noexcept 
362 { 
363 store(__i); 
364 return __i; 
365 } 
366 
367 __int_type 
368 operator++(int) noexcept 
369 { return fetch_add(1); } 
370 
371 __int_type 
372 operator++(int) volatile noexcept 
373 { return fetch_add(1); } 
374 
375 __int_type 
376 operator--(int) noexcept 
377 { return fetch_sub(1); } 
378 
379 __int_type 
380 operator--(int) volatile noexcept 
381 { return fetch_sub(1); } 
382 
383 __int_type 
384 operator++() noexcept 
385 { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } 
386 
387 __int_type 
388 operator++() volatile noexcept 
389 { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } 
390 
391 __int_type 
392 operator--() noexcept 
393 { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } 
394 
395 __int_type 
396 operator--() volatile noexcept 
397 { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } 
398 
399 __int_type 
400 operator+=(__int_type __i) noexcept 
401 { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
402 
403 __int_type 
404 operator+=(__int_type __i) volatile noexcept 
405 { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
406 
407 __int_type 
408 operator-=(__int_type __i) noexcept 
409 { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
410 
411 __int_type 
412 operator-=(__int_type __i) volatile noexcept 
413 { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
414 
415 __int_type 
416 operator&=(__int_type __i) noexcept 
417 { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
418 
419 __int_type 
420 operator&=(__int_type __i) volatile noexcept 
421 { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
422 
423 __int_type 
424 operator|=(__int_type __i) noexcept 
425 { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
426 
427 __int_type 
428 operator|=(__int_type __i) volatile noexcept 
429 { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
430 
431 __int_type 
432 operator^=(__int_type __i) noexcept 
433 { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
434 
435 __int_type 
436 operator^=(__int_type __i) volatile noexcept 
437 { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } 
438 
439 bool 
440 is_lock_free() const noexcept 
441 { 
442 // Use a fake, minimally aligned pointer. 
443 return __atomic_is_lock_free(sizeof(_M_i), 
444 reinterpret_cast<void *>(-_S_alignment)); 
445 } 
446 
447 bool 
448 is_lock_free() const volatile noexcept 
449 { 
450 // Use a fake, minimally aligned pointer. 
451 return __atomic_is_lock_free(sizeof(_M_i), 
452 reinterpret_cast<void *>(-_S_alignment)); 
453 } 
454 
455 _GLIBCXX_ALWAYS_INLINE void 
456 store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept 
457 { 
458 memory_order __b __attribute__ ((__unused__)) 
459 = __m & __memory_order_mask; 
460 __glibcxx_assert(__b != memory_order_acquire); 
461 __glibcxx_assert(__b != memory_order_acq_rel); 
462 __glibcxx_assert(__b != memory_order_consume); 
463 
464 __atomic_store_n(&_M_i, __i, int(__m)); 
465 } 
466 
467 _GLIBCXX_ALWAYS_INLINE void 
468 store(__int_type __i, 
469 memory_order __m = memory_order_seq_cst) volatile noexcept 
470 { 
471 memory_order __b __attribute__ ((__unused__)) 
472 = __m & __memory_order_mask; 
473 __glibcxx_assert(__b != memory_order_acquire); 
474 __glibcxx_assert(__b != memory_order_acq_rel); 
475 __glibcxx_assert(__b != memory_order_consume); 
476 
477 __atomic_store_n(&_M_i, __i, int(__m)); 
478 } 
479 
480 _GLIBCXX_ALWAYS_INLINE __int_type 
481 load(memory_order __m = memory_order_seq_cst) const noexcept 
482 { 
483 memory_order __b __attribute__ ((__unused__)) 
484 = __m & __memory_order_mask; 
485 __glibcxx_assert(__b != memory_order_release); 
486 __glibcxx_assert(__b != memory_order_acq_rel); 
487 
488 return __atomic_load_n(&_M_i, int(__m)); 
489 } 
490 
491 _GLIBCXX_ALWAYS_INLINE __int_type 
492 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 
493 { 
494 memory_order __b __attribute__ ((__unused__)) 
495 = __m & __memory_order_mask; 
496 __glibcxx_assert(__b != memory_order_release); 
497 __glibcxx_assert(__b != memory_order_acq_rel); 
498 
499 return __atomic_load_n(&_M_i, int(__m)); 
500 } 
501 
502 _GLIBCXX_ALWAYS_INLINE __int_type 
503 exchange(__int_type __i, 
504 memory_order __m = memory_order_seq_cst) noexcept 
505 { 
506 return __atomic_exchange_n(&_M_i, __i, int(__m)); 
507 } 
508 
509 
510 _GLIBCXX_ALWAYS_INLINE __int_type 
511 exchange(__int_type __i, 
512 memory_order __m = memory_order_seq_cst) volatile noexcept 
513 { 
514 return __atomic_exchange_n(&_M_i, __i, int(__m)); 
515 } 
516 
517 _GLIBCXX_ALWAYS_INLINE bool 
518 compare_exchange_weak(__int_type& __i1, __int_type __i2, 
519 memory_order __m1, memory_order __m2) noexcept 
520 { 
521 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
522 
523 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, 
524 int(__m1), int(__m2)); 
525 } 
526 
527 _GLIBCXX_ALWAYS_INLINE bool 
528 compare_exchange_weak(__int_type& __i1, __int_type __i2, 
529 memory_order __m1, 
530 memory_order __m2) volatile noexcept 
531 { 
532 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
533 
534 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, 
535 int(__m1), int(__m2)); 
536 } 
537 
538 _GLIBCXX_ALWAYS_INLINE bool 
539 compare_exchange_weak(__int_type& __i1, __int_type __i2, 
540 memory_order __m = memory_order_seq_cst) noexcept 
541 { 
542 return compare_exchange_weak(__i1, __i2, __m, 
543 __cmpexch_failure_order(__m)); 
544 } 
545 
546 _GLIBCXX_ALWAYS_INLINE bool 
547 compare_exchange_weak(__int_type& __i1, __int_type __i2, 
548 memory_order __m = memory_order_seq_cst) volatile noexcept 
549 { 
550 return compare_exchange_weak(__i1, __i2, __m, 
551 __cmpexch_failure_order(__m)); 
552 } 
553 
554 _GLIBCXX_ALWAYS_INLINE bool 
555 compare_exchange_strong(__int_type& __i1, __int_type __i2, 
556 memory_order __m1, memory_order __m2) noexcept 
557 { 
558 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
559 
560 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, 
561 int(__m1), int(__m2)); 
562 } 
563 
564 _GLIBCXX_ALWAYS_INLINE bool 
565 compare_exchange_strong(__int_type& __i1, __int_type __i2, 
566 memory_order __m1, 
567 memory_order __m2) volatile noexcept 
568 { 
569 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
570 
571 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, 
572 int(__m1), int(__m2)); 
573 } 
574 
575 _GLIBCXX_ALWAYS_INLINE bool 
576 compare_exchange_strong(__int_type& __i1, __int_type __i2, 
577 memory_order __m = memory_order_seq_cst) noexcept 
578 { 
579 return compare_exchange_strong(__i1, __i2, __m, 
580 __cmpexch_failure_order(__m)); 
581 } 
582 
583 _GLIBCXX_ALWAYS_INLINE bool 
584 compare_exchange_strong(__int_type& __i1, __int_type __i2, 
585 memory_order __m = memory_order_seq_cst) volatile noexcept 
586 { 
587 return compare_exchange_strong(__i1, __i2, __m, 
588 __cmpexch_failure_order(__m)); 
589 } 
590 
591#if __cpp_lib_atomic_wait 
592 _GLIBCXX_ALWAYS_INLINE void 
593 wait(__int_type __old, 
594 memory_order __m = memory_order_seq_cst) const noexcept 
595 { 
596 std::__atomic_wait_address_v(&_M_i, __old, 
597 [__m, this] { return this->load(__m); }); 
598 } 
599 
600 // TODO add const volatile overload 
601 
602 _GLIBCXX_ALWAYS_INLINE void 
603 notify_one() noexcept 
604 { std::__atomic_notify_address(&_M_i, false); } 
605 
606 // TODO add const volatile overload 
607 
608 _GLIBCXX_ALWAYS_INLINE void 
609 notify_all() noexcept 
610 { std::__atomic_notify_address(&_M_i, true); } 
611 
612 // TODO add const volatile overload 
613#endif // __cpp_lib_atomic_wait 
614 
615 _GLIBCXX_ALWAYS_INLINE __int_type 
616 fetch_add(__int_type __i, 
617 memory_order __m = memory_order_seq_cst) noexcept 
618 { return __atomic_fetch_add(&_M_i, __i, int(__m)); } 
619 
620 _GLIBCXX_ALWAYS_INLINE __int_type 
621 fetch_add(__int_type __i, 
622 memory_order __m = memory_order_seq_cst) volatile noexcept 
623 { return __atomic_fetch_add(&_M_i, __i, int(__m)); } 
624 
625 _GLIBCXX_ALWAYS_INLINE __int_type 
626 fetch_sub(__int_type __i, 
627 memory_order __m = memory_order_seq_cst) noexcept 
628 { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } 
629 
630 _GLIBCXX_ALWAYS_INLINE __int_type 
631 fetch_sub(__int_type __i, 
632 memory_order __m = memory_order_seq_cst) volatile noexcept 
633 { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } 
634 
635 _GLIBCXX_ALWAYS_INLINE __int_type 
636 fetch_and(__int_type __i, 
637 memory_order __m = memory_order_seq_cst) noexcept 
638 { return __atomic_fetch_and(&_M_i, __i, int(__m)); } 
639 
640 _GLIBCXX_ALWAYS_INLINE __int_type 
641 fetch_and(__int_type __i, 
642 memory_order __m = memory_order_seq_cst) volatile noexcept 
643 { return __atomic_fetch_and(&_M_i, __i, int(__m)); } 
644 
645 _GLIBCXX_ALWAYS_INLINE __int_type 
646 fetch_or(__int_type __i, 
647 memory_order __m = memory_order_seq_cst) noexcept 
648 { return __atomic_fetch_or(&_M_i, __i, int(__m)); } 
649 
650 _GLIBCXX_ALWAYS_INLINE __int_type 
651 fetch_or(__int_type __i, 
652 memory_order __m = memory_order_seq_cst) volatile noexcept 
653 { return __atomic_fetch_or(&_M_i, __i, int(__m)); } 
654 
655 _GLIBCXX_ALWAYS_INLINE __int_type 
656 fetch_xor(__int_type __i, 
657 memory_order __m = memory_order_seq_cst) noexcept 
658 { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } 
659 
660 _GLIBCXX_ALWAYS_INLINE __int_type 
661 fetch_xor(__int_type __i, 
662 memory_order __m = memory_order_seq_cst) volatile noexcept 
663 { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } 
664 }; 
665 
666 
667 /// Partial specialization for pointer types. 
668 template<typename _PTp> 
669 struct __atomic_base<_PTp*> 
670 { 
671 private: 
672 typedef _PTp* __pointer_type; 
673 
674 __pointer_type _M_p _GLIBCXX20_INIT(nullptr); 
675 
676 // Factored out to facilitate explicit specialization. 
677 constexpr ptrdiff_t 
678 _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } 
679 
680 constexpr ptrdiff_t 
681 _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } 
682 
683 public: 
684 __atomic_base() noexcept = default; 
685 ~__atomic_base() noexcept = default; 
686 __atomic_base(const __atomic_base&) = delete; 
687 __atomic_base& operator=(const __atomic_base&) = delete; 
688 __atomic_base& operator=(const __atomic_base&) volatile = delete; 
689 
690 // Requires __pointer_type convertible to _M_p. 
691 constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } 
692 
693 operator __pointer_type() const noexcept 
694 { return load(); } 
695 
696 operator __pointer_type() const volatile noexcept 
697 { return load(); } 
698 
699 __pointer_type 
700 operator=(__pointer_type __p) noexcept 
701 { 
702 store(__p); 
703 return __p; 
704 } 
705 
706 __pointer_type 
707 operator=(__pointer_type __p) volatile noexcept 
708 { 
709 store(__p); 
710 return __p; 
711 } 
712 
713 __pointer_type 
714 operator++(int) noexcept 
715 { return fetch_add(1); } 
716 
717 __pointer_type 
718 operator++(int) volatile noexcept 
719 { return fetch_add(1); } 
720 
721 __pointer_type 
722 operator--(int) noexcept 
723 { return fetch_sub(1); } 
724 
725 __pointer_type 
726 operator--(int) volatile noexcept 
727 { return fetch_sub(1); } 
728 
729 __pointer_type 
730 operator++() noexcept 
731 { return __atomic_add_fetch(&_M_p, _M_type_size(1), 
732 int(memory_order_seq_cst)); } 
733 
734 __pointer_type 
735 operator++() volatile noexcept 
736 { return __atomic_add_fetch(&_M_p, _M_type_size(1), 
737 int(memory_order_seq_cst)); } 
738 
739 __pointer_type 
740 operator--() noexcept 
741 { return __atomic_sub_fetch(&_M_p, _M_type_size(1), 
742 int(memory_order_seq_cst)); } 
743 
744 __pointer_type 
745 operator--() volatile noexcept 
746 { return __atomic_sub_fetch(&_M_p, _M_type_size(1), 
747 int(memory_order_seq_cst)); } 
748 
749 __pointer_type 
750 operator+=(ptrdiff_t __d) noexcept 
751 { return __atomic_add_fetch(&_M_p, _M_type_size(__d), 
752 int(memory_order_seq_cst)); } 
753 
754 __pointer_type 
755 operator+=(ptrdiff_t __d) volatile noexcept 
756 { return __atomic_add_fetch(&_M_p, _M_type_size(__d), 
757 int(memory_order_seq_cst)); } 
758 
759 __pointer_type 
760 operator-=(ptrdiff_t __d) noexcept 
761 { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), 
762 int(memory_order_seq_cst)); } 
763 
764 __pointer_type 
765 operator-=(ptrdiff_t __d) volatile noexcept 
766 { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), 
767 int(memory_order_seq_cst)); } 
768 
769 bool 
770 is_lock_free() const noexcept 
771 { 
772 // Produce a fake, minimally aligned pointer. 
773 return __atomic_is_lock_free(sizeof(_M_p), 
774 reinterpret_cast<void *>(-__alignof(_M_p))); 
775 } 
776 
777 bool 
778 is_lock_free() const volatile noexcept 
779 { 
780 // Produce a fake, minimally aligned pointer. 
781 return __atomic_is_lock_free(sizeof(_M_p), 
782 reinterpret_cast<void *>(-__alignof(_M_p))); 
783 } 
784 
785 _GLIBCXX_ALWAYS_INLINE void 
786 store(__pointer_type __p, 
787 memory_order __m = memory_order_seq_cst) noexcept 
788 { 
789 memory_order __b __attribute__ ((__unused__)) 
790 = __m & __memory_order_mask; 
791 
792 __glibcxx_assert(__b != memory_order_acquire); 
793 __glibcxx_assert(__b != memory_order_acq_rel); 
794 __glibcxx_assert(__b != memory_order_consume); 
795 
796 __atomic_store_n(&_M_p, __p, int(__m)); 
797 } 
798 
799 _GLIBCXX_ALWAYS_INLINE void 
800 store(__pointer_type __p, 
801 memory_order __m = memory_order_seq_cst) volatile noexcept 
802 { 
803 memory_order __b __attribute__ ((__unused__)) 
804 = __m & __memory_order_mask; 
805 __glibcxx_assert(__b != memory_order_acquire); 
806 __glibcxx_assert(__b != memory_order_acq_rel); 
807 __glibcxx_assert(__b != memory_order_consume); 
808 
809 __atomic_store_n(&_M_p, __p, int(__m)); 
810 } 
811 
812 _GLIBCXX_ALWAYS_INLINE __pointer_type 
813 load(memory_order __m = memory_order_seq_cst) const noexcept 
814 { 
815 memory_order __b __attribute__ ((__unused__)) 
816 = __m & __memory_order_mask; 
817 __glibcxx_assert(__b != memory_order_release); 
818 __glibcxx_assert(__b != memory_order_acq_rel); 
819 
820 return __atomic_load_n(&_M_p, int(__m)); 
821 } 
822 
823 _GLIBCXX_ALWAYS_INLINE __pointer_type 
824 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 
825 { 
826 memory_order __b __attribute__ ((__unused__)) 
827 = __m & __memory_order_mask; 
828 __glibcxx_assert(__b != memory_order_release); 
829 __glibcxx_assert(__b != memory_order_acq_rel); 
830 
831 return __atomic_load_n(&_M_p, int(__m)); 
832 } 
833 
834 _GLIBCXX_ALWAYS_INLINE __pointer_type 
835 exchange(__pointer_type __p, 
836 memory_order __m = memory_order_seq_cst) noexcept 
837 { 
838 return __atomic_exchange_n(&_M_p, __p, int(__m)); 
839 } 
840 
841 
842 _GLIBCXX_ALWAYS_INLINE __pointer_type 
843 exchange(__pointer_type __p, 
844 memory_order __m = memory_order_seq_cst) volatile noexcept 
845 { 
846 return __atomic_exchange_n(&_M_p, __p, int(__m)); 
847 } 
848 
849 _GLIBCXX_ALWAYS_INLINE bool 
850 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 
851 memory_order __m1, 
852 memory_order __m2) noexcept 
853 { 
854 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
855 
856 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, 
857 int(__m1), int(__m2)); 
858 } 
859 
860 _GLIBCXX_ALWAYS_INLINE bool 
861 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, 
862 memory_order __m1, 
863 memory_order __m2) volatile noexcept 
864 { 
865 __glibcxx_assert(__is_valid_cmpexch_failure_order(__m2)); 
866 
867 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, 
868 int(__m1), int(__m2)); 
869 } 
870 
871#if __cpp_lib_atomic_wait 
872 _GLIBCXX_ALWAYS_INLINE void 
873 wait(__pointer_type __old, 
874 memory_order __m = memory_order_seq_cst) const noexcept 
875 { 
876 std::__atomic_wait_address_v(&_M_p, __old, 
877 [__m, this] 
878 { return this->load(__m); }); 
879 } 
880 
881 // TODO add const volatile overload 
882 
883 _GLIBCXX_ALWAYS_INLINE void 
884 notify_one() const noexcept 
885 { std::__atomic_notify_address(&_M_p, false); } 
886 
887 // TODO add const volatile overload 
888 
889 _GLIBCXX_ALWAYS_INLINE void 
890 notify_all() const noexcept 
891 { std::__atomic_notify_address(&_M_p, true); } 
892 
893 // TODO add const volatile overload 
894#endif // __cpp_lib_atomic_wait 
895 
896 _GLIBCXX_ALWAYS_INLINE __pointer_type 
897 fetch_add(ptrdiff_t __d, 
898 memory_order __m = memory_order_seq_cst) noexcept 
899 { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } 
900 
901 _GLIBCXX_ALWAYS_INLINE __pointer_type 
902 fetch_add(ptrdiff_t __d, 
903 memory_order __m = memory_order_seq_cst) volatile noexcept 
904 { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } 
905 
906 _GLIBCXX_ALWAYS_INLINE __pointer_type 
907 fetch_sub(ptrdiff_t __d, 
908 memory_order __m = memory_order_seq_cst) noexcept 
909 { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } 
910 
911 _GLIBCXX_ALWAYS_INLINE __pointer_type 
912 fetch_sub(ptrdiff_t __d, 
913 memory_order __m = memory_order_seq_cst) volatile noexcept 
914 { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } 
915 }; 
916 
917#if __cplusplus > 201703L 
918 // Implementation details of atomic_ref and atomic<floating-point>. 
919 namespace __atomic_impl 
920 { 
921 // Remove volatile and create a non-deduced context for value arguments. 
922 template<typename _Tp> 
923 using _Val = remove_volatile_t<_Tp>; 
924 
925 // As above, but for difference_type arguments. 
926 template<typename _Tp> 
927 using _Diff = conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>; 
928 
929 template<size_t _Size, size_t _Align> 
930 _GLIBCXX_ALWAYS_INLINE bool 
931 is_lock_free() noexcept 
932 { 
933 // Produce a fake, minimally aligned pointer. 
934 return __atomic_is_lock_free(_Size, reinterpret_cast<void *>(-_Align)); 
935 } 
936 
937 template<typename _Tp> 
938 _GLIBCXX_ALWAYS_INLINE void 
939 store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept 
940 { __atomic_store(__ptr, std::__addressof(__t), int(__m)); } 
941 
942 template<typename _Tp> 
943 _GLIBCXX_ALWAYS_INLINE _Val<_Tp> 
944 load(const _Tp* __ptr, memory_order __m) noexcept 
945 { 
946 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 
947 auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf); 
948 __atomic_load(__ptr, __dest, int(__m)); 
949 return *__dest; 
950 } 
951 
952 template<typename _Tp> 
953 _GLIBCXX_ALWAYS_INLINE _Val<_Tp> 
954 exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m) noexcept 
955 { 
956 alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; 
957 auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf); 
958 __atomic_exchange(__ptr, std::__addressof(__desired), __dest, int(__m)); 
959 return *__dest; 
960 } 
961 
962 template<typename _Tp> 
963 _GLIBCXX_ALWAYS_INLINE bool 
964 compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected, 
965 _Val<_Tp> __desired, memory_order __success, 
966 memory_order __failure) noexcept 
967 { 
968 __glibcxx_assert(__is_valid_cmpexch_failure_order(__failure)); 
969 
970 return __atomic_compare_exchange(__ptr, std::__addressof(__expected), 
971 std::__addressof(__desired), true, 
972 int(__success), int(__failure)); 
973 } 
974 
975 template<typename _Tp> 
976 _GLIBCXX_ALWAYS_INLINE bool 
977 compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected, 
978 _Val<_Tp> __desired, memory_order __success, 
979 memory_order __failure) noexcept 
980 { 
981 __glibcxx_assert(__is_valid_cmpexch_failure_order(__failure)); 
982 
983 return __atomic_compare_exchange(__ptr, std::__addressof(__expected), 
984 std::__addressof(__desired), false, 
985 int(__success), int(__failure)); 
986 } 
987 
988#if __cpp_lib_atomic_wait 
989 template<typename _Tp> 
990 _GLIBCXX_ALWAYS_INLINE void 
991 wait(const _Tp* __ptr, _Val<_Tp> __old, 
992 memory_order __m = memory_order_seq_cst) noexcept 
993 { 
994 std::__atomic_wait_address_v(__ptr, __old, 
995 [__ptr, __m]() { return __atomic_impl::load(__ptr, __m); }); 
996 } 
997 
998 // TODO add const volatile overload 
999 
1000 template<typename _Tp> 
1001 _GLIBCXX_ALWAYS_INLINE void 
1002 notify_one(const _Tp* __ptr) noexcept 
1003 { std::__atomic_notify_address(__ptr, false); } 
1004 
1005 // TODO add const volatile overload 
1006 
1007 template<typename _Tp> 
1008 _GLIBCXX_ALWAYS_INLINE void 
1009 notify_all(const _Tp* __ptr) noexcept 
1010 { std::__atomic_notify_address(__ptr, true); } 
1011 
1012 // TODO add const volatile overload 
1013#endif // __cpp_lib_atomic_wait 
1014 
1015 template<typename _Tp> 
1016 _GLIBCXX_ALWAYS_INLINE _Tp 
1017 fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept 
1018 { return __atomic_fetch_add(__ptr, __i, int(__m)); } 
1019 
1020 template<typename _Tp> 
1021 _GLIBCXX_ALWAYS_INLINE _Tp 
1022 fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept 
1023 { return __atomic_fetch_sub(__ptr, __i, int(__m)); } 
1024 
1025 template<typename _Tp> 
1026 _GLIBCXX_ALWAYS_INLINE _Tp 
1027 fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept 
1028 { return __atomic_fetch_and(__ptr, __i, int(__m)); } 
1029 
1030 template<typename _Tp> 
1031 _GLIBCXX_ALWAYS_INLINE _Tp 
1032 fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept 
1033 { return __atomic_fetch_or(__ptr, __i, int(__m)); } 
1034 
1035 template<typename _Tp> 
1036 _GLIBCXX_ALWAYS_INLINE _Tp 
1037 fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept 
1038 { return __atomic_fetch_xor(__ptr, __i, int(__m)); } 
1039 
1040 template<typename _Tp> 
1041 _GLIBCXX_ALWAYS_INLINE _Tp 
1042 __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept 
1043 { return __atomic_add_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } 
1044 
1045 template<typename _Tp> 
1046 _GLIBCXX_ALWAYS_INLINE _Tp 
1047 __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept 
1048 { return __atomic_sub_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } 
1049 
1050 template<typename _Tp> 
1051 _GLIBCXX_ALWAYS_INLINE _Tp 
1052 __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept 
1053 { return __atomic_and_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } 
1054 
1055 template<typename _Tp> 
1056 _GLIBCXX_ALWAYS_INLINE _Tp 
1057 __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept 
1058 { return __atomic_or_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } 
1059 
1060 template<typename _Tp> 
1061 _GLIBCXX_ALWAYS_INLINE _Tp 
1062 __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept 
1063 { return __atomic_xor_fetch(__ptr, __i, __ATOMIC_SEQ_CST); } 
1064 
1065 template<typename _Tp> 
1066 _Tp 
1067 __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept 
1068 { 
1069 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); 
1070 _Val<_Tp> __newval = __oldval + __i; 
1071 while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, 
1072 memory_order_relaxed)) 
1073 __newval = __oldval + __i; 
1074 return __oldval; 
1075 } 
1076 
1077 template<typename _Tp> 
1078 _Tp 
1079 __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept 
1080 { 
1081 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); 
1082 _Val<_Tp> __newval = __oldval - __i; 
1083 while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, 
1084 memory_order_relaxed)) 
1085 __newval = __oldval - __i; 
1086 return __oldval; 
1087 } 
1088 
1089 template<typename _Tp> 
1090 _Tp 
1091 __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept 
1092 { 
1093 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); 
1094 _Val<_Tp> __newval = __oldval + __i; 
1095 while (!compare_exchange_weak(__ptr, __oldval, __newval, 
1096 memory_order_seq_cst, 
1097 memory_order_relaxed)) 
1098 __newval = __oldval + __i; 
1099 return __newval; 
1100 } 
1101 
1102 template<typename _Tp> 
1103 _Tp 
1104 __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept 
1105 { 
1106 _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); 
1107 _Val<_Tp> __newval = __oldval - __i; 
1108 while (!compare_exchange_weak(__ptr, __oldval, __newval, 
1109 memory_order_seq_cst, 
1110 memory_order_relaxed)) 
1111 __newval = __oldval - __i; 
1112 return __newval; 
1113 } 
1114 } // namespace __atomic_impl 
1115 
1116 // base class for atomic<floating-point-type> 
1117 template<typename _Fp> 
1118 struct __atomic_float 
1119 { 
1120 static_assert(is_floating_point_v<_Fp>); 
1121 
1122 static constexpr size_t _S_alignment = __alignof__(_Fp); 
1123 
1124 public: 
1125 using value_type = _Fp; 
1126 using difference_type = value_type; 
1127 
1128 static constexpr bool is_always_lock_free 
1129 = __atomic_always_lock_free(sizeof(_Fp), 0); 
1130 
1131 __atomic_float() = default; 
1132 
1133 constexpr 
1134 __atomic_float(_Fp __t) : _M_fp(__t) 
1135 { } 
1136 
1137 __atomic_float(const __atomic_float&) = delete; 
1138 __atomic_float& operator=(const __atomic_float&) = delete; 
1139 __atomic_float& operator=(const __atomic_float&) volatile = delete; 
1140 
1141 _Fp 
1142 operator=(_Fp __t) volatile noexcept 
1143 { 
1144 this->store(__t); 
1145 return __t; 
1146 } 
1147 
1148 _Fp 
1149 operator=(_Fp __t) noexcept 
1150 { 
1151 this->store(__t); 
1152 return __t; 
1153 } 
1154 
1155 bool 
1156 is_lock_free() const volatile noexcept 
1157 { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); } 
1158 
1159 bool 
1160 is_lock_free() const noexcept 
1161 { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); } 
1162 
1163 void 
1164 store(_Fp __t, memory_order __m = memory_order_seq_cst) volatile noexcept 
1165 { __atomic_impl::store(&_M_fp, __t, __m); } 
1166 
1167 void 
1168 store(_Fp __t, memory_order __m = memory_order_seq_cst) noexcept 
1169 { __atomic_impl::store(&_M_fp, __t, __m); } 
1170 
1171 _Fp 
1172 load(memory_order __m = memory_order_seq_cst) const volatile noexcept 
1173 { return __atomic_impl::load(&_M_fp, __m); } 
1174 
1175 _Fp 
1176 load(memory_order __m = memory_order_seq_cst) const noexcept 
1177 { return __atomic_impl::load(&_M_fp, __m); } 
1178 
1179 operator _Fp() const volatile noexcept { return this->load(); } 
1180 operator _Fp() const noexcept { return this->load(); } 
1181 
1182 _Fp 
1183 exchange(_Fp __desired, 
1184 memory_order __m = memory_order_seq_cst) volatile noexcept 
1185 { return __atomic_impl::exchange(&_M_fp, __desired, __m); } 
1186 
1187 _Fp 
1188 exchange(_Fp __desired, 
1189 memory_order __m = memory_order_seq_cst) noexcept 
1190 { return __atomic_impl::exchange(&_M_fp, __desired, __m); } 
1191 
1192 bool 
1193 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1194 memory_order __success, 
1195 memory_order __failure) noexcept 
1196 { 
1197 return __atomic_impl::compare_exchange_weak(&_M_fp, 
1198 __expected, __desired, 
1199 __success, __failure); 
1200 } 
1201 
1202 bool 
1203 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1204 memory_order __success, 
1205 memory_order __failure) volatile noexcept 
1206 { 
1207 return __atomic_impl::compare_exchange_weak(&_M_fp, 
1208 __expected, __desired, 
1209 __success, __failure); 
1210 } 
1211 
1212 bool 
1213 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1214 memory_order __success, 
1215 memory_order __failure) noexcept 
1216 { 
1217 return __atomic_impl::compare_exchange_strong(&_M_fp, 
1218 __expected, __desired, 
1219 __success, __failure); 
1220 } 
1221 
1222 bool 
1223 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1224 memory_order __success, 
1225 memory_order __failure) volatile noexcept 
1226 { 
1227 return __atomic_impl::compare_exchange_strong(&_M_fp, 
1228 __expected, __desired, 
1229 __success, __failure); 
1230 } 
1231 
1232 bool 
1233 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1234 memory_order __order = memory_order_seq_cst) 
1235 noexcept 
1236 { 
1237 return compare_exchange_weak(__expected, __desired, __order, 
1238 __cmpexch_failure_order(m: __order)); 
1239 } 
1240 
1241 bool 
1242 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1243 memory_order __order = memory_order_seq_cst) 
1244 volatile noexcept 
1245 { 
1246 return compare_exchange_weak(__expected, __desired, __order, 
1247 __cmpexch_failure_order(m: __order)); 
1248 } 
1249 
1250 bool 
1251 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1252 memory_order __order = memory_order_seq_cst) 
1253 noexcept 
1254 { 
1255 return compare_exchange_strong(__expected, __desired, __order, 
1256 __cmpexch_failure_order(m: __order)); 
1257 } 
1258 
1259 bool 
1260 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1261 memory_order __order = memory_order_seq_cst) 
1262 volatile noexcept 
1263 { 
1264 return compare_exchange_strong(__expected, __desired, __order, 
1265 __cmpexch_failure_order(m: __order)); 
1266 } 
1267 
1268#if __cpp_lib_atomic_wait 
1269 _GLIBCXX_ALWAYS_INLINE void 
1270 wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept 
1271 { __atomic_impl::wait(&_M_fp, __old, __m); } 
1272 
1273 // TODO add const volatile overload 
1274 
1275 _GLIBCXX_ALWAYS_INLINE void 
1276 notify_one() const noexcept 
1277 { __atomic_impl::notify_one(&_M_fp); } 
1278 
1279 // TODO add const volatile overload 
1280 
1281 _GLIBCXX_ALWAYS_INLINE void 
1282 notify_all() const noexcept 
1283 { __atomic_impl::notify_all(&_M_fp); } 
1284 
1285 // TODO add const volatile overload 
1286#endif // __cpp_lib_atomic_wait 
1287 
1288 value_type 
1289 fetch_add(value_type __i, 
1290 memory_order __m = memory_order_seq_cst) noexcept 
1291 { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } 
1292 
1293 value_type 
1294 fetch_add(value_type __i, 
1295 memory_order __m = memory_order_seq_cst) volatile noexcept 
1296 { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } 
1297 
1298 value_type 
1299 fetch_sub(value_type __i, 
1300 memory_order __m = memory_order_seq_cst) noexcept 
1301 { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } 
1302 
1303 value_type 
1304 fetch_sub(value_type __i, 
1305 memory_order __m = memory_order_seq_cst) volatile noexcept 
1306 { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } 
1307 
1308 value_type 
1309 operator+=(value_type __i) noexcept 
1310 { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); } 
1311 
1312 value_type 
1313 operator+=(value_type __i) volatile noexcept 
1314 { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); } 
1315 
1316 value_type 
1317 operator-=(value_type __i) noexcept 
1318 { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); } 
1319 
1320 value_type 
1321 operator-=(value_type __i) volatile noexcept 
1322 { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); } 
1323 
1324 private: 
1325 alignas(_S_alignment) _Fp _M_fp _GLIBCXX20_INIT(0); 
1326 }; 
1327#undef _GLIBCXX20_INIT 
1328 
1329 template<typename _Tp, 
1330 bool = is_integral_v<_Tp>, bool = is_floating_point_v<_Tp>> 
1331 struct __atomic_ref; 
1332 
1333 // base class for non-integral, non-floating-point, non-pointer types 
1334 template<typename _Tp> 
1335 struct __atomic_ref<_Tp, false, false> 
1336 { 
1337 static_assert(is_trivially_copyable_v<_Tp>); 
1338 
1339 // 1/2/4/8/16-byte types must be aligned to at least their size. 
1340 static constexpr int _S_min_alignment 
1341 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 
1342 ? 0 : sizeof(_Tp); 
1343 
1344 public: 
1345 using value_type = _Tp; 
1346 
1347 static constexpr bool is_always_lock_free 
1348 = __atomic_always_lock_free(sizeof(_Tp), 0); 
1349 
1350 static constexpr size_t required_alignment 
1351 = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); 
1352 
1353 __atomic_ref& operator=(const __atomic_ref&) = delete; 
1354 
1355 explicit 
1356 __atomic_ref(_Tp& __t) : _M_ptr(std::__addressof(__t)) 
1357 { __glibcxx_assert(((uintptr_t)_M_ptr % required_alignment) == 0); } 
1358 
1359 __atomic_ref(const __atomic_ref&) noexcept = default; 
1360 
1361 _Tp 
1362 operator=(_Tp __t) const noexcept 
1363 { 
1364 this->store(__t); 
1365 return __t; 
1366 } 
1367 
1368 operator _Tp() const noexcept { return this->load(); } 
1369 
1370 bool 
1371 is_lock_free() const noexcept 
1372 { return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>(); } 
1373 
1374 void 
1375 store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept 
1376 { __atomic_impl::store(_M_ptr, __t, __m); } 
1377 
1378 _Tp 
1379 load(memory_order __m = memory_order_seq_cst) const noexcept 
1380 { return __atomic_impl::load(_M_ptr, __m); } 
1381 
1382 _Tp 
1383 exchange(_Tp __desired, memory_order __m = memory_order_seq_cst) 
1384 const noexcept 
1385 { return __atomic_impl::exchange(_M_ptr, __desired, __m); } 
1386 
1387 bool 
1388 compare_exchange_weak(_Tp& __expected, _Tp __desired, 
1389 memory_order __success, 
1390 memory_order __failure) const noexcept 
1391 { 
1392 return __atomic_impl::compare_exchange_weak(_M_ptr, 
1393 __expected, __desired, 
1394 __success, __failure); 
1395 } 
1396 
1397 bool 
1398 compare_exchange_strong(_Tp& __expected, _Tp __desired, 
1399 memory_order __success, 
1400 memory_order __failure) const noexcept 
1401 { 
1402 return __atomic_impl::compare_exchange_strong(_M_ptr, 
1403 __expected, __desired, 
1404 __success, __failure); 
1405 } 
1406 
1407 bool 
1408 compare_exchange_weak(_Tp& __expected, _Tp __desired, 
1409 memory_order __order = memory_order_seq_cst) 
1410 const noexcept 
1411 { 
1412 return compare_exchange_weak(__expected, __desired, __order, 
1413 __cmpexch_failure_order(m: __order)); 
1414 } 
1415 
1416 bool 
1417 compare_exchange_strong(_Tp& __expected, _Tp __desired, 
1418 memory_order __order = memory_order_seq_cst) 
1419 const noexcept 
1420 { 
1421 return compare_exchange_strong(__expected, __desired, __order, 
1422 __cmpexch_failure_order(m: __order)); 
1423 } 
1424 
1425#if __cpp_lib_atomic_wait 
1426 _GLIBCXX_ALWAYS_INLINE void 
1427 wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept 
1428 { __atomic_impl::wait(_M_ptr, __old, __m); } 
1429 
1430 // TODO add const volatile overload 
1431 
1432 _GLIBCXX_ALWAYS_INLINE void 
1433 notify_one() const noexcept 
1434 { __atomic_impl::notify_one(_M_ptr); } 
1435 
1436 // TODO add const volatile overload 
1437 
1438 _GLIBCXX_ALWAYS_INLINE void 
1439 notify_all() const noexcept 
1440 { __atomic_impl::notify_all(_M_ptr); } 
1441 
1442 // TODO add const volatile overload 
1443#endif // __cpp_lib_atomic_wait 
1444 
1445 private: 
1446 _Tp* _M_ptr; 
1447 }; 
1448 
1449 // base class for atomic_ref<integral-type> 
1450 template<typename _Tp> 
1451 struct __atomic_ref<_Tp, true, false> 
1452 { 
1453 static_assert(is_integral_v<_Tp>); 
1454 
1455 public: 
1456 using value_type = _Tp; 
1457 using difference_type = value_type; 
1458 
1459 static constexpr bool is_always_lock_free 
1460 = __atomic_always_lock_free(sizeof(_Tp), 0); 
1461 
1462 static constexpr size_t required_alignment 
1463 = sizeof(_Tp) > alignof(_Tp) ? sizeof(_Tp) : alignof(_Tp); 
1464 
1465 __atomic_ref() = delete; 
1466 __atomic_ref& operator=(const __atomic_ref&) = delete; 
1467 
1468 explicit 
1469 __atomic_ref(_Tp& __t) : _M_ptr(&__t) 
1470 { __glibcxx_assert(((uintptr_t)_M_ptr % required_alignment) == 0); } 
1471 
1472 __atomic_ref(const __atomic_ref&) noexcept = default; 
1473 
1474 _Tp 
1475 operator=(_Tp __t) const noexcept 
1476 { 
1477 this->store(__t); 
1478 return __t; 
1479 } 
1480 
1481 operator _Tp() const noexcept { return this->load(); } 
1482 
1483 bool 
1484 is_lock_free() const noexcept 
1485 { 
1486 return __atomic_impl::is_lock_free<sizeof(_Tp), required_alignment>(); 
1487 } 
1488 
1489 void 
1490 store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept 
1491 { __atomic_impl::store(_M_ptr, __t, __m); } 
1492 
1493 _Tp 
1494 load(memory_order __m = memory_order_seq_cst) const noexcept 
1495 { return __atomic_impl::load(_M_ptr, __m); } 
1496 
1497 _Tp 
1498 exchange(_Tp __desired, 
1499 memory_order __m = memory_order_seq_cst) const noexcept 
1500 { return __atomic_impl::exchange(_M_ptr, __desired, __m); } 
1501 
1502 bool 
1503 compare_exchange_weak(_Tp& __expected, _Tp __desired, 
1504 memory_order __success, 
1505 memory_order __failure) const noexcept 
1506 { 
1507 return __atomic_impl::compare_exchange_weak(_M_ptr, 
1508 __expected, __desired, 
1509 __success, __failure); 
1510 } 
1511 
1512 bool 
1513 compare_exchange_strong(_Tp& __expected, _Tp __desired, 
1514 memory_order __success, 
1515 memory_order __failure) const noexcept 
1516 { 
1517 return __atomic_impl::compare_exchange_strong(_M_ptr, 
1518 __expected, __desired, 
1519 __success, __failure); 
1520 } 
1521 
1522 bool 
1523 compare_exchange_weak(_Tp& __expected, _Tp __desired, 
1524 memory_order __order = memory_order_seq_cst) 
1525 const noexcept 
1526 { 
1527 return compare_exchange_weak(__expected, __desired, __order, 
1528 __cmpexch_failure_order(m: __order)); 
1529 } 
1530 
1531 bool 
1532 compare_exchange_strong(_Tp& __expected, _Tp __desired, 
1533 memory_order __order = memory_order_seq_cst) 
1534 const noexcept 
1535 { 
1536 return compare_exchange_strong(__expected, __desired, __order, 
1537 __cmpexch_failure_order(m: __order)); 
1538 } 
1539 
1540#if __cpp_lib_atomic_wait 
1541 _GLIBCXX_ALWAYS_INLINE void 
1542 wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept 
1543 { __atomic_impl::wait(_M_ptr, __old, __m); } 
1544 
1545 // TODO add const volatile overload 
1546 
1547 _GLIBCXX_ALWAYS_INLINE void 
1548 notify_one() const noexcept 
1549 { __atomic_impl::notify_one(_M_ptr); } 
1550 
1551 // TODO add const volatile overload 
1552 
1553 _GLIBCXX_ALWAYS_INLINE void 
1554 notify_all() const noexcept 
1555 { __atomic_impl::notify_all(_M_ptr); } 
1556 
1557 // TODO add const volatile overload 
1558#endif // __cpp_lib_atomic_wait  
1559 
1560 value_type 
1561 fetch_add(value_type __i, 
1562 memory_order __m = memory_order_seq_cst) const noexcept 
1563 { return __atomic_impl::fetch_add(_M_ptr, __i, __m); } 
1564 
1565 value_type 
1566 fetch_sub(value_type __i, 
1567 memory_order __m = memory_order_seq_cst) const noexcept 
1568 { return __atomic_impl::fetch_sub(_M_ptr, __i, __m); } 
1569 
1570 value_type 
1571 fetch_and(value_type __i, 
1572 memory_order __m = memory_order_seq_cst) const noexcept 
1573 { return __atomic_impl::fetch_and(_M_ptr, __i, __m); } 
1574 
1575 value_type 
1576 fetch_or(value_type __i, 
1577 memory_order __m = memory_order_seq_cst) const noexcept 
1578 { return __atomic_impl::fetch_or(_M_ptr, __i, __m); } 
1579 
1580 value_type 
1581 fetch_xor(value_type __i, 
1582 memory_order __m = memory_order_seq_cst) const noexcept 
1583 { return __atomic_impl::fetch_xor(_M_ptr, __i, __m); } 
1584 
1585 _GLIBCXX_ALWAYS_INLINE value_type 
1586 operator++(int) const noexcept 
1587 { return fetch_add(i: 1); } 
1588 
1589 _GLIBCXX_ALWAYS_INLINE value_type 
1590 operator--(int) const noexcept 
1591 { return fetch_sub(i: 1); } 
1592 
1593 value_type 
1594 operator++() const noexcept 
1595 { return __atomic_impl::__add_fetch(_M_ptr, value_type(1)); } 
1596 
1597 value_type 
1598 operator--() const noexcept 
1599 { return __atomic_impl::__sub_fetch(_M_ptr, value_type(1)); } 
1600 
1601 value_type 
1602 operator+=(value_type __i) const noexcept 
1603 { return __atomic_impl::__add_fetch(_M_ptr, __i); } 
1604 
1605 value_type 
1606 operator-=(value_type __i) const noexcept 
1607 { return __atomic_impl::__sub_fetch(_M_ptr, __i); } 
1608 
1609 value_type 
1610 operator&=(value_type __i) const noexcept 
1611 { return __atomic_impl::__and_fetch(_M_ptr, __i); } 
1612 
1613 value_type 
1614 operator|=(value_type __i) const noexcept 
1615 { return __atomic_impl::__or_fetch(_M_ptr, __i); } 
1616 
1617 value_type 
1618 operator^=(value_type __i) const noexcept 
1619 { return __atomic_impl::__xor_fetch(_M_ptr, __i); } 
1620 
1621 private: 
1622 _Tp* _M_ptr; 
1623 }; 
1624 
1625 // base class for atomic_ref<floating-point-type> 
1626 template<typename _Fp> 
1627 struct __atomic_ref<_Fp, false, true> 
1628 { 
1629 static_assert(is_floating_point_v<_Fp>); 
1630 
1631 public: 
1632 using value_type = _Fp; 
1633 using difference_type = value_type; 
1634 
1635 static constexpr bool is_always_lock_free 
1636 = __atomic_always_lock_free(sizeof(_Fp), 0); 
1637 
1638 static constexpr size_t required_alignment = __alignof__(_Fp); 
1639 
1640 __atomic_ref() = delete; 
1641 __atomic_ref& operator=(const __atomic_ref&) = delete; 
1642 
1643 explicit 
1644 __atomic_ref(_Fp& __t) : _M_ptr(&__t) 
1645 { __glibcxx_assert(((uintptr_t)_M_ptr % required_alignment) == 0); } 
1646 
1647 __atomic_ref(const __atomic_ref&) noexcept = default; 
1648 
1649 _Fp 
1650 operator=(_Fp __t) const noexcept 
1651 { 
1652 this->store(__t); 
1653 return __t; 
1654 } 
1655 
1656 operator _Fp() const noexcept { return this->load(); } 
1657 
1658 bool 
1659 is_lock_free() const noexcept 
1660 { 
1661 return __atomic_impl::is_lock_free<sizeof(_Fp), required_alignment>(); 
1662 } 
1663 
1664 void 
1665 store(_Fp __t, memory_order __m = memory_order_seq_cst) const noexcept 
1666 { __atomic_impl::store(_M_ptr, __t, __m); } 
1667 
1668 _Fp 
1669 load(memory_order __m = memory_order_seq_cst) const noexcept 
1670 { return __atomic_impl::load(_M_ptr, __m); } 
1671 
1672 _Fp 
1673 exchange(_Fp __desired, 
1674 memory_order __m = memory_order_seq_cst) const noexcept 
1675 { return __atomic_impl::exchange(_M_ptr, __desired, __m); } 
1676 
1677 bool 
1678 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1679 memory_order __success, 
1680 memory_order __failure) const noexcept 
1681 { 
1682 return __atomic_impl::compare_exchange_weak(_M_ptr, 
1683 __expected, __desired, 
1684 __success, __failure); 
1685 } 
1686 
1687 bool 
1688 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1689 memory_order __success, 
1690 memory_order __failure) const noexcept 
1691 { 
1692 return __atomic_impl::compare_exchange_strong(_M_ptr, 
1693 __expected, __desired, 
1694 __success, __failure); 
1695 } 
1696 
1697 bool 
1698 compare_exchange_weak(_Fp& __expected, _Fp __desired, 
1699 memory_order __order = memory_order_seq_cst) 
1700 const noexcept 
1701 { 
1702 return compare_exchange_weak(__expected, __desired, __order, 
1703 __cmpexch_failure_order(m: __order)); 
1704 } 
1705 
1706 bool 
1707 compare_exchange_strong(_Fp& __expected, _Fp __desired, 
1708 memory_order __order = memory_order_seq_cst) 
1709 const noexcept 
1710 { 
1711 return compare_exchange_strong(__expected, __desired, __order, 
1712 __cmpexch_failure_order(m: __order)); 
1713 } 
1714 
1715#if __cpp_lib_atomic_wait 
1716 _GLIBCXX_ALWAYS_INLINE void 
1717 wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept 
1718 { __atomic_impl::wait(_M_ptr, __old, __m); } 
1719 
1720 // TODO add const volatile overload 
1721 
1722 _GLIBCXX_ALWAYS_INLINE void 
1723 notify_one() const noexcept 
1724 { __atomic_impl::notify_one(_M_ptr); } 
1725 
1726 // TODO add const volatile overload 
1727 
1728 _GLIBCXX_ALWAYS_INLINE void 
1729 notify_all() const noexcept 
1730 { __atomic_impl::notify_all(_M_ptr); } 
1731 
1732 // TODO add const volatile overload 
1733#endif // __cpp_lib_atomic_wait 
1734 
1735 value_type 
1736 fetch_add(value_type __i, 
1737 memory_order __m = memory_order_seq_cst) const noexcept 
1738 { return __atomic_impl::__fetch_add_flt(_M_ptr, __i, __m); } 
1739 
1740 value_type 
1741 fetch_sub(value_type __i, 
1742 memory_order __m = memory_order_seq_cst) const noexcept 
1743 { return __atomic_impl::__fetch_sub_flt(_M_ptr, __i, __m); } 
1744 
1745 value_type 
1746 operator+=(value_type __i) const noexcept 
1747 { return __atomic_impl::__add_fetch_flt(_M_ptr, __i); } 
1748 
1749 value_type 
1750 operator-=(value_type __i) const noexcept 
1751 { return __atomic_impl::__sub_fetch_flt(_M_ptr, __i); } 
1752 
1753 private: 
1754 _Fp* _M_ptr; 
1755 }; 
1756 
1757 // base class for atomic_ref<pointer-type> 
1758 template<typename _Tp> 
1759 struct __atomic_ref<_Tp*, false, false> 
1760 { 
1761 public: 
1762 using value_type = _Tp*; 
1763 using difference_type = ptrdiff_t; 
1764 
1765 static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2; 
1766 
1767 static constexpr size_t required_alignment = __alignof__(_Tp*); 
1768 
1769 __atomic_ref() = delete; 
1770 __atomic_ref& operator=(const __atomic_ref&) = delete; 
1771 
1772 explicit 
1773 __atomic_ref(_Tp*& __t) : _M_ptr(std::__addressof(__t)) 
1774 { __glibcxx_assert(((uintptr_t)_M_ptr % required_alignment) == 0); } 
1775 
1776 __atomic_ref(const __atomic_ref&) noexcept = default; 
1777 
1778 _Tp* 
1779 operator=(_Tp* __t) const noexcept 
1780 { 
1781 this->store(__t); 
1782 return __t; 
1783 } 
1784 
1785 operator _Tp*() const noexcept { return this->load(); } 
1786 
1787 bool 
1788 is_lock_free() const noexcept 
1789 { 
1790 return __atomic_impl::is_lock_free<sizeof(_Tp*), required_alignment>(); 
1791 } 
1792 
1793 void 
1794 store(_Tp* __t, memory_order __m = memory_order_seq_cst) const noexcept 
1795 { __atomic_impl::store(_M_ptr, __t, __m); } 
1796 
1797 _Tp* 
1798 load(memory_order __m = memory_order_seq_cst) const noexcept 
1799 { return __atomic_impl::load(_M_ptr, __m); } 
1800 
1801 _Tp* 
1802 exchange(_Tp* __desired, 
1803 memory_order __m = memory_order_seq_cst) const noexcept 
1804 { return __atomic_impl::exchange(_M_ptr, __desired, __m); } 
1805 
1806 bool 
1807 compare_exchange_weak(_Tp*& __expected, _Tp* __desired, 
1808 memory_order __success, 
1809 memory_order __failure) const noexcept 
1810 { 
1811 return __atomic_impl::compare_exchange_weak(_M_ptr, 
1812 __expected, __desired, 
1813 __success, __failure); 
1814 } 
1815 
1816 bool 
1817 compare_exchange_strong(_Tp*& __expected, _Tp* __desired, 
1818 memory_order __success, 
1819 memory_order __failure) const noexcept 
1820 { 
1821 return __atomic_impl::compare_exchange_strong(_M_ptr, 
1822 __expected, __desired, 
1823 __success, __failure); 
1824 } 
1825 
1826 bool 
1827 compare_exchange_weak(_Tp*& __expected, _Tp* __desired, 
1828 memory_order __order = memory_order_seq_cst) 
1829 const noexcept 
1830 { 
1831 return compare_exchange_weak(__expected, __desired, __order, 
1832 __cmpexch_failure_order(m: __order)); 
1833 } 
1834 
1835 bool 
1836 compare_exchange_strong(_Tp*& __expected, _Tp* __desired, 
1837 memory_order __order = memory_order_seq_cst) 
1838 const noexcept 
1839 { 
1840 return compare_exchange_strong(__expected, __desired, __order, 
1841 __cmpexch_failure_order(m: __order)); 
1842 } 
1843 
1844#if __cpp_lib_atomic_wait 
1845 _GLIBCXX_ALWAYS_INLINE void 
1846 wait(_Tp* __old, memory_order __m = memory_order_seq_cst) const noexcept 
1847 { __atomic_impl::wait(_M_ptr, __old, __m); } 
1848 
1849 // TODO add const volatile overload 
1850 
1851 _GLIBCXX_ALWAYS_INLINE void 
1852 notify_one() const noexcept 
1853 { __atomic_impl::notify_one(_M_ptr); } 
1854 
1855 // TODO add const volatile overload 
1856 
1857 _GLIBCXX_ALWAYS_INLINE void 
1858 notify_all() const noexcept 
1859 { __atomic_impl::notify_all(_M_ptr); } 
1860 
1861 // TODO add const volatile overload 
1862#endif // __cpp_lib_atomic_wait 
1863 
1864 _GLIBCXX_ALWAYS_INLINE value_type 
1865 fetch_add(difference_type __d, 
1866 memory_order __m = memory_order_seq_cst) const noexcept 
1867 { return __atomic_impl::fetch_add(_M_ptr, _S_type_size(__d), __m); } 
1868 
1869 _GLIBCXX_ALWAYS_INLINE value_type 
1870 fetch_sub(difference_type __d, 
1871 memory_order __m = memory_order_seq_cst) const noexcept 
1872 { return __atomic_impl::fetch_sub(_M_ptr, _S_type_size(__d), __m); } 
1873 
1874 value_type 
1875 operator++(int) const noexcept 
1876 { return fetch_add(d: 1); } 
1877 
1878 value_type 
1879 operator--(int) const noexcept 
1880 { return fetch_sub(d: 1); } 
1881 
1882 value_type 
1883 operator++() const noexcept 
1884 { 
1885 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(d: 1)); 
1886 } 
1887 
1888 value_type 
1889 operator--() const noexcept 
1890 { 
1891 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(d: 1)); 
1892 } 
1893 
1894 value_type 
1895 operator+=(difference_type __d) const noexcept 
1896 { 
1897 return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(__d)); 
1898 } 
1899 
1900 value_type 
1901 operator-=(difference_type __d) const noexcept 
1902 { 
1903 return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(__d)); 
1904 } 
1905 
1906 private: 
1907 static constexpr ptrdiff_t 
1908 _S_type_size(ptrdiff_t __d) noexcept 
1909 { 
1910 static_assert(is_object_v<_Tp>); 
1911 return __d * sizeof(_Tp); 
1912 } 
1913 
1914 _Tp** _M_ptr; 
1915 }; 
1916 
1917#endif // C++2a 
1918 
1919 /// @} group atomics 
1920 
1921_GLIBCXX_END_NAMESPACE_VERSION 
1922} // namespace std 
1923 
1924#endif 
1925