atomic_base.h source code [include/c++/7/bits/atomic

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
43	namespace 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