Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / libcxx / 21ef47f436bd01aada17e757959352b6b82d40bf / . / include / atomic
blob: d3423f6cedbfcdc71e5cf9ff340a70b7bc8a7658 [file] [log] [blame]
Howard Hinnant8f73c632010-09-27 21:17:38 +0000[diff] [blame]1// -*- C++ -*-
2//===--------------------------- atomic -----------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
6// This file is distributed under the University of Illinois Open Source
7// License. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_ATOMIC
12#define _LIBCPP_ATOMIC
13
14/*
15 atomic synopsis
16
17namespace std
18{
19
20// order and consistency
21
22typedef enum memory_order
23{
Howard Hinnantd1176e22010-09-28 17:13:38 +0000[diff] [blame]24 memory_order_relaxed,
25 memory_order_consume, // load-consume
26 memory_order_acquire, // load-acquire
27 memory_order_release, // store-release
28 memory_order_acq_rel, // store-release load-acquire
29 memory_order_seq_cst // store-release load-acquire
Howard Hinnant8f73c632010-09-27 21:17:38 +0000[diff] [blame]30} memory_order;
31
32template <class T> T kill_dependency(T y);
33
34// lock-free property
35
36#define ATOMIC_CHAR_LOCK_FREE unspecified
37#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
38#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
39#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
40#define ATOMIC_SHORT_LOCK_FREE unspecified
41#define ATOMIC_INT_LOCK_FREE unspecified
42#define ATOMIC_LONG_LOCK_FREE unspecified
43#define ATOMIC_LLONG_LOCK_FREE unspecified
44#define ATOMIC_ADDRESS_LOCK_FREE unspecified
45
46// operations on atomic types
47
48#define ATOMIC_VAR_INIT(value) see below
49
50// flag type and operations
51
52typedef struct atomic_flag
53{
54 bool test_and_set(memory_order = memory_order_seq_cst) volatile;
55 bool test_and_set(memory_order = memory_order_seq_cst);
56 void clear(memory_order = memory_order_seq_cst) volatile;
57 void clear(memory_order = memory_order_seq_cst);
58 atomic_flag() = default;
59 atomic_flag(const atomic_flag&) = delete;
60 atomic_flag& operator=(const atomic_flag&) = delete;
61 atomic_flag& operator=(const atomic_flag&) volatile = delete;
62} atomic_flag;
63
64bool atomic_flag_test_and_set(volatile atomic_flag*);
65bool atomic_flag_test_and_set(atomic_flag*);
66bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
67bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);
68void atomic_flag_clear(volatile atomic_flag*);
69void atomic_flag_clear(atomic_flag*);
70void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
71void atomic_flag_clear_explicit(atomic_flag*, memory_order);
72
73#define ATOMIC_FLAG_INIT see below
74
75// atomic_bool
76
77typedef struct atomic_bool
78{
79 bool is_lock_free() const volatile;
80 bool is_lock_free() const;
81 void store(bool, memory_order = memory_order_seq_cst) volatile;
82 void store(bool, memory_order = memory_order_seq_cst);
83 bool load(memory_order = memory_order_seq_cst) const volatile;
84 bool load(memory_order = memory_order_seq_cst) const;
85 operator bool() const volatile;
86 operator bool() const;
87 bool exchange(bool, memory_order = memory_order_seq_cst) volatile;
88 bool exchange(bool, memory_order = memory_order_seq_cst);
89 bool compare_exchange_weak(bool&, bool, memory_order,
90 memory_order) volatile;
91 bool compare_exchange_weak(bool&, bool, memory_order, memory_order);
92 bool compare_exchange_strong(bool&, bool, memory_order,
93 memory_order) volatile;
94 bool compare_exchange_strong(bool&, bool, memory_order, memory_order);
95 bool compare_exchange_weak(bool&, bool,
96 memory_order = memory_order_seq_cst) volatile;
97 bool compare_exchange_weak(bool&, bool,
98 memory_order = memory_order_seq_cst);
99 bool compare_exchange_strong(bool&, bool,
100 memory_order = memory_order_seq_cst) volatile;
101 bool compare_exchange_strong(bool&, bool,
102 memory_order = memory_order_seq_cst);
103 atomic_bool() = default;
104 constexpr atomic_bool(bool);
105 atomic_bool(const atomic_bool&) = delete;
106 atomic_bool& operator=(const atomic_bool&) = delete;
107 atomic_bool& operator=(const atomic_bool&) volatile = delete;
108 bool operator=(bool) volatile;
109} atomic_bool;
110
111bool atomic_is_lock_free(const volatile atomic_bool*);
112bool atomic_is_lock_free(const atomic_bool*);
113void atomic_init(volatile atomic_bool*, bool);
114void atomic_init(atomic_bool*, bool);
115void atomic_store(volatile atomic_bool*, bool);
116void atomic_store(atomic_bool*, bool);
117void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
118void atomic_store_explicit(atomic_bool*, bool, memory_order);
119bool atomic_load(const volatile atomic_bool*);
120bool atomic_load(const atomic_bool*);
121bool atomic_load_explicit(const volatile atomic_bool*, memory_order);
122bool atomic_load_explicit(const atomic_bool*, memory_order);
123bool atomic_exchange(volatile atomic_bool*, bool);
124bool atomic_exchange(atomic_bool*, bool);
125bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
126bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);
127bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);
128bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);
129bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);
130bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);
131bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,
132 memory_order, memory_order);
133bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,
134 memory_order, memory_order);
135bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,
136 memory_order, memory_order);
137bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,
138 memory_order, memory_order);
139
140// atomic_char
141
142typedef struct atomic_char
143{
144 bool is_lock_free() const volatile;
145 bool is_lock_free() const;
146 void store(char, memory_order = memory_order_seq_cst) volatile;
147 void store(char, memory_order = memory_order_seq_cst);
148 char load(memory_order = memory_order_seq_cst) const volatile;
149 char load(memory_order = memory_order_seq_cst) const;
150 operator char() const volatile;
151 operator char() const;
152 char exchange(char,
153 memory_order = memory_order_seq_cst) volatile;
154 char exchange(char, memory_order = memory_order_seq_cst);
155 bool compare_exchange_weak(char&, char, memory_order,
156 memory_order) volatile;
157 bool compare_exchange_weak(char&, char, memory_order, memory_order);
158 bool compare_exchange_strong(char&, char, memory_order,
159 memory_order) volatile;
160 bool compare_exchange_strong(char&, char, memory_order, memory_order);
161 bool compare_exchange_weak(char&, char,
162 memory_order = memory_order_seq_cst) volatile;
163 bool compare_exchange_weak(char&, char,
164 memory_order = memory_order_seq_cst);
165 bool compare_exchange_strong(char&, char,
166 memory_order = memory_order_seq_cst) volatile;
167 bool compare_exchange_strong(char&, char,
168 memory_order = memory_order_seq_cst);
169 char fetch_add(char, memory_order = memory_order_seq_cst) volatile;
170 char fetch_add(char, memory_order = memory_order_seq_cst);
171 char fetch_sub(char, memory_order = memory_order_seq_cst) volatile;
172 char fetch_sub(char, memory_order = memory_order_seq_cst);
173 char fetch_and(char, memory_order = memory_order_seq_cst) volatile;
174 char fetch_and(char, memory_order = memory_order_seq_cst);
175 char fetch_or(char, memory_order = memory_order_seq_cst) volatile;
176 char fetch_or(char, memory_order = memory_order_seq_cst);
177 char fetch_xor(char, memory_order = memory_order_seq_cst) volatile;
178 char fetch_xor(char, memory_order = memory_order_seq_cst);
179 atomic_char() = default;
180 constexpr atomic_char(char);
181 atomic_char(const atomic_char&) = delete;
182 atomic_char& operator=(const atomic_char&) = delete;
183 atomic_char& operator=(const atomic_char&) volatile = delete;
184 char operator=(char) volatile;
185 char operator=(char);
186 char operator++(int) volatile;
187 char operator++(int);
188 char operator--(int) volatile;
189 char operator--(int);
190 char operator++() volatile;
191 char operator++();
192 char operator--() volatile;
193 char operator--();
194 char operator+=(char) volatile;
195 char operator+=(char);
196 char operator-=(char) volatile;
197 char operator-=(char);
198 char operator&=(char) volatile;
199 char operator&=(char);
200 char operator|=(char) volatile;
201 char operator|=(char);
202 char operator^=(char) volatile;
203 char operator^=(char);
204} atomic_char;
205
206bool atomic_is_lock_free(const volatile atomic_char*);
207bool atomic_is_lock_free(const atomic_char*);
208void atomic_init(volatile atomic_char*, itype);
209void atomic_init(atomic_char*, itype);
210void atomic_store(volatile atomic_char*, char);
211void atomic_store(atomic_char*, char);
212void atomic_store_explicit(volatile atomic_char*, char, memory_order);
213void atomic_store_explicit(atomic_char*, char, memory_order);
214char atomic_load(const volatile atomic_char*);
215char atomic_load(const atomic_char*);
216char atomic_load_explicit(const volatile atomic_char*, memory_order);
217char atomic_load_explicit(const atomic_char*, memory_order);
218char atomic_exchange(volatile atomic_char*, char);
219char atomic_exchange(atomic_char*, char);
220char atomic_exchange_explicit(volatile atomic_char*, char, memory_order);
221char atomic_exchange_explicit(atomic_char*, char, memory_order);
222bool atomic_compare_exchange_weak(volatile atomic_char*, char*, char);
223bool atomic_compare_exchange_weak(atomic_char*, char*, char);
224bool atomic_compare_exchange_strong(volatile atomic_char*, char*, char);
225bool atomic_compare_exchange_strong(atomic_char*, char*, char);
226bool atomic_compare_exchange_weak_explicit(volatile atomic_char*, char*, char,
227 memory_order, memory_order);
228bool atomic_compare_exchange_weak_explicit(atomic_char*, char*, char,
229 memory_order, memory_order);
230bool atomic_compare_exchange_strong_explicit(volatile atomic_char*, char*, char,
231 memory_order, memory_order);
232bool atomic_compare_exchange_strong_explicit(atomic_char*, char*, char,
233 memory_order, memory_order);
234char atomic_fetch_add(volatile atomic_char*, char);
235char atomic_fetch_add(atomic_char*, char);
236char atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);
237char atomic_fetch_add_explicit(atomic_char*, char, memory_order);
238char atomic_fetch_sub(volatile atomic_char*, char);
239char atomic_fetch_sub(atomic_char*, char);
240char atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);
241char atomic_fetch_sub_explicit(atomic_char*, char, memory_order);
242char atomic_fetch_and(volatile atomic_char*, char);
243char atomic_fetch_and(atomic_char*, char);
244char atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);
245char atomic_fetch_and_explicit(atomic_char*, char, memory_order);
246char atomic_fetch_or(volatile atomic_char*, char);
247char atomic_fetch_or(atomic_char*, char);
248char atomic_fetch_or_explicit(volatile atomic_char*, char, memory_order);
249char atomic_fetch_or_explicit(atomic_char*, char, memory_order);
250char atomic_fetch_xor(volatile atomic_char*, char);
251char atomic_fetch_xor(atomic_char*, char);
252char atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);
253char atomic_fetch_xor_explicit(atomic_char*, char, memory_order);
254
255// atomic_schar
256
257typedef struct atomic_schar
258{
259 bool is_lock_free() const volatile;
260 bool is_lock_free() const;
261 void store(signed char, memory_order = memory_order_seq_cst) volatile;
262 void store(signed char, memory_order = memory_order_seq_cst);
263 signed char load(memory_order = memory_order_seq_cst) const volatile;
264 signed char load(memory_order = memory_order_seq_cst) const;
265 operator signed char() const volatile;
266 operator signed char() const;
267 signed char exchange(signed char,
268 memory_order = memory_order_seq_cst) volatile;
269 signed char exchange(signed char, memory_order = memory_order_seq_cst);
270 bool compare_exchange_weak(signed char&, signed char, memory_order,
271 memory_order) volatile;
272 bool compare_exchange_weak(signed char&, signed char, memory_order,
273 memory_order);
274 bool compare_exchange_strong(signed char&, signed char, memory_order,
275 memory_order) volatile;
276 bool compare_exchange_strong(signed char&, signed char, memory_order,
277 memory_order);
278 bool compare_exchange_weak(signed char&, signed char,
279 memory_order = memory_order_seq_cst) volatile;
280 bool compare_exchange_weak(signed char&, signed char,
281 memory_order = memory_order_seq_cst);
282 bool compare_exchange_strong(signed char&, signed char,
283 memory_order = memory_order_seq_cst) volatile;
284 bool compare_exchange_strong(signed char&, signed char,
285 memory_order = memory_order_seq_cst);
286 signed char fetch_add(signed char,
287 memory_order = memory_order_seq_cst) volatile;
288 signed char fetch_add(signed char, memory_order = memory_order_seq_cst);
289 signed char fetch_sub(signed char,
290 memory_order = memory_order_seq_cst) volatile;
291 signed char fetch_sub(signed char, memory_order = memory_order_seq_cst);
292 signed char fetch_and(signed char,
293 memory_order = memory_order_seq_cst) volatile;
294 signed char fetch_and(signed char, memory_order = memory_order_seq_cst);
295 signed char fetch_or(signed char,
296 memory_order = memory_order_seq_cst) volatile;
297 signed char fetch_or(signed char, memory_order = memory_order_seq_cst);
298 signed char fetch_xor(signed char,
299 memory_order = memory_order_seq_cst) volatile;
300 signed char fetch_xor(signed char, memory_order = memory_order_seq_cst);
301 atomic_schar() = default;
302 constexpr atomic_schar(signed char);
303 atomic_schar(const atomic_schar&) = delete;
304 atomic_schar& operator=(const atomic_schar&) = delete;
305 atomic_schar& operator=(const atomic_schar&) volatile = delete;
306 signed char operator=(signed char) volatile;
307 signed char operator=(signed char);
308 signed char operator++(int) volatile;
309 signed char operator++(int);
310 signed char operator--(int) volatile;
311 signed char operator--(int);
312 signed char operator++() volatile;
313 signed char operator++();
314 signed char operator--() volatile;
315 signed char operator--();
316 signed char operator+=(signed char) volatile;
317 signed char operator+=(signed char);
318 signed char operator-=(signed char) volatile;
319 signed char operator-=(signed char);
320 signed char operator&=(signed char) volatile;
321 signed char operator&=(signed char);
322 signed char operator|=(signed char) volatile;
323 signed char operator|=(signed char);
324 signed char operator^=(signed char) volatile;
325 signed char operator^=(signed char);
326} atomic_schar;
327
328bool atomic_is_lock_free(const volatile atomic_schar*);
329bool atomic_is_lock_free(const atomic_schar*);
330void atomic_init(volatile atomic_schar*, itype);
331void atomic_init(atomic_schar*, itype);
332void atomic_store(volatile atomic_schar*, signed char);
333void atomic_store(atomic_schar*, signed char);
334void atomic_store_explicit(volatile atomic_schar*, signed char, memory_order);
335void atomic_store_explicit(atomic_schar*, signed char, memory_order);
336signed char atomic_load(const volatile atomic_schar*);
337signed char atomic_load(const atomic_schar*);
338signed char atomic_load_explicit(const volatile atomic_schar*, memory_order);
339signed char atomic_load_explicit(const atomic_schar*, memory_order);
340signed char atomic_exchange(volatile atomic_schar*, signed char);
341signed char atomic_exchange(atomic_schar*, signed char);
342signed char atomic_exchange_explicit(volatile atomic_schar*, signed char,
343 memory_order);
344signed char atomic_exchange_explicit(atomic_schar*, signed char, memory_order);
345bool atomic_compare_exchange_weak(volatile atomic_schar*, signed char*,
346 signed char);
347bool atomic_compare_exchange_weak(atomic_schar*, signed char*, signed char);
348bool atomic_compare_exchange_strong(volatile atomic_schar*, signed char*,
349 signed char);
350bool atomic_compare_exchange_strong(atomic_schar*, signed char*, signed char);
351bool atomic_compare_exchange_weak_explicit(volatile atomic_schar*, signed char*,
352 signed char, memory_order,
353 memory_order);
354bool atomic_compare_exchange_weak_explicit(atomic_schar*, signed char*,
355 signed char, memory_order,
356 memory_order);
357bool atomic_compare_exchange_strong_explicit(volatile atomic_schar*,
358 signed char*, signed char,
359 memory_order, memory_order);
360bool atomic_compare_exchange_strong_explicit(atomic_schar*, signed char*,
361 signed char, memory_order, memory_order);
362signed char atomic_fetch_add(volatile atomic_schar*, signed char);
363signed char atomic_fetch_add(atomic_schar*, signed char);
364signed char atomic_fetch_add_explicit(volatile atomic_schar*, signed char,
365 memory_order);
366signed char atomic_fetch_add_explicit(atomic_schar*, signed char, memory_order);
367signed char atomic_fetch_sub(volatile atomic_schar*, signed char);
368signed char atomic_fetch_sub(atomic_schar*, signed char);
369signed char atomic_fetch_sub_explicit(volatile atomic_schar*, signed char,
370 memory_order);
371signed char atomic_fetch_sub_explicit(atomic_schar*, signed char, memory_order);
372signed char atomic_fetch_and(volatile atomic_schar*, signed char);
373signed char atomic_fetch_and(atomic_schar*, signed char);
374signed char atomic_fetch_and_explicit(volatile atomic_schar*, signed char,
375 memory_order);
376signed char atomic_fetch_and_explicit(atomic_schar*, signed char, memory_order);
377signed char atomic_fetch_or(volatile atomic_schar*, signed char);
378signed char atomic_fetch_or(atomic_schar*, signed char);
379signed char atomic_fetch_or_explicit(volatile atomic_schar*, signed char,
380 memory_order);
381signed char atomic_fetch_or_explicit(atomic_schar*, signed char, memory_order);
382signed char atomic_fetch_xor(volatile atomic_schar*, signed char);
383signed char atomic_fetch_xor(atomic_schar*, signed char);
384signed char atomic_fetch_xor_explicit(volatile atomic_schar*, signed char,
385 memory_order);
386signed char atomic_fetch_xor_explicit(atomic_schar*, signed char, memory_order);
387
388// atomic_uchar
389
390typedef struct atomic_uchar
391{
392 bool is_lock_free() const volatile;
393 bool is_lock_free() const;
394 void store(unsigned char, memory_order = memory_order_seq_cst) volatile;
395 void store(unsigned char, memory_order = memory_order_seq_cst);
396 unsigned char load(memory_order = memory_order_seq_cst) const volatile;
397 unsigned char load(memory_order = memory_order_seq_cst) const;
398 operator unsigned char() const volatile;
399 operator unsigned char() const;
400 unsigned char exchange(unsigned char,
401 memory_order = memory_order_seq_cst) volatile;
402 unsigned char exchange(unsigned char, memory_order = memory_order_seq_cst);
403 bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
404 memory_order) volatile;
405 bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
406 memory_order);
407 bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
408 memory_order) volatile;
409 bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
410 memory_order);
411 bool compare_exchange_weak(unsigned char&, unsigned char,
412 memory_order = memory_order_seq_cst) volatile;
413 bool compare_exchange_weak(unsigned char&, unsigned char,
414 memory_order = memory_order_seq_cst);
415 bool compare_exchange_strong(unsigned char&, unsigned char,
416 memory_order = memory_order_seq_cst) volatile;
417 bool compare_exchange_strong(unsigned char&, unsigned char,
418 memory_order = memory_order_seq_cst);
419 unsigned char fetch_add(unsigned char,
420 memory_order = memory_order_seq_cst) volatile;
421 unsigned char fetch_add(unsigned char, memory_order = memory_order_seq_cst);
422 unsigned char fetch_sub(unsigned char,
423 memory_order = memory_order_seq_cst) volatile;
424 unsigned char fetch_sub(unsigned char, memory_order = memory_order_seq_cst);
425 unsigned char fetch_and(unsigned char,
426 memory_order = memory_order_seq_cst) volatile;
427 unsigned char fetch_and(unsigned char, memory_order = memory_order_seq_cst);
428 unsigned char fetch_or(unsigned char,
429 memory_order = memory_order_seq_cst) volatile;
430 unsigned char fetch_or(unsigned char, memory_order = memory_order_seq_cst);
431 unsigned char fetch_xor(unsigned char,
432 memory_order = memory_order_seq_cst) volatile;
433 unsigned char fetch_xor(unsigned char, memory_order = memory_order_seq_cst);
434 atomic_uchar() = default;
435 constexpr atomic_uchar(unsigned char);
436 atomic_uchar(const atomic_uchar&) = delete;
437 atomic_uchar& operator=(const atomic_uchar&) = delete;
438 atomic_uchar& operator=(const atomic_uchar&) volatile = delete;
439 unsigned char operator=(unsigned char) volatile;
440 unsigned char operator=(unsigned char);
441 unsigned char operator++(int) volatile;
442 unsigned char operator++(int);
443 unsigned char operator--(int) volatile;
444 unsigned char operator--(int);
445 unsigned char operator++() volatile;
446 unsigned char operator++();
447 unsigned char operator--() volatile;
448 unsigned char operator--();
449 unsigned char operator+=(unsigned char) volatile;
450 unsigned char operator+=(unsigned char);
451 unsigned char operator-=(unsigned char) volatile;
452 unsigned char operator-=(unsigned char);
453 unsigned char operator&=(unsigned char) volatile;
454 unsigned char operator&=(unsigned char);
455 unsigned char operator|=(unsigned char) volatile;
456 unsigned char operator|=(unsigned char);
457 unsigned char operator^=(unsigned char) volatile;
458 unsigned char operator^=(unsigned char);
459} atomic_uchar;
460
461bool atomic_is_lock_free(const volatile atomic_uchar*);
462bool atomic_is_lock_free(const atomic_uchar*);
463void atomic_init(volatile atomic_uchar*, itype);
464void atomic_init(atomic_uchar*, itype);
465void atomic_store(volatile atomic_uchar*, unsigned char);
466void atomic_store(atomic_uchar*, unsigned char);
467void atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order);
468void atomic_store_explicit(atomic_uchar*, unsigned char, memory_order);
469unsigned char atomic_load(const volatile atomic_uchar*);
470unsigned char atomic_load(const atomic_uchar*);
471unsigned char atomic_load_explicit(const volatile atomic_uchar*, memory_order);
472unsigned char atomic_load_explicit(const atomic_uchar*, memory_order);
473unsigned char atomic_exchange(volatile atomic_uchar*, unsigned char);
474unsigned char atomic_exchange(atomic_uchar*, unsigned char);
475unsigned char atomic_exchange_explicit(volatile atomic_uchar*, unsigned char,
476 memory_order);
477unsigned char atomic_exchange_explicit(atomic_uchar*, unsigned char,
478 memory_order);
479bool atomic_compare_exchange_weak(volatile atomic_uchar*, unsigned char*,
480 unsigned char);
481bool atomic_compare_exchange_weak(atomic_uchar*, unsigned char*, unsigned char);
482bool atomic_compare_exchange_strong(volatile atomic_uchar*, unsigned char*,
483 unsigned char);
484bool atomic_compare_exchange_strong(atomic_uchar*, unsigned char*,
485 unsigned char);
486bool atomic_compare_exchange_weak_explicit(volatile atomic_uchar*,
487 unsigned char*, unsigned char,
488 memory_order, memory_order);
489bool atomic_compare_exchange_weak_explicit(atomic_uchar*, unsigned char*,
490 unsigned char, memory_order,
491 memory_order);
492bool atomic_compare_exchange_strong_explicit(volatile atomic_uchar*,
493 unsigned char*, unsigned char,
494 memory_order, memory_order);
495bool atomic_compare_exchange_strong_explicit(atomic_uchar*, unsigned char*,
496 unsigned char, memory_order,
497 memory_order);
498unsigned char atomic_fetch_add(volatile atomic_uchar*, unsigned char);
499unsigned char atomic_fetch_add(atomic_uchar*, unsigned char);
500unsigned char atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char,
501 memory_order);
502unsigned char atomic_fetch_add_explicit(atomic_uchar*, unsigned char,
503 memory_order);
504unsigned char atomic_fetch_sub(volatile atomic_uchar*, unsigned char);
505unsigned char atomic_fetch_sub(atomic_uchar*, unsigned char);
506unsigned char atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char,
507 memory_order);
508unsigned char atomic_fetch_sub_explicit(atomic_uchar*, unsigned char,
509 memory_order);
510unsigned char atomic_fetch_and(volatile atomic_uchar*, unsigned char);
511unsigned char atomic_fetch_and(atomic_uchar*, unsigned char);
512unsigned char atomic_fetch_and_explicit(volatile atomic_uchar*, unsigned char,
513 memory_order);
514unsigned char atomic_fetch_and_explicit(atomic_uchar*, unsigned char,
515 memory_order);
516unsigned char atomic_fetch_or(volatile atomic_uchar*, unsigned char);
517unsigned char atomic_fetch_or(atomic_uchar*, unsigned char);
518unsigned char atomic_fetch_or_explicit(volatile atomic_uchar*, unsigned char,
519 memory_order);
520unsigned char atomic_fetch_or_explicit(atomic_uchar*, unsigned char,
521 memory_order);
522unsigned char atomic_fetch_xor(volatile atomic_uchar*, unsigned char);
523unsigned char atomic_fetch_xor(atomic_uchar*, unsigned char);
524unsigned char atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char,
525 memory_order);
526unsigned char atomic_fetch_xor_explicit(atomic_uchar*, unsigned char,
527 memory_order);
528
529// atomic_short
530
531typedef struct atomic_short
532{
533 bool is_lock_free() const volatile;
534 bool is_lock_free() const;
535 void store(short, memory_order = memory_order_seq_cst) volatile;
536 void store(short, memory_order = memory_order_seq_cst);
537 short load(memory_order = memory_order_seq_cst) const volatile;
538 short load(memory_order = memory_order_seq_cst) const;
539 operator short() const volatile;
540 operator short() const;
541 short exchange(short,
542 memory_order = memory_order_seq_cst) volatile;
543 short exchange(short, memory_order = memory_order_seq_cst);
544 bool compare_exchange_weak(short&, short, memory_order,
545 memory_order) volatile;
546 bool compare_exchange_weak(short&, short, memory_order, memory_order);
547 bool compare_exchange_strong(short&, short, memory_order,
548 memory_order) volatile;
549 bool compare_exchange_strong(short&, short, memory_order, memory_order);
550 bool compare_exchange_weak(short&, short,
551 memory_order = memory_order_seq_cst) volatile;
552 bool compare_exchange_weak(short&, short,
553 memory_order = memory_order_seq_cst);
554 bool compare_exchange_strong(short&, short,
555 memory_order = memory_order_seq_cst) volatile;
556 bool compare_exchange_strong(short&, short,
557 memory_order = memory_order_seq_cst);
558 short fetch_add(short, memory_order = memory_order_seq_cst) volatile;
559 short fetch_add(short, memory_order = memory_order_seq_cst);
560 short fetch_sub(short, memory_order = memory_order_seq_cst) volatile;
561 short fetch_sub(short, memory_order = memory_order_seq_cst);
562 short fetch_and(short, memory_order = memory_order_seq_cst) volatile;
563 short fetch_and(short, memory_order = memory_order_seq_cst);
564 short fetch_or(short, memory_order = memory_order_seq_cst) volatile;
565 short fetch_or(short, memory_order = memory_order_seq_cst);
566 short fetch_xor(short, memory_order = memory_order_seq_cst) volatile;
567 short fetch_xor(short, memory_order = memory_order_seq_cst);
568 atomic_short() = default;
569 constexpr atomic_short(short);
570 atomic_short(const atomic_short&) = delete;
571 atomic_short& operator=(const atomic_short&) = delete;
572 atomic_short& operator=(const atomic_short&) volatile = delete;
573 short operator=(short) volatile;
574 short operator=(short);
575 short operator++(int) volatile;
576 short operator++(int);
577 short operator--(int) volatile;
578 short operator--(int);
579 short operator++() volatile;
580 short operator++();
581 short operator--() volatile;
582 short operator--();
583 short operator+=(short) volatile;
584 short operator+=(short);
585 short operator-=(short) volatile;
586 short operator-=(short);
587 short operator&=(short) volatile;
588 short operator&=(short);
589 short operator|=(short) volatile;
590 short operator|=(short);
591 short operator^=(short) volatile;
592 short operator^=(short);
593} atomic_short;
594
595bool atomic_is_lock_free(const volatile atomic_short*);
596bool atomic_is_lock_free(const atomic_short*);
597void atomic_init(volatile atomic_short*, itype);
598void atomic_init(atomic_short*, itype);
599void atomic_store(volatile atomic_short*, short);
600void atomic_store(atomic_short*, short);
601void atomic_store_explicit(volatile atomic_short*, short, memory_order);
602void atomic_store_explicit(atomic_short*, short, memory_order);
603short atomic_load(const volatile atomic_short*);
604short atomic_load(const atomic_short*);
605short atomic_load_explicit(const volatile atomic_short*, memory_order);
606short atomic_load_explicit(const atomic_short*, memory_order);
607short atomic_exchange(volatile atomic_short*, short);
608short atomic_exchange(atomic_short*, short);
609short atomic_exchange_explicit(volatile atomic_short*, short, memory_order);
610short atomic_exchange_explicit(atomic_short*, short, memory_order);
611bool atomic_compare_exchange_weak(volatile atomic_short*, short*, short);
612bool atomic_compare_exchange_weak(atomic_short*, short*, short);
613bool atomic_compare_exchange_strong(volatile atomic_short*, short*, short);
614bool atomic_compare_exchange_strong(atomic_short*, short*, short);
615bool atomic_compare_exchange_weak_explicit(volatile atomic_short*, short*,
616 short, memory_order, memory_order);
617bool atomic_compare_exchange_weak_explicit(atomic_short*, short*, short,
618 memory_order, memory_order);
619bool atomic_compare_exchange_strong_explicit(volatile atomic_short*, short*,
620 short, memory_order, memory_order);
621bool atomic_compare_exchange_strong_explicit(atomic_short*, short*, short,
622 memory_order, memory_order);
623short atomic_fetch_add(volatile atomic_short*, short);
624short atomic_fetch_add(atomic_short*, short);
625short atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order);
626short atomic_fetch_add_explicit(atomic_short*, short, memory_order);
627short atomic_fetch_sub(volatile atomic_short*, short);
628short atomic_fetch_sub(atomic_short*, short);
629short atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order);
630short atomic_fetch_sub_explicit(atomic_short*, short, memory_order);
631short atomic_fetch_and(volatile atomic_short*, short);
632short atomic_fetch_and(atomic_short*, short);
633short atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order);
634short atomic_fetch_and_explicit(atomic_short*, short, memory_order);
635short atomic_fetch_or(volatile atomic_short*, short);
636short atomic_fetch_or(atomic_short*, short);
637short atomic_fetch_or_explicit(volatile atomic_short*, short, memory_order);
638short atomic_fetch_or_explicit(atomic_short*, short, memory_order);
639short atomic_fetch_xor(volatile atomic_short*, short);
640short atomic_fetch_xor(atomic_short*, short);
641short atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order);
642short atomic_fetch_xor_explicit(atomic_short*, short, memory_order);
643
644// atomic_ushort
645
646typedef struct atomic_ushort
647{
648 bool is_lock_free() const volatile;
649 bool is_lock_free() const;
650 void store(unsigned short, memory_order = memory_order_seq_cst) volatile;
651 void store(unsigned short, memory_order = memory_order_seq_cst);
652 unsigned short load(memory_order = memory_order_seq_cst) const volatile;
653 unsigned short load(memory_order = memory_order_seq_cst) const;
654 operator unsigned short() const volatile;
655 operator unsigned short() const;
656 unsigned short exchange(unsigned short,
657 memory_order = memory_order_seq_cst) volatile;
658 unsigned short exchange(unsigned short,
659 memory_order = memory_order_seq_cst);
660 bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
661 memory_order) volatile;
662 bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
663 memory_order);
664 bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
665 memory_order) volatile;
666 bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
667 memory_order);
668 bool compare_exchange_weak(unsigned short&, unsigned short,
669 memory_order = memory_order_seq_cst) volatile;
670 bool compare_exchange_weak(unsigned short&, unsigned short,
671 memory_order = memory_order_seq_cst);
672 bool compare_exchange_strong(unsigned short&, unsigned short,
673 memory_order = memory_order_seq_cst) volatile;
674 bool compare_exchange_strong(unsigned short&, unsigned short,
675 memory_order = memory_order_seq_cst);
676 unsigned short fetch_add(unsigned short,
677 memory_order = memory_order_seq_cst) volatile;
678 unsigned short fetch_add(unsigned short,
679 memory_order = memory_order_seq_cst);
680 unsigned short fetch_sub(unsigned short,
681 memory_order = memory_order_seq_cst) volatile;
682 unsigned short fetch_sub(unsigned short,
683 memory_order = memory_order_seq_cst);
684 unsigned short fetch_and(unsigned short,
685 memory_order = memory_order_seq_cst) volatile;
686 unsigned short fetch_and(unsigned short,
687 memory_order = memory_order_seq_cst);
688 unsigned short fetch_or(unsigned short,
689 memory_order = memory_order_seq_cst) volatile;
690 unsigned short fetch_or(unsigned short,
691 memory_order = memory_order_seq_cst);
692 unsigned short fetch_xor(unsigned short,
693 memory_order = memory_order_seq_cst) volatile;
694 unsigned short fetch_xor(unsigned short,
695 memory_order = memory_order_seq_cst);
696 atomic_ushort() = default;
697 constexpr atomic_ushort(unsigned short);
698 atomic_ushort(const atomic_ushort&) = delete;
699 atomic_ushort& operator=(const atomic_ushort&) = delete;
700 atomic_ushort& operator=(const atomic_ushort&) volatile = delete;
701 unsigned short operator=(unsigned short) volatile;
702 unsigned short operator=(unsigned short);
703 unsigned short operator++(int) volatile;
704 unsigned short operator++(int);
705 unsigned short operator--(int) volatile;
706 unsigned short operator--(int);
707 unsigned short operator++() volatile;
708 unsigned short operator++();
709 unsigned short operator--() volatile;
710 unsigned short operator--();
711 unsigned short operator+=(unsigned short) volatile;
712 unsigned short operator+=(unsigned short);
713 unsigned short operator-=(unsigned short) volatile;
714 unsigned short operator-=(unsigned short);
715 unsigned short operator&=(unsigned short) volatile;
716 unsigned short operator&=(unsigned short);
717 unsigned short operator|=(unsigned short) volatile;
718 unsigned short operator|=(unsigned short);
719 unsigned short operator^=(unsigned short) volatile;
720 unsigned short operator^=(unsigned short);
721} atomic_ushort;
722
723bool atomic_is_lock_free(const volatile atomic_ushort*);
724bool atomic_is_lock_free(const atomic_ushort*);
725void atomic_init(volatile atomic_ushort*, itype);
726void atomic_init(atomic_ushort*, itype);
727void atomic_store(volatile atomic_ushort*, unsigned short);
728void atomic_store(atomic_ushort*, unsigned short);
729void atomic_store_explicit(volatile atomic_ushort*, unsigned short,
730 memory_order);
731void atomic_store_explicit(atomic_ushort*, unsigned short, memory_order);
732unsigned short atomic_load(const volatile atomic_ushort*);
733unsigned short atomic_load(const atomic_ushort*);
734unsigned short atomic_load_explicit(const volatile atomic_ushort*,
735 memory_order);
736unsigned short atomic_load_explicit(const atomic_ushort*, memory_order);
737unsigned short atomic_exchange(volatile atomic_ushort*, unsigned short);
738unsigned short atomic_exchange(atomic_ushort*, unsigned short);
739unsigned short atomic_exchange_explicit(volatile atomic_ushort*, unsigned short,
740 memory_order);
741unsigned short atomic_exchange_explicit(atomic_ushort*, unsigned short,
742 memory_order);
743bool atomic_compare_exchange_weak(volatile atomic_ushort*, unsigned short*,
744 unsigned short);
745bool atomic_compare_exchange_weak(atomic_ushort*, unsigned short*,
746 unsigned short);
747bool atomic_compare_exchange_strong(volatile atomic_ushort*, unsigned short*,
748 unsigned short);
749bool atomic_compare_exchange_strong(atomic_ushort*, unsigned short*,
750 unsigned short);
751bool atomic_compare_exchange_weak_explicit(volatile atomic_ushort*,
752 unsigned short*, unsigned short,
753 memory_order, memory_order);
754bool atomic_compare_exchange_weak_explicit(atomic_ushort*, unsigned short*,
755 unsigned short, memory_order,
756 memory_order);
757bool atomic_compare_exchange_strong_explicit(volatile atomic_ushort*,
758 unsigned short*, unsigned short,
759 memory_order, memory_order);
760bool atomic_compare_exchange_strong_explicit(atomic_ushort*, unsigned short*,
761 unsigned short, memory_order,
762 memory_order);
763unsigned short atomic_fetch_add(volatile atomic_ushort*, unsigned short);
764unsigned short atomic_fetch_add(atomic_ushort*, unsigned short);
765unsigned short atomic_fetch_add_explicit(volatile atomic_ushort*,
766 unsigned short, memory_order);
767unsigned short atomic_fetch_add_explicit(atomic_ushort*, unsigned short,
768 memory_order);
769unsigned short atomic_fetch_sub(volatile atomic_ushort*, unsigned short);
770unsigned short atomic_fetch_sub(atomic_ushort*, unsigned short);
771unsigned short atomic_fetch_sub_explicit(volatile atomic_ushort*,
772 unsigned short, memory_order);
773unsigned short atomic_fetch_sub_explicit(atomic_ushort*, unsigned short,
774 memory_order);
775unsigned short atomic_fetch_and(volatile atomic_ushort*, unsigned short);
776unsigned short atomic_fetch_and(atomic_ushort*, unsigned short);
777unsigned short atomic_fetch_and_explicit(volatile atomic_ushort*,
778 unsigned short, memory_order);
779unsigned short atomic_fetch_and_explicit(atomic_ushort*, unsigned short,
780 memory_order);
781unsigned short atomic_fetch_or(volatile atomic_ushort*, unsigned short);
782unsigned short atomic_fetch_or(atomic_ushort*, unsigned short);
783unsigned short atomic_fetch_or_explicit(volatile atomic_ushort*, unsigned short,
784 memory_order);
785unsigned short atomic_fetch_or_explicit(atomic_ushort*, unsigned short,
786 memory_order);
787unsigned short atomic_fetch_xor(volatile atomic_ushort*, unsigned short);
788unsigned short atomic_fetch_xor(atomic_ushort*, unsigned short);
789unsigned short atomic_fetch_xor_explicit(volatile atomic_ushort*,
790 unsigned short, memory_order);
791unsigned short atomic_fetch_xor_explicit(atomic_ushort*, unsigned short,
792 memory_order);
793
794// atomic_int
795
796typedef struct atomic_int
797{
798 bool is_lock_free() const volatile;
799 bool is_lock_free() const;
800 void store(int, memory_order = memory_order_seq_cst) volatile;
801 void store(int, memory_order = memory_order_seq_cst);
802 int load(memory_order = memory_order_seq_cst) const volatile;
803 int load(memory_order = memory_order_seq_cst) const;
804 operator int() const volatile;
805 operator int() const;
806 int exchange(int,
807 memory_order = memory_order_seq_cst) volatile;
808 int exchange(int, memory_order = memory_order_seq_cst);
809 bool compare_exchange_weak(int&, int, memory_order, memory_order) volatile;
810 bool compare_exchange_weak(int&, int, memory_order, memory_order);
811 bool compare_exchange_strong(int&, int, memory_order,
812 memory_order) volatile;
813 bool compare_exchange_strong(int&, int, memory_order, memory_order);
814 bool compare_exchange_weak(int&, int,
815 memory_order = memory_order_seq_cst) volatile;
816 bool compare_exchange_weak(int&, int, memory_order = memory_order_seq_cst);
817 bool compare_exchange_strong(int&, int,
818 memory_order = memory_order_seq_cst) volatile;
819 bool compare_exchange_strong(int&, int,
820 memory_order = memory_order_seq_cst);
821 int fetch_add(int, memory_order = memory_order_seq_cst) volatile;
822 int fetch_add(int, memory_order = memory_order_seq_cst);
823 int fetch_sub(int, memory_order = memory_order_seq_cst) volatile;
824 int fetch_sub(int, memory_order = memory_order_seq_cst);
825 int fetch_and(int, memory_order = memory_order_seq_cst) volatile;
826 int fetch_and(int, memory_order = memory_order_seq_cst);
827 int fetch_or(int, memory_order = memory_order_seq_cst) volatile;
828 int fetch_or(int, memory_order = memory_order_seq_cst);
829 int fetch_xor(int, memory_order = memory_order_seq_cst) volatile;
830 int fetch_xor(int, memory_order = memory_order_seq_cst);
831 atomic_int() = default;
832 constexpr atomic_int(int);
833 atomic_int(const atomic_int&) = delete;
834 atomic_int& operator=(const atomic_int&) = delete;
835 atomic_int& operator=(const atomic_int&) volatile = delete;
836 int operator=(int) volatile;
837 int operator=(int);
838 int operator++(int) volatile;
839 int operator++(int);
840 int operator--(int) volatile;
841 int operator--(int);
842 int operator++() volatile;
843 int operator++();
844 int operator--() volatile;
845 int operator--();
846 int operator+=(int) volatile;
847 int operator+=(int);
848 int operator-=(int) volatile;
849 int operator-=(int);
850 int operator&=(int) volatile;
851 int operator&=(int);
852 int operator|=(int) volatile;
853 int operator|=(int);
854 int operator^=(int) volatile;
855 int operator^=(int);
856} atomic_int;
857
858bool atomic_is_lock_free(const volatile atomic_int*);
859bool atomic_is_lock_free(const atomic_int*);
860void atomic_init(volatile atomic_int*, itype);
861void atomic_init(atomic_int*, itype);
862void atomic_store(volatile atomic_int*, int);
863void atomic_store(atomic_int*, int);
864void atomic_store_explicit(volatile atomic_int*, int, memory_order);
865void atomic_store_explicit(atomic_int*, int, memory_order);
866int atomic_load(const volatile atomic_int*);
867int atomic_load(const atomic_int*);
868int atomic_load_explicit(const volatile atomic_int*, memory_order);
869int atomic_load_explicit(const atomic_int*, memory_order);
870int atomic_exchange(volatile atomic_int*, int);
871int atomic_exchange(atomic_int*, int);
872int atomic_exchange_explicit(volatile atomic_int*, int, memory_order);
873int atomic_exchange_explicit(atomic_int*, int, memory_order);
874bool atomic_compare_exchange_weak(volatile atomic_int*, int*, int);
875bool atomic_compare_exchange_weak(atomic_int*, int*, int);
876bool atomic_compare_exchange_strong(volatile atomic_int*, int*, int);
877bool atomic_compare_exchange_strong(atomic_int*, int*, int);
878bool atomic_compare_exchange_weak_explicit(volatile atomic_int*, int*, int,
879 memory_order, memory_order);
880bool atomic_compare_exchange_weak_explicit(atomic_int*, int*, int, memory_order,
881 memory_order);
882bool atomic_compare_exchange_strong_explicit(volatile atomic_int*, int*, int,
883 memory_order, memory_order);
884bool atomic_compare_exchange_strong_explicit(atomic_int*, int*, int,
885 memory_order, memory_order);
886int atomic_fetch_add(volatile atomic_int*, int);
887int atomic_fetch_add(atomic_int*, int);
888int atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order);
889int atomic_fetch_add_explicit(atomic_int*, int, memory_order);
890int atomic_fetch_sub(volatile atomic_int*, int);
891int atomic_fetch_sub(atomic_int*, int);
892int atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order);
893int atomic_fetch_sub_explicit(atomic_int*, int, memory_order);
894int atomic_fetch_and(volatile atomic_int*, int);
895int atomic_fetch_and(atomic_int*, int);
896int atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order);
897int atomic_fetch_and_explicit(atomic_int*, int, memory_order);
898int atomic_fetch_or(volatile atomic_int*, int);
899int atomic_fetch_or(atomic_int*, int);
900int atomic_fetch_or_explicit(volatile atomic_int*, int, memory_order);
901int atomic_fetch_or_explicit(atomic_int*, int, memory_order);
902int atomic_fetch_xor(volatile atomic_int*, int);
903int atomic_fetch_xor(atomic_int*, int);
904int atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order);
905int atomic_fetch_xor_explicit(atomic_int*, int, memory_order);
906
907// atomic_uint
908
909typedef struct atomic_uint
910{
911 bool is_lock_free() const volatile;
912 bool is_lock_free() const;
913 void store(unsigned int, memory_order = memory_order_seq_cst) volatile;
914 void store(unsigned int, memory_order = memory_order_seq_cst);
915 unsigned int load(memory_order = memory_order_seq_cst) const volatile;
916 unsigned int load(memory_order = memory_order_seq_cst) const;
917 operator unsigned int() const volatile;
918 operator unsigned int() const;
919 unsigned int exchange(unsigned int,
920 memory_order = memory_order_seq_cst) volatile;
921 unsigned int exchange(unsigned int, memory_order = memory_order_seq_cst);
922 bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
923 memory_order) volatile;
924 bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
925 memory_order);
926 bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
927 memory_order) volatile;
928 bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
929 memory_order);
930 bool compare_exchange_weak(unsigned int&, unsigned int,
931 memory_order = memory_order_seq_cst) volatile;
932 bool compare_exchange_weak(unsigned int&, unsigned int,
933 memory_order = memory_order_seq_cst);
934 bool compare_exchange_strong(unsigned int&, unsigned int,
935 memory_order = memory_order_seq_cst) volatile;
936 bool compare_exchange_strong(unsigned int&, unsigned int,
937 memory_order = memory_order_seq_cst);
938 unsigned int fetch_add(unsigned int,
939 memory_order = memory_order_seq_cst) volatile;
940 unsigned int fetch_add(unsigned int, memory_order = memory_order_seq_cst);
941 unsigned int fetch_sub(unsigned int,
942 memory_order = memory_order_seq_cst) volatile;
943 unsigned int fetch_sub(unsigned int, memory_order = memory_order_seq_cst);
944 unsigned int fetch_and(unsigned int,
945 memory_order = memory_order_seq_cst) volatile;
946 unsigned int fetch_and(unsigned int, memory_order = memory_order_seq_cst);
947 unsigned int fetch_or(unsigned int,
948 memory_order = memory_order_seq_cst) volatile;
949 unsigned int fetch_or(unsigned int, memory_order = memory_order_seq_cst);
950 unsigned int fetch_xor(unsigned int,
951 memory_order = memory_order_seq_cst) volatile;
952 unsigned int fetch_xor(unsigned int, memory_order = memory_order_seq_cst);
953 atomic_uint() = default;
954 constexpr atomic_uint(unsigned int);
955 atomic_uint(const atomic_uint&) = delete;
956 atomic_uint& operator=(const atomic_uint&) = delete;
957 atomic_uint& operator=(const atomic_uint&) volatile = delete;
958 unsigned int operator=(unsigned int) volatile;
959 unsigned int operator=(unsigned int);
960 unsigned int operator++(int) volatile;
961 unsigned int operator++(int);
962 unsigned int operator--(int) volatile;
963 unsigned int operator--(int);
964 unsigned int operator++() volatile;
965 unsigned int operator++();
966 unsigned int operator--() volatile;
967 unsigned int operator--();
968 unsigned int operator+=(unsigned int) volatile;
969 unsigned int operator+=(unsigned int);
970 unsigned int operator-=(unsigned int) volatile;
971 unsigned int operator-=(unsigned int);
972 unsigned int operator&=(unsigned int) volatile;
973 unsigned int operator&=(unsigned int);
974 unsigned int operator|=(unsigned int) volatile;
975 unsigned int operator|=(unsigned int);
976 unsigned int operator^=(unsigned int) volatile;
977 unsigned int operator^=(unsigned int);
978} atomic_uint;
979
980bool atomic_is_lock_free(const volatile atomic_uint*);
981bool atomic_is_lock_free(const atomic_uint*);
982void atomic_init(volatile atomic_uint*, itype);
983void atomic_init(atomic_uint*, itype);
984void atomic_store(volatile atomic_uint*, unsigned int);
985void atomic_store(atomic_uint*, unsigned int);
986void atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order);
987void atomic_store_explicit(atomic_uint*, unsigned int, memory_order);
988unsigned int atomic_load(const volatile atomic_uint*);
989unsigned int atomic_load(const atomic_uint*);
990unsigned int atomic_load_explicit(const volatile atomic_uint*, memory_order);
991unsigned int atomic_load_explicit(const atomic_uint*, memory_order);
992unsigned int atomic_exchange(volatile atomic_uint*, unsigned int);
993unsigned int atomic_exchange(atomic_uint*, unsigned int);
994unsigned int atomic_exchange_explicit(volatile atomic_uint*, unsigned int,
995 memory_order);
996unsigned int atomic_exchange_explicit(atomic_uint*, unsigned int, memory_order);
997bool atomic_compare_exchange_weak(volatile atomic_uint*, unsigned int*,
998 unsigned int);
999bool atomic_compare_exchange_weak(atomic_uint*, unsigned int*, unsigned int);
1000bool atomic_compare_exchange_strong(volatile atomic_uint*, unsigned int*,
1001 unsigned int);
1002bool atomic_compare_exchange_strong(atomic_uint*, unsigned int*, unsigned int);
1003bool atomic_compare_exchange_weak_explicit(volatile atomic_uint*, unsigned int*,
1004 unsigned int, memory_order,
1005 memory_order);
1006bool atomic_compare_exchange_weak_explicit(atomic_uint*, unsigned int*,
1007 unsigned int, memory_order,
1008 memory_order);
1009bool atomic_compare_exchange_strong_explicit(volatile atomic_uint*,
1010 unsigned int*, unsigned int,
1011 memory_order, memory_order);
1012bool atomic_compare_exchange_strong_explicit(atomic_uint*, unsigned int*,
1013 unsigned int, memory_order,
1014 memory_order);
1015unsigned int atomic_fetch_add(volatile atomic_uint*, unsigned int);
1016unsigned int atomic_fetch_add(atomic_uint*, unsigned int);
1017unsigned int atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int,
1018 memory_order);
1019unsigned int atomic_fetch_add_explicit(atomic_uint*, unsigned int,
1020 memory_order);
1021unsigned int atomic_fetch_sub(volatile atomic_uint*, unsigned int);
1022unsigned int atomic_fetch_sub(atomic_uint*, unsigned int);
1023unsigned int atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int,
1024 memory_order);
1025unsigned int atomic_fetch_sub_explicit(atomic_uint*, unsigned int,
1026 memory_order);
1027unsigned int atomic_fetch_and(volatile atomic_uint*, unsigned int);
1028unsigned int atomic_fetch_and(atomic_uint*, unsigned int);
1029unsigned int atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int,
1030 memory_order);
1031unsigned int atomic_fetch_and_explicit(atomic_uint*, unsigned int,
1032 memory_order);
1033unsigned int atomic_fetch_or(volatile atomic_uint*, unsigned int);
1034unsigned int atomic_fetch_or(atomic_uint*, unsigned int);
1035unsigned int atomic_fetch_or_explicit(volatile atomic_uint*, unsigned int,
1036 memory_order);
1037unsigned int atomic_fetch_or_explicit(atomic_uint*, unsigned int, memory_order);
1038unsigned int atomic_fetch_xor(volatile atomic_uint*, unsigned int);
1039unsigned int atomic_fetch_xor(atomic_uint*, unsigned int);
1040unsigned int atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int,
1041 memory_order);
1042unsigned int atomic_fetch_xor_explicit(atomic_uint*, unsigned int,
1043 memory_order);
1044
1045// atomic_long
1046
1047typedef struct atomic_long
1048{
1049 bool is_lock_free() const volatile;
1050 bool is_lock_free() const;
1051 void store(long, memory_order = memory_order_seq_cst) volatile;
1052 void store(long, memory_order = memory_order_seq_cst);
1053 long load(memory_order = memory_order_seq_cst) const volatile;
1054 long load(memory_order = memory_order_seq_cst) const;
1055 operator long() const volatile;
1056 operator long() const;
1057 long exchange(long,
1058 memory_order = memory_order_seq_cst) volatile;
1059 long exchange(long, memory_order = memory_order_seq_cst);
1060 bool compare_exchange_weak(long&, long, memory_order,
1061 memory_order) volatile;
1062 bool compare_exchange_weak(long&, long, memory_order, memory_order);
1063 bool compare_exchange_strong(long&, long, memory_order,
1064 memory_order) volatile;
1065 bool compare_exchange_strong(long&, long, memory_order, memory_order);
1066 bool compare_exchange_weak(long&, long,
1067 memory_order = memory_order_seq_cst) volatile;
1068 bool compare_exchange_weak(long&, long,
1069 memory_order = memory_order_seq_cst);
1070 bool compare_exchange_strong(long&, long,
1071 memory_order = memory_order_seq_cst) volatile;
1072 bool compare_exchange_strong(long&, long,
1073 memory_order = memory_order_seq_cst);
1074 long fetch_add(long, memory_order = memory_order_seq_cst) volatile;
1075 long fetch_add(long, memory_order = memory_order_seq_cst);
1076 long fetch_sub(long, memory_order = memory_order_seq_cst) volatile;
1077 long fetch_sub(long, memory_order = memory_order_seq_cst);
1078 long fetch_and(long, memory_order = memory_order_seq_cst) volatile;
1079 long fetch_and(long, memory_order = memory_order_seq_cst);
1080 long fetch_or(long, memory_order = memory_order_seq_cst) volatile;
1081 long fetch_or(long, memory_order = memory_order_seq_cst);
1082 long fetch_xor(long, memory_order = memory_order_seq_cst) volatile;
1083 long fetch_xor(long, memory_order = memory_order_seq_cst);
1084 atomic_long() = default;
1085 constexpr atomic_long(long);
1086 atomic_long(const atomic_long&) = delete;
1087 atomic_long& operator=(const atomic_long&) = delete;
1088 atomic_long& operator=(const atomic_long&) volatile = delete;
1089 long operator=(long) volatile;
1090 long operator=(long);
1091 long operator++(int) volatile;
1092 long operator++(int);
1093 long operator--(int) volatile;
1094 long operator--(int);
1095 long operator++() volatile;
1096 long operator++();
1097 long operator--() volatile;
1098 long operator--();
1099 long operator+=(long) volatile;
1100 long operator+=(long);
1101 long operator-=(long) volatile;
1102 long operator-=(long);
1103 long operator&=(long) volatile;
1104 long operator&=(long);
1105 long operator|=(long) volatile;
1106 long operator|=(long);
1107 long operator^=(long) volatile;
1108 long operator^=(long);
1109} atomic_long;
1110
1111bool atomic_is_lock_free(const volatile atomic_long*);
1112bool atomic_is_lock_free(const atomic_long*);
1113void atomic_init(volatile atomic_long*, itype);
1114void atomic_init(atomic_long*, itype);
1115void atomic_store(volatile atomic_long*, long);
1116void atomic_store(atomic_long*, long);
1117void atomic_store_explicit(volatile atomic_long*, long, memory_order);
1118void atomic_store_explicit(atomic_long*, long, memory_order);
1119long atomic_load(const volatile atomic_long*);
1120long atomic_load(const atomic_long*);
1121long atomic_load_explicit(const volatile atomic_long*, memory_order);
1122long atomic_load_explicit(const atomic_long*, memory_order);
1123long atomic_exchange(volatile atomic_long*, long);
1124long atomic_exchange(atomic_long*, long);
1125long atomic_exchange_explicit(volatile atomic_long*, long, memory_order);
1126long atomic_exchange_explicit(atomic_long*, long, memory_order);
1127bool atomic_compare_exchange_weak(volatile atomic_long*, long*, long);
1128bool atomic_compare_exchange_weak(atomic_long*, long*, long);
1129bool atomic_compare_exchange_strong(volatile atomic_long*, long*, long);
1130bool atomic_compare_exchange_strong(atomic_long*, long*, long);
1131bool atomic_compare_exchange_weak_explicit(volatile atomic_long*, long*, long,
1132 memory_order, memory_order);
1133bool atomic_compare_exchange_weak_explicit(atomic_long*, long*, long,
1134 memory_order, memory_order);
1135bool atomic_compare_exchange_strong_explicit(volatile atomic_long*, long*, long,
1136 memory_order, memory_order);
1137bool atomic_compare_exchange_strong_explicit(atomic_long*, long*, long,
1138 memory_order, memory_order);
1139long atomic_fetch_add(volatile atomic_long*, long);
1140long atomic_fetch_add(atomic_long*, long);
1141long atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order);
1142long atomic_fetch_add_explicit(atomic_long*, long, memory_order);
1143long atomic_fetch_sub(volatile atomic_long*, long);
1144long atomic_fetch_sub(atomic_long*, long);
1145long atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order);
1146long atomic_fetch_sub_explicit(atomic_long*, long, memory_order);
1147long atomic_fetch_and(volatile atomic_long*, long);
1148long atomic_fetch_and(atomic_long*, long);
1149long atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order);
1150long atomic_fetch_and_explicit(atomic_long*, long, memory_order);
1151long atomic_fetch_or(volatile atomic_long*, long);
1152long atomic_fetch_or(atomic_long*, long);
1153long atomic_fetch_or_explicit(volatile atomic_long*, long, memory_order);
1154long atomic_fetch_or_explicit(atomic_long*, long, memory_order);
1155long atomic_fetch_xor(volatile atomic_long*, long);
1156long atomic_fetch_xor(atomic_long*, long);
1157long atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order);
1158long atomic_fetch_xor_explicit(atomic_long*, long, memory_order);
1159
1160// atomic_ulong
1161
1162typedef struct atomic_ulong
1163{
1164 bool is_lock_free() const volatile;
1165 bool is_lock_free() const;
1166 void store(unsigned long, memory_order = memory_order_seq_cst) volatile;
1167 void store(unsigned long, memory_order = memory_order_seq_cst);
1168 unsigned long load(memory_order = memory_order_seq_cst) const volatile;
1169 unsigned long load(memory_order = memory_order_seq_cst) const;
1170 operator unsigned long() const volatile;
1171 operator unsigned long() const;
1172 unsigned long exchange(unsigned long,
1173 memory_order = memory_order_seq_cst) volatile;
1174 unsigned long exchange(unsigned long, memory_order = memory_order_seq_cst);
1175 bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
1176 memory_order) volatile;
1177 bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
1178 memory_order);
1179 bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
1180 memory_order) volatile;
1181 bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
1182 memory_order);
1183 bool compare_exchange_weak(unsigned long&, unsigned long,
1184 memory_order = memory_order_seq_cst) volatile;
1185 bool compare_exchange_weak(unsigned long&, unsigned long,
1186 memory_order = memory_order_seq_cst);
1187 bool compare_exchange_strong(unsigned long&, unsigned long,
1188 memory_order = memory_order_seq_cst) volatile;
1189 bool compare_exchange_strong(unsigned long&, unsigned long,
1190 memory_order = memory_order_seq_cst);
1191 unsigned long fetch_add(unsigned long,
1192 memory_order = memory_order_seq_cst) volatile;
1193 unsigned long fetch_add(unsigned long, memory_order = memory_order_seq_cst);
1194 unsigned long fetch_sub(unsigned long,
1195 memory_order = memory_order_seq_cst) volatile;
1196 unsigned long fetch_sub(unsigned long, memory_order = memory_order_seq_cst);
1197 unsigned long fetch_and(unsigned long,
1198 memory_order = memory_order_seq_cst) volatile;
1199 unsigned long fetch_and(unsigned long, memory_order = memory_order_seq_cst);
1200 unsigned long fetch_or(unsigned long,
1201 memory_order = memory_order_seq_cst) volatile;
1202 unsigned long fetch_or(unsigned long, memory_order = memory_order_seq_cst);
1203 unsigned long fetch_xor(unsigned long,
1204 memory_order = memory_order_seq_cst) volatile;
1205 unsigned long fetch_xor(unsigned long, memory_order = memory_order_seq_cst);
1206 atomic_ulong() = default;
1207 constexpr atomic_ulong(unsigned long);
1208 atomic_ulong(const atomic_ulong&) = delete;
1209 atomic_ulong& operator=(const atomic_ulong&) = delete;
1210 atomic_ulong& operator=(const atomic_ulong&) volatile = delete;
1211 unsigned long operator=(unsigned long) volatile;
1212 unsigned long operator=(unsigned long);
1213 unsigned long operator++(int) volatile;
1214 unsigned long operator++(int);
1215 unsigned long operator--(int) volatile;
1216 unsigned long operator--(int);
1217 unsigned long operator++() volatile;
1218 unsigned long operator++();
1219 unsigned long operator--() volatile;
1220 unsigned long operator--();
1221 unsigned long operator+=(unsigned long) volatile;
1222 unsigned long operator+=(unsigned long);
1223 unsigned long operator-=(unsigned long) volatile;
1224 unsigned long operator-=(unsigned long);
1225 unsigned long operator&=(unsigned long) volatile;
1226 unsigned long operator&=(unsigned long);
1227 unsigned long operator|=(unsigned long) volatile;
1228 unsigned long operator|=(unsigned long);
1229 unsigned long operator^=(unsigned long) volatile;
1230 unsigned long operator^=(unsigned long);
1231} atomic_ulong;
1232
1233bool atomic_is_lock_free(const volatile atomic_ulong*);
1234bool atomic_is_lock_free(const atomic_ulong*);
1235void atomic_init(volatile atomic_ulong*, itype);
1236void atomic_init(atomic_ulong*, itype);
1237void atomic_store(volatile atomic_ulong*, unsigned long);
1238void atomic_store(atomic_ulong*, unsigned long);
1239void atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order);
1240void atomic_store_explicit(atomic_ulong*, unsigned long, memory_order);
1241unsigned long atomic_load(const volatile atomic_ulong*);
1242unsigned long atomic_load(const atomic_ulong*);
1243unsigned long atomic_load_explicit(const volatile atomic_ulong*, memory_order);
1244unsigned long atomic_load_explicit(const atomic_ulong*, memory_order);
1245unsigned long atomic_exchange(volatile atomic_ulong*, unsigned long);
1246unsigned long atomic_exchange(atomic_ulong*, unsigned long);
1247unsigned long atomic_exchange_explicit(volatile atomic_ulong*, unsigned long,
1248 memory_order);
1249unsigned long atomic_exchange_explicit(atomic_ulong*, unsigned long,
1250 memory_order);
1251bool atomic_compare_exchange_weak(volatile atomic_ulong*, unsigned long*,
1252 unsigned long);
1253bool atomic_compare_exchange_weak(atomic_ulong*, unsigned long*, unsigned long);
1254bool atomic_compare_exchange_strong(volatile atomic_ulong*, unsigned long*,
1255 unsigned long);
1256bool atomic_compare_exchange_strong(atomic_ulong*, unsigned long*,
1257 unsigned long);
1258bool atomic_compare_exchange_weak_explicit(volatile atomic_ulong*,
1259 unsigned long*, unsigned long,
1260 memory_order, memory_order);
1261bool atomic_compare_exchange_weak_explicit(atomic_ulong*, unsigned long*,
1262 unsigned long, memory_order,
1263 memory_order);
1264bool atomic_compare_exchange_strong_explicit(volatile atomic_ulong*,
1265 unsigned long*, unsigned long,
1266 memory_order, memory_order);
1267bool atomic_compare_exchange_strong_explicit(atomic_ulong*, unsigned long*,
1268 unsigned long, memory_order,
1269 memory_order);
1270unsigned long atomic_fetch_add(volatile atomic_ulong*, unsigned long);
1271unsigned long atomic_fetch_add(atomic_ulong*, unsigned long);
1272unsigned long atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long,
1273 memory_order);
1274unsigned long atomic_fetch_add_explicit(atomic_ulong*, unsigned long,
1275 memory_order);
1276unsigned long atomic_fetch_sub(volatile atomic_ulong*, unsigned long);
1277unsigned long atomic_fetch_sub(atomic_ulong*, unsigned long);
1278unsigned long atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long,
1279 memory_order);
1280unsigned long atomic_fetch_sub_explicit(atomic_ulong*, unsigned long,
1281 memory_order);
1282unsigned long atomic_fetch_and(volatile atomic_ulong*, unsigned long);
1283unsigned long atomic_fetch_and(atomic_ulong*, unsigned long);
1284unsigned long atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long,
1285 memory_order);
1286unsigned long atomic_fetch_and_explicit(atomic_ulong*, unsigned long,
1287 memory_order);
1288unsigned long atomic_fetch_or(volatile atomic_ulong*, unsigned long);
1289unsigned long atomic_fetch_or(atomic_ulong*, unsigned long);
1290unsigned long atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long,
1291 memory_order);
1292unsigned long atomic_fetch_or_explicit(atomic_ulong*, unsigned long,
1293 memory_order);
1294unsigned long atomic_fetch_xor(volatile atomic_ulong*, unsigned long);
1295unsigned long atomic_fetch_xor(atomic_ulong*, unsigned long);
1296unsigned long atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long,
1297 memory_order);
1298unsigned long atomic_fetch_xor_explicit(atomic_ulong*, unsigned long,
1299 memory_order);
1300
1301// atomic_llong
1302
1303typedef struct atomic_llong
1304{
1305 bool is_lock_free() const volatile;
1306 bool is_lock_free() const;
1307 void store(long long, memory_order = memory_order_seq_cst) volatile;
1308 void store(long long, memory_order = memory_order_seq_cst);
1309 long long load(memory_order = memory_order_seq_cst) const volatile;
1310 long long load(memory_order = memory_order_seq_cst) const;
1311 operator long long() const volatile;
1312 operator long long() const;
1313 long long exchange(long long,
1314 memory_order = memory_order_seq_cst) volatile;
1315 long long exchange(long long, memory_order = memory_order_seq_cst);
1316 bool compare_exchange_weak(long long&, long long, memory_order,
1317 memory_order) volatile;
1318 bool compare_exchange_weak(long long&, long long, memory_order,
1319 memory_order);
1320 bool compare_exchange_strong(long long&, long long, memory_order,
1321 memory_order) volatile;
1322 bool compare_exchange_strong(long long&, long long, memory_order,
1323 memory_order);
1324 bool compare_exchange_weak(long long&, long long,
1325 memory_order = memory_order_seq_cst) volatile;
1326 bool compare_exchange_weak(long long&, long long,
1327 memory_order = memory_order_seq_cst);
1328 bool compare_exchange_strong(long long&, long long,
1329 memory_order = memory_order_seq_cst) volatile;
1330 bool compare_exchange_strong(long long&, long long,
1331 memory_order = memory_order_seq_cst);
1332 long long fetch_add(long long,
1333 memory_order = memory_order_seq_cst) volatile;
1334 long long fetch_add(long long, memory_order = memory_order_seq_cst);
1335 long long fetch_sub(long long,
1336 memory_order = memory_order_seq_cst) volatile;
1337 long long fetch_sub(long long, memory_order = memory_order_seq_cst);
1338 long long fetch_and(long long,
1339 memory_order = memory_order_seq_cst) volatile;
1340 long long fetch_and(long long, memory_order = memory_order_seq_cst);
1341 long long fetch_or(long long, memory_order = memory_order_seq_cst) volatile;
1342 long long fetch_or(long long, memory_order = memory_order_seq_cst);
1343 long long fetch_xor(long long,
1344 memory_order = memory_order_seq_cst) volatile;
1345 long long fetch_xor(long long, memory_order = memory_order_seq_cst);
1346 atomic_llong() = default;
1347 constexpr atomic_llong(long long);
1348 atomic_llong(const atomic_llong&) = delete;
1349 atomic_llong& operator=(const atomic_llong&) = delete;
1350 atomic_llong& operator=(const atomic_llong&) volatile = delete;
1351 long long operator=(long long) volatile;
1352 long long operator=(long long);
1353 long long operator++(int) volatile;
1354 long long operator++(int);
1355 long long operator--(int) volatile;
1356 long long operator--(int);
1357 long long operator++() volatile;
1358 long long operator++();
1359 long long operator--() volatile;
1360 long long operator--();
1361 long long operator+=(long long) volatile;
1362 long long operator+=(long long);
1363 long long operator-=(long long) volatile;
1364 long long operator-=(long long);
1365 long long operator&=(long long) volatile;
1366 long long operator&=(long long);
1367 long long operator|=(long long) volatile;
1368 long long operator|=(long long);
1369 long long operator^=(long long) volatile;
1370 long long operator^=(long long);
1371} atomic_llong;
1372
1373bool atomic_is_lock_free(const volatile atomic_llong*);
1374bool atomic_is_lock_free(const atomic_llong*);
1375void atomic_init(volatile atomic_llong*, itype);
1376void atomic_init(atomic_llong*, itype);
1377void atomic_store(volatile atomic_llong*, long long);
1378void atomic_store(atomic_llong*, long long);
1379void atomic_store_explicit(volatile atomic_llong*, long long, memory_order);
1380void atomic_store_explicit(atomic_llong*, long long, memory_order);
1381long long atomic_load(const volatile atomic_llong*);
1382long long atomic_load(const atomic_llong*);
1383long long atomic_load_explicit(const volatile atomic_llong*, memory_order);
1384long long atomic_load_explicit(const atomic_llong*, memory_order);
1385long long atomic_exchange(volatile atomic_llong*, long long);
1386long long atomic_exchange(atomic_llong*, long long);
1387long long atomic_exchange_explicit(volatile atomic_llong*, long long,
1388 memory_order);
1389long long atomic_exchange_explicit(atomic_llong*, long long, memory_order);
1390bool atomic_compare_exchange_weak(volatile atomic_llong*, long long*,
1391 long long);
1392bool atomic_compare_exchange_weak(atomic_llong*, long long*, long long);
1393bool atomic_compare_exchange_strong(volatile atomic_llong*, long long*,
1394 long long);
1395bool atomic_compare_exchange_strong(atomic_llong*, long long*, long long);
1396bool atomic_compare_exchange_weak_explicit(volatile atomic_llong*, long long*,
1397 long long, memory_order,
1398 memory_order);
1399bool atomic_compare_exchange_weak_explicit(atomic_llong*, long long*, long long,
1400 memory_order, memory_order);
1401bool atomic_compare_exchange_strong_explicit(volatile atomic_llong*, long long*,
1402 long long, memory_order,
1403 memory_order);
1404bool atomic_compare_exchange_strong_explicit(atomic_llong*, long long*,
1405 long long, memory_order,
1406 memory_order);
1407long long atomic_fetch_add(volatile atomic_llong*, long long);
1408long long atomic_fetch_add(atomic_llong*, long long);
1409long long atomic_fetch_add_explicit(volatile atomic_llong*, long long,
1410 memory_order);
1411long long atomic_fetch_add_explicit(atomic_llong*, long long, memory_order);
1412long long atomic_fetch_sub(volatile atomic_llong*, long long);
1413long long atomic_fetch_sub(atomic_llong*, long long);
1414long long atomic_fetch_sub_explicit(volatile atomic_llong*, long long,
1415 memory_order);
1416long long atomic_fetch_sub_explicit(atomic_llong*, long long, memory_order);
1417long long atomic_fetch_and(volatile atomic_llong*, long long);
1418long long atomic_fetch_and(atomic_llong*, long long);
1419long long atomic_fetch_and_explicit(volatile atomic_llong*, long long,
1420 memory_order);
1421long long atomic_fetch_and_explicit(atomic_llong*, long long, memory_order);
1422long long atomic_fetch_or(volatile atomic_llong*, long long);
1423long long atomic_fetch_or(atomic_llong*, long long);
1424long long atomic_fetch_or_explicit(volatile atomic_llong*, long long,
1425 memory_order);
1426long long atomic_fetch_or_explicit(atomic_llong*, long long, memory_order);
1427long long atomic_fetch_xor(volatile atomic_llong*, long long);
1428long long atomic_fetch_xor(atomic_llong*, long long);
1429long long atomic_fetch_xor_explicit(volatile atomic_llong*, long long,
1430 memory_order);
1431long long atomic_fetch_xor_explicit(atomic_llong*, long long, memory_order);
1432
1433// atomic_ullong
1434
1435typedef struct atomic_ullong
1436{
1437 bool is_lock_free() const volatile;
1438 bool is_lock_free() const;
1439 void store(unsigned long long,
1440 memory_order = memory_order_seq_cst) volatile;
1441 void store(unsigned long long, memory_order = memory_order_seq_cst);
1442 unsigned long long load(memory_order = memory_order_seq_cst) const volatile;
1443 unsigned long long load(memory_order = memory_order_seq_cst) const;
1444 operator unsigned long long() const volatile;
1445 operator unsigned long long() const;
1446 unsigned long long exchange(unsigned long long,
1447 memory_order = memory_order_seq_cst) volatile;
1448 unsigned long long exchange(unsigned long long,
1449 memory_order = memory_order_seq_cst);
1450 bool compare_exchange_weak(unsigned long long&, unsigned long long,
1451 memory_order, memory_order) volatile;
1452 bool compare_exchange_weak(unsigned long long&, unsigned long long,
1453 memory_order, memory_order);
1454 bool compare_exchange_strong(unsigned long long&, unsigned long long,
1455 memory_order, memory_order) volatile;
1456 bool compare_exchange_strong(unsigned long long&, unsigned long long,
1457 memory_order, memory_order);
1458 bool compare_exchange_weak(unsigned long long&, unsigned long long,
1459 memory_order = memory_order_seq_cst) volatile;
1460 bool compare_exchange_weak(unsigned long long&, unsigned long long,
1461 memory_order = memory_order_seq_cst);
1462 bool compare_exchange_strong(unsigned long long&, unsigned long long,
1463 memory_order = memory_order_seq_cst) volatile;
1464 bool compare_exchange_strong(unsigned long long&, unsigned long long,
1465 memory_order = memory_order_seq_cst);
1466 unsigned long long fetch_add(unsigned long long,
1467 memory_order = memory_order_seq_cst) volatile;
1468 unsigned long long fetch_add(unsigned long long,
1469 memory_order = memory_order_seq_cst);
1470 unsigned long long fetch_sub(unsigned long long,
1471 memory_order = memory_order_seq_cst) volatile;
1472 unsigned long long fetch_sub(unsigned long long,
1473 memory_order = memory_order_seq_cst);
1474 unsigned long long fetch_and(unsigned long long,
1475 memory_order = memory_order_seq_cst) volatile;
1476 unsigned long long fetch_and(unsigned long long,
1477 memory_order = memory_order_seq_cst);
1478 unsigned long long fetch_or(unsigned long long,
1479 memory_order = memory_order_seq_cst) volatile;
1480 unsigned long long fetch_or(unsigned long long,
1481 memory_order = memory_order_seq_cst);
1482 unsigned long long fetch_xor(unsigned long long,
1483 memory_order = memory_order_seq_cst) volatile;
1484 unsigned long long fetch_xor(unsigned long long,
1485 memory_order = memory_order_seq_cst);
1486 atomic_ullong() = default;
1487 constexpr atomic_ullong(unsigned long long);
1488 atomic_ullong(const atomic_ullong&) = delete;
1489 atomic_ullong& operator=(const atomic_ullong&) = delete;
1490 atomic_ullong& operator=(const atomic_ullong&) volatile = delete;
1491 unsigned long long operator=(unsigned long long) volatile;
1492 unsigned long long operator=(unsigned long long);
1493 unsigned long long operator++(int) volatile;
1494 unsigned long long operator++(int);
1495 unsigned long long operator--(int) volatile;
1496 unsigned long long operator--(int);
1497 unsigned long long operator++() volatile;
1498 unsigned long long operator++();
1499 unsigned long long operator--() volatile;
1500 unsigned long long operator--();
1501 unsigned long long operator+=(unsigned long long) volatile;
1502 unsigned long long operator+=(unsigned long long);
1503 unsigned long long operator-=(unsigned long long) volatile;
1504 unsigned long long operator-=(unsigned long long);
1505 unsigned long long operator&=(unsigned long long) volatile;
1506 unsigned long long operator&=(unsigned long long);
1507 unsigned long long operator|=(unsigned long long) volatile;
1508 unsigned long long operator|=(unsigned long long);
1509 unsigned long long operator^=(unsigned long long) volatile;
1510 unsigned long long operator^=(unsigned long long);
1511} atomic_ullong;
1512
1513bool atomic_is_lock_free(const volatile atomic_ullong*);
1514bool atomic_is_lock_free(const atomic_ullong*);
1515void atomic_init(volatile atomic_ullong*, itype);
1516void atomic_init(atomic_ullong*, itype);
1517void atomic_store(volatile atomic_ullong*, unsigned long long);
1518void atomic_store(atomic_ullong*, unsigned long long);
1519void atomic_store_explicit(volatile atomic_ullong*, unsigned long long,
1520 memory_order);
1521void atomic_store_explicit(atomic_ullong*, unsigned long long, memory_order);
1522unsigned long long atomic_load(const volatile atomic_ullong*);
1523unsigned long long atomic_load(const atomic_ullong*);
1524unsigned long long atomic_load_explicit(const volatile atomic_ullong*,
1525 memory_order);
1526unsigned long long atomic_load_explicit(const atomic_ullong*, memory_order);
1527unsigned long long atomic_exchange(volatile atomic_ullong*, unsigned long long);
1528unsigned long long atomic_exchange(atomic_ullong*, unsigned long long);
1529unsigned long long atomic_exchange_explicit(volatile atomic_ullong*,
1530 unsigned long long, memory_order);
1531unsigned long long atomic_exchange_explicit(atomic_ullong*, unsigned long long,
1532 memory_order);
1533bool atomic_compare_exchange_weak(volatile atomic_ullong*, unsigned long long*,
1534 unsigned long long);
1535bool atomic_compare_exchange_weak(atomic_ullong*, unsigned long long*,
1536 unsigned long long);
1537bool atomic_compare_exchange_strong(volatile atomic_ullong*,
1538 unsigned long long*, unsigned long long);
1539bool atomic_compare_exchange_strong(atomic_ullong*, unsigned long long*,
1540 unsigned long long);
1541bool atomic_compare_exchange_weak_explicit(volatile atomic_ullong*,
1542 unsigned long long*,
1543 unsigned long long, memory_order,
1544 memory_order);
1545bool atomic_compare_exchange_weak_explicit(atomic_ullong*, unsigned long long*,
1546 unsigned long long, memory_order,
1547 memory_order);
1548bool atomic_compare_exchange_strong_explicit(volatile atomic_ullong*,
1549 unsigned long long*,
1550 unsigned long long, memory_order,
1551 memory_order);
1552bool atomic_compare_exchange_strong_explicit(atomic_ullong*,
1553 unsigned long long*,
1554 unsigned long long, memory_order,
1555 memory_order);
1556unsigned long long atomic_fetch_add(volatile atomic_ullong*,
1557 unsigned long long);
1558unsigned long long atomic_fetch_add(atomic_ullong*, unsigned long long);
1559unsigned long long atomic_fetch_add_explicit(volatile atomic_ullong*,
1560 unsigned long long, memory_order);
1561unsigned long long atomic_fetch_add_explicit(atomic_ullong*, unsigned long long,
1562 memory_order);
1563unsigned long long atomic_fetch_sub(volatile atomic_ullong*,
1564 unsigned long long);
1565unsigned long long atomic_fetch_sub(atomic_ullong*, unsigned long long);
1566unsigned long long atomic_fetch_sub_explicit(volatile atomic_ullong*,
1567 unsigned long long, memory_order);
1568unsigned long long atomic_fetch_sub_explicit(atomic_ullong*, unsigned long long,
1569 memory_order);
1570unsigned long long atomic_fetch_and(volatile atomic_ullong*,
1571 unsigned long long);
1572unsigned long long atomic_fetch_and(atomic_ullong*, unsigned long long);
1573unsigned long long atomic_fetch_and_explicit(volatile atomic_ullong*,
1574 unsigned long long, memory_order);
1575unsigned long long atomic_fetch_and_explicit(atomic_ullong*, unsigned long long,
1576 memory_order);
1577unsigned long long atomic_fetch_or(volatile atomic_ullong*, unsigned long long);
1578unsigned long long atomic_fetch_or(atomic_ullong*, unsigned long long);
1579unsigned long long atomic_fetch_or_explicit(volatile atomic_ullong*,
1580 unsigned long long, memory_order);
1581unsigned long long atomic_fetch_or_explicit(atomic_ullong*, unsigned long long,
1582 memory_order);
1583unsigned long long atomic_fetch_xor(volatile atomic_ullong*,
1584 unsigned long long);
1585unsigned long long atomic_fetch_xor(atomic_ullong*, unsigned long long);
1586unsigned long long atomic_fetch_xor_explicit(volatile atomic_ullong*,
1587 unsigned long long, memory_order);
1588unsigned long long atomic_fetch_xor_explicit(atomic_ullong*, unsigned long long,
1589 memory_order);
1590
1591// atomic_char16_t
1592
1593typedef struct atomic_char16_t
1594{
1595 bool is_lock_free() const volatile;
1596 bool is_lock_free() const;
1597 void store(char16_t, memory_order = memory_order_seq_cst) volatile;
1598 void store(char16_t, memory_order = memory_order_seq_cst);
1599 char16_t load(memory_order = memory_order_seq_cst) const volatile;
1600 char16_t load(memory_order = memory_order_seq_cst) const;
1601 operator char16_t() const volatile;
1602 operator char16_t() const;
1603 char16_t exchange(char16_t,
1604 memory_order = memory_order_seq_cst) volatile;
1605 char16_t exchange(char16_t, memory_order = memory_order_seq_cst);
1606 bool compare_exchange_weak(char16_t&, char16_t, memory_order,
1607 memory_order) volatile;
1608 bool compare_exchange_weak(char16_t&, char16_t, memory_order, memory_order);
1609 bool compare_exchange_strong(char16_t&, char16_t, memory_order,
1610 memory_order) volatile;
1611 bool compare_exchange_strong(char16_t&, char16_t,
1612 memory_order, memory_order);
1613 bool compare_exchange_weak(char16_t&, char16_t,
1614 memory_order = memory_order_seq_cst) volatile;
1615 bool compare_exchange_weak(char16_t&, char16_t,
1616 memory_order = memory_order_seq_cst);
1617 bool compare_exchange_strong(char16_t&, char16_t,
1618 memory_order = memory_order_seq_cst) volatile;
1619 bool compare_exchange_strong(char16_t&, char16_t,
1620 memory_order = memory_order_seq_cst);
1621 char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst) volatile;
1622 char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst);
1623 char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst) volatile;
1624 char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst);
1625 char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst) volatile;
1626 char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst);
1627 char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst) volatile;
1628 char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst);
1629 char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst) volatile;
1630 char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst);
1631 atomic_char16_t() = default;
1632 constexpr atomic_char16_t(char16_t);
1633 atomic_char16_t(const atomic_char16_t&) = delete;
1634 atomic_char16_t& operator=(const atomic_char16_t&) = delete;
1635 atomic_char16_t& operator=(const atomic_char16_t&) volatile = delete;
1636 char16_t operator=(char16_t) volatile;
1637 char16_t operator=(char16_t);
1638 char16_t operator++(int) volatile;
1639 char16_t operator++(int);
1640 char16_t operator--(int) volatile;
1641 char16_t operator--(int);
1642 char16_t operator++() volatile;
1643 char16_t operator++();
1644 char16_t operator--() volatile;
1645 char16_t operator--();
1646 char16_t operator+=(char16_t) volatile;
1647 char16_t operator+=(char16_t);
1648 char16_t operator-=(char16_t) volatile;
1649 char16_t operator-=(char16_t);
1650 char16_t operator&=(char16_t) volatile;
1651 char16_t operator&=(char16_t);
1652 char16_t operator|=(char16_t) volatile;
1653 char16_t operator|=(char16_t);
1654 char16_t operator^=(char16_t) volatile;
1655 char16_t operator^=(char16_t);
1656} atomic_char16_t;
1657
1658bool atomic_is_lock_free(const volatile atomic_char16_t*);
1659bool atomic_is_lock_free(const atomic_char16_t*);
1660void atomic_init(volatile atomic_char16_t*, itype);
1661void atomic_init(atomic_char16_t*, itype);
1662void atomic_store(volatile atomic_char16_t*, char16_t);
1663void atomic_store(atomic_char16_t*, char16_t);
1664void atomic_store_explicit(volatile atomic_char16_t*, char16_t, memory_order);
1665void atomic_store_explicit(atomic_char16_t*, char16_t, memory_order);
1666char16_t atomic_load(const volatile atomic_char16_t*);
1667char16_t atomic_load(const atomic_char16_t*);
1668char16_t atomic_load_explicit(const volatile atomic_char16_t*, memory_order);
1669char16_t atomic_load_explicit(const atomic_char16_t*, memory_order);
1670char16_t atomic_exchange(volatile atomic_char16_t*, char16_t);
1671char16_t atomic_exchange(atomic_char16_t*, char16_t);
1672char16_t atomic_exchange_explicit(volatile atomic_char16_t*, char16_t,
1673 memory_order);
1674char16_t atomic_exchange_explicit(atomic_char16_t*, char16_t, memory_order);
1675bool atomic_compare_exchange_weak(volatile atomic_char16_t*, char16_t*,
1676 char16_t);
1677bool atomic_compare_exchange_weak(atomic_char16_t*, char16_t*, char16_t);
1678bool atomic_compare_exchange_strong(volatile atomic_char16_t*, char16_t*,
1679 char16_t);
1680bool atomic_compare_exchange_strong(atomic_char16_t*, char16_t*, char16_t);
1681bool atomic_compare_exchange_weak_explicit(volatile atomic_char16_t*, char16_t*,
1682 char16_t, memory_order,
1683 memory_order);
1684bool atomic_compare_exchange_weak_explicit(atomic_char16_t*, char16_t*,
1685 char16_t, memory_order,
1686 memory_order);
1687bool atomic_compare_exchange_strong_explicit(volatile atomic_char16_t*,
1688 char16_t*, char16_t, memory_order,
1689 memory_order);
1690bool atomic_compare_exchange_strong_explicit(atomic_char16_t*, char16_t*,
1691 char16_t, memory_order,
1692 memory_order);
1693char16_t atomic_fetch_add(volatile atomic_char16_t*, char16_t);
1694char16_t atomic_fetch_add(atomic_char16_t*, char16_t);
1695char16_t atomic_fetch_add_explicit(volatile atomic_char16_t*, char16_t,
1696 memory_order);
1697char16_t atomic_fetch_add_explicit(atomic_char16_t*, char16_t, memory_order);
1698char16_t atomic_fetch_sub(volatile atomic_char16_t*, char16_t);
1699char16_t atomic_fetch_sub(atomic_char16_t*, char16_t);
1700char16_t atomic_fetch_sub_explicit(volatile atomic_char16_t*, char16_t,
1701 memory_order);
1702char16_t atomic_fetch_sub_explicit(atomic_char16_t*, char16_t, memory_order);
1703char16_t atomic_fetch_and(volatile atomic_char16_t*, char16_t);
1704char16_t atomic_fetch_and(atomic_char16_t*, char16_t);
1705char16_t atomic_fetch_and_explicit(volatile atomic_char16_t*, char16_t,
1706 memory_order);
1707char16_t atomic_fetch_and_explicit(atomic_char16_t*, char16_t, memory_order);
1708char16_t atomic_fetch_or(volatile atomic_char16_t*, char16_t);
1709char16_t atomic_fetch_or(atomic_char16_t*, char16_t);
1710char16_t atomic_fetch_or_explicit(volatile atomic_char16_t*, char16_t,
1711 memory_order);
1712char16_t atomic_fetch_or_explicit(atomic_char16_t*, char16_t, memory_order);
1713char16_t atomic_fetch_xor(volatile atomic_char16_t*, char16_t);
1714char16_t atomic_fetch_xor(atomic_char16_t*, char16_t);
1715char16_t atomic_fetch_xor_explicit(volatile atomic_char16_t*, char16_t,
1716 memory_order);
1717char16_t atomic_fetch_xor_explicit(atomic_char16_t*, char16_t, memory_order);
1718
1719// atomic_char32_t
1720
1721typedef struct atomic_char32_t
1722{
1723 bool is_lock_free() const volatile;
1724 bool is_lock_free() const;
1725 void store(char32_t, memory_order = memory_order_seq_cst) volatile;
1726 void store(char32_t, memory_order = memory_order_seq_cst);
1727 char32_t load(memory_order = memory_order_seq_cst) const volatile;
1728 char32_t load(memory_order = memory_order_seq_cst) const;
1729 operator char32_t() const volatile;
1730 operator char32_t() const;
1731 char32_t exchange(char32_t,
1732 memory_order = memory_order_seq_cst) volatile;
1733 char32_t exchange(char32_t, memory_order = memory_order_seq_cst);
1734 bool compare_exchange_weak(char32_t&, char32_t, memory_order,
1735 memory_order) volatile;
1736 bool compare_exchange_weak(char32_t&, char32_t, memory_order, memory_order);
1737 bool compare_exchange_strong(char32_t&, char32_t, memory_order,
1738 memory_order) volatile;
1739 bool compare_exchange_strong(char32_t&, char32_t,
1740 memory_order, memory_order);
1741 bool compare_exchange_weak(char32_t&, char32_t,
1742 memory_order = memory_order_seq_cst) volatile;
1743 bool compare_exchange_weak(char32_t&, char32_t,
1744 memory_order = memory_order_seq_cst);
1745 bool compare_exchange_strong(char32_t&, char32_t,
1746 memory_order = memory_order_seq_cst) volatile;
1747 bool compare_exchange_strong(char32_t&, char32_t,
1748 memory_order = memory_order_seq_cst);
1749 char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst) volatile;
1750 char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst);
1751 char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst) volatile;
1752 char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst);
1753 char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst) volatile;
1754 char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst);
1755 char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst) volatile;
1756 char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst);
1757 char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst) volatile;
1758 char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst);
1759 atomic_char32_t() = default;
1760 constexpr atomic_char32_t(char32_t);
1761 atomic_char32_t(const atomic_char32_t&) = delete;
1762 atomic_char32_t& operator=(const atomic_char32_t&) = delete;
1763 atomic_char32_t& operator=(const atomic_char32_t&) volatile = delete;
1764 char32_t operator=(char32_t) volatile;
1765 char32_t operator=(char32_t);
1766 char32_t operator++(int) volatile;
1767 char32_t operator++(int);
1768 char32_t operator--(int) volatile;
1769 char32_t operator--(int);
1770 char32_t operator++() volatile;
1771 char32_t operator++();
1772 char32_t operator--() volatile;
1773 char32_t operator--();
1774 char32_t operator+=(char32_t) volatile;
1775 char32_t operator+=(char32_t);
1776 char32_t operator-=(char32_t) volatile;
1777 char32_t operator-=(char32_t);
1778 char32_t operator&=(char32_t) volatile;
1779 char32_t operator&=(char32_t);
1780 char32_t operator|=(char32_t) volatile;
1781 char32_t operator|=(char32_t);
1782 char32_t operator^=(char32_t) volatile;
1783 char32_t operator^=(char32_t);
1784} atomic_char32_t;
1785
1786bool atomic_is_lock_free(const volatile atomic_char32_t*);
1787bool atomic_is_lock_free(const atomic_char32_t*);
1788void atomic_init(volatile atomic_char32_t*, itype);
1789void atomic_init(atomic_char32_t*, itype);
1790void atomic_store(volatile atomic_char32_t*, char32_t);
1791void atomic_store(atomic_char32_t*, char32_t);
1792void atomic_store_explicit(volatile atomic_char32_t*, char32_t, memory_order);
1793void atomic_store_explicit(atomic_char32_t*, char32_t, memory_order);
1794char32_t atomic_load(const volatile atomic_char32_t*);
1795char32_t atomic_load(const atomic_char32_t*);
1796char32_t atomic_load_explicit(const volatile atomic_char32_t*, memory_order);
1797char32_t atomic_load_explicit(const atomic_char32_t*, memory_order);
1798char32_t atomic_exchange(volatile atomic_char32_t*, char32_t);
1799char32_t atomic_exchange(atomic_char32_t*, char32_t);
1800char32_t atomic_exchange_explicit(volatile atomic_char32_t*, char32_t,
1801 memory_order);
1802char32_t atomic_exchange_explicit(atomic_char32_t*, char32_t, memory_order);
1803bool atomic_compare_exchange_weak(volatile atomic_char32_t*, char32_t*,
1804 char32_t);
1805bool atomic_compare_exchange_weak(atomic_char32_t*, char32_t*, char32_t);
1806bool atomic_compare_exchange_strong(volatile atomic_char32_t*, char32_t*,
1807 char32_t);
1808bool atomic_compare_exchange_strong(atomic_char32_t*, char32_t*, char32_t);
1809bool atomic_compare_exchange_weak_explicit(volatile atomic_char32_t*, char32_t*,
1810 char32_t, memory_order,
1811 memory_order);
1812bool atomic_compare_exchange_weak_explicit(atomic_char32_t*, char32_t*,
1813 char32_t, memory_order,
1814 memory_order);
1815bool atomic_compare_exchange_strong_explicit(volatile atomic_char32_t*,
1816 char32_t*, char32_t, memory_order,
1817 memory_order);
1818bool atomic_compare_exchange_strong_explicit(atomic_char32_t*, char32_t*,
1819 char32_t, memory_order,
1820 memory_order);
1821char32_t atomic_fetch_add(volatile atomic_char32_t*, char32_t);
1822char32_t atomic_fetch_add(atomic_char32_t*, char32_t);
1823char32_t atomic_fetch_add_explicit(volatile atomic_char32_t*, char32_t,
1824 memory_order);
1825char32_t atomic_fetch_add_explicit(atomic_char32_t*, char32_t, memory_order);
1826char32_t atomic_fetch_sub(volatile atomic_char32_t*, char32_t);
1827char32_t atomic_fetch_sub(atomic_char32_t*, char32_t);
1828char32_t atomic_fetch_sub_explicit(volatile atomic_char32_t*, char32_t,
1829 memory_order);
1830char32_t atomic_fetch_sub_explicit(atomic_char32_t*, char32_t, memory_order);
1831char32_t atomic_fetch_and(volatile atomic_char32_t*, char32_t);
1832char32_t atomic_fetch_and(atomic_char32_t*, char32_t);
1833char32_t atomic_fetch_and_explicit(volatile atomic_char32_t*, char32_t,
1834 memory_order);
1835char32_t atomic_fetch_and_explicit(atomic_char32_t*, char32_t, memory_order);
1836char32_t atomic_fetch_or(volatile atomic_char32_t*, char32_t);
1837char32_t atomic_fetch_or(atomic_char32_t*, char32_t);
1838char32_t atomic_fetch_or_explicit(volatile atomic_char32_t*, char32_t,
1839 memory_order);
1840char32_t atomic_fetch_or_explicit(atomic_char32_t*, char32_t, memory_order);
1841char32_t atomic_fetch_xor(volatile atomic_char32_t*, char32_t);
1842char32_t atomic_fetch_xor(atomic_char32_t*, char32_t);
1843char32_t atomic_fetch_xor_explicit(volatile atomic_char32_t*, char32_t,
1844 memory_order);
1845char32_t atomic_fetch_xor_explicit(atomic_char32_t*, char32_t, memory_order);
1846
1847// atomic_wchar_t
1848
1849typedef struct atomic_wchar_t
1850{
1851 bool is_lock_free() const volatile;
1852 bool is_lock_free() const;
1853 void store(wchar_t, memory_order = memory_order_seq_cst) volatile;
1854 void store(wchar_t, memory_order = memory_order_seq_cst);
1855 wchar_t load(memory_order = memory_order_seq_cst) const volatile;
1856 wchar_t load(memory_order = memory_order_seq_cst) const;
1857 operator wchar_t() const volatile;
1858 operator wchar_t() const;
1859 wchar_t exchange(wchar_t,
1860 memory_order = memory_order_seq_cst) volatile;
1861 wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst);
1862 bool compare_exchange_weak(wchar_t&, wchar_t, memory_order,
1863 memory_order) volatile;
1864 bool compare_exchange_weak(wchar_t&, wchar_t, memory_order, memory_order);
1865 bool compare_exchange_strong(wchar_t&, wchar_t, memory_order,
1866 memory_order) volatile;
1867 bool compare_exchange_strong(wchar_t&, wchar_t, memory_order, memory_order);
1868 bool compare_exchange_weak(wchar_t&, wchar_t,
1869 memory_order = memory_order_seq_cst) volatile;
1870 bool compare_exchange_weak(wchar_t&, wchar_t,
1871 memory_order = memory_order_seq_cst);
1872 bool compare_exchange_strong(wchar_t&, wchar_t,
1873 memory_order = memory_order_seq_cst) volatile;
1874 bool compare_exchange_strong(wchar_t&, wchar_t,
1875 memory_order = memory_order_seq_cst);
1876 wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile;
1877 wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst);
1878 wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile;
1879 wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst);
1880 wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile;
1881 wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst);
1882 wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile;
1883 wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst);
1884 wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile;
1885 wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst);
1886 atomic_wchar_t() = default;
1887 constexpr atomic_wchar_t(wchar_t);
1888 atomic_wchar_t(const atomic_wchar_t&) = delete;
1889 atomic_wchar_t& operator=(const atomic_wchar_t&) = delete;
1890 atomic_wchar_t& operator=(const atomic_wchar_t&) volatile = delete;
1891 wchar_t operator=(wchar_t) volatile;
1892 wchar_t operator=(wchar_t);
1893 wchar_t operator++(int) volatile;
1894 wchar_t operator++(int);
1895 wchar_t operator--(int) volatile;
1896 wchar_t operator--(int);
1897 wchar_t operator++() volatile;
1898 wchar_t operator++();
1899 wchar_t operator--() volatile;
1900 wchar_t operator--();
1901 wchar_t operator+=(wchar_t) volatile;
1902 wchar_t operator+=(wchar_t);
1903 wchar_t operator-=(wchar_t) volatile;
1904 wchar_t operator-=(wchar_t);
1905 wchar_t operator&=(wchar_t) volatile;
1906 wchar_t operator&=(wchar_t);
1907 wchar_t operator|=(wchar_t) volatile;
1908 wchar_t operator|=(wchar_t);
1909 wchar_t operator^=(wchar_t) volatile;
1910 wchar_t operator^=(wchar_t);
1911} atomic_wchar_t;
1912
1913bool atomic_is_lock_free(const volatile atomic_wchar_t*);
1914bool atomic_is_lock_free(const atomic_wchar_t*);
1915void atomic_init(volatile atomic_wchar_t*, itype);
1916void atomic_init(atomic_wchar_t*, itype);
1917void atomic_store(volatile atomic_wchar_t*, wchar_t);
1918void atomic_store(atomic_wchar_t*, wchar_t);
1919void atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
1920void atomic_store_explicit(atomic_wchar_t*, wchar_t, memory_order);
1921wchar_t atomic_load(const volatile atomic_wchar_t*);
1922wchar_t atomic_load(const atomic_wchar_t*);
1923wchar_t atomic_load_explicit(const volatile atomic_wchar_t*, memory_order);
1924wchar_t atomic_load_explicit(const atomic_wchar_t*, memory_order);
1925wchar_t atomic_exchange(volatile atomic_wchar_t*, wchar_t);
1926wchar_t atomic_exchange(atomic_wchar_t*, wchar_t);
1927wchar_t atomic_exchange_explicit(volatile atomic_wchar_t*,
1928 wchar_t, memory_order);
1929wchar_t atomic_exchange_explicit(atomic_wchar_t*, wchar_t, memory_order);
1930bool atomic_compare_exchange_weak(volatile atomic_wchar_t*, wchar_t*, wchar_t);
1931bool atomic_compare_exchange_weak(atomic_wchar_t*, wchar_t*, wchar_t);
1932bool atomic_compare_exchange_strong(volatile atomic_wchar_t*, wchar_t*,
1933 wchar_t);
1934bool atomic_compare_exchange_strong(atomic_wchar_t*, wchar_t*, wchar_t);
1935bool atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t*, wchar_t*,
1936 wchar_t, memory_order, memory_order);
1937bool atomic_compare_exchange_weak_explicit(atomic_wchar_t*, wchar_t*, wchar_t,
1938 memory_order, memory_order);
1939bool atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t*, wchar_t*,
1940 wchar_t, memory_order,
1941 memory_order);
1942bool atomic_compare_exchange_strong_explicit(atomic_wchar_t*, wchar_t*, wchar_t,
1943 memory_order, memory_order);
1944wchar_t atomic_fetch_add(volatile atomic_wchar_t*, wchar_t);
1945wchar_t atomic_fetch_add(atomic_wchar_t*, wchar_t);
1946wchar_t atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t,
1947 memory_order);
1948wchar_t atomic_fetch_add_explicit(atomic_wchar_t*, wchar_t, memory_order);
1949wchar_t atomic_fetch_sub(volatile atomic_wchar_t*, wchar_t);
1950wchar_t atomic_fetch_sub(atomic_wchar_t*, wchar_t);
1951wchar_t atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t,
1952 memory_order);
1953wchar_t atomic_fetch_sub_explicit(atomic_wchar_t*, wchar_t, memory_order);
1954wchar_t atomic_fetch_and(volatile atomic_wchar_t*, wchar_t);
1955wchar_t atomic_fetch_and(atomic_wchar_t*, wchar_t);
1956wchar_t atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t,
1957 memory_order);
1958wchar_t atomic_fetch_and_explicit(atomic_wchar_t*, wchar_t, memory_order);
1959wchar_t atomic_fetch_or(volatile atomic_wchar_t*, wchar_t);
1960wchar_t atomic_fetch_or(atomic_wchar_t*, wchar_t);
1961wchar_t atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t,
1962 memory_order);
1963wchar_t atomic_fetch_or_explicit(atomic_wchar_t*, wchar_t, memory_order);
1964wchar_t atomic_fetch_xor(volatile atomic_wchar_t*, wchar_t);
1965wchar_t atomic_fetch_xor(atomic_wchar_t*, wchar_t);
1966wchar_t atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t,
1967 memory_order);
1968wchar_t atomic_fetch_xor_explicit(atomic_wchar_t*, wchar_t, memory_order);
1969
1970// Atomics for standard typedef types
1971
1972typedef atomic_schar atomic_int_least8_t;
1973typedef atomic_uchar atomic_uint_least8_t;
1974typedef atomic_short atomic_int_least16_t;
1975typedef atomic_ushort atomic_uint_least16_t;
1976typedef atomic_int atomic_int_least32_t;
1977typedef atomic_uint atomic_uint_least32_t;
1978typedef atomic_llong atomic_int_least64_t;
1979typedef atomic_ullong atomic_uint_least64_t;
1980
1981typedef atomic_schar atomic_int_fast8_t;
1982typedef atomic_uchar atomic_uint_fast8_t;
1983typedef atomic_short atomic_int_fast16_t;
1984typedef atomic_ushort atomic_uint_fast16_t;
1985typedef atomic_int atomic_int_fast32_t;
1986typedef atomic_uint atomic_uint_fast32_t;
1987typedef atomic_llong atomic_int_fast64_t;
1988typedef atomic_ullong atomic_uint_fast64_t;
1989
1990typedef atomic_long atomic_intptr_t;
1991typedef atomic_ulong atomic_uintptr_t;
1992typedef atomic_ulong atomic_size_t;
1993typedef atomic_long atomic_ptrdiff_t;
1994typedef atomic_llong atomic_intmax_t;
1995typedef atomic_ullong atomic_uintmax_t;
1996
1997// address types
1998
1999typedef struct atomic_address
2000{
2001 bool is_lock_free() const volatile;
2002 bool is_lock_free() const;
2003 void store(void*, memory_order = memory_order_seq_cst) volatile;
2004 void store(void*, memory_order = memory_order_seq_cst);
2005 void* load(memory_order = memory_order_seq_cst) const volatile;
2006 void* load(memory_order = memory_order_seq_cst) const;
2007 operator void*() const volatile;
2008 operator void*() const;
2009 void* exchange(void*, memory_order = memory_order_seq_cst) volatile;
2010 void* exchange(void*, memory_order = memory_order_seq_cst);
2011 bool compare_exchange_weak(void*&, void*, memory_order,
2012 memory_order) volatile;
2013 bool compare_exchange_weak(void*&, void*, memory_order, memory_order);
2014 bool compare_exchange_strong(void*&, void*, memory_order,
2015 memory_order) volatile;
2016 bool compare_exchange_strong(void*&, void*, memory_order, memory_order);
2017 bool compare_exchange_weak(void*&, void*,
2018 memory_order = memory_order_seq_cst) volatile;
2019 bool compare_exchange_weak(void*&, void*,
2020 memory_order = memory_order_seq_cst);
2021 bool compare_exchange_strong(void*&, void*,
2022 memory_order = memory_order_seq_cst) volatile;
2023 bool compare_exchange_strong(void*&, void*,
2024 memory_order = memory_order_seq_cst);
2025 bool compare_exchange_weak(const void*&, const void*,
2026 memory_order, memory_order) volatile;
2027 bool compare_exchange_weak(const void*&, const void*, memory_order,
2028 memory_order);
2029 bool compare_exchange_strong(const void*&, const void*, memory_order,
2030 memory_order) volatile;
2031 bool compare_exchange_strong(const void*&, const void*, memory_order,
2032 memory_order);
2033 bool compare_exchange_weak(const void*&, const void*,
2034 memory_order = memory_order_seq_cst) volatile;
2035 bool compare_exchange_weak(const void*&, const void*,
2036 memory_order = memory_order_seq_cst);
2037 bool compare_exchange_strong(const void*&, const void*,
2038 memory_order = memory_order_seq_cst) volatile;
2039 bool compare_exchange_strong(const void*&, const void*,
2040 memory_order = memory_order_seq_cst);
2041 void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
2042 void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
2043 void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
2044 void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
2045 atomic_address() = default;
2046 constexpr atomic_address(void*);
2047 atomic_address(const atomic_address&) = delete;
2048 atomic_address& operator=(const atomic_address&) = delete;
2049 atomic_address& operator=(const atomic_address&) volatile = delete;
2050 void* operator=(const void*) volatile;
2051 void* operator=(const void*);
2052 void* operator+=(ptrdiff_t) volatile;
2053 void* operator+=(ptrdiff_t);
2054 void* operator-=(ptrdiff_t) volatile;
2055 void* operator-=(ptrdiff_t);
2056} atomic_address;
2057
2058bool atomic_is_lock_free(const volatile atomic_address*);
2059bool atomic_is_lock_free(const atomic_address*);
2060void atomic_init(volatile atomic_address*, void*);
2061void atomic_init(atomic_address*, void*);
2062void atomic_store(volatile atomic_address*, void*);
2063void atomic_store(atomic_address*, void*);
2064void atomic_store_explicit(volatile atomic_address*, void*, memory_order);
2065void atomic_store_explicit(atomic_address*, void*, memory_order);
2066void* atomic_load(const volatile atomic_address*);
2067void* atomic_load(const atomic_address*);
2068void* atomic_load_explicit(const volatile atomic_address*, memory_order);
2069void* atomic_load_explicit(const atomic_address*, memory_order);
2070void* atomic_exchange(volatile atomic_address*, void*);
2071void* atomic_exchange(atomic_address*, void*);
2072void* atomic_exchange_explicit(volatile atomic_address*, void*, memory_order);
2073void* atomic_exchange_explicit(atomic_address*, void*, memory_order);
2074bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*);
2075bool atomic_compare_exchange_weak(atomic_address*, void**, void*);
2076bool atomic_compare_exchange_strong(volatile atomic_address*, void**, void*);
2077bool atomic_compare_exchange_strong(atomic_address*, void**, void*);
2078bool atomic_compare_exchange_weak_explicit(volatile atomic_address*, void**,
2079 void*, memory_order, memory_order);
2080bool atomic_compare_exchange_weak_explicit(atomic_address*, void**, void*,
2081 memory_order, memory_order);
2082bool atomic_compare_exchange_strong_explicit(volatile atomic_address*, void**,
2083 void*, memory_order, memory_order);
2084bool atomic_compare_exchange_strong_explicit(atomic_address*, void**, void*,
2085 memory_order, memory_order);
2086void* atomic_fetch_add(volatile atomic_address*, ptrdiff_t);
2087void* atomic_fetch_add(atomic_address*, ptrdiff_t);
2088void* atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t,
2089 memory_order);
2090void* atomic_fetch_add_explicit(atomic_address*, ptrdiff_t, memory_order);
2091void* atomic_fetch_sub(volatile atomic_address*, ptrdiff_t);
2092void* atomic_fetch_sub(atomic_address*, ptrdiff_t);
2093void* atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t,
2094 memory_order);
2095void* atomic_fetch_sub_explicit(atomic_address*, ptrdiff_t, memory_order);
2096
2097// generic types
2098
2099template <class T>
2100struct atomic
2101{
2102 bool is_lock_free() const volatile;
2103 bool is_lock_free() const;
2104 void store(T, memory_order = memory_order_seq_cst) volatile;
2105 void store(T, memory_order = memory_order_seq_cst);
2106 T load(memory_order = memory_order_seq_cst) const volatile;
2107 T load(memory_order = memory_order_seq_cst) const;
2108 operator T() const volatile;
2109 operator T() const;
2110 T exchange(T, memory_order = memory_order_seq_cst) volatile;
2111 T exchange(T, memory_order = memory_order_seq_cst);
2112 bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile;
2113 bool compare_exchange_weak(T&, T, memory_order, memory_order);
2114 bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile;
2115 bool compare_exchange_strong(T&, T, memory_order, memory_order);
2116 bool compare_exchange_weak(T&, T,
2117 memory_order = memory_order_seq_cst) volatile;
2118 bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst);
2119 bool compare_exchange_strong(T&, T,
2120 memory_order = memory_order_seq_cst) volatile;
2121 bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst);
2122
2123 atomic() = default;
2124 constexpr atomic(T);
2125 atomic(const atomic&) = delete;
2126 atomic& operator=(const atomic&) = delete;
2127 atomic& operator=(const atomic&) volatile = delete;
2128 T operator=(T) volatile;
2129 T operator=(T);
2130};
2131
2132template <>
2133struct atomic<bool>
2134 : public atomic_bool
2135{
2136 atomic() = default;
2137 constexpr atomic(bool);
2138 atomic(const atomic&) = delete;
2139 atomic& operator=(const atomic&) = delete;
2140 atomic& operator=(const atomic&) volatile = delete;
2141 bool operator=(bool) volatile;
2142 bool operator=(bool);
2143 operator bool() const volatile;
2144 operator bool() const;
2145};
2146
2147template <>
2148struct atomic<char>
2149 : public atomic_char
2150{
2151 atomic() = default;
2152 constexpr atomic(char);
2153 atomic(const atomic&) = delete;
2154 atomic& operator=(const atomic&) = delete;
2155 atomic& operator=(const atomic&) volatile = delete;
2156 char operator=(char) volatile;
2157 char operator=(char);
2158 operator char() const volatile;
2159 operator char() const;
2160};
2161
2162template <>
2163struct atomic<signed char>
2164 : public atomic_schar
2165{
2166 atomic() = default;
2167 constexpr atomic(signed char);
2168 atomic(const atomic&) = delete;
2169 atomic& operator=(const atomic&) = delete;
2170 atomic& operator=(const atomic&) volatile = delete;
2171 signed char operator=(signed char) volatile;
2172 signed char operator=(signed char);
2173 operator signed char() const volatile;
2174 operator signed char() const;
2175};
2176
2177template <>
2178struct atomic<unsigned char>
2179 : public atomic_uchar
2180{
2181 atomic() = default;
2182 constexpr atomic(unsigned char);
2183 atomic(const atomic&) = delete;
2184 atomic& operator=(const atomic&) = delete;
2185 atomic& operator=(const atomic&) volatile = delete;
2186 unsigned char operator=(unsigned char) volatile;
2187 unsigned char operator=(unsigned char);
2188 operator unsigned char() const volatile;
2189 operator unsigned char() const;
2190};
2191
2192template <>
2193struct atomic<short>
2194 : public atomic_short
2195{
2196 atomic() = default;
2197 constexpr atomic(short);
2198 atomic(const atomic&) = delete;
2199 atomic& operator=(const atomic&) = delete;
2200 atomic& operator=(const atomic&) volatile = delete;
2201 short operator=(short) volatile;
2202 short operator=(short);
2203 operator short() const volatile;
2204 operator short() const;
2205};
2206
2207template <>
2208struct atomic<unsigned short>
2209 : public atomic_ushort
2210{
2211 atomic() = default;
2212 constexpr atomic(unsigned short);
2213 atomic(const atomic&) = delete;
2214 atomic& operator=(const atomic&) = delete;
2215 atomic& operator=(const atomic&) volatile = delete;
2216 unsigned short operator=(unsigned short) volatile;
2217 unsigned short operator=(unsigned short);
2218 operator unsigned short() const volatile;
2219 operator unsigned short() const;
2220};
2221
2222template <>
2223struct atomic<int>
2224 : public atomic_int
2225{
2226 atomic() = default;
2227 constexpr atomic(int);
2228 atomic(const atomic&) = delete;
2229 atomic& operator=(const atomic&) = delete;
2230 atomic& operator=(const atomic&) volatile = delete;
2231 int operator=(int) volatile;
2232 int operator=(int);
2233 operator int() const volatile;
2234 operator int() const;
2235};
2236
2237template <>
2238struct atomic<unsigned int>
2239 : public atomic_uint
2240{
2241 atomic() = default;
2242 constexpr atomic(unsigned int);
2243 atomic(const atomic&) = delete;
2244 atomic& operator=(const atomic&) = delete;
2245 atomic& operator=(const atomic&) volatile = delete;
2246 unsigned int operator=(unsigned int) volatile;
2247 unsigned int operator=(unsigned int);
2248 operator unsigned int() const volatile;
2249 operator unsigned int() const;
2250};
2251
2252template <>
2253struct atomic<long>
2254 : public atomic_long
2255{
2256 atomic() = default;
2257 constexpr atomic(long);
2258 atomic(const atomic&) = delete;
2259 atomic& operator=(const atomic&) = delete;
2260 atomic& operator=(const atomic&) volatile = delete;
2261 long operator=(long) volatile;
2262 long operator=(long);
2263 operator long() const volatile;
2264 operator long() const;
2265};
2266
2267template <>
2268struct atomic<unsigned long>
2269 : public atomic_ulong
2270{
2271 atomic() = default;
2272 constexpr atomic(unsigned long);
2273 atomic(const atomic&) = delete;
2274 atomic& operator=(const atomic&) = delete;
2275 atomic& operator=(const atomic&) volatile = delete;
2276 unsigned long operator=(unsigned long) volatile;
2277 unsigned long operator=(unsigned long);
2278 operator unsigned long() const volatile;
2279 operator unsigned long() const;
2280};
2281
2282template <>
2283struct atomic<long long>
2284 : public atomic_llong
2285{
2286 atomic() = default;
2287 constexpr atomic(long long);
2288 atomic(const atomic&) = delete;
2289 atomic& operator=(const atomic&) = delete;
2290 atomic& operator=(const atomic&) volatile = delete;
2291 long long operator=(long long) volatile;
2292 long long operator=(long long);
2293 operator long long() const volatile;
2294 operator long long() const;
2295};
2296
2297template <>
2298struct atomic<unsigned long long>
2299 : public atomic_ullong
2300{
2301 atomic() = default;
2302 constexpr atomic(unsigned long long);
2303 atomic(const atomic&) = delete;
2304 atomic& operator=(const atomic&) = delete;
2305 atomic& operator=(const atomic&) volatile = delete;
2306 unsigned long long operator=(unsigned long long) volatile;
2307 unsigned long long operator=(unsigned long long);
2308 operator unsigned long long() const volatile;
2309 operator unsigned long long() const;
2310};
2311
2312template <>
2313struct atomic<char16_t>
2314 : public atomic_char16_t
2315{
2316 atomic() = default;
2317 constexpr atomic(char16_t);
2318 atomic(const atomic&) = delete;
2319 atomic& operator=(const atomic&) = delete;
2320 atomic& operator=(const atomic&) volatile = delete;
2321 char16_t operator=(char16_t) volatile;
2322 char16_t operator=(char16_t);
2323 operator char16_t() const volatile;
2324 operator char16_t() const;
2325};
2326
2327template <>
2328struct atomic<char32_t>
2329 : public atomic_char32_t
2330{
2331 atomic() = default;
2332 constexpr atomic(char32_t);
2333 atomic(const atomic&) = delete;
2334 atomic& operator=(const atomic&) = delete;
2335 atomic& operator=(const atomic&) volatile = delete;
2336 char32_t operator=(char32_t) volatile;
2337 char32_t operator=(char32_t);
2338 operator char32_t() const volatile;
2339 operator char32_t() const;
2340};
2341
2342template <>
2343struct atomic<wchar_t>
2344 : public atomic_wchar_t
2345{
2346 atomic() = default;
2347 constexpr atomic(wchar_t);
2348 atomic(const atomic&) = delete;
2349 atomic& operator=(const atomic&) = delete;
2350 atomic& operator=(const atomic&) volatile = delete;
2351 wchar_t operator=(wchar_t) volatile;
2352 wchar_t operator=(wchar_t);
2353 operator wchar_t() const volatile;
2354 operator wchar_t() const;
2355};
2356
2357template <class T>
2358struct atomic<T*>
2359 : public atomic_address
2360{
2361 void store(T*, memory_order = memory_order_seq_cst) volatile;
2362 void store(T*, memory_order = memory_order_seq_cst);
2363 T* load(memory_order = memory_order_seq_cst) const volatile;
2364 T* load(memory_order = memory_order_seq_cst) const;
2365 operator T*() const volatile;
2366 operator T*() const;
2367 T* exchange(T*, memory_order = memory_order_seq_cst) volatile;
2368 T* exchange(T*, memory_order = memory_order_seq_cst);
2369 bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile;
2370 bool compare_exchange_weak(T*&, T*, memory_order, memory_order);
2371 bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile;
2372 bool compare_exchange_strong(T*&, T*, memory_order, memory_order);
2373 bool compare_exchange_weak(T*&, T*,
2374 memory_order = memory_order_seq_cst) volatile;
2375 bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);
2376 bool compare_exchange_strong(T*&, T*,
2377 memory_order = memory_order_seq_cst) volatile;
2378 bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);
2379 T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
2380 T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
2381 T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
2382 T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
2383 atomic() = default;
2384 constexpr atomic(T*);
2385 atomic(const atomic&) = delete;
2386 atomic& operator=(const atomic&) = delete;
2387 atomic& operator=(const atomic&) volatile = delete;
2388 T* operator=(T*) volatile;
2389 T* operator=(T*);
2390 T* operator++(int) volatile;
2391 T* operator++(int);
2392 T* operator--(int) volatile;
2393 T* operator--(int);
2394 T* operator++() volatile;
2395 T* operator++();
2396 T* operator--() volatile;
2397 T* operator--();
2398 T* operator+=(ptrdiff_t) volatile;
2399 T* operator+=(ptrdiff_t);
2400 T* operator-=(ptrdiff_t) volatile;
2401 T* operator-=(ptrdiff_t);
2402};
2403
2404// fences
2405
2406void atomic_thread_fence(memory_order);
2407void atomic_signal_fence(memory_order);
2408
2409} // std
2410
2411*/
2412
2413#include <__config>
2414
2415#pragma GCC system_header
2416
2417_LIBCPP_BEGIN_NAMESPACE_STD
2418
Howard Hinnantd1176e22010-09-28 17:13:38 +0000[diff] [blame]2419typedef enum memory_order
2420{
2421 memory_order_relaxed, memory_order_consume, memory_order_acquire,
2422 memory_order_release, memory_order_acq_rel, memory_order_seq_cst
2423} memory_order;
2424
2425template <class _Tp>
2426inline _LIBCPP_INLINE_VISIBILITY
2427_Tp
2428kill_dependency(_Tp __y)
2429{
2430 return __y;
2431}
Howard Hinnant8f73c632010-09-27 21:17:38 +0000[diff] [blame]2432
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2433// flag type and operations
2434
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2435typedef bool __atomic_flag__;
Howard Hinnant6cac2c22010-10-05 14:02:23 +0000[diff] [blame]2436
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2437struct atomic_flag;
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2438
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2439bool atomic_flag_test_and_set(volatile atomic_flag*);
2440bool atomic_flag_test_and_set(atomic_flag*);
2441bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
2442bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);
2443void atomic_flag_clear(volatile atomic_flag*);
2444void atomic_flag_clear(atomic_flag*);
2445void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
2446void atomic_flag_clear_explicit(atomic_flag*, memory_order);
2447
2448typedef struct _LIBCPP_VISIBLE atomic_flag
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2449{
Howard Hinnant6cac2c22010-10-05 14:02:23 +0000[diff] [blame]2450 __atomic_flag__ __flg_;
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2451
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2452 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2453 bool test_and_set(memory_order __o = memory_order_seq_cst) volatile
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2454 {return atomic_flag_test_and_set_explicit(this, __o);}
2455 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2456 bool test_and_set(memory_order __o = memory_order_seq_cst)
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2457 {return atomic_flag_test_and_set_explicit(this, __o);}
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2458
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2459 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2460 void clear(memory_order __o = memory_order_seq_cst) volatile
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2461 {atomic_flag_clear_explicit(this, __o);}
2462 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2463 void clear(memory_order __o = memory_order_seq_cst)
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2464 {atomic_flag_clear_explicit(this, __o);}
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2465
2466#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
2467 atomic_flag() = default;
2468#else
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2469 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant79101ae2010-09-30 21:05:29 +0000[diff] [blame]2470 atomic_flag() {};
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2471#endif
2472
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2473#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
2474 atomic_flag(const atomic_flag&) = delete;
2475 atomic_flag& operator=(const atomic_flag&) = delete;
2476 atomic_flag& operator=(const atomic_flag&) volatile = delete;
2477#else
2478private:
2479 atomic_flag(const atomic_flag&);
2480 atomic_flag& operator=(const atomic_flag&);
2481 atomic_flag& operator=(const atomic_flag&) volatile;
2482public:
2483#endif
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2484} atomic_flag;
2485
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2486inline _LIBCPP_INLINE_VISIBILITY
2487bool
2488atomic_flag_test_and_set(volatile atomic_flag* __f)
2489{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2490 return __atomic_exchange(&__f->__flg_, __atomic_flag__(true),
2491 memory_order_seq_cst)
Howard Hinnant6cac2c22010-10-05 14:02:23 +0000[diff] [blame]2492 == __atomic_flag__(true);
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2493}
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2494
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2495inline _LIBCPP_INLINE_VISIBILITY
2496bool
2497atomic_flag_test_and_set(atomic_flag* __f)
2498{
2499 return atomic_flag_test_and_set(const_cast<volatile atomic_flag*>(__f));
2500}
2501
2502inline _LIBCPP_INLINE_VISIBILITY
2503bool
2504atomic_flag_test_and_set_explicit(volatile atomic_flag* __f, memory_order __o)
2505{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2506 return __atomic_exchange(&__f->__flg_, __atomic_flag__(true), __o)
Howard Hinnant6cac2c22010-10-05 14:02:23 +0000[diff] [blame]2507 == __atomic_flag__(true);
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2508}
2509
2510inline _LIBCPP_INLINE_VISIBILITY
2511bool
2512atomic_flag_test_and_set_explicit(atomic_flag* __f, memory_order __o)
2513{
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2514 return atomic_flag_test_and_set_explicit(const_cast<volatile atomic_flag*>
2515 (__f), __o);
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2516}
2517
2518inline _LIBCPP_INLINE_VISIBILITY
2519void
2520atomic_flag_clear(volatile atomic_flag* __f)
2521{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2522 __atomic_store(&__f->__flg_, __atomic_flag__(false), memory_order_seq_cst);
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2523}
2524
2525inline _LIBCPP_INLINE_VISIBILITY
2526void
2527atomic_flag_clear(atomic_flag* __f)
2528{
2529 atomic_flag_clear(const_cast<volatile atomic_flag*>(__f));
2530}
2531
2532inline _LIBCPP_INLINE_VISIBILITY
2533void
2534atomic_flag_clear_explicit(volatile atomic_flag* __f, memory_order __o)
2535{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2536 __atomic_store(&__f->__flg_, __atomic_flag__(false), __o);
Howard Hinnant767ae2b2010-09-29 21:20:03 +0000[diff] [blame]2537}
2538
2539inline _LIBCPP_INLINE_VISIBILITY
2540void
2541atomic_flag_clear_explicit(atomic_flag* __f, memory_order __o)
2542{
2543 atomic_flag_clear_explicit(const_cast<volatile atomic_flag*>(__f), __o);
2544}
2545
2546#define ATOMIC_FLAG_INIT {false}
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2547#define ATOMIC_VAR_INIT(__v) {__v}
2548
2549inline _LIBCPP_INLINE_VISIBILITY
2550memory_order
2551__translate_memory_order(memory_order __o)
2552{
2553 switch (__o)
2554 {
2555 case memory_order_acq_rel:
2556 return memory_order_acquire;
2557 case memory_order_release:
2558 return memory_order_relaxed;
2559 }
2560 return __o;
2561}
2562
2563// atomic_bool
2564
2565struct atomic_bool;
2566
2567bool atomic_is_lock_free(const volatile atomic_bool*);
2568bool atomic_is_lock_free(const atomic_bool*);
2569void atomic_init(volatile atomic_bool*, bool);
2570void atomic_init(atomic_bool*, bool);
2571void atomic_store(volatile atomic_bool*, bool);
2572void atomic_store(atomic_bool*, bool);
2573void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
2574void atomic_store_explicit(atomic_bool*, bool, memory_order);
2575bool atomic_load(const volatile atomic_bool*);
2576bool atomic_load(const atomic_bool*);
2577bool atomic_load_explicit(const volatile atomic_bool*, memory_order);
2578bool atomic_load_explicit(const atomic_bool*, memory_order);
2579bool atomic_exchange(volatile atomic_bool*, bool);
2580bool atomic_exchange(atomic_bool*, bool);
2581bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
2582bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);
2583bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);
2584bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);
2585bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);
2586bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);
2587bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,
2588 memory_order, memory_order);
2589bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,
2590 memory_order, memory_order);
2591bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,
2592 memory_order, memory_order);
2593bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,
2594 memory_order, memory_order);
2595
2596typedef struct atomic_bool
2597{
2598 bool __v_;
2599
2600 _LIBCPP_INLINE_VISIBILITY
2601 bool is_lock_free() const volatile
2602 {return atomic_is_lock_free(this);}
2603 _LIBCPP_INLINE_VISIBILITY
2604 bool is_lock_free() const
2605 {return atomic_is_lock_free(this);}
2606 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2607 void store(bool __v, memory_order __o = memory_order_seq_cst) volatile
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2608 {atomic_store_explicit(this, __v, __o);}
2609 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2610 void store(bool __v, memory_order __o = memory_order_seq_cst)
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2611 {atomic_store_explicit(this, __v, __o);}
2612 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2613 bool load(memory_order __o = memory_order_seq_cst) const volatile
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2614 {return atomic_load_explicit(this, __o);}
2615 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2616 bool load(memory_order __o = memory_order_seq_cst) const
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2617 {return atomic_load_explicit(this, __o);}
2618 _LIBCPP_INLINE_VISIBILITY
2619 operator bool() const volatile
2620 {return load();}
2621 _LIBCPP_INLINE_VISIBILITY
2622 operator bool() const
2623 {return load();}
2624 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2625 bool exchange(bool __v, memory_order __o = memory_order_seq_cst) volatile
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2626 {return atomic_exchange_explicit(this, __v, __o);}
2627 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2628 bool exchange(bool __v, memory_order __o = memory_order_seq_cst)
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2629 {return atomic_exchange_explicit(this, __v, __o);}
2630 _LIBCPP_INLINE_VISIBILITY
2631 bool compare_exchange_weak(bool& __v, bool __e, memory_order __s,
2632 memory_order __f) volatile
2633 {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
2634 __f);}
2635 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2636 bool compare_exchange_weak(bool& __v, bool __e,
2637 memory_order __s = memory_order_seq_cst) volatile
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2638 {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2639 __translate_memory_order(__s));}
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2640 _LIBCPP_INLINE_VISIBILITY
2641 bool compare_exchange_weak(bool& __v, bool __e, memory_order __s,
2642 memory_order __f)
2643 {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
2644 __f);}
2645 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2646 bool compare_exchange_weak(bool& __v, bool __e,
2647 memory_order __s = memory_order_seq_cst)
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2648 {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2649 __translate_memory_order(__s));}
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2650 _LIBCPP_INLINE_VISIBILITY
2651 bool compare_exchange_strong(bool& __v, bool __e, memory_order __s,
2652 memory_order __f) volatile
2653 {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
2654 __f);}
2655 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2656 bool compare_exchange_strong(bool& __v, bool __e,
2657 memory_order __s = memory_order_seq_cst) volatile
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2658 {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2659 __translate_memory_order(__s));}
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2660 _LIBCPP_INLINE_VISIBILITY
2661 bool compare_exchange_strong(bool& __v, bool __e, memory_order __s,
2662 memory_order __f)
2663 {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
2664 __f);}
2665 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2666 bool compare_exchange_strong(bool& __v, bool __e,
2667 memory_order __s = memory_order_seq_cst)
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2668 {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2669 __translate_memory_order(__s));}
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2670#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
2671 atomic_bool() = default;
2672#else
2673 _LIBCPP_INLINE_VISIBILITY
2674 atomic_bool() {}
2675#endif
2676 _LIBCPP_INLINE_VISIBILITY
2677 /*constexpr*/ atomic_bool(bool __v)
2678 : __v_(__v) {}
2679#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
2680 atomic_bool(const atomic_bool&) = delete;
2681 atomic_bool& operator=(const atomic_bool&) = delete;
2682 atomic_bool& operator=(const atomic_bool&) volatile = delete;
2683#else
2684private:
2685 atomic_bool(const atomic_bool&);
2686 atomic_bool& operator=(const atomic_bool&);
2687 atomic_bool& operator=(const atomic_bool&) volatile;
2688public:
2689#endif
2690 _LIBCPP_INLINE_VISIBILITY
2691 bool operator=(bool __v) volatile
2692 {store(__v); return __v;}
2693} atomic_bool;
2694
2695inline _LIBCPP_INLINE_VISIBILITY
2696bool atomic_is_lock_free(const volatile atomic_bool*)
2697{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2698 return __atomic_is_lock_free(bool);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2699}
2700
2701inline _LIBCPP_INLINE_VISIBILITY
2702bool atomic_is_lock_free(const atomic_bool* __obj)
2703{
2704 return atomic_is_lock_free(const_cast<const volatile atomic_bool*>(__obj));
2705}
2706
2707inline _LIBCPP_INLINE_VISIBILITY
2708void atomic_init(volatile atomic_bool* __obj, bool __desr)
2709{
2710 __obj->__v_ = __desr;
2711}
2712
2713inline _LIBCPP_INLINE_VISIBILITY
2714void atomic_init(atomic_bool* __obj, bool __desr)
2715{
2716 __obj->__v_ = __desr;
2717}
2718
2719inline _LIBCPP_INLINE_VISIBILITY
2720void atomic_store(volatile atomic_bool* __obj, bool __desr)
2721{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2722 __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2723}
2724
2725inline _LIBCPP_INLINE_VISIBILITY
2726void atomic_store(atomic_bool* __obj, bool __desr)
2727{
2728 atomic_store(const_cast<volatile atomic_bool*>(__obj), __desr);
2729}
2730
2731inline _LIBCPP_INLINE_VISIBILITY
2732void atomic_store_explicit(volatile atomic_bool* __obj, bool __desr,
2733 memory_order __o)
2734{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2735 __atomic_store(&__obj->__v_, __desr, __o);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2736}
2737
2738inline _LIBCPP_INLINE_VISIBILITY
2739void atomic_store_explicit(atomic_bool* __obj, bool __desr, memory_order __o)
2740{
2741 atomic_store_explicit(const_cast<volatile atomic_bool*>(__obj), __desr,
2742 __o);
2743}
2744
2745inline _LIBCPP_INLINE_VISIBILITY
2746bool atomic_load(const volatile atomic_bool* __obj)
2747{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2748 return __atomic_load(&__obj->__v_, memory_order_seq_cst);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2749}
2750
2751inline _LIBCPP_INLINE_VISIBILITY
2752bool atomic_load(const atomic_bool* __obj)
2753{
2754 return atomic_load(const_cast<const volatile atomic_bool*>(__obj));
2755}
2756
2757inline _LIBCPP_INLINE_VISIBILITY
2758bool atomic_load_explicit(const volatile atomic_bool* __obj, memory_order __o)
2759{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2760 return __atomic_load(&__obj->__v_, __o);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2761}
2762
2763inline _LIBCPP_INLINE_VISIBILITY
2764bool atomic_load_explicit(const atomic_bool* __obj, memory_order __o)
2765{
2766 return atomic_load_explicit(const_cast<const volatile atomic_bool*>
2767 (__obj), __o);
2768}
2769
2770inline _LIBCPP_INLINE_VISIBILITY
2771bool atomic_exchange(volatile atomic_bool* __obj, bool __desr)
2772{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2773 return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2774}
2775
2776inline _LIBCPP_INLINE_VISIBILITY
2777bool atomic_exchange(atomic_bool* __obj, bool __desr)
2778{
2779 return atomic_exchange(const_cast<volatile atomic_bool*>(__obj), __desr);
2780}
2781
2782inline _LIBCPP_INLINE_VISIBILITY
2783bool atomic_exchange_explicit(volatile atomic_bool* __obj, bool __desr,
2784 memory_order __o)
2785{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2786 return __atomic_exchange(&__obj->__v_, __desr, __o);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2787}
2788
2789inline _LIBCPP_INLINE_VISIBILITY
2790bool atomic_exchange_explicit(atomic_bool* __obj, bool __desr, memory_order __o)
2791{
2792 return atomic_exchange_explicit(const_cast<volatile atomic_bool*>
2793 (__obj), __desr, __o);
2794}
2795
2796inline _LIBCPP_INLINE_VISIBILITY
2797bool atomic_compare_exchange_weak(volatile atomic_bool* __obj, bool* __exp,
2798 bool __desr)
2799{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2800 return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
2801 memory_order_seq_cst, memory_order_seq_cst);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2802}
2803
2804inline _LIBCPP_INLINE_VISIBILITY
2805bool atomic_compare_exchange_weak(atomic_bool* __obj, bool* __exp, bool __desr)
2806{
2807 return atomic_compare_exchange_weak(const_cast<volatile atomic_bool*>
2808 (__obj), __exp, __desr);
2809}
2810
2811inline _LIBCPP_INLINE_VISIBILITY
2812bool atomic_compare_exchange_weak_explicit(volatile atomic_bool* __obj,
2813 bool* __exp, bool __desr,
2814 memory_order __s, memory_order __f)
2815{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2816 return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
2817 __f);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2818}
2819
2820inline _LIBCPP_INLINE_VISIBILITY
2821bool atomic_compare_exchange_weak_explicit(atomic_bool* __obj, bool* __exp,
2822 bool __desr,
2823 memory_order __s, memory_order __f)
2824{
2825 return atomic_compare_exchange_weak_explicit(
2826 const_cast<volatile atomic_bool*>(__obj), __exp, __desr, __s, __f);
2827}
2828
2829inline _LIBCPP_INLINE_VISIBILITY
2830bool atomic_compare_exchange_strong(volatile atomic_bool* __obj, bool* __exp,
2831 bool __desr)
2832{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2833 return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
2834 memory_order_seq_cst, memory_order_seq_cst);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2835}
2836
2837inline _LIBCPP_INLINE_VISIBILITY
2838bool atomic_compare_exchange_strong(atomic_bool* __obj, bool* __exp,
2839 bool __desr)
2840{
2841 return atomic_compare_exchange_strong(const_cast<volatile atomic_bool*>
2842 (__obj), __exp, __desr);
2843}
2844
2845inline _LIBCPP_INLINE_VISIBILITY
2846bool atomic_compare_exchange_strong_explicit(volatile atomic_bool* __obj,
2847 bool* __exp, bool __desr,
2848 memory_order __s, memory_order __f)
2849{
Howard Hinnant21ef47f2010-10-18 20:39:07 +0000[diff] [blame^]2850 return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
2851 __f);
Howard Hinnant611fdaf2010-10-04 18:52:54 +0000[diff] [blame]2852}
2853
2854inline _LIBCPP_INLINE_VISIBILITY
2855bool atomic_compare_exchange_strong_explicit(atomic_bool* __obj, bool* __exp,
2856 bool __desr,
2857 memory_order __s, memory_order __f)
2858{
2859 return atomic_compare_exchange_strong_explicit(
2860 const_cast<volatile atomic_bool*>(__obj), __exp, __desr, __s, __f);
2861}
Howard Hinnanted760f42010-09-29 18:13:54 +0000[diff] [blame]2862
Howard Hinnant8f73c632010-09-27 21:17:38 +0000[diff] [blame]2863_LIBCPP_END_NAMESPACE_STD
2864
2865#endif // _LIBCPP_ATOMIC