1 // -*- C++ -*- header.
2
3 // Copyright (C) 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file bits/atomic_base.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{atomic}
28 */
29
30 #ifndef _GLIBCXX_ATOMIC_BASE_H
31 #define _GLIBCXX_ATOMIC_BASE_H 1
32
33 #pragma GCC system_header
34
35 #include <bits/c++config.h>
36 #include <stdbool.h>
37 #include <stdint.h>
38 #include <bits/atomic_lockfree_defines.h>
39
_GLIBCXX_VISIBILITY(default)40 namespace std _GLIBCXX_VISIBILITY(default)
41 {
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
43
44 /**
45 * @defgroup atomics Atomics
46 *
47 * Components for performing atomic operations.
48 * @{
49 */
50
51 /// Enumeration for memory_order
52 typedef enum memory_order
53 {
54 memory_order_relaxed,
55 memory_order_consume,
56 memory_order_acquire,
57 memory_order_release,
58 memory_order_acq_rel,
59 memory_order_seq_cst
60 } memory_order;
61
62 // Drop release ordering as per [atomics.types.operations.req]/21
63 constexpr memory_order
64 __cmpexch_failure_order(memory_order __m) noexcept
65 {
66 return __m == memory_order_acq_rel ? memory_order_acquire
67 : __m == memory_order_release ? memory_order_relaxed : __m;
68 }
69
70 inline void
71 atomic_thread_fence(memory_order __m) noexcept
72 { __atomic_thread_fence(__m); }
73
74 inline void
75 atomic_signal_fence(memory_order __m) noexcept
76 { __atomic_signal_fence(__m); }
77
78 /// kill_dependency
79 template<typename _Tp>
80 inline _Tp
81 kill_dependency(_Tp __y) noexcept
82 {
83 _Tp __ret(__y);
84 return __ret;
85 }
86
87
88 // Base types for atomics.
89 template<typename _IntTp>
90 struct __atomic_base;
91
92 /// atomic_char
93 typedef __atomic_base<char> atomic_char;
94
95 /// atomic_schar
96 typedef __atomic_base<signed char> atomic_schar;
97
98 /// atomic_uchar
99 typedef __atomic_base<unsigned char> atomic_uchar;
100
101 /// atomic_short
102 typedef __atomic_base<short> atomic_short;
103
104 /// atomic_ushort
105 typedef __atomic_base<unsigned short> atomic_ushort;
106
107 /// atomic_int
108 typedef __atomic_base<int> atomic_int;
109
110 /// atomic_uint
111 typedef __atomic_base<unsigned int> atomic_uint;
112
113 /// atomic_long
114 typedef __atomic_base<long> atomic_long;
115
116 /// atomic_ulong
117 typedef __atomic_base<unsigned long> atomic_ulong;
118
119 /// atomic_llong
120 typedef __atomic_base<long long> atomic_llong;
121
122 /// atomic_ullong
123 typedef __atomic_base<unsigned long long> atomic_ullong;
124
125 /// atomic_wchar_t
126 typedef __atomic_base<wchar_t> atomic_wchar_t;
127
128 /// atomic_char16_t
129 typedef __atomic_base<char16_t> atomic_char16_t;
130
131 /// atomic_char32_t
132 typedef __atomic_base<char32_t> atomic_char32_t;
133
134 /// atomic_char32_t
135 typedef __atomic_base<char32_t> atomic_char32_t;
136
137
138 /// atomic_int_least8_t
139 typedef __atomic_base<int_least8_t> atomic_int_least8_t;
140
141 /// atomic_uint_least8_t
142 typedef __atomic_base<uint_least8_t> atomic_uint_least8_t;
143
144 /// atomic_int_least16_t
145 typedef __atomic_base<int_least16_t> atomic_int_least16_t;
146
147 /// atomic_uint_least16_t
148 typedef __atomic_base<uint_least16_t> atomic_uint_least16_t;
149
150 /// atomic_int_least32_t
151 typedef __atomic_base<int_least32_t> atomic_int_least32_t;
152
153 /// atomic_uint_least32_t
154 typedef __atomic_base<uint_least32_t> atomic_uint_least32_t;
155
156 /// atomic_int_least64_t
157 typedef __atomic_base<int_least64_t> atomic_int_least64_t;
158
159 /// atomic_uint_least64_t
160 typedef __atomic_base<uint_least64_t> atomic_uint_least64_t;
161
162
163 /// atomic_int_fast8_t
164 typedef __atomic_base<int_fast8_t> atomic_int_fast8_t;
165
166 /// atomic_uint_fast8_t
167 typedef __atomic_base<uint_fast8_t> atomic_uint_fast8_t;
168
169 /// atomic_int_fast16_t
170 typedef __atomic_base<int_fast16_t> atomic_int_fast16_t;
171
172 /// atomic_uint_fast16_t
173 typedef __atomic_base<uint_fast16_t> atomic_uint_fast16_t;
174
175 /// atomic_int_fast32_t
176 typedef __atomic_base<int_fast32_t> atomic_int_fast32_t;
177
178 /// atomic_uint_fast32_t
179 typedef __atomic_base<uint_fast32_t> atomic_uint_fast32_t;
180
181 /// atomic_int_fast64_t
182 typedef __atomic_base<int_fast64_t> atomic_int_fast64_t;
183
184 /// atomic_uint_fast64_t
185 typedef __atomic_base<uint_fast64_t> atomic_uint_fast64_t;
186
187
188 /// atomic_intptr_t
189 typedef __atomic_base<intptr_t> atomic_intptr_t;
190
191 /// atomic_uintptr_t
192 typedef __atomic_base<uintptr_t> atomic_uintptr_t;
193
194 /// atomic_size_t
195 typedef __atomic_base<size_t> atomic_size_t;
196
197 /// atomic_intmax_t
198 typedef __atomic_base<intmax_t> atomic_intmax_t;
199
200 /// atomic_uintmax_t
201 typedef __atomic_base<uintmax_t> atomic_uintmax_t;
202
203 /// atomic_ptrdiff_t
204 typedef __atomic_base<ptrdiff_t> atomic_ptrdiff_t;
205
206
207 #define ATOMIC_VAR_INIT(_VI) { _VI }
208
209 template<typename _Tp>
210 struct atomic;
211
212 template<typename _Tp>
213 struct atomic<_Tp*>;
214
215 /* The target's "set" value for test-and-set may not be exactly 1. */
216 #if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
217 typedef bool __atomic_flag_data_type;
218 #else
219 typedef unsigned char __atomic_flag_data_type;
220 #endif
221
222 /**
223 * @brief Base type for atomic_flag.
224 *
225 * Base type is POD with data, allowing atomic_flag to derive from
226 * it and meet the standard layout type requirement. In addition to
227 * compatibilty with a C interface, this allows different
228 * implementations of atomic_flag to use the same atomic operation
229 * functions, via a standard conversion to the __atomic_flag_base
230 * argument.
231 */
232 _GLIBCXX_BEGIN_EXTERN_C
233
234 struct __atomic_flag_base
235 {
236 __atomic_flag_data_type _M_i;
237 };
238
239 _GLIBCXX_END_EXTERN_C
240
241 #define ATOMIC_FLAG_INIT { 0 }
242
243 /// atomic_flag
244 struct atomic_flag : public __atomic_flag_base
245 {
246 atomic_flag() noexcept = default;
247 ~atomic_flag() noexcept = default;
248 atomic_flag(const atomic_flag&) = delete;
249 atomic_flag& operator=(const atomic_flag&) = delete;
250 atomic_flag& operator=(const atomic_flag&) volatile = delete;
251
252 // Conversion to ATOMIC_FLAG_INIT.
253 constexpr atomic_flag(bool __i) noexcept
254 : __atomic_flag_base{ _S_init(__i) }
255 { }
256
257 bool
258 test_and_set(memory_order __m = memory_order_seq_cst) noexcept
259 {
260 return __atomic_test_and_set (&_M_i, __m);
261 }
262
263 bool
264 test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
265 {
266 return __atomic_test_and_set (&_M_i, __m);
267 }
268
269 void
270 clear(memory_order __m = memory_order_seq_cst) noexcept
271 {
272 __glibcxx_assert(__m != memory_order_consume);
273 __glibcxx_assert(__m != memory_order_acquire);
274 __glibcxx_assert(__m != memory_order_acq_rel);
275
276 __atomic_clear (&_M_i, __m);
277 }
278
279 void
280 clear(memory_order __m = memory_order_seq_cst) volatile noexcept
281 {
282 __glibcxx_assert(__m != memory_order_consume);
283 __glibcxx_assert(__m != memory_order_acquire);
284 __glibcxx_assert(__m != memory_order_acq_rel);
285
286 __atomic_clear (&_M_i, __m);
287 }
288
289 private:
290 static constexpr __atomic_flag_data_type
291 _S_init(bool __i)
292 { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; }
293 };
294
295
296 /// Base class for atomic integrals.
297 //
298 // For each of the integral types, define atomic_[integral type] struct
299 //
300 // atomic_bool bool
301 // atomic_char char
302 // atomic_schar signed char
303 // atomic_uchar unsigned char
304 // atomic_short short
305 // atomic_ushort unsigned short
306 // atomic_int int
307 // atomic_uint unsigned int
308 // atomic_long long
309 // atomic_ulong unsigned long
310 // atomic_llong long long
311 // atomic_ullong unsigned long long
312 // atomic_char16_t char16_t
313 // atomic_char32_t char32_t
314 // atomic_wchar_t wchar_t
315 //
316 // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or
317 // 8 bytes, since that is what GCC built-in functions for atomic
318 // memory access expect.
319 template<typename _ITp>
320 struct __atomic_base
321 {
322 private:
323 typedef _ITp __int_type;
324
325 __int_type _M_i;
326
327 public:
328 __atomic_base() noexcept = default;
329 ~__atomic_base() noexcept = default;
330 __atomic_base(const __atomic_base&) = delete;
331 __atomic_base& operator=(const __atomic_base&) = delete;
332 __atomic_base& operator=(const __atomic_base&) volatile = delete;
333
334 // Requires __int_type convertible to _M_i.
335 constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
336
337 operator __int_type() const noexcept
338 { return load(); }
339
340 operator __int_type() const volatile noexcept
341 { return load(); }
342
343 __int_type
344 operator=(__int_type __i) noexcept
345 {
346 store(__i);
347 return __i;
348 }
349
350 __int_type
351 operator=(__int_type __i) volatile noexcept
352 {
353 store(__i);
354 return __i;
355 }
356
357 __int_type
358 operator++(int) noexcept
359 { return fetch_add(1); }
360
361 __int_type
362 operator++(int) volatile noexcept
363 { return fetch_add(1); }
364
365 __int_type
366 operator--(int) noexcept
367 { return fetch_sub(1); }
368
369 __int_type
370 operator--(int) volatile noexcept
371 { return fetch_sub(1); }
372
373 __int_type
374 operator++() noexcept
375 { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
376
377 __int_type
378 operator++() volatile noexcept
379 { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
380
381 __int_type
382 operator--() noexcept
383 { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
384
385 __int_type
386 operator--() volatile noexcept
387 { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
388
389 __int_type
390 operator+=(__int_type __i) noexcept
391 { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
392
393 __int_type
394 operator+=(__int_type __i) volatile noexcept
395 { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
396
397 __int_type
398 operator-=(__int_type __i) noexcept
399 { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
400
401 __int_type
402 operator-=(__int_type __i) volatile noexcept
403 { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
404
405 __int_type
406 operator&=(__int_type __i) noexcept
407 { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
408
409 __int_type
410 operator&=(__int_type __i) volatile noexcept
411 { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
412
413 __int_type
414 operator|=(__int_type __i) noexcept
415 { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
416
417 __int_type
418 operator|=(__int_type __i) volatile noexcept
419 { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
420
421 __int_type
422 operator^=(__int_type __i) noexcept
423 { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
424
425 __int_type
426 operator^=(__int_type __i) volatile noexcept
427 { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
428
429 bool
430 is_lock_free() const noexcept
431 { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); }
432
433 bool
434 is_lock_free() const volatile noexcept
435 { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); }
436
437 void
438 store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
439 {
440 __glibcxx_assert(__m != memory_order_acquire);
441 __glibcxx_assert(__m != memory_order_acq_rel);
442 __glibcxx_assert(__m != memory_order_consume);
443
444 __atomic_store_n(&_M_i, __i, __m);
445 }
446
447 void
448 store(__int_type __i,
449 memory_order __m = memory_order_seq_cst) volatile noexcept
450 {
451 __glibcxx_assert(__m != memory_order_acquire);
452 __glibcxx_assert(__m != memory_order_acq_rel);
453 __glibcxx_assert(__m != memory_order_consume);
454
455 __atomic_store_n(&_M_i, __i, __m);
456 }
457
458 __int_type
459 load(memory_order __m = memory_order_seq_cst) const noexcept
460 {
461 __glibcxx_assert(__m != memory_order_release);
462 __glibcxx_assert(__m != memory_order_acq_rel);
463
464 return __atomic_load_n(&_M_i, __m);
465 }
466
467 __int_type
468 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
469 {
470 __glibcxx_assert(__m != memory_order_release);
471 __glibcxx_assert(__m != memory_order_acq_rel);
472
473 return __atomic_load_n(&_M_i, __m);
474 }
475
476 __int_type
477 exchange(__int_type __i,
478 memory_order __m = memory_order_seq_cst) noexcept
479 {
480 return __atomic_exchange_n(&_M_i, __i, __m);
481 }
482
483
484 __int_type
485 exchange(__int_type __i,
486 memory_order __m = memory_order_seq_cst) volatile noexcept
487 {
488 return __atomic_exchange_n(&_M_i, __i, __m);
489 }
490
491 bool
492 compare_exchange_weak(__int_type& __i1, __int_type __i2,
493 memory_order __m1, memory_order __m2) noexcept
494 {
495 __glibcxx_assert(__m2 != memory_order_release);
496 __glibcxx_assert(__m2 != memory_order_acq_rel);
497 __glibcxx_assert(__m2 <= __m1);
498
499 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
500 }
501
502 bool
503 compare_exchange_weak(__int_type& __i1, __int_type __i2,
504 memory_order __m1,
505 memory_order __m2) volatile noexcept
506 {
507 __glibcxx_assert(__m2 != memory_order_release);
508 __glibcxx_assert(__m2 != memory_order_acq_rel);
509 __glibcxx_assert(__m2 <= __m1);
510
511 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
512 }
513
514 bool
515 compare_exchange_weak(__int_type& __i1, __int_type __i2,
516 memory_order __m = memory_order_seq_cst) noexcept
517 {
518 return compare_exchange_weak(__i1, __i2, __m,
519 __cmpexch_failure_order(__m));
520 }
521
522 bool
523 compare_exchange_weak(__int_type& __i1, __int_type __i2,
524 memory_order __m = memory_order_seq_cst) volatile noexcept
525 {
526 return compare_exchange_weak(__i1, __i2, __m,
527 __cmpexch_failure_order(__m));
528 }
529
530 bool
531 compare_exchange_strong(__int_type& __i1, __int_type __i2,
532 memory_order __m1, memory_order __m2) noexcept
533 {
534 __glibcxx_assert(__m2 != memory_order_release);
535 __glibcxx_assert(__m2 != memory_order_acq_rel);
536 __glibcxx_assert(__m2 <= __m1);
537
538 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
539 }
540
541 bool
542 compare_exchange_strong(__int_type& __i1, __int_type __i2,
543 memory_order __m1,
544 memory_order __m2) volatile noexcept
545 {
546 __glibcxx_assert(__m2 != memory_order_release);
547 __glibcxx_assert(__m2 != memory_order_acq_rel);
548 __glibcxx_assert(__m2 <= __m1);
549
550 return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
551 }
552
553 bool
554 compare_exchange_strong(__int_type& __i1, __int_type __i2,
555 memory_order __m = memory_order_seq_cst) noexcept
556 {
557 return compare_exchange_strong(__i1, __i2, __m,
558 __cmpexch_failure_order(__m));
559 }
560
561 bool
562 compare_exchange_strong(__int_type& __i1, __int_type __i2,
563 memory_order __m = memory_order_seq_cst) volatile noexcept
564 {
565 return compare_exchange_strong(__i1, __i2, __m,
566 __cmpexch_failure_order(__m));
567 }
568
569 __int_type
570 fetch_add(__int_type __i,
571 memory_order __m = memory_order_seq_cst) noexcept
572 { return __atomic_fetch_add(&_M_i, __i, __m); }
573
574 __int_type
575 fetch_add(__int_type __i,
576 memory_order __m = memory_order_seq_cst) volatile noexcept
577 { return __atomic_fetch_add(&_M_i, __i, __m); }
578
579 __int_type
580 fetch_sub(__int_type __i,
581 memory_order __m = memory_order_seq_cst) noexcept
582 { return __atomic_fetch_sub(&_M_i, __i, __m); }
583
584 __int_type
585 fetch_sub(__int_type __i,
586 memory_order __m = memory_order_seq_cst) volatile noexcept
587 { return __atomic_fetch_sub(&_M_i, __i, __m); }
588
589 __int_type
590 fetch_and(__int_type __i,
591 memory_order __m = memory_order_seq_cst) noexcept
592 { return __atomic_fetch_and(&_M_i, __i, __m); }
593
594 __int_type
595 fetch_and(__int_type __i,
596 memory_order __m = memory_order_seq_cst) volatile noexcept
597 { return __atomic_fetch_and(&_M_i, __i, __m); }
598
599 __int_type
600 fetch_or(__int_type __i,
601 memory_order __m = memory_order_seq_cst) noexcept
602 { return __atomic_fetch_or(&_M_i, __i, __m); }
603
604 __int_type
605 fetch_or(__int_type __i,
606 memory_order __m = memory_order_seq_cst) volatile noexcept
607 { return __atomic_fetch_or(&_M_i, __i, __m); }
608
609 __int_type
610 fetch_xor(__int_type __i,
611 memory_order __m = memory_order_seq_cst) noexcept
612 { return __atomic_fetch_xor(&_M_i, __i, __m); }
613
614 __int_type
615 fetch_xor(__int_type __i,
616 memory_order __m = memory_order_seq_cst) volatile noexcept
617 { return __atomic_fetch_xor(&_M_i, __i, __m); }
618 };
619
620
621 /// Partial specialization for pointer types.
622 template<typename _PTp>
623 struct __atomic_base<_PTp*>
624 {
625 private:
626 typedef _PTp* __pointer_type;
627
628 __pointer_type _M_p;
629
630 // Factored out to facilitate explicit specialization.
631 constexpr ptrdiff_t
632 _M_type_size(ptrdiff_t __d) { return __d * sizeof(_PTp); }
633
634 constexpr ptrdiff_t
635 _M_type_size(ptrdiff_t __d) volatile { return __d * sizeof(_PTp); }
636
637 public:
638 __atomic_base() noexcept = default;
639 ~__atomic_base() noexcept = default;
640 __atomic_base(const __atomic_base&) = delete;
641 __atomic_base& operator=(const __atomic_base&) = delete;
642 __atomic_base& operator=(const __atomic_base&) volatile = delete;
643
644 // Requires __pointer_type convertible to _M_p.
645 constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
646
647 operator __pointer_type() const noexcept
648 { return load(); }
649
650 operator __pointer_type() const volatile noexcept
651 { return load(); }
652
653 __pointer_type
654 operator=(__pointer_type __p) noexcept
655 {
656 store(__p);
657 return __p;
658 }
659
660 __pointer_type
661 operator=(__pointer_type __p) volatile noexcept
662 {
663 store(__p);
664 return __p;
665 }
666
667 __pointer_type
668 operator++(int) noexcept
669 { return fetch_add(1); }
670
671 __pointer_type
672 operator++(int) volatile noexcept
673 { return fetch_add(1); }
674
675 __pointer_type
676 operator--(int) noexcept
677 { return fetch_sub(1); }
678
679 __pointer_type
680 operator--(int) volatile noexcept
681 { return fetch_sub(1); }
682
683 __pointer_type
684 operator++() noexcept
685 { return __atomic_add_fetch(&_M_p, _M_type_size(1),
686 memory_order_seq_cst); }
687
688 __pointer_type
689 operator++() volatile noexcept
690 { return __atomic_add_fetch(&_M_p, _M_type_size(1),
691 memory_order_seq_cst); }
692
693 __pointer_type
694 operator--() noexcept
695 { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
696 memory_order_seq_cst); }
697
698 __pointer_type
699 operator--() volatile noexcept
700 { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
701 memory_order_seq_cst); }
702
703 __pointer_type
704 operator+=(ptrdiff_t __d) noexcept
705 { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
706 memory_order_seq_cst); }
707
708 __pointer_type
709 operator+=(ptrdiff_t __d) volatile noexcept
710 { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
711 memory_order_seq_cst); }
712
713 __pointer_type
714 operator-=(ptrdiff_t __d) noexcept
715 { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
716 memory_order_seq_cst); }
717
718 __pointer_type
719 operator-=(ptrdiff_t __d) volatile noexcept
720 { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
721 memory_order_seq_cst); }
722
723 bool
724 is_lock_free() const noexcept
725 { return __atomic_is_lock_free(sizeof(__pointer_type), &_M_p); }
726
727 bool
728 is_lock_free() const volatile noexcept
729 { return __atomic_is_lock_free(sizeof(__pointer_type), &_M_p); }
730
731 void
732 store(__pointer_type __p,
733 memory_order __m = memory_order_seq_cst) noexcept
734 {
735 __glibcxx_assert(__m != memory_order_acquire);
736 __glibcxx_assert(__m != memory_order_acq_rel);
737 __glibcxx_assert(__m != memory_order_consume);
738
739 __atomic_store_n(&_M_p, __p, __m);
740 }
741
742 void
743 store(__pointer_type __p,
744 memory_order __m = memory_order_seq_cst) volatile noexcept
745 {
746 __glibcxx_assert(__m != memory_order_acquire);
747 __glibcxx_assert(__m != memory_order_acq_rel);
748 __glibcxx_assert(__m != memory_order_consume);
749
750 __atomic_store_n(&_M_p, __p, __m);
751 }
752
753 __pointer_type
754 load(memory_order __m = memory_order_seq_cst) const noexcept
755 {
756 __glibcxx_assert(__m != memory_order_release);
757 __glibcxx_assert(__m != memory_order_acq_rel);
758
759 return __atomic_load_n(&_M_p, __m);
760 }
761
762 __pointer_type
763 load(memory_order __m = memory_order_seq_cst) const volatile noexcept
764 {
765 __glibcxx_assert(__m != memory_order_release);
766 __glibcxx_assert(__m != memory_order_acq_rel);
767
768 return __atomic_load_n(&_M_p, __m);
769 }
770
771 __pointer_type
772 exchange(__pointer_type __p,
773 memory_order __m = memory_order_seq_cst) noexcept
774 {
775 return __atomic_exchange_n(&_M_p, __p, __m);
776 }
777
778
779 __pointer_type
780 exchange(__pointer_type __p,
781 memory_order __m = memory_order_seq_cst) volatile noexcept
782 {
783 return __atomic_exchange_n(&_M_p, __p, __m);
784 }
785
786 bool
787 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
788 memory_order __m1,
789 memory_order __m2) noexcept
790 {
791 __glibcxx_assert(__m2 != memory_order_release);
792 __glibcxx_assert(__m2 != memory_order_acq_rel);
793 __glibcxx_assert(__m2 <= __m1);
794
795 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
796 }
797
798 bool
799 compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
800 memory_order __m1,
801 memory_order __m2) volatile noexcept
802 {
803 __glibcxx_assert(__m2 != memory_order_release);
804 __glibcxx_assert(__m2 != memory_order_acq_rel);
805 __glibcxx_assert(__m2 <= __m1);
806
807 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
808 }
809
810 __pointer_type
811 fetch_add(ptrdiff_t __d,
812 memory_order __m = memory_order_seq_cst) noexcept
813 { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
814
815 __pointer_type
816 fetch_add(ptrdiff_t __d,
817 memory_order __m = memory_order_seq_cst) volatile noexcept
818 { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
819
820 __pointer_type
821 fetch_sub(ptrdiff_t __d,
822 memory_order __m = memory_order_seq_cst) noexcept
823 { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
824
825 __pointer_type
826 fetch_sub(ptrdiff_t __d,
827 memory_order __m = memory_order_seq_cst) volatile noexcept
828 { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
829 };
830
831 // @} group atomics
832
833 _GLIBCXX_END_NAMESPACE_VERSION
834 } // namespace std
835
836 #endif
837