stdatomic.h source code [libcxx/include/stdatomic.h]

Warning: This file is not a C or C++ file. It does not have highlighting.

1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP_STDATOMIC_H
11	#define _LIBCPP_STDATOMIC_H
12
13	/*
14	stdatomic.h synopsis
15
16	template<class T>
17	using std-atomic = std::atomic<T>; // exposition only
18
19	#define _Atomic(T) std-atomic<T>
20
21	#define ATOMIC_BOOL_LOCK_FREE see below
22	#define ATOMIC_CHAR_LOCK_FREE see below
23	#define ATOMIC_CHAR16_T_LOCK_FREE see below
24	#define ATOMIC_CHAR32_T_LOCK_FREE see below
25	#define ATOMIC_WCHAR_T_LOCK_FREE see below
26	#define ATOMIC_SHORT_LOCK_FREE see below
27	#define ATOMIC_INT_LOCK_FREE see below
28	#define ATOMIC_LONG_LOCK_FREE see below
29	#define ATOMIC_LLONG_LOCK_FREE see below
30	#define ATOMIC_POINTER_LOCK_FREE see below
31
32	using std::memory_order // see below
33	using std::memory_order_relaxed // see below
34	using std::memory_order_consume // see below
35	using std::memory_order_acquire // see below
36	using std::memory_order_release // see below
37	using std::memory_order_acq_rel // see below
38	using std::memory_order_seq_cst // see below
39
40	using std::atomic_flag // see below
41
42	using std::atomic_bool // see below
43	using std::atomic_char // see below
44	using std::atomic_schar // see below
45	using std::atomic_uchar // see below
46	using std::atomic_short // see below
47	using std::atomic_ushort // see below
48	using std::atomic_int // see below
49	using std::atomic_uint // see below
50	using std::atomic_long // see below
51	using std::atomic_ulong // see below
52	using std::atomic_llong // see below
53	using std::atomic_ullong // see below
54	using std::atomic_char8_t // see below
55	using std::atomic_char16_t // see below
56	using std::atomic_char32_t // see below
57	using std::atomic_wchar_t // see below
58	using std::atomic_int8_t // see below
59	using std::atomic_uint8_t // see below
60	using std::atomic_int16_t // see below
61	using std::atomic_uint16_t // see below
62	using std::atomic_int32_t // see below
63	using std::atomic_uint32_t // see below
64	using std::atomic_int64_t // see below
65	using std::atomic_uint64_t // see below
66	using std::atomic_int_least8_t // see below
67	using std::atomic_uint_least8_t // see below
68	using std::atomic_int_least16_t // see below
69	using std::atomic_uint_least16_t // see below
70	using std::atomic_int_least32_t // see below
71	using std::atomic_uint_least32_t // see below
72	using std::atomic_int_least64_t // see below
73	using std::atomic_uint_least64_t // see below
74	using std::atomic_int_fast8_t // see below
75	using std::atomic_uint_fast8_t // see below
76	using std::atomic_int_fast16_t // see below
77	using std::atomic_uint_fast16_t // see below
78	using std::atomic_int_fast32_t // see below
79	using std::atomic_uint_fast32_t // see below
80	using std::atomic_int_fast64_t // see below
81	using std::atomic_uint_fast64_t // see below
82	using std::atomic_intptr_t // see below
83	using std::atomic_uintptr_t // see below
84	using std::atomic_size_t // see below
85	using std::atomic_ptrdiff_t // see below
86	using std::atomic_intmax_t // see below
87	using std::atomic_uintmax_t // see below
88
89	using std::atomic_is_lock_free // see below
90	using std::atomic_load // see below
91	using std::atomic_load_explicit // see below
92	using std::atomic_store // see below
93	using std::atomic_store_explicit // see below
94	using std::atomic_exchange // see below
95	using std::atomic_exchange_explicit // see below
96	using std::atomic_compare_exchange_strong // see below
97	using std::atomic_compare_exchange_strong_explicit // see below
98	using std::atomic_compare_exchange_weak // see below
99	using std::atomic_compare_exchange_weak_explicit // see below
100	using std::atomic_fetch_add // see below
101	using std::atomic_fetch_add_explicit // see below
102	using std::atomic_fetch_sub // see below
103	using std::atomic_fetch_sub_explicit // see below
104	using std::atomic_fetch_or // see below
105	using std::atomic_fetch_or_explicit // see below
106	using std::atomic_fetch_xor // see below
107	using std::atomic_fetch_xor_explicit // see below
108	using std::atomic_fetch_and // see below
109	using std::atomic_fetch_and_explicit // see below
110	using std::atomic_flag_test_and_set // see below
111	using std::atomic_flag_test_and_set_explicit // see below
112	using std::atomic_flag_clear // see below
113	using std::atomic_flag_clear_explicit // see below
114
115	using std::atomic_thread_fence // see below
116	using std::atomic_signal_fence // see below
117
118	*/
119
120	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
121	# include <__cxx03/stdatomic.h>
122	#else
123	# include <__config>
124
125	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
126	# pragma GCC system_header
127	# endif
128
129	# if defined(__cplusplus) && _LIBCPP_STD_VER >= 23
130
131	# include <atomic>
132	# include <version>
133
134	# ifdef _Atomic
135	# undef _Atomic
136	# endif
137
138	# define _Atomic(_Tp) ::std::atomic<_Tp>
139
140	using std::memory_order _LIBCPP_USING_IF_EXISTS;
141	using std::memory_order_relaxed _LIBCPP_USING_IF_EXISTS;
142	using std::memory_order_consume _LIBCPP_USING_IF_EXISTS;
143	using std::memory_order_acquire _LIBCPP_USING_IF_EXISTS;
144	using std::memory_order_release _LIBCPP_USING_IF_EXISTS;
145	using std::memory_order_acq_rel _LIBCPP_USING_IF_EXISTS;
146	using std::memory_order_seq_cst _LIBCPP_USING_IF_EXISTS;
147
148	using std::atomic_flag _LIBCPP_USING_IF_EXISTS;
149
150	using std::atomic_bool _LIBCPP_USING_IF_EXISTS;
151	using std::atomic_char _LIBCPP_USING_IF_EXISTS;
152	using std::atomic_schar _LIBCPP_USING_IF_EXISTS;
153	using std::atomic_uchar _LIBCPP_USING_IF_EXISTS;
154	using std::atomic_short _LIBCPP_USING_IF_EXISTS;
155	using std::atomic_ushort _LIBCPP_USING_IF_EXISTS;
156	using std::atomic_int _LIBCPP_USING_IF_EXISTS;
157	using std::atomic_uint _LIBCPP_USING_IF_EXISTS;
158	using std::atomic_long _LIBCPP_USING_IF_EXISTS;
159	using std::atomic_ulong _LIBCPP_USING_IF_EXISTS;
160	using std::atomic_llong _LIBCPP_USING_IF_EXISTS;
161	using std::atomic_ullong _LIBCPP_USING_IF_EXISTS;
162	# if _LIBCPP_HAS_CHAR8_T
163	using std::atomic_char8_t _LIBCPP_USING_IF_EXISTS;
164	# endif
165	using std::atomic_char16_t _LIBCPP_USING_IF_EXISTS;
166	using std::atomic_char32_t _LIBCPP_USING_IF_EXISTS;
167	# if _LIBCPP_HAS_WIDE_CHARACTERS
168	using std::atomic_wchar_t _LIBCPP_USING_IF_EXISTS;
169	# endif
170
171	using std::atomic_int8_t _LIBCPP_USING_IF_EXISTS;
172	using std::atomic_uint8_t _LIBCPP_USING_IF_EXISTS;
173	using std::atomic_int16_t _LIBCPP_USING_IF_EXISTS;
174	using std::atomic_uint16_t _LIBCPP_USING_IF_EXISTS;
175	using std::atomic_int32_t _LIBCPP_USING_IF_EXISTS;
176	using std::atomic_uint32_t _LIBCPP_USING_IF_EXISTS;
177	using std::atomic_int64_t _LIBCPP_USING_IF_EXISTS;
178	using std::atomic_uint64_t _LIBCPP_USING_IF_EXISTS;
179
180	using std::atomic_int_least8_t _LIBCPP_USING_IF_EXISTS;
181	using std::atomic_uint_least8_t _LIBCPP_USING_IF_EXISTS;
182	using std::atomic_int_least16_t _LIBCPP_USING_IF_EXISTS;
183	using std::atomic_uint_least16_t _LIBCPP_USING_IF_EXISTS;
184	using std::atomic_int_least32_t _LIBCPP_USING_IF_EXISTS;
185	using std::atomic_uint_least32_t _LIBCPP_USING_IF_EXISTS;
186	using std::atomic_int_least64_t _LIBCPP_USING_IF_EXISTS;
187	using std::atomic_uint_least64_t _LIBCPP_USING_IF_EXISTS;
188
189	using std::atomic_int_fast8_t _LIBCPP_USING_IF_EXISTS;
190	using std::atomic_uint_fast8_t _LIBCPP_USING_IF_EXISTS;
191	using std::atomic_int_fast16_t _LIBCPP_USING_IF_EXISTS;
192	using std::atomic_uint_fast16_t _LIBCPP_USING_IF_EXISTS;
193	using std::atomic_int_fast32_t _LIBCPP_USING_IF_EXISTS;
194	using std::atomic_uint_fast32_t _LIBCPP_USING_IF_EXISTS;
195	using std::atomic_int_fast64_t _LIBCPP_USING_IF_EXISTS;
196	using std::atomic_uint_fast64_t _LIBCPP_USING_IF_EXISTS;
197
198	using std::atomic_intptr_t _LIBCPP_USING_IF_EXISTS;
199	using std::atomic_uintptr_t _LIBCPP_USING_IF_EXISTS;
200	using std::atomic_size_t _LIBCPP_USING_IF_EXISTS;
201	using std::atomic_ptrdiff_t _LIBCPP_USING_IF_EXISTS;
202	using std::atomic_intmax_t _LIBCPP_USING_IF_EXISTS;
203	using std::atomic_uintmax_t _LIBCPP_USING_IF_EXISTS;
204
205	using std::atomic_compare_exchange_strong _LIBCPP_USING_IF_EXISTS;
206	using std::atomic_compare_exchange_strong_explicit _LIBCPP_USING_IF_EXISTS;
207	using std::atomic_compare_exchange_weak _LIBCPP_USING_IF_EXISTS;
208	using std::atomic_compare_exchange_weak_explicit _LIBCPP_USING_IF_EXISTS;
209	using std::atomic_exchange _LIBCPP_USING_IF_EXISTS;
210	using std::atomic_exchange_explicit _LIBCPP_USING_IF_EXISTS;
211	using std::atomic_fetch_add _LIBCPP_USING_IF_EXISTS;
212	using std::atomic_fetch_add_explicit _LIBCPP_USING_IF_EXISTS;
213	using std::atomic_fetch_and _LIBCPP_USING_IF_EXISTS;
214	using std::atomic_fetch_and_explicit _LIBCPP_USING_IF_EXISTS;
215	using std::atomic_fetch_or _LIBCPP_USING_IF_EXISTS;
216	using std::atomic_fetch_xor_explicit _LIBCPP_USING_IF_EXISTS;
217	using std::atomic_fetch_xor _LIBCPP_USING_IF_EXISTS;
218	using std::atomic_fetch_or_explicit _LIBCPP_USING_IF_EXISTS;
219	using std::atomic_fetch_sub _LIBCPP_USING_IF_EXISTS;
220	using std::atomic_fetch_sub_explicit _LIBCPP_USING_IF_EXISTS;
221	using std::atomic_flag_clear _LIBCPP_USING_IF_EXISTS;
222	using std::atomic_flag_clear_explicit _LIBCPP_USING_IF_EXISTS;
223	using std::atomic_flag_test_and_set _LIBCPP_USING_IF_EXISTS;
224	using std::atomic_flag_test_and_set_explicit _LIBCPP_USING_IF_EXISTS;
225	using std::atomic_is_lock_free _LIBCPP_USING_IF_EXISTS;
226	using std::atomic_load _LIBCPP_USING_IF_EXISTS;
227	using std::atomic_load_explicit _LIBCPP_USING_IF_EXISTS;
228	using std::atomic_store _LIBCPP_USING_IF_EXISTS;
229	using std::atomic_store_explicit _LIBCPP_USING_IF_EXISTS;
230
231	using std::atomic_signal_fence _LIBCPP_USING_IF_EXISTS;
232	using std::atomic_thread_fence _LIBCPP_USING_IF_EXISTS;
233
234	# elif defined(_LIBCPP_COMPILER_CLANG_BASED)
235
236	// Before C++23, we include the next <stdatomic.h> on the path to avoid hijacking
237	// the header. We do this because Clang has historically shipped a <stdatomic.h>
238	// header that would be available in all Standard modes, and we don't want to
239	// break that use case.
240	# if __has_include_next(<stdatomic.h>)
241	# include_next <stdatomic.h>
242	# endif
243
244	# endif // defined(__cplusplus) && _LIBCPP_STD_VER >= 23
245	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
246
247	#endif // _LIBCPP_STDATOMIC_H
248

Warning: This file is not a C or C++ file. It does not have highlighting.

source code of libcxx/include/stdatomic.h