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