blob: f0707b7c50e3064fc30bd555a2360060155c68c5 [file] [log] [blame]
Howard Hinnant71be7292010-09-27 21:17:38 +00001// -*- C++ -*-
2//===--------------------------- atomic -----------------------------------===//
3//
Chandler Carruth7642bb12019-01-19 08:50:56 +00004// 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
Howard Hinnant71be7292010-09-27 21:17:38 +00007//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_ATOMIC
11#define _LIBCPP_ATOMIC
12
13/*
14 atomic synopsis
15
16namespace std
17{
18
JF Bastienfdb42c22016-03-25 15:48:21 +000019// feature test macro
20
21#define __cpp_lib_atomic_is_always_lock_free // as specified by SG10
22
Davide Italiano011f80a2019-03-05 18:40:49 +000023 // order and consistency
Howard Hinnant71be7292010-09-27 21:17:38 +000024
Davide Italiano011f80a2019-03-05 18:40:49 +000025 enum memory_order: unspecified // enum class in C++20
26 {
27 relaxed,
28 consume, // load-consume
29 acquire, // load-acquire
30 release, // store-release
31 acq_rel, // store-release load-acquire
32 seq_cst // store-release load-acquire
33 };
34
35 inline constexpr auto memory_order_relaxed = memory_order::relaxed;
36 inline constexpr auto memory_order_consume = memory_order::consume;
37 inline constexpr auto memory_order_acquire = memory_order::acquire;
38 inline constexpr auto memory_order_release = memory_order::release;
39 inline constexpr auto memory_order_acq_rel = memory_order::acq_rel;
40 inline constexpr auto memory_order_seq_cst = memory_order::seq_cst;
Howard Hinnant71be7292010-09-27 21:17:38 +000041
Howard Hinnanteee2c142012-04-11 20:14:21 +000042template <class T> T kill_dependency(T y) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +000043
44// lock-free property
45
Howard Hinnant931e3402013-01-21 20:39:41 +000046#define ATOMIC_BOOL_LOCK_FREE unspecified
Howard Hinnant71be7292010-09-27 21:17:38 +000047#define ATOMIC_CHAR_LOCK_FREE unspecified
48#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
49#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
50#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
51#define ATOMIC_SHORT_LOCK_FREE unspecified
52#define ATOMIC_INT_LOCK_FREE unspecified
53#define ATOMIC_LONG_LOCK_FREE unspecified
54#define ATOMIC_LLONG_LOCK_FREE unspecified
Howard Hinnant931e3402013-01-21 20:39:41 +000055#define ATOMIC_POINTER_LOCK_FREE unspecified
Howard Hinnant71be7292010-09-27 21:17:38 +000056
Howard Hinnant71be7292010-09-27 21:17:38 +000057// flag type and operations
58
59typedef struct atomic_flag
60{
Howard Hinnanteee2c142012-04-11 20:14:21 +000061 bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
62 bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
63 void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
64 void clear(memory_order m = memory_order_seq_cst) noexcept;
65 atomic_flag() noexcept = default;
Howard Hinnant71be7292010-09-27 21:17:38 +000066 atomic_flag(const atomic_flag&) = delete;
67 atomic_flag& operator=(const atomic_flag&) = delete;
68 atomic_flag& operator=(const atomic_flag&) volatile = delete;
69} atomic_flag;
70
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000071bool
Howard Hinnanteee2c142012-04-11 20:14:21 +000072 atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000073
74bool
Howard Hinnanteee2c142012-04-11 20:14:21 +000075 atomic_flag_test_and_set(atomic_flag* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000076
77bool
78 atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
Howard Hinnanteee2c142012-04-11 20:14:21 +000079 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000080
81bool
Howard Hinnanteee2c142012-04-11 20:14:21 +000082 atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000083
84void
Howard Hinnanteee2c142012-04-11 20:14:21 +000085 atomic_flag_clear(volatile atomic_flag* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000086
87void
Howard Hinnanteee2c142012-04-11 20:14:21 +000088 atomic_flag_clear(atomic_flag* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000089
90void
Howard Hinnanteee2c142012-04-11 20:14:21 +000091 atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +000092
93void
Howard Hinnanteee2c142012-04-11 20:14:21 +000094 atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +000095
96#define ATOMIC_FLAG_INIT see below
Howard Hinnant493d1d92010-10-19 16:51:18 +000097#define ATOMIC_VAR_INIT(value) see below
Howard Hinnant71be7292010-09-27 21:17:38 +000098
Howard Hinnant71be7292010-09-27 21:17:38 +000099template <class T>
100struct atomic
101{
JF Bastienfdb42c22016-03-25 15:48:21 +0000102 static constexpr bool is_always_lock_free;
Howard Hinnanteee2c142012-04-11 20:14:21 +0000103 bool is_lock_free() const volatile noexcept;
104 bool is_lock_free() const noexcept;
105 void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
106 void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
107 T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
108 T load(memory_order m = memory_order_seq_cst) const noexcept;
109 operator T() const volatile noexcept;
110 operator T() const noexcept;
111 T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
112 T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000113 bool compare_exchange_weak(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000114 memory_order s, memory_order f) volatile noexcept;
115 bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000116 bool compare_exchange_strong(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000117 memory_order s, memory_order f) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000118 bool compare_exchange_strong(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000119 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000120 bool compare_exchange_weak(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000121 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000122 bool compare_exchange_weak(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000123 memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000124 bool compare_exchange_strong(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000125 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000126 bool compare_exchange_strong(T& expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000127 memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000128
Howard Hinnanteee2c142012-04-11 20:14:21 +0000129 atomic() noexcept = default;
130 constexpr atomic(T desr) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000131 atomic(const atomic&) = delete;
132 atomic& operator=(const atomic&) = delete;
133 atomic& operator=(const atomic&) volatile = delete;
Howard Hinnanteee2c142012-04-11 20:14:21 +0000134 T operator=(T) volatile noexcept;
135 T operator=(T) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000136};
137
138template <>
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000139struct atomic<integral>
Howard Hinnant71be7292010-09-27 21:17:38 +0000140{
JF Bastienfdb42c22016-03-25 15:48:21 +0000141 static constexpr bool is_always_lock_free;
Howard Hinnanteee2c142012-04-11 20:14:21 +0000142 bool is_lock_free() const volatile noexcept;
143 bool is_lock_free() const noexcept;
144 void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
145 void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
146 integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
147 integral load(memory_order m = memory_order_seq_cst) const noexcept;
148 operator integral() const volatile noexcept;
149 operator integral() const noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000150 integral exchange(integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000151 memory_order m = memory_order_seq_cst) volatile noexcept;
152 integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000153 bool compare_exchange_weak(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000154 memory_order s, memory_order f) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000155 bool compare_exchange_weak(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000156 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000157 bool compare_exchange_strong(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000158 memory_order s, memory_order f) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000159 bool compare_exchange_strong(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000160 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000161 bool compare_exchange_weak(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000162 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000163 bool compare_exchange_weak(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000164 memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000165 bool compare_exchange_strong(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000166 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000167 bool compare_exchange_strong(integral& expc, integral desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000168 memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000169
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000170 integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000171 fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
172 integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000173 integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000174 fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
175 integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000176 integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000177 fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
178 integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000179 integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000180 fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
181 integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000182 integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000183 fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
184 integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000185
Howard Hinnanteee2c142012-04-11 20:14:21 +0000186 atomic() noexcept = default;
187 constexpr atomic(integral desr) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000188 atomic(const atomic&) = delete;
189 atomic& operator=(const atomic&) = delete;
190 atomic& operator=(const atomic&) volatile = delete;
Howard Hinnanteee2c142012-04-11 20:14:21 +0000191 integral operator=(integral desr) volatile noexcept;
192 integral operator=(integral desr) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000193
Howard Hinnanteee2c142012-04-11 20:14:21 +0000194 integral operator++(int) volatile noexcept;
195 integral operator++(int) noexcept;
196 integral operator--(int) volatile noexcept;
197 integral operator--(int) noexcept;
198 integral operator++() volatile noexcept;
199 integral operator++() noexcept;
200 integral operator--() volatile noexcept;
201 integral operator--() noexcept;
202 integral operator+=(integral op) volatile noexcept;
203 integral operator+=(integral op) noexcept;
204 integral operator-=(integral op) volatile noexcept;
205 integral operator-=(integral op) noexcept;
206 integral operator&=(integral op) volatile noexcept;
207 integral operator&=(integral op) noexcept;
208 integral operator|=(integral op) volatile noexcept;
209 integral operator|=(integral op) noexcept;
210 integral operator^=(integral op) volatile noexcept;
211 integral operator^=(integral op) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000212};
213
214template <class T>
215struct atomic<T*>
Howard Hinnant71be7292010-09-27 21:17:38 +0000216{
JF Bastienfdb42c22016-03-25 15:48:21 +0000217 static constexpr bool is_always_lock_free;
Howard Hinnanteee2c142012-04-11 20:14:21 +0000218 bool is_lock_free() const volatile noexcept;
219 bool is_lock_free() const noexcept;
220 void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
221 void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
222 T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
223 T* load(memory_order m = memory_order_seq_cst) const noexcept;
224 operator T*() const volatile noexcept;
225 operator T*() const noexcept;
226 T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
227 T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000228 bool compare_exchange_weak(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000229 memory_order s, memory_order f) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000230 bool compare_exchange_weak(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000231 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000232 bool compare_exchange_strong(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000233 memory_order s, memory_order f) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000234 bool compare_exchange_strong(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000235 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000236 bool compare_exchange_weak(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000237 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000238 bool compare_exchange_weak(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000239 memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000240 bool compare_exchange_strong(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000241 memory_order m = memory_order_seq_cst) volatile noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000242 bool compare_exchange_strong(T*& expc, T* desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000243 memory_order m = memory_order_seq_cst) noexcept;
244 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
245 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
246 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
247 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000248
Howard Hinnanteee2c142012-04-11 20:14:21 +0000249 atomic() noexcept = default;
250 constexpr atomic(T* desr) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000251 atomic(const atomic&) = delete;
252 atomic& operator=(const atomic&) = delete;
253 atomic& operator=(const atomic&) volatile = delete;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000254
Howard Hinnanteee2c142012-04-11 20:14:21 +0000255 T* operator=(T*) volatile noexcept;
256 T* operator=(T*) noexcept;
257 T* operator++(int) volatile noexcept;
258 T* operator++(int) noexcept;
259 T* operator--(int) volatile noexcept;
260 T* operator--(int) noexcept;
261 T* operator++() volatile noexcept;
262 T* operator++() noexcept;
263 T* operator--() volatile noexcept;
264 T* operator--() noexcept;
265 T* operator+=(ptrdiff_t op) volatile noexcept;
266 T* operator+=(ptrdiff_t op) noexcept;
267 T* operator-=(ptrdiff_t op) volatile noexcept;
268 T* operator-=(ptrdiff_t op) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000269};
270
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000271
272template <class T>
273 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000274 atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000275
276template <class T>
277 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000278 atomic_is_lock_free(const atomic<T>* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000279
280template <class T>
281 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000282 atomic_init(volatile atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000283
284template <class T>
285 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000286 atomic_init(atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000287
288template <class T>
289 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000290 atomic_store(volatile atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000291
292template <class T>
293 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000294 atomic_store(atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000295
296template <class T>
297 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000298 atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000299
300template <class T>
301 void
Howard Hinnanteee2c142012-04-11 20:14:21 +0000302 atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000303
304template <class T>
305 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000306 atomic_load(const volatile atomic<T>* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000307
308template <class T>
309 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000310 atomic_load(const atomic<T>* obj) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000311
312template <class T>
313 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000314 atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000315
316template <class T>
317 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000318 atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000319
320template <class T>
321 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000322 atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000323
324template <class T>
325 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000326 atomic_exchange(atomic<T>* obj, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000327
328template <class T>
329 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000330 atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000331
332template <class T>
333 T
Howard Hinnanteee2c142012-04-11 20:14:21 +0000334 atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000335
336template <class T>
337 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000338 atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000339
340template <class T>
341 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000342 atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000343
344template <class T>
345 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000346 atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000347
348template <class T>
349 bool
Howard Hinnanteee2c142012-04-11 20:14:21 +0000350 atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000351
352template <class T>
353 bool
354 atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
355 T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000356 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000357
358template <class T>
359 bool
360 atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000361 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000362
363template <class T>
364 bool
365 atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
366 T* expc, T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000367 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000368
369template <class T>
370 bool
371 atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
372 T desr,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000373 memory_order s, memory_order f) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000374
375template <class Integral>
376 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000377 atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000378
379template <class Integral>
380 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000381 atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000382
383template <class Integral>
384 Integral
385 atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000386 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000387template <class Integral>
388 Integral
389 atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000390 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000391template <class Integral>
392 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000393 atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000394
395template <class Integral>
396 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000397 atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000398
399template <class Integral>
400 Integral
401 atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000402 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000403template <class Integral>
404 Integral
405 atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000406 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000407template <class Integral>
408 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000409 atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000410
411template <class Integral>
412 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000413 atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000414
415template <class Integral>
416 Integral
417 atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000418 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000419template <class Integral>
420 Integral
421 atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000422 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000423template <class Integral>
424 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000425 atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000426
427template <class Integral>
428 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000429 atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000430
431template <class Integral>
432 Integral
433 atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000434 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000435template <class Integral>
436 Integral
437 atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000438 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000439template <class Integral>
440 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000441 atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000442
443template <class Integral>
444 Integral
Howard Hinnanteee2c142012-04-11 20:14:21 +0000445 atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000446
447template <class Integral>
448 Integral
449 atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000450 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000451template <class Integral>
452 Integral
453 atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000454 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000455
456template <class T>
457 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000458 atomic_fetch_add(volatile atomic<T*>* obj, ptrdiff_t op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000459
460template <class T>
461 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000462 atomic_fetch_add(atomic<T*>* obj, ptrdiff_t op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000463
464template <class T>
465 T*
466 atomic_fetch_add_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000467 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000468template <class T>
469 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000470 atomic_fetch_add_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000471
472template <class T>
473 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000474 atomic_fetch_sub(volatile atomic<T*>* obj, ptrdiff_t op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000475
476template <class T>
477 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000478 atomic_fetch_sub(atomic<T*>* obj, ptrdiff_t op) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000479
480template <class T>
481 T*
482 atomic_fetch_sub_explicit(volatile atomic<T*>* obj, ptrdiff_t op,
Howard Hinnanteee2c142012-04-11 20:14:21 +0000483 memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000484template <class T>
485 T*
Howard Hinnanteee2c142012-04-11 20:14:21 +0000486 atomic_fetch_sub_explicit(atomic<T*>* obj, ptrdiff_t op, memory_order m) noexcept;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000487
488// Atomics for standard typedef types
489
Howard Hinnantf0af8d92013-01-04 18:58:50 +0000490typedef atomic<bool> atomic_bool;
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000491typedef atomic<char> atomic_char;
492typedef atomic<signed char> atomic_schar;
493typedef atomic<unsigned char> atomic_uchar;
494typedef atomic<short> atomic_short;
495typedef atomic<unsigned short> atomic_ushort;
496typedef atomic<int> atomic_int;
497typedef atomic<unsigned int> atomic_uint;
498typedef atomic<long> atomic_long;
499typedef atomic<unsigned long> atomic_ulong;
500typedef atomic<long long> atomic_llong;
501typedef atomic<unsigned long long> atomic_ullong;
502typedef atomic<char16_t> atomic_char16_t;
503typedef atomic<char32_t> atomic_char32_t;
504typedef atomic<wchar_t> atomic_wchar_t;
505
506typedef atomic<int_least8_t> atomic_int_least8_t;
507typedef atomic<uint_least8_t> atomic_uint_least8_t;
508typedef atomic<int_least16_t> atomic_int_least16_t;
509typedef atomic<uint_least16_t> atomic_uint_least16_t;
510typedef atomic<int_least32_t> atomic_int_least32_t;
511typedef atomic<uint_least32_t> atomic_uint_least32_t;
512typedef atomic<int_least64_t> atomic_int_least64_t;
513typedef atomic<uint_least64_t> atomic_uint_least64_t;
514
515typedef atomic<int_fast8_t> atomic_int_fast8_t;
516typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
517typedef atomic<int_fast16_t> atomic_int_fast16_t;
518typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
519typedef atomic<int_fast32_t> atomic_int_fast32_t;
520typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
521typedef atomic<int_fast64_t> atomic_int_fast64_t;
522typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
523
Marshall Clowf710afc2016-06-30 15:28:38 +0000524typedef atomic<int8_t> atomic_int8_t;
525typedef atomic<uint8_t> atomic_uint8_t;
526typedef atomic<int16_t> atomic_int16_t;
527typedef atomic<uint16_t> atomic_uint16_t;
528typedef atomic<int32_t> atomic_int32_t;
529typedef atomic<uint32_t> atomic_uint32_t;
530typedef atomic<int64_t> atomic_int64_t;
531typedef atomic<uint64_t> atomic_uint64_t;
532
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000533typedef atomic<intptr_t> atomic_intptr_t;
534typedef atomic<uintptr_t> atomic_uintptr_t;
535typedef atomic<size_t> atomic_size_t;
536typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
537typedef atomic<intmax_t> atomic_intmax_t;
538typedef atomic<uintmax_t> atomic_uintmax_t;
539
Howard Hinnant71be7292010-09-27 21:17:38 +0000540// fences
541
Howard Hinnanteee2c142012-04-11 20:14:21 +0000542void atomic_thread_fence(memory_order m) noexcept;
543void atomic_signal_fence(memory_order m) noexcept;
Howard Hinnant71be7292010-09-27 21:17:38 +0000544
545} // std
546
547*/
548
549#include <__config>
Howard Hinnant7bfaeb82010-12-06 23:10:08 +0000550#include <cstddef>
551#include <cstdint>
552#include <type_traits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000553#include <version>
Howard Hinnant71be7292010-09-27 21:17:38 +0000554
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000555#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnant71be7292010-09-27 21:17:38 +0000556#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000557#endif
Howard Hinnant71be7292010-09-27 21:17:38 +0000558
Jonathan Roelofs39cb6bf2014-09-05 19:45:05 +0000559#ifdef _LIBCPP_HAS_NO_THREADS
Davide Italiano011f80a2019-03-05 18:40:49 +0000560# error <atomic> is not supported on this single threaded system
Eric Fiselier8020b6c2015-08-19 17:21:46 +0000561#endif
Davide Italiano011f80a2019-03-05 18:40:49 +0000562#ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER
563# error <atomic> is not implemented
Eric Fiselier8020b6c2015-08-19 17:21:46 +0000564#endif
Volodymyr Sapsaif3ed1fd2018-05-15 22:38:31 +0000565#ifdef kill_dependency
Davide Italiano011f80a2019-03-05 18:40:49 +0000566# error C++ standard library is incompatible with <stdatomic.h>
Volodymyr Sapsaif3ed1fd2018-05-15 22:38:31 +0000567#endif
Jonathan Roelofs39cb6bf2014-09-05 19:45:05 +0000568
Eric Fiselierb5ab51d2017-01-13 23:45:39 +0000569#define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \
570 _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume || \
571 __m == memory_order_acquire || \
572 __m == memory_order_acq_rel, \
573 "memory order argument to atomic operation is invalid")
574
575#define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) \
576 _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || \
577 __m == memory_order_acq_rel, \
578 "memory order argument to atomic operation is invalid")
579
580#define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__m, __f) \
581 _LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release || \
582 __f == memory_order_acq_rel, \
583 "memory order argument to atomic operation is invalid")
584
Howard Hinnant71be7292010-09-27 21:17:38 +0000585_LIBCPP_BEGIN_NAMESPACE_STD
586
Davide Italiano011f80a2019-03-05 18:40:49 +0000587#if _LIBCPP_STD_VER > 17
588
Louis Dionne66af0602019-03-06 17:07:24 +0000589enum class memory_order {
Davide Italiano011f80a2019-03-05 18:40:49 +0000590 relaxed, consume, acquire, release, acq_rel, seq_cst
591};
592
593inline constexpr auto memory_order_relaxed = memory_order::relaxed;
594inline constexpr auto memory_order_consume = memory_order::consume;
595inline constexpr auto memory_order_acquire = memory_order::acquire;
596inline constexpr auto memory_order_release = memory_order::release;
597inline constexpr auto memory_order_acq_rel = memory_order::acq_rel;
598inline constexpr auto memory_order_seq_cst = memory_order::seq_cst;
599
Davide Italiano011f80a2019-03-05 18:40:49 +0000600#else
601
602typedef enum memory_order {
603 memory_order_relaxed, memory_order_consume, memory_order_acquire,
604 memory_order_release, memory_order_acq_rel, memory_order_seq_cst
Howard Hinnantdca6e712010-09-28 17:13:38 +0000605} memory_order;
606
Davide Italiano011f80a2019-03-05 18:40:49 +0000607#endif // _LIBCPP_STD_VER > 17
608
Louis Dionne66af0602019-03-06 17:07:24 +0000609typedef underlying_type<memory_order>::type __memory_order_underlying_t;
Davide Italiano011f80a2019-03-05 18:40:49 +0000610
611
612#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) || \
613 defined(_LIBCPP_ATOMIC_ONLY_USE_BUILTINS)
614
615// [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because
616// the default operator= in an object is not volatile, a byte-by-byte copy
617// is required.
618template <typename _Tp, typename _Tv> _LIBCPP_INLINE_VISIBILITY
619typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
620__cxx_atomic_assign_volatile(_Tp& __a_value, _Tv const& __val) {
621 __a_value = __val;
622}
623template <typename _Tp, typename _Tv> _LIBCPP_INLINE_VISIBILITY
624typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
625__cxx_atomic_assign_volatile(_Tp volatile& __a_value, _Tv volatile const& __val) {
626 volatile char* __to = reinterpret_cast<volatile char*>(&__a_value);
627 volatile char* __end = __to + sizeof(_Tp);
628 volatile const char* __from = reinterpret_cast<volatile const char*>(&__val);
629 while (__to != __end)
630 *__to++ = *__from++;
631}
632
Davide Italiano31f218a2019-03-05 17:38:33 +0000633#endif
Louis Dionnea1ae0032019-03-04 15:26:27 +0000634
Davide Italiano011f80a2019-03-05 18:40:49 +0000635#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
636
637template <typename _Tp>
638struct __cxx_atomic_base_impl {
639
Eric Fiselier684aaca2015-10-14 08:36:22 +0000640 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier07b2b552016-11-18 06:42:17 +0000641#ifndef _LIBCPP_CXX03_LANG
Davide Italiano011f80a2019-03-05 18:40:49 +0000642 __cxx_atomic_base_impl() _NOEXCEPT = default;
Eric Fiselier684aaca2015-10-14 08:36:22 +0000643#else
Davide Italiano011f80a2019-03-05 18:40:49 +0000644 __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
Eric Fiselier07b2b552016-11-18 06:42:17 +0000645#endif // _LIBCPP_CXX03_LANG
Davide Italiano011f80a2019-03-05 18:40:49 +0000646 _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
Eric Fiselier719e0442015-07-14 17:50:27 +0000647 : __a_value(value) {}
Marshall Clow290eb3f2015-01-11 06:15:59 +0000648 _Tp __a_value;
Dan Albert7b65ace2014-08-09 23:51:51 +0000649};
Dan Albert7b65ace2014-08-09 23:51:51 +0000650
Davide Italiano011f80a2019-03-05 18:40:49 +0000651_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000652 // Avoid switch statement to make this a constexpr.
653 return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
654 (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
655 (__order == memory_order_release ? __ATOMIC_RELEASE:
656 (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
657 (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
658 __ATOMIC_CONSUME))));
659}
660
Davide Italiano011f80a2019-03-05 18:40:49 +0000661_LIBCPP_INLINE_VISIBILITY inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
Dan Albert48815f22015-01-06 18:39:37 +0000662 // Avoid switch statement to make this a constexpr.
663 return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
664 (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
665 (__order == memory_order_release ? __ATOMIC_RELAXED:
666 (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
667 (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE:
668 __ATOMIC_CONSUME))));
669}
670
Davide Italiano011f80a2019-03-05 18:40:49 +0000671template <typename _Tp>
672_LIBCPP_INLINE_VISIBILITY
673void __cxx_atomic_init(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val) {
674 __cxx_atomic_assign_volatile(__a->__a_value, __val);
675}
Dan Albert7b65ace2014-08-09 23:51:51 +0000676
677template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000678_LIBCPP_INLINE_VISIBILITY
679void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000680 __a->__a_value = __val;
681}
682
Davide Italiano011f80a2019-03-05 18:40:49 +0000683_LIBCPP_INLINE_VISIBILITY inline
684void __cxx_atomic_thread_fence(memory_order __order) {
685 __atomic_thread_fence(__to_gcc_order(__order));
686}
687
688_LIBCPP_INLINE_VISIBILITY inline
689void __cxx_atomic_signal_fence(memory_order __order) {
690 __atomic_signal_fence(__to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000691}
692
693template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000694_LIBCPP_INLINE_VISIBILITY
695void __cxx_atomic_store(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val,
696 memory_order __order) {
Dan Albert48815f22015-01-06 18:39:37 +0000697 __atomic_store(&__a->__a_value, &__val,
Davide Italiano011f80a2019-03-05 18:40:49 +0000698 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000699}
700
701template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000702_LIBCPP_INLINE_VISIBILITY
703void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val,
704 memory_order __order) {
705 __atomic_store(&__a->__a_value, &__val,
706 __to_gcc_order(__order));
707}
708
709template <typename _Tp>
710_LIBCPP_INLINE_VISIBILITY
711_Tp __cxx_atomic_load(const volatile __cxx_atomic_base_impl<_Tp>* __a,
712 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000713 _Tp __ret;
714 __atomic_load(&__a->__a_value, &__ret,
Davide Italiano011f80a2019-03-05 18:40:49 +0000715 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000716 return __ret;
717}
718
719template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000720_LIBCPP_INLINE_VISIBILITY
721_Tp __cxx_atomic_load(const __cxx_atomic_base_impl<_Tp>* __a, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000722 _Tp __ret;
723 __atomic_load(&__a->__a_value, &__ret,
Davide Italiano011f80a2019-03-05 18:40:49 +0000724 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000725 return __ret;
726}
727
728template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000729_LIBCPP_INLINE_VISIBILITY
730_Tp __cxx_atomic_exchange(volatile __cxx_atomic_base_impl<_Tp>* __a,
731 _Tp __value, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000732 _Tp __ret;
733 __atomic_exchange(&__a->__a_value, &__value, &__ret,
Davide Italiano011f80a2019-03-05 18:40:49 +0000734 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000735 return __ret;
736}
737
738template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000739_LIBCPP_INLINE_VISIBILITY
740_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp>* __a, _Tp __value,
741 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000742 _Tp __ret;
743 __atomic_exchange(&__a->__a_value, &__value, &__ret,
Davide Italiano011f80a2019-03-05 18:40:49 +0000744 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000745 return __ret;
746}
747
748template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000749_LIBCPP_INLINE_VISIBILITY
750bool __cxx_atomic_compare_exchange_strong(
751 volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value,
JF Bastien6e412d92018-05-26 19:44:45 +0000752 memory_order __success, memory_order __failure) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000753 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
754 false,
Davide Italiano011f80a2019-03-05 18:40:49 +0000755 __to_gcc_order(__success),
756 __to_gcc_failure_order(__failure));
Dan Albert7b65ace2014-08-09 23:51:51 +0000757}
758
759template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000760_LIBCPP_INLINE_VISIBILITY
761bool __cxx_atomic_compare_exchange_strong(
762 __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success,
JF Bastien6e412d92018-05-26 19:44:45 +0000763 memory_order __failure) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000764 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
765 false,
Davide Italiano011f80a2019-03-05 18:40:49 +0000766 __to_gcc_order(__success),
767 __to_gcc_failure_order(__failure));
Dan Albert7b65ace2014-08-09 23:51:51 +0000768}
769
770template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000771_LIBCPP_INLINE_VISIBILITY
772bool __cxx_atomic_compare_exchange_weak(
773 volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value,
JF Bastien6e412d92018-05-26 19:44:45 +0000774 memory_order __success, memory_order __failure) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000775 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
776 true,
Davide Italiano011f80a2019-03-05 18:40:49 +0000777 __to_gcc_order(__success),
778 __to_gcc_failure_order(__failure));
Dan Albert7b65ace2014-08-09 23:51:51 +0000779}
780
781template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000782_LIBCPP_INLINE_VISIBILITY
783bool __cxx_atomic_compare_exchange_weak(
784 __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success,
JF Bastien6e412d92018-05-26 19:44:45 +0000785 memory_order __failure) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000786 return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
787 true,
Davide Italiano011f80a2019-03-05 18:40:49 +0000788 __to_gcc_order(__success),
789 __to_gcc_failure_order(__failure));
Dan Albert7b65ace2014-08-09 23:51:51 +0000790}
791
792template <typename _Tp>
793struct __skip_amt { enum {value = 1}; };
794
795template <typename _Tp>
796struct __skip_amt<_Tp*> { enum {value = sizeof(_Tp)}; };
797
798// FIXME: Haven't figured out what the spec says about using arrays with
799// atomic_fetch_add. Force a failure rather than creating bad behavior.
800template <typename _Tp>
801struct __skip_amt<_Tp[]> { };
802template <typename _Tp, int n>
803struct __skip_amt<_Tp[n]> { };
804
805template <typename _Tp, typename _Td>
Davide Italiano011f80a2019-03-05 18:40:49 +0000806_LIBCPP_INLINE_VISIBILITY
807_Tp __cxx_atomic_fetch_add(volatile __cxx_atomic_base_impl<_Tp>* __a,
808 _Td __delta, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000809 return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
Davide Italiano011f80a2019-03-05 18:40:49 +0000810 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000811}
812
813template <typename _Tp, typename _Td>
Davide Italiano011f80a2019-03-05 18:40:49 +0000814_LIBCPP_INLINE_VISIBILITY
815_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta,
816 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000817 return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
Davide Italiano011f80a2019-03-05 18:40:49 +0000818 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000819}
820
821template <typename _Tp, typename _Td>
Davide Italiano011f80a2019-03-05 18:40:49 +0000822_LIBCPP_INLINE_VISIBILITY
823_Tp __cxx_atomic_fetch_sub(volatile __cxx_atomic_base_impl<_Tp>* __a,
824 _Td __delta, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000825 return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
Davide Italiano011f80a2019-03-05 18:40:49 +0000826 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000827}
828
829template <typename _Tp, typename _Td>
Davide Italiano011f80a2019-03-05 18:40:49 +0000830_LIBCPP_INLINE_VISIBILITY
831_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta,
832 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000833 return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
Davide Italiano011f80a2019-03-05 18:40:49 +0000834 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000835}
836
837template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000838_LIBCPP_INLINE_VISIBILITY
839_Tp __cxx_atomic_fetch_and(volatile __cxx_atomic_base_impl<_Tp>* __a,
840 _Tp __pattern, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000841 return __atomic_fetch_and(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000842 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000843}
844
845template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000846_LIBCPP_INLINE_VISIBILITY
847_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp>* __a,
848 _Tp __pattern, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000849 return __atomic_fetch_and(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000850 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000851}
852
853template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000854_LIBCPP_INLINE_VISIBILITY
855_Tp __cxx_atomic_fetch_or(volatile __cxx_atomic_base_impl<_Tp>* __a,
856 _Tp __pattern, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000857 return __atomic_fetch_or(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000858 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000859}
860
861template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000862_LIBCPP_INLINE_VISIBILITY
863_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
864 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000865 return __atomic_fetch_or(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000866 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000867}
868
869template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000870_LIBCPP_INLINE_VISIBILITY
871_Tp __cxx_atomic_fetch_xor(volatile __cxx_atomic_base_impl<_Tp>* __a,
872 _Tp __pattern, memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000873 return __atomic_fetch_xor(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000874 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000875}
876
877template <typename _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +0000878_LIBCPP_INLINE_VISIBILITY
879_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
880 memory_order __order) {
Dan Albert7b65ace2014-08-09 23:51:51 +0000881 return __atomic_fetch_xor(&__a->__a_value, __pattern,
Davide Italiano011f80a2019-03-05 18:40:49 +0000882 __to_gcc_order(__order));
Dan Albert7b65ace2014-08-09 23:51:51 +0000883}
Davide Italiano011f80a2019-03-05 18:40:49 +0000884
885#define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
886
887#elif defined(_LIBCPP_HAS_C_ATOMIC_IMP)
888
889template <typename _Tp>
890struct __cxx_atomic_base_impl {
891
892 _LIBCPP_INLINE_VISIBILITY
893#ifndef _LIBCPP_CXX03_LANG
894 __cxx_atomic_base_impl() _NOEXCEPT = default;
895#else
896 __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
897#endif // _LIBCPP_CXX03_LANG
898 _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
899 : __a_value(value) {}
900 _Atomic(_Tp) __a_value;
901};
902
903#define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)
904
905_LIBCPP_INLINE_VISIBILITY inline
906void __cxx_atomic_thread_fence(memory_order __order) {
907 __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));
908}
909
910_LIBCPP_INLINE_VISIBILITY inline
911void __cxx_atomic_signal_fence(memory_order __order) {
912 __c11_atomic_signal_fence(static_cast<__memory_order_underlying_t>(__order));
913}
914
915template<class _Tp>
916_LIBCPP_INLINE_VISIBILITY
917void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val) {
918 __c11_atomic_init(&__a->__a_value, __val);
919}
920template<class _Tp>
921_LIBCPP_INLINE_VISIBILITY
922void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val) {
923 __c11_atomic_init(&__a->__a_value, __val);
924}
925
926template<class _Tp>
927_LIBCPP_INLINE_VISIBILITY
928void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) {
929 __c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order));
930}
931template<class _Tp>
932_LIBCPP_INLINE_VISIBILITY
933void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val, memory_order __order) {
934 __c11_atomic_store(&__a->__a_value, __val, static_cast<__memory_order_underlying_t>(__order));
935}
936
937template<class _Tp>
938_LIBCPP_INLINE_VISIBILITY
939_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) {
940 using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*;
941 return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
942}
943template<class _Tp>
944_LIBCPP_INLINE_VISIBILITY
945_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) {
946 using __ptr_type = typename remove_const<decltype(__a->__a_value)>::type*;
947 return __c11_atomic_load(const_cast<__ptr_type>(&__a->__a_value), static_cast<__memory_order_underlying_t>(__order));
948}
949
950template<class _Tp>
951_LIBCPP_INLINE_VISIBILITY
952_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) {
953 return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order));
954}
955template<class _Tp>
956_LIBCPP_INLINE_VISIBILITY
957_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> * __a, _Tp __value, memory_order __order) {
958 return __c11_atomic_exchange(&__a->__a_value, __value, static_cast<__memory_order_underlying_t>(__order));
959}
960
961template<class _Tp>
962_LIBCPP_INLINE_VISIBILITY
963bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
964 return __c11_atomic_compare_exchange_strong(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
965}
966template<class _Tp>
967_LIBCPP_INLINE_VISIBILITY
968bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
969 return __c11_atomic_compare_exchange_strong(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
970}
971
972template<class _Tp>
973_LIBCPP_INLINE_VISIBILITY
974bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
975 return __c11_atomic_compare_exchange_weak(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
976}
977template<class _Tp>
978_LIBCPP_INLINE_VISIBILITY
979bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
980 return __c11_atomic_compare_exchange_weak(&__a->__a_value, __expected, __value, static_cast<__memory_order_underlying_t>(__success), static_cast<__memory_order_underlying_t>(__failure));
981}
982
983template<class _Tp>
984_LIBCPP_INLINE_VISIBILITY
985_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) {
986 return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
987}
988template<class _Tp>
989_LIBCPP_INLINE_VISIBILITY
990_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) {
991 return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
992}
993
994template<class _Tp>
995_LIBCPP_INLINE_VISIBILITY
996_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) {
997 return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
998}
999template<class _Tp>
1000_LIBCPP_INLINE_VISIBILITY
1001_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) {
1002 return __c11_atomic_fetch_add(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
1003}
1004
1005template<class _Tp>
1006_LIBCPP_INLINE_VISIBILITY
1007_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) {
1008 return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
1009}
1010template<class _Tp>
1011_LIBCPP_INLINE_VISIBILITY
1012_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) {
1013 return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
1014}
1015template<class _Tp>
1016_LIBCPP_INLINE_VISIBILITY
1017_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) {
1018 return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
1019}
1020template<class _Tp>
1021_LIBCPP_INLINE_VISIBILITY
1022_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) {
1023 return __c11_atomic_fetch_sub(&__a->__a_value, __delta, static_cast<__memory_order_underlying_t>(__order));
1024}
1025
1026template<class _Tp>
1027_LIBCPP_INLINE_VISIBILITY
1028_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) {
1029 return __c11_atomic_fetch_and(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1030}
1031template<class _Tp>
1032_LIBCPP_INLINE_VISIBILITY
1033_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) {
1034 return __c11_atomic_fetch_and(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1035}
1036
1037template<class _Tp>
1038_LIBCPP_INLINE_VISIBILITY
1039_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) {
1040 return __c11_atomic_fetch_or(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1041}
1042template<class _Tp>
1043_LIBCPP_INLINE_VISIBILITY
1044_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) {
1045 return __c11_atomic_fetch_or(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1046}
1047
1048template<class _Tp>
1049_LIBCPP_INLINE_VISIBILITY
1050_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) {
1051 return __c11_atomic_fetch_xor(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1052}
1053template<class _Tp>
1054_LIBCPP_INLINE_VISIBILITY
1055_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) {
1056 return __c11_atomic_fetch_xor(&__a->__a_value, __pattern, static_cast<__memory_order_underlying_t>(__order));
1057}
1058
1059#endif // _LIBCPP_HAS_GCC_ATOMIC_IMP, _LIBCPP_HAS_C_ATOMIC_IMP
Dan Albert7b65ace2014-08-09 23:51:51 +00001060
Howard Hinnantdca6e712010-09-28 17:13:38 +00001061template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001062_LIBCPP_INLINE_VISIBILITY
1063_Tp kill_dependency(_Tp __y) _NOEXCEPT
Howard Hinnantdca6e712010-09-28 17:13:38 +00001064{
1065 return __y;
1066}
Howard Hinnant71be7292010-09-27 21:17:38 +00001067
Eric Fiselierbed42df2017-04-20 23:22:46 +00001068#if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
1069# define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE
1070# define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE
1071# define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
1072# define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
1073# define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
1074# define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
1075# define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
1076# define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
1077# define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
1078# define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
Davide Italiano011f80a2019-03-05 18:40:49 +00001079#elif defined(__GCC_ATOMIC_BOOL_LOCK_FREE)
Eric Fiselierbed42df2017-04-20 23:22:46 +00001080# define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
1081# define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
1082# define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
1083# define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
1084# define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
1085# define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
1086# define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
1087# define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
1088# define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
1089# define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
1090#endif
JF Bastienfdb42c22016-03-25 15:48:21 +00001091
Davide Italiano011f80a2019-03-05 18:40:49 +00001092#ifdef _LIBCPP_ATOMIC_ONLY_USE_BUILTINS
1093
1094template<typename _Tp>
1095struct __cxx_atomic_lock_impl {
1096
1097 _LIBCPP_INLINE_VISIBILITY
1098 __cxx_atomic_lock_impl() _NOEXCEPT
1099 : __a_value(), __a_lock(0) {}
1100 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit
1101 __cxx_atomic_lock_impl(_Tp value) _NOEXCEPT
1102 : __a_value(value), __a_lock(0) {}
1103
1104 _Tp __a_value;
1105 mutable __cxx_atomic_base_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_lock;
1106
1107 _LIBCPP_INLINE_VISIBILITY void __lock() const volatile {
1108 while(1 == __cxx_atomic_exchange(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(true), memory_order_acquire))
1109 /*spin*/;
1110 }
1111 _LIBCPP_INLINE_VISIBILITY void __lock() const {
1112 while(1 == __cxx_atomic_exchange(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(true), memory_order_acquire))
1113 /*spin*/;
1114 }
1115 _LIBCPP_INLINE_VISIBILITY void __unlock() const volatile {
1116 __cxx_atomic_store(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(false), memory_order_release);
1117 }
1118 _LIBCPP_INLINE_VISIBILITY void __unlock() const {
1119 __cxx_atomic_store(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(false), memory_order_release);
1120 }
1121 _LIBCPP_INLINE_VISIBILITY _Tp __read() const volatile {
1122 __lock();
1123 _Tp __old;
1124 __cxx_atomic_assign_volatile(__old, __a_value);
1125 __unlock();
1126 return __old;
1127 }
1128 _LIBCPP_INLINE_VISIBILITY _Tp __read() const {
1129 __lock();
1130 _Tp __old = __a_value;
1131 __unlock();
1132 return __old;
1133 }
1134};
1135
1136template <typename _Tp>
1137_LIBCPP_INLINE_VISIBILITY
1138void __cxx_atomic_init(volatile __cxx_atomic_lock_impl<_Tp>* __a, _Tp __val) {
1139 __cxx_atomic_assign_volatile(__a->__a_value, __val);
1140}
1141template <typename _Tp>
1142_LIBCPP_INLINE_VISIBILITY
1143void __cxx_atomic_init(__cxx_atomic_lock_impl<_Tp>* __a, _Tp __val) {
1144 __a->__a_value = __val;
1145}
1146
1147template <typename _Tp>
1148_LIBCPP_INLINE_VISIBILITY
1149void __cxx_atomic_store(volatile __cxx_atomic_lock_impl<_Tp>* __a, _Tp __val, memory_order) {
1150 __a->__lock();
1151 __cxx_atomic_assign_volatile(__a->__a_value, __val);
1152 __a->__unlock();
1153}
1154template <typename _Tp>
1155_LIBCPP_INLINE_VISIBILITY
1156void __cxx_atomic_store(__cxx_atomic_lock_impl<_Tp>* __a, _Tp __val, memory_order) {
1157 __a->__lock();
1158 __a->__a_value = __val;
1159 __a->__unlock();
1160}
1161
1162template <typename _Tp>
1163_LIBCPP_INLINE_VISIBILITY
1164_Tp __cxx_atomic_load(const volatile __cxx_atomic_lock_impl<_Tp>* __a, memory_order) {
1165 return __a->__read();
1166}
1167template <typename _Tp>
1168_LIBCPP_INLINE_VISIBILITY
1169_Tp __cxx_atomic_load(const __cxx_atomic_lock_impl<_Tp>* __a, memory_order) {
1170 return __a->__read();
1171}
1172
1173template <typename _Tp>
1174_LIBCPP_INLINE_VISIBILITY
1175_Tp __cxx_atomic_exchange(volatile __cxx_atomic_lock_impl<_Tp>* __a, _Tp __value, memory_order) {
1176 __a->__lock();
1177 _Tp __old;
1178 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1179 __cxx_atomic_assign_volatile(__a->__a_value, __value);
1180 __a->__unlock();
1181 return __old;
1182}
1183template <typename _Tp>
1184_LIBCPP_INLINE_VISIBILITY
1185_Tp __cxx_atomic_exchange(__cxx_atomic_lock_impl<_Tp>* __a, _Tp __value, memory_order) {
1186 __a->__lock();
1187 _Tp __old = __a->__a_value;
1188 __a->__a_value = __value;
1189 __a->__unlock();
1190 return __old;
1191}
1192
1193template <typename _Tp>
1194_LIBCPP_INLINE_VISIBILITY
1195bool __cxx_atomic_compare_exchange_strong(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1196 _Tp* __expected, _Tp __value, memory_order, memory_order) {
1197 __a->__lock();
1198 _Tp temp;
1199 __cxx_atomic_assign_volatile(temp, __a->__a_value);
1200 bool __ret = temp == *__expected;
1201 if(__ret)
1202 __cxx_atomic_assign_volatile(__a->__a_value, __value);
1203 else
1204 __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
1205 __a->__unlock();
1206 return __ret;
1207}
1208template <typename _Tp>
1209_LIBCPP_INLINE_VISIBILITY
1210bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_lock_impl<_Tp>* __a,
1211 _Tp* __expected, _Tp __value, memory_order, memory_order) {
1212 __a->__lock();
1213 bool __ret = __a->__a_value == *__expected;
1214 if(__ret)
1215 __a->__a_value = __value;
1216 else
1217 *__expected = __a->__a_value;
1218 __a->__unlock();
1219 return __ret;
1220}
1221
1222template <typename _Tp>
1223_LIBCPP_INLINE_VISIBILITY
1224bool __cxx_atomic_compare_exchange_weak(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1225 _Tp* __expected, _Tp __value, memory_order, memory_order) {
1226 __a->__lock();
1227 _Tp temp;
1228 __cxx_atomic_assign_volatile(temp, __a->__a_value);
1229 bool __ret = temp == *__expected;
1230 if(__ret)
1231 __cxx_atomic_assign_volatile(__a->__a_value, __value);
1232 else
1233 __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
1234 __a->__unlock();
1235 return __ret;
1236}
1237template <typename _Tp>
1238_LIBCPP_INLINE_VISIBILITY
1239bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_lock_impl<_Tp>* __a,
1240 _Tp* __expected, _Tp __value, memory_order, memory_order) {
1241 __a->__lock();
1242 bool __ret = __a->__a_value == *__expected;
1243 if(__ret)
1244 __a->__a_value = __value;
1245 else
1246 *__expected = __a->__a_value;
1247 __a->__unlock();
1248 return __ret;
1249}
1250
1251template <typename _Tp, typename _Td>
1252_LIBCPP_INLINE_VISIBILITY
1253_Tp __cxx_atomic_fetch_add(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1254 _Td __delta, memory_order) {
1255 __a->__lock();
1256 _Tp __old;
1257 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1258 __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old + __delta));
1259 __a->__unlock();
1260 return __old;
1261}
1262template <typename _Tp, typename _Td>
1263_LIBCPP_INLINE_VISIBILITY
1264_Tp __cxx_atomic_fetch_add(__cxx_atomic_lock_impl<_Tp>* __a,
1265 _Td __delta, memory_order) {
1266 __a->__lock();
1267 _Tp __old = __a->__a_value;
1268 __a->__a_value += __delta;
1269 __a->__unlock();
1270 return __old;
1271}
1272
1273template <typename _Tp, typename _Td>
1274_LIBCPP_INLINE_VISIBILITY
1275_Tp* __cxx_atomic_fetch_add(volatile __cxx_atomic_lock_impl<_Tp*>* __a,
1276 ptrdiff_t __delta, memory_order) {
1277 __a->__lock();
1278 _Tp* __old;
1279 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1280 __cxx_atomic_assign_volatile(__a->__a_value, __old + __delta);
1281 __a->__unlock();
1282 return __old;
1283}
1284template <typename _Tp, typename _Td>
1285_LIBCPP_INLINE_VISIBILITY
1286_Tp* __cxx_atomic_fetch_add(__cxx_atomic_lock_impl<_Tp*>* __a,
1287 ptrdiff_t __delta, memory_order) {
1288 __a->__lock();
1289 _Tp* __old = __a->__a_value;
1290 __a->__a_value += __delta;
1291 __a->__unlock();
1292 return __old;
1293}
1294
1295template <typename _Tp, typename _Td>
1296_LIBCPP_INLINE_VISIBILITY
1297_Tp __cxx_atomic_fetch_sub(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1298 _Td __delta, memory_order) {
1299 __a->__lock();
1300 _Tp __old;
1301 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1302 __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old - __delta));
1303 __a->__unlock();
1304 return __old;
1305}
1306template <typename _Tp, typename _Td>
1307_LIBCPP_INLINE_VISIBILITY
1308_Tp __cxx_atomic_fetch_sub(__cxx_atomic_lock_impl<_Tp>* __a,
1309 _Td __delta, memory_order) {
1310 __a->__lock();
1311 _Tp __old = __a->__a_value;
1312 __a->__a_value -= __delta;
1313 __a->__unlock();
1314 return __old;
1315}
1316
1317template <typename _Tp>
1318_LIBCPP_INLINE_VISIBILITY
1319_Tp __cxx_atomic_fetch_and(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1320 _Tp __pattern, memory_order) {
1321 __a->__lock();
1322 _Tp __old;
1323 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1324 __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old & __pattern));
1325 __a->__unlock();
1326 return __old;
1327}
1328template <typename _Tp>
1329_LIBCPP_INLINE_VISIBILITY
1330_Tp __cxx_atomic_fetch_and(__cxx_atomic_lock_impl<_Tp>* __a,
1331 _Tp __pattern, memory_order) {
1332 __a->__lock();
1333 _Tp __old = __a->__a_value;
1334 __a->__a_value &= __pattern;
1335 __a->__unlock();
1336 return __old;
1337}
1338
1339template <typename _Tp>
1340_LIBCPP_INLINE_VISIBILITY
1341_Tp __cxx_atomic_fetch_or(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1342 _Tp __pattern, memory_order) {
1343 __a->__lock();
1344 _Tp __old;
1345 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1346 __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old | __pattern));
1347 __a->__unlock();
1348 return __old;
1349}
1350template <typename _Tp>
1351_LIBCPP_INLINE_VISIBILITY
1352_Tp __cxx_atomic_fetch_or(__cxx_atomic_lock_impl<_Tp>* __a,
1353 _Tp __pattern, memory_order) {
1354 __a->__lock();
1355 _Tp __old = __a->__a_value;
1356 __a->__a_value |= __pattern;
1357 __a->__unlock();
1358 return __old;
1359}
1360
1361template <typename _Tp>
1362_LIBCPP_INLINE_VISIBILITY
1363_Tp __cxx_atomic_fetch_xor(volatile __cxx_atomic_lock_impl<_Tp>* __a,
1364 _Tp __pattern, memory_order) {
1365 __a->__lock();
1366 _Tp __old;
1367 __cxx_atomic_assign_volatile(__old, __a->__a_value);
1368 __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old ^ __pattern));
1369 __a->__unlock();
1370 return __old;
1371}
1372template <typename _Tp>
1373_LIBCPP_INLINE_VISIBILITY
1374_Tp __cxx_atomic_fetch_xor(__cxx_atomic_lock_impl<_Tp>* __a,
1375 _Tp __pattern, memory_order) {
1376 __a->__lock();
1377 _Tp __old = __a->__a_value;
1378 __a->__a_value ^= __pattern;
1379 __a->__unlock();
1380 return __old;
1381}
1382
1383#ifdef __cpp_lib_atomic_is_always_lock_free
1384
1385template<typename _Tp> struct __cxx_is_always_lock_free {
1386 enum { __value = __atomic_always_lock_free(sizeof(_Tp), 0) }; };
1387
1388#else
1389
1390template<typename _Tp> struct __cxx_is_always_lock_free { enum { __value = false }; };
1391// Implementations must match the C ATOMIC_*_LOCK_FREE macro values.
1392template<> struct __cxx_is_always_lock_free<bool> { enum { __value = 2 == ATOMIC_BOOL_LOCK_FREE }; };
1393template<> struct __cxx_is_always_lock_free<char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
1394template<> struct __cxx_is_always_lock_free<signed char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
1395template<> struct __cxx_is_always_lock_free<unsigned char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
1396template<> struct __cxx_is_always_lock_free<char16_t> { enum { __value = 2 == ATOMIC_CHAR16_T_LOCK_FREE }; };
1397template<> struct __cxx_is_always_lock_free<char32_t> { enum { __value = 2 == ATOMIC_CHAR32_T_LOCK_FREE }; };
1398template<> struct __cxx_is_always_lock_free<wchar_t> { enum { __value = 2 == ATOMIC_WCHAR_T_LOCK_FREE }; };
1399template<> struct __cxx_is_always_lock_free<short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
1400template<> struct __cxx_is_always_lock_free<unsigned short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
1401template<> struct __cxx_is_always_lock_free<int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
1402template<> struct __cxx_is_always_lock_free<unsigned int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
1403template<> struct __cxx_is_always_lock_free<long> { enum { __value = 2 == ATOMIC_LONG_LOCK_FREE }; };
1404template<> struct __cxx_is_always_lock_free<unsigned long> { enum { __value = 2 == ATOMIC_LONG_LOCK_FREE }; };
1405template<> struct __cxx_is_always_lock_free<long long> { enum { __value = 2 == ATOMIC_LLONG_LOCK_FREE }; };
1406template<> struct __cxx_is_always_lock_free<unsigned long long> { enum { __value = 2 == ATOMIC_LLONG_LOCK_FREE }; };
1407template<typename _Tp> struct __cxx_is_always_lock_free<_Tp*> { enum { __value = 2 == ATOMIC_POINTER_LOCK_FREE }; };
1408template<> struct __cxx_is_always_lock_free<std::nullptr_t> { enum { __value = 2 == ATOMIC_POINTER_LOCK_FREE }; };
1409
1410#endif //__cpp_lib_atomic_is_always_lock_free
1411
1412template <typename _Tp,
1413 typename _Base = typename conditional<__cxx_is_always_lock_free<_Tp>::__value,
1414 __cxx_atomic_base_impl<_Tp>,
1415 __cxx_atomic_lock_impl<_Tp> >::type>
1416#else
1417template <typename _Tp,
1418 typename _Base = __cxx_atomic_base_impl<_Tp> >
1419#endif //_LIBCPP_ATOMIC_ONLY_USE_BUILTINS
1420struct __cxx_atomic_impl : public _Base {
1421
1422#if _GNUC_VER >= 501
1423 static_assert(is_trivially_copyable<_Tp>::value,
1424 "std::atomic<Tp> requires that 'Tp' be a trivially copyable type");
1425#endif
1426
1427 _LIBCPP_INLINE_VISIBILITY __cxx_atomic_impl() _NOEXCEPT _LIBCPP_DEFAULT
1428 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp value) _NOEXCEPT
1429 : _Base(value) {}
1430};
1431
Howard Hinnant138f5922010-12-07 20:46:14 +00001432// general atomic<T>
1433
1434template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
1435struct __atomic_base // false
1436{
Davide Italiano011f80a2019-03-05 18:40:49 +00001437 mutable __cxx_atomic_impl<_Tp> __a_;
Howard Hinnant138f5922010-12-07 20:46:14 +00001438
JF Bastienfdb42c22016-03-25 15:48:21 +00001439#if defined(__cpp_lib_atomic_is_always_lock_free)
1440 static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0);
1441#endif
1442
Howard Hinnant138f5922010-12-07 20:46:14 +00001443 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001444 bool is_lock_free() const volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001445 {return __cxx_atomic_is_lock_free(sizeof(_Tp));}
Howard Hinnant138f5922010-12-07 20:46:14 +00001446 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001447 bool is_lock_free() const _NOEXCEPT
Eric Fiselier3fd22c22015-06-13 00:23:07 +00001448 {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
Howard Hinnant138f5922010-12-07 20:46:14 +00001449 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001450 void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001451 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
Davide Italiano011f80a2019-03-05 18:40:49 +00001452 {__cxx_atomic_store(&__a_, __d, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001453 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001454 void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001455 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
Davide Italiano011f80a2019-03-05 18:40:49 +00001456 {__cxx_atomic_store(&__a_, __d, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001457 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001458 _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001459 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
Davide Italiano011f80a2019-03-05 18:40:49 +00001460 {return __cxx_atomic_load(&__a_, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001461 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001462 _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001463 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
Davide Italiano011f80a2019-03-05 18:40:49 +00001464 {return __cxx_atomic_load(&__a_, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001465 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001466 operator _Tp() const volatile _NOEXCEPT {return load();}
Howard Hinnant138f5922010-12-07 20:46:14 +00001467 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001468 operator _Tp() const _NOEXCEPT {return load();}
Howard Hinnant138f5922010-12-07 20:46:14 +00001469 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001470 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001471 {return __cxx_atomic_exchange(&__a_, __d, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001472 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001473 _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001474 {return __cxx_atomic_exchange(&__a_, __d, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001475 _LIBCPP_INLINE_VISIBILITY
1476 bool compare_exchange_weak(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001477 memory_order __s, memory_order __f) volatile _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001478 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Davide Italiano011f80a2019-03-05 18:40:49 +00001479 {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001480 _LIBCPP_INLINE_VISIBILITY
1481 bool compare_exchange_weak(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001482 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001483 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Davide Italiano011f80a2019-03-05 18:40:49 +00001484 {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001485 _LIBCPP_INLINE_VISIBILITY
1486 bool compare_exchange_strong(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001487 memory_order __s, memory_order __f) volatile _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001488 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Davide Italiano011f80a2019-03-05 18:40:49 +00001489 {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001490 _LIBCPP_INLINE_VISIBILITY
1491 bool compare_exchange_strong(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001492 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001493 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Davide Italiano011f80a2019-03-05 18:40:49 +00001494 {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001495 _LIBCPP_INLINE_VISIBILITY
1496 bool compare_exchange_weak(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001497 memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001498 {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001499 _LIBCPP_INLINE_VISIBILITY
1500 bool compare_exchange_weak(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001501 memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001502 {return __cxx_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001503 _LIBCPP_INLINE_VISIBILITY
1504 bool compare_exchange_strong(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001505 memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001506 {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001507 _LIBCPP_INLINE_VISIBILITY
1508 bool compare_exchange_strong(_Tp& __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001509 memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001510 {return __cxx_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001511
1512 _LIBCPP_INLINE_VISIBILITY
Davide Italiano011f80a2019-03-05 18:40:49 +00001513 __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
Howard Hinnant3d284222013-05-02 20:18:43 +00001514
Davide Italiano011f80a2019-03-05 18:40:49 +00001515 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1516 __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
1517
Eric Fiselier2d8515f2017-01-06 20:58:25 +00001518#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant138f5922010-12-07 20:46:14 +00001519 __atomic_base(const __atomic_base&) = delete;
1520 __atomic_base& operator=(const __atomic_base&) = delete;
1521 __atomic_base& operator=(const __atomic_base&) volatile = delete;
Eric Fiselier2d8515f2017-01-06 20:58:25 +00001522#else
Howard Hinnant6ac60f82010-12-08 17:20:28 +00001523private:
1524 __atomic_base(const __atomic_base&);
1525 __atomic_base& operator=(const __atomic_base&);
1526 __atomic_base& operator=(const __atomic_base&) volatile;
Eric Fiselier2d8515f2017-01-06 20:58:25 +00001527#endif
Howard Hinnant138f5922010-12-07 20:46:14 +00001528};
1529
JF Bastienfdb42c22016-03-25 15:48:21 +00001530#if defined(__cpp_lib_atomic_is_always_lock_free)
1531template <class _Tp, bool __b>
1532_LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
1533#endif
1534
Howard Hinnant138f5922010-12-07 20:46:14 +00001535// atomic<Integral>
1536
1537template <class _Tp>
1538struct __atomic_base<_Tp, true>
1539 : public __atomic_base<_Tp, false>
1540{
1541 typedef __atomic_base<_Tp, false> __base;
1542 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3d284222013-05-02 20:18:43 +00001543 __atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
Howard Hinnant138f5922010-12-07 20:46:14 +00001544 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001545 _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
Howard Hinnant138f5922010-12-07 20:46:14 +00001546
1547 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001548 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001549 {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001550 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001551 _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001552 {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001553 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001554 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001555 {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001556 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001557 _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001558 {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001559 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001560 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001561 {return __cxx_atomic_fetch_and(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001562 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001563 _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001564 {return __cxx_atomic_fetch_and(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001565 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001566 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001567 {return __cxx_atomic_fetch_or(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001568 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001569 _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001570 {return __cxx_atomic_fetch_or(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001571 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001572 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001573 {return __cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001574 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001575 _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001576 {return __cxx_atomic_fetch_xor(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001577
1578 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001579 _Tp operator++(int) volatile _NOEXCEPT {return fetch_add(_Tp(1));}
Howard Hinnant138f5922010-12-07 20:46:14 +00001580 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001581 _Tp operator++(int) _NOEXCEPT {return fetch_add(_Tp(1));}
Howard Hinnant138f5922010-12-07 20:46:14 +00001582 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001583 _Tp operator--(int) volatile _NOEXCEPT {return fetch_sub(_Tp(1));}
Howard Hinnant138f5922010-12-07 20:46:14 +00001584 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001585 _Tp operator--(int) _NOEXCEPT {return fetch_sub(_Tp(1));}
Howard Hinnant138f5922010-12-07 20:46:14 +00001586 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001587 _Tp operator++() volatile _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001588 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001589 _Tp operator++() _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001590 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001591 _Tp operator--() volatile _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001592 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001593 _Tp operator--() _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001594 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001595 _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001596 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001597 _Tp operator+=(_Tp __op) _NOEXCEPT {return fetch_add(__op) + __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001598 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001599 _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001600 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001601 _Tp operator-=(_Tp __op) _NOEXCEPT {return fetch_sub(__op) - __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001602 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001603 _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001604 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001605 _Tp operator&=(_Tp __op) _NOEXCEPT {return fetch_and(__op) & __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001606 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001607 _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001608 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001609 _Tp operator|=(_Tp __op) _NOEXCEPT {return fetch_or(__op) | __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001610 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001611 _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001612 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001613 _Tp operator^=(_Tp __op) _NOEXCEPT {return fetch_xor(__op) ^ __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001614};
1615
1616// atomic<T>
1617
1618template <class _Tp>
1619struct atomic
1620 : public __atomic_base<_Tp>
1621{
1622 typedef __atomic_base<_Tp> __base;
1623 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3d284222013-05-02 20:18:43 +00001624 atomic() _NOEXCEPT _LIBCPP_DEFAULT
Howard Hinnant138f5922010-12-07 20:46:14 +00001625 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001626 _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001627
1628 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001629 _Tp operator=(_Tp __d) volatile _NOEXCEPT
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001630 {__base::store(__d); return __d;}
1631 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001632 _Tp operator=(_Tp __d) _NOEXCEPT
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001633 {__base::store(__d); return __d;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001634};
1635
1636// atomic<T*>
1637
1638template <class _Tp>
1639struct atomic<_Tp*>
1640 : public __atomic_base<_Tp*>
1641{
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001642 typedef __atomic_base<_Tp*> __base;
Howard Hinnant138f5922010-12-07 20:46:14 +00001643 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3d284222013-05-02 20:18:43 +00001644 atomic() _NOEXCEPT _LIBCPP_DEFAULT
Howard Hinnant138f5922010-12-07 20:46:14 +00001645 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001646 _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
Howard Hinnant138f5922010-12-07 20:46:14 +00001647
1648 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001649 _Tp* operator=(_Tp* __d) volatile _NOEXCEPT
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001650 {__base::store(__d); return __d;}
1651 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001652 _Tp* operator=(_Tp* __d) _NOEXCEPT
Howard Hinnant96e4cd62010-12-07 23:24:41 +00001653 {__base::store(__d); return __d;}
1654
1655 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001656 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
Howard Hinnanteee2c142012-04-11 20:14:21 +00001657 volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001658 {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001659 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001660 _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001661 {return __cxx_atomic_fetch_add(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001662 _LIBCPP_INLINE_VISIBILITY
1663 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
Howard Hinnanteee2c142012-04-11 20:14:21 +00001664 volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001665 {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001666 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001667 _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00001668 {return __cxx_atomic_fetch_sub(&this->__a_, __op, __m);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001669
1670 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001671 _Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001672 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001673 _Tp* operator++(int) _NOEXCEPT {return fetch_add(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001674 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001675 _Tp* operator--(int) volatile _NOEXCEPT {return fetch_sub(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001676 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001677 _Tp* operator--(int) _NOEXCEPT {return fetch_sub(1);}
Howard Hinnant138f5922010-12-07 20:46:14 +00001678 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001679 _Tp* operator++() volatile _NOEXCEPT {return fetch_add(1) + 1;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001680 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001681 _Tp* operator++() _NOEXCEPT {return fetch_add(1) + 1;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001682 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001683 _Tp* operator--() volatile _NOEXCEPT {return fetch_sub(1) - 1;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001684 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001685 _Tp* operator--() _NOEXCEPT {return fetch_sub(1) - 1;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001686 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001687 _Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001688 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001689 _Tp* operator+=(ptrdiff_t __op) _NOEXCEPT {return fetch_add(__op) + __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001690 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001691 _Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001692 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00001693 _Tp* operator-=(ptrdiff_t __op) _NOEXCEPT {return fetch_sub(__op) - __op;}
Howard Hinnant138f5922010-12-07 20:46:14 +00001694};
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001695
1696// atomic_is_lock_free
1697
1698template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001699_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001700bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001701atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001702{
Howard Hinnant138f5922010-12-07 20:46:14 +00001703 return __o->is_lock_free();
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001704}
1705
1706template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001707_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001708bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001709atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001710{
Howard Hinnant138f5922010-12-07 20:46:14 +00001711 return __o->is_lock_free();
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001712}
1713
1714// atomic_init
1715
1716template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001717_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001718void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001719atomic_init(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001720{
Davide Italiano011f80a2019-03-05 18:40:49 +00001721 __cxx_atomic_init(&__o->__a_, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001722}
1723
1724template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001725_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001726void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001727atomic_init(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001728{
Davide Italiano011f80a2019-03-05 18:40:49 +00001729 __cxx_atomic_init(&__o->__a_, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001730}
1731
1732// atomic_store
1733
1734template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001735_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001736void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001737atomic_store(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001738{
Howard Hinnant138f5922010-12-07 20:46:14 +00001739 __o->store(__d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001740}
1741
1742template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001743_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001744void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001745atomic_store(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001746{
Howard Hinnant138f5922010-12-07 20:46:14 +00001747 __o->store(__d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001748}
1749
1750// atomic_store_explicit
1751
1752template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001753_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001754void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001755atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001756 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001757{
Howard Hinnant138f5922010-12-07 20:46:14 +00001758 __o->store(__d, __m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001759}
1760
1761template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001762_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001763void
Howard Hinnanteee2c142012-04-11 20:14:21 +00001764atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001765 _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001766{
Howard Hinnant138f5922010-12-07 20:46:14 +00001767 __o->store(__d, __m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001768}
1769
1770// atomic_load
1771
1772template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001773_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001774_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001775atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001776{
Howard Hinnant138f5922010-12-07 20:46:14 +00001777 return __o->load();
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001778}
1779
1780template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001781_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001782_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001783atomic_load(const atomic<_Tp>* __o) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001784{
Howard Hinnant138f5922010-12-07 20:46:14 +00001785 return __o->load();
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001786}
1787
1788// atomic_load_explicit
1789
1790template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001791_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001792_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001793atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001794 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001795{
Howard Hinnant138f5922010-12-07 20:46:14 +00001796 return __o->load(__m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001797}
1798
1799template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001800_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001801_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001802atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001803 _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001804{
Howard Hinnant138f5922010-12-07 20:46:14 +00001805 return __o->load(__m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001806}
1807
1808// atomic_exchange
1809
1810template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001811_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001812_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001813atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001814{
Howard Hinnant138f5922010-12-07 20:46:14 +00001815 return __o->exchange(__d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001816}
1817
1818template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001819_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001820_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001821atomic_exchange(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001822{
Howard Hinnant138f5922010-12-07 20:46:14 +00001823 return __o->exchange(__d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001824}
1825
1826// atomic_exchange_explicit
1827
1828template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001829_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001830_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001831atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001832{
Howard Hinnant138f5922010-12-07 20:46:14 +00001833 return __o->exchange(__d, __m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001834}
1835
1836template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001837_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001838_Tp
Howard Hinnanteee2c142012-04-11 20:14:21 +00001839atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001840{
Howard Hinnant138f5922010-12-07 20:46:14 +00001841 return __o->exchange(__d, __m);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001842}
1843
1844// atomic_compare_exchange_weak
1845
1846template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001847_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001848bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001849atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001850{
Howard Hinnant138f5922010-12-07 20:46:14 +00001851 return __o->compare_exchange_weak(*__e, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001852}
1853
1854template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001855_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001856bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001857atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001858{
Howard Hinnant138f5922010-12-07 20:46:14 +00001859 return __o->compare_exchange_weak(*__e, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001860}
1861
1862// atomic_compare_exchange_strong
1863
1864template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001865_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001866bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001867atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001868{
Howard Hinnant138f5922010-12-07 20:46:14 +00001869 return __o->compare_exchange_strong(*__e, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001870}
1871
1872template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001873_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001874bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00001875atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001876{
Howard Hinnant138f5922010-12-07 20:46:14 +00001877 return __o->compare_exchange_strong(*__e, __d);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001878}
1879
1880// atomic_compare_exchange_weak_explicit
1881
1882template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001883_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001884bool
1885atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e,
1886 _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001887 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001888 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001889{
Howard Hinnant138f5922010-12-07 20:46:14 +00001890 return __o->compare_exchange_weak(*__e, __d, __s, __f);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001891}
1892
1893template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001894_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001895bool
1896atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001897 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001898 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001899{
Howard Hinnant138f5922010-12-07 20:46:14 +00001900 return __o->compare_exchange_weak(*__e, __d, __s, __f);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001901}
1902
1903// atomic_compare_exchange_strong_explicit
1904
1905template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001906_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001907bool
1908atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o,
1909 _Tp* __e, _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001910 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001911 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001912{
Howard Hinnant138f5922010-12-07 20:46:14 +00001913 return __o->compare_exchange_strong(*__e, __d, __s, __f);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001914}
1915
1916template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001917_LIBCPP_INLINE_VISIBILITY
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001918bool
1919atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,
1920 _Tp __d,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001921 memory_order __s, memory_order __f) _NOEXCEPT
Eric Fiselierb5ab51d2017-01-13 23:45:39 +00001922 _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001923{
Howard Hinnant138f5922010-12-07 20:46:14 +00001924 return __o->compare_exchange_strong(*__e, __d, __s, __f);
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001925}
1926
Howard Hinnant138f5922010-12-07 20:46:14 +00001927// atomic_fetch_add
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001928
1929template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001930_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001931typename enable_if
1932<
1933 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
1934 _Tp
1935>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00001936atomic_fetch_add(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001937{
Howard Hinnant138f5922010-12-07 20:46:14 +00001938 return __o->fetch_add(__op);
1939}
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001940
Howard Hinnant138f5922010-12-07 20:46:14 +00001941template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001942_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001943typename enable_if
1944<
1945 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
1946 _Tp
1947>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00001948atomic_fetch_add(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00001949{
1950 return __o->fetch_add(__op);
1951}
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00001952
Howard Hinnant138f5922010-12-07 20:46:14 +00001953template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001954_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001955_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00001956atomic_fetch_add(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00001957{
1958 return __o->fetch_add(__op);
1959}
1960
1961template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001962_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001963_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00001964atomic_fetch_add(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00001965{
1966 return __o->fetch_add(__op);
1967}
1968
1969// atomic_fetch_add_explicit
1970
1971template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001972_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001973typename enable_if
1974<
1975 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
1976 _Tp
1977>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00001978atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00001979{
1980 return __o->fetch_add(__op, __m);
1981}
1982
1983template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001984_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001985typename enable_if
1986<
1987 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
1988 _Tp
1989>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00001990atomic_fetch_add_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00001991{
1992 return __o->fetch_add(__op, __m);
1993}
1994
1995template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00001996_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00001997_Tp*
1998atomic_fetch_add_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op,
Howard Hinnanteee2c142012-04-11 20:14:21 +00001999 memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002000{
2001 return __o->fetch_add(__op, __m);
2002}
2003
2004template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002005_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002006_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00002007atomic_fetch_add_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002008{
2009 return __o->fetch_add(__op, __m);
2010}
2011
2012// atomic_fetch_sub
2013
2014template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002015_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002016typename enable_if
2017<
2018 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2019 _Tp
2020>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002021atomic_fetch_sub(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002022{
2023 return __o->fetch_sub(__op);
2024}
2025
2026template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002027_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002028typename enable_if
2029<
2030 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2031 _Tp
2032>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002033atomic_fetch_sub(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002034{
2035 return __o->fetch_sub(__op);
2036}
2037
2038template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002039_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002040_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00002041atomic_fetch_sub(volatile atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002042{
2043 return __o->fetch_sub(__op);
2044}
2045
2046template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002047_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002048_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00002049atomic_fetch_sub(atomic<_Tp*>* __o, ptrdiff_t __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002050{
2051 return __o->fetch_sub(__op);
2052}
2053
2054// atomic_fetch_sub_explicit
2055
2056template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002057_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002058typename enable_if
2059<
2060 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2061 _Tp
2062>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002063atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002064{
2065 return __o->fetch_sub(__op, __m);
2066}
2067
2068template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002069_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002070typename enable_if
2071<
2072 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2073 _Tp
2074>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002075atomic_fetch_sub_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002076{
2077 return __o->fetch_sub(__op, __m);
2078}
2079
2080template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002081_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002082_Tp*
2083atomic_fetch_sub_explicit(volatile atomic<_Tp*>* __o, ptrdiff_t __op,
Howard Hinnanteee2c142012-04-11 20:14:21 +00002084 memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002085{
2086 return __o->fetch_sub(__op, __m);
2087}
2088
2089template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002090_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002091_Tp*
Howard Hinnanteee2c142012-04-11 20:14:21 +00002092atomic_fetch_sub_explicit(atomic<_Tp*>* __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002093{
2094 return __o->fetch_sub(__op, __m);
2095}
2096
2097// atomic_fetch_and
2098
2099template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002100_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002101typename enable_if
2102<
2103 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2104 _Tp
2105>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002106atomic_fetch_and(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002107{
2108 return __o->fetch_and(__op);
2109}
2110
2111template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002112_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002113typename enable_if
2114<
2115 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2116 _Tp
2117>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002118atomic_fetch_and(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002119{
2120 return __o->fetch_and(__op);
2121}
2122
2123// atomic_fetch_and_explicit
2124
2125template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002126_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002127typename enable_if
2128<
2129 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2130 _Tp
2131>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002132atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002133{
2134 return __o->fetch_and(__op, __m);
2135}
2136
2137template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002138_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002139typename enable_if
2140<
2141 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2142 _Tp
2143>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002144atomic_fetch_and_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002145{
2146 return __o->fetch_and(__op, __m);
2147}
2148
2149// atomic_fetch_or
2150
2151template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002152_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002153typename enable_if
2154<
2155 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2156 _Tp
2157>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002158atomic_fetch_or(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002159{
2160 return __o->fetch_or(__op);
2161}
2162
2163template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002164_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002165typename enable_if
2166<
2167 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2168 _Tp
2169>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002170atomic_fetch_or(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002171{
2172 return __o->fetch_or(__op);
2173}
2174
2175// atomic_fetch_or_explicit
2176
2177template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002178_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002179typename enable_if
2180<
2181 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2182 _Tp
2183>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002184atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002185{
2186 return __o->fetch_or(__op, __m);
2187}
2188
2189template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002190_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002191typename enable_if
2192<
2193 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2194 _Tp
2195>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002196atomic_fetch_or_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002197{
2198 return __o->fetch_or(__op, __m);
2199}
2200
2201// atomic_fetch_xor
2202
2203template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002204_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002205typename enable_if
2206<
2207 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2208 _Tp
2209>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002210atomic_fetch_xor(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002211{
2212 return __o->fetch_xor(__op);
2213}
2214
2215template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002216_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002217typename enable_if
2218<
2219 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2220 _Tp
2221>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002222atomic_fetch_xor(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002223{
2224 return __o->fetch_xor(__op);
2225}
2226
2227// atomic_fetch_xor_explicit
2228
2229template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002230_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002231typename enable_if
2232<
2233 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2234 _Tp
2235>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002236atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002237{
2238 return __o->fetch_xor(__op, __m);
2239}
2240
2241template <class _Tp>
Davide Italiano011f80a2019-03-05 18:40:49 +00002242_LIBCPP_INLINE_VISIBILITY
Howard Hinnant138f5922010-12-07 20:46:14 +00002243typename enable_if
2244<
2245 is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
2246 _Tp
2247>::type
Howard Hinnanteee2c142012-04-11 20:14:21 +00002248atomic_fetch_xor_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
Howard Hinnant138f5922010-12-07 20:46:14 +00002249{
2250 return __o->fetch_xor(__op, __m);
2251}
Howard Hinnant7bfaeb82010-12-06 23:10:08 +00002252
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002253// flag type and operations
2254
2255typedef struct atomic_flag
2256{
Davide Italiano011f80a2019-03-05 18:40:49 +00002257 __cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_;
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002258
2259 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00002260 bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00002261 {return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002262 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00002263 bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00002264 {return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002265 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00002266 void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00002267 {__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002268 _LIBCPP_INLINE_VISIBILITY
Howard Hinnanteee2c142012-04-11 20:14:21 +00002269 void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT
Davide Italiano011f80a2019-03-05 18:40:49 +00002270 {__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002271
2272 _LIBCPP_INLINE_VISIBILITY
Davide Italiano011f80a2019-03-05 18:40:49 +00002273 atomic_flag() _NOEXCEPT _LIBCPP_DEFAULT
Howard Hinnant3d284222013-05-02 20:18:43 +00002274
Marshall Clowcf990752018-04-25 14:27:29 +00002275 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Eric Fiselierfec26a92016-05-03 02:12:26 +00002276 atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002277
Eric Fiselier2d8515f2017-01-06 20:58:25 +00002278#ifndef _LIBCPP_CXX03_LANG
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002279 atomic_flag(const atomic_flag&) = delete;
2280 atomic_flag& operator=(const atomic_flag&) = delete;
2281 atomic_flag& operator=(const atomic_flag&) volatile = delete;
Eric Fiselier2d8515f2017-01-06 20:58:25 +00002282#else
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002283private:
2284 atomic_flag(const atomic_flag&);
2285 atomic_flag& operator=(const atomic_flag&);
2286 atomic_flag& operator=(const atomic_flag&) volatile;
Eric Fiselier2d8515f2017-01-06 20:58:25 +00002287#endif
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002288} atomic_flag;
2289
2290inline _LIBCPP_INLINE_VISIBILITY
2291bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00002292atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002293{
2294 return __o->test_and_set();
2295}
2296
2297inline _LIBCPP_INLINE_VISIBILITY
2298bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00002299atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002300{
2301 return __o->test_and_set();
2302}
2303
2304inline _LIBCPP_INLINE_VISIBILITY
2305bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00002306atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002307{
2308 return __o->test_and_set(__m);
2309}
2310
2311inline _LIBCPP_INLINE_VISIBILITY
2312bool
Howard Hinnanteee2c142012-04-11 20:14:21 +00002313atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002314{
2315 return __o->test_and_set(__m);
2316}
2317
2318inline _LIBCPP_INLINE_VISIBILITY
2319void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002320atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002321{
2322 __o->clear();
2323}
2324
2325inline _LIBCPP_INLINE_VISIBILITY
2326void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002327atomic_flag_clear(atomic_flag* __o) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002328{
2329 __o->clear();
2330}
2331
2332inline _LIBCPP_INLINE_VISIBILITY
2333void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002334atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002335{
2336 __o->clear(__m);
2337}
2338
2339inline _LIBCPP_INLINE_VISIBILITY
2340void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002341atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002342{
2343 __o->clear(__m);
2344}
2345
2346// fences
2347
2348inline _LIBCPP_INLINE_VISIBILITY
2349void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002350atomic_thread_fence(memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002351{
Davide Italiano011f80a2019-03-05 18:40:49 +00002352 __cxx_atomic_thread_fence(__m);
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002353}
2354
2355inline _LIBCPP_INLINE_VISIBILITY
2356void
Howard Hinnanteee2c142012-04-11 20:14:21 +00002357atomic_signal_fence(memory_order __m) _NOEXCEPT
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002358{
Davide Italiano011f80a2019-03-05 18:40:49 +00002359 __cxx_atomic_signal_fence(__m);
Howard Hinnant6ac60f82010-12-08 17:20:28 +00002360}
2361
Howard Hinnant96e4cd62010-12-07 23:24:41 +00002362// Atomics for standard typedef types
2363
Howard Hinnantf0af8d92013-01-04 18:58:50 +00002364typedef atomic<bool> atomic_bool;
Howard Hinnant96e4cd62010-12-07 23:24:41 +00002365typedef atomic<char> atomic_char;
2366typedef atomic<signed char> atomic_schar;
2367typedef atomic<unsigned char> atomic_uchar;
2368typedef atomic<short> atomic_short;
2369typedef atomic<unsigned short> atomic_ushort;
2370typedef atomic<int> atomic_int;
2371typedef atomic<unsigned int> atomic_uint;
2372typedef atomic<long> atomic_long;
2373typedef atomic<unsigned long> atomic_ulong;
2374typedef atomic<long long> atomic_llong;
2375typedef atomic<unsigned long long> atomic_ullong;
2376typedef atomic<char16_t> atomic_char16_t;
2377typedef atomic<char32_t> atomic_char32_t;
2378typedef atomic<wchar_t> atomic_wchar_t;
2379
2380typedef atomic<int_least8_t> atomic_int_least8_t;
2381typedef atomic<uint_least8_t> atomic_uint_least8_t;
2382typedef atomic<int_least16_t> atomic_int_least16_t;
2383typedef atomic<uint_least16_t> atomic_uint_least16_t;
2384typedef atomic<int_least32_t> atomic_int_least32_t;
2385typedef atomic<uint_least32_t> atomic_uint_least32_t;
2386typedef atomic<int_least64_t> atomic_int_least64_t;
2387typedef atomic<uint_least64_t> atomic_uint_least64_t;
2388
2389typedef atomic<int_fast8_t> atomic_int_fast8_t;
2390typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
2391typedef atomic<int_fast16_t> atomic_int_fast16_t;
2392typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
2393typedef atomic<int_fast32_t> atomic_int_fast32_t;
2394typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
2395typedef atomic<int_fast64_t> atomic_int_fast64_t;
2396typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
2397
Marshall Clowf710afc2016-06-30 15:28:38 +00002398typedef atomic< int8_t> atomic_int8_t;
2399typedef atomic<uint8_t> atomic_uint8_t;
2400typedef atomic< int16_t> atomic_int16_t;
2401typedef atomic<uint16_t> atomic_uint16_t;
2402typedef atomic< int32_t> atomic_int32_t;
2403typedef atomic<uint32_t> atomic_uint32_t;
2404typedef atomic< int64_t> atomic_int64_t;
2405typedef atomic<uint64_t> atomic_uint64_t;
2406
Howard Hinnant96e4cd62010-12-07 23:24:41 +00002407typedef atomic<intptr_t> atomic_intptr_t;
2408typedef atomic<uintptr_t> atomic_uintptr_t;
2409typedef atomic<size_t> atomic_size_t;
2410typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
2411typedef atomic<intmax_t> atomic_intmax_t;
2412typedef atomic<uintmax_t> atomic_uintmax_t;
2413
Howard Hinnantf1f066a2010-09-29 21:20:03 +00002414#define ATOMIC_FLAG_INIT {false}
Howard Hinnant953c31d2010-10-04 18:52:54 +00002415#define ATOMIC_VAR_INIT(__v) {__v}
2416
Howard Hinnant71be7292010-09-27 21:17:38 +00002417_LIBCPP_END_NAMESPACE_STD
2418
Howard Hinnant71be7292010-09-27 21:17:38 +00002419#endif // _LIBCPP_ATOMIC