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