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