11 #define CPP0X( feature )
14 typedef enum memory_order {
15 memory_order_relaxed, memory_order_acquire, memory_order_release,
16 memory_order_acq_rel, memory_order_seq_cst
20 typedef struct atomic_flag
23 bool test_and_set( memory_order = memory_order_seq_cst ) volatile;
24 void clear( memory_order = memory_order_seq_cst ) volatile;
25 void fence( memory_order ) const volatile;
27 CPP0X( atomic_flag() = default; )
28 CPP0X( atomic_flag( const atomic_flag& ) = delete; )
29 atomic_flag& operator =( const atomic_flag& ) CPP0X(=delete);
36 #define ATOMIC_FLAG_INIT { false }
42 extern bool atomic_flag_test_and_set( volatile atomic_flag* );
43 extern bool atomic_flag_test_and_set_explicit
44 ( volatile atomic_flag*, memory_order );
45 extern void atomic_flag_clear( volatile atomic_flag* );
46 extern void atomic_flag_clear_explicit
47 ( volatile atomic_flag*, memory_order );
48 extern void atomic_flag_fence
49 ( const volatile atomic_flag*, memory_order );
50 extern void __atomic_flag_wait__
51 ( volatile atomic_flag* );
52 extern void __atomic_flag_wait_explicit__
53 ( volatile atomic_flag*, memory_order );
54 extern volatile atomic_flag* __atomic_flag_for_address__
55 ( const volatile void* __z__ )
56 __attribute__((const));
64 inline bool atomic_flag::test_and_set( memory_order __x__ ) volatile
65 { return atomic_flag_test_and_set_explicit( this, __x__ ); }
67 inline void atomic_flag::clear( memory_order __x__ ) volatile
68 { atomic_flag_clear_explicit( this, __x__ ); }
70 inline void atomic_flag::fence( memory_order __x__ ) const volatile
71 { atomic_flag_fence( this, __x__ ); }
77 The remainder of the example implementation uses the following
78 macros. These macros exploit GNU extensions for value-returning
79 blocks (AKA statement expressions) and __typeof__.
81 The macros rely on data fields of atomic structs being named __f__.
82 Other symbols used are __a__=atomic, __e__=expected, __f__=field,
83 __g__=flag, __m__=modified, __o__=operation, __r__=result,
84 __p__=pointer to field, __v__=value (for single evaluation),
85 __x__=memory-ordering, and __y__=memory-ordering.
88 #define _ATOMIC_LOAD_( __a__, __x__ ) \
89 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
90 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
91 ((__typeof__((__a__)->__f__)) (thread_current()->get_return_value())); \
95 #define _ATOMIC_STORE_( __a__, __m__, __x__ ) \
96 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
97 __typeof__(__m__) __v__ = (__m__); \
98 model->switch_to_master(new ModelAction(ATOMIC_WRITE, __x__, __p__, __v__)); \
101 #define _ATOMIC_MODIFY_( __a__, __o__, __m__, __x__ ) \
102 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
103 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
104 __typeof__((__a__)->__f__) __old__=(__typeof__((__a__)->__f__)) thread_current()->get_return_value(); \
105 __typeof__(__m__) __v__ = (__m__); \
106 __typeof__((__a__)->__f__) __copy__= __old__; \
107 __copy__ __o__ __v__; \
108 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, __copy__)); \
111 #define _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ) \
112 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
113 __typeof__(__e__) __q__ = (__e__); \
114 __typeof__(__m__) __v__ = (__m__); \
116 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
117 __typeof__((__a__)->__f__) __t__=(__typeof__((__a__)->__f__)) thread_current()->get_return_value(); \
118 if (__t__ == * __q__ ) { \
119 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, __v__)); __r__ = true; } \
120 else { *__q__ = __t__; __r__ = false;} \
123 #define _ATOMIC_FENCE_( __a__, __x__ ) \
126 #define ATOMIC_INTEGRAL_LOCK_FREE 1
127 #define ATOMIC_ADDRESS_LOCK_FREE 1
129 typedef struct atomic_bool
132 bool is_lock_free() const volatile;
133 void store( bool, memory_order = memory_order_seq_cst ) volatile;
134 bool load( memory_order = memory_order_seq_cst ) volatile;
135 bool swap( bool, memory_order = memory_order_seq_cst ) volatile;
136 bool compare_swap ( bool&, bool, memory_order, memory_order ) volatile;
137 bool compare_swap ( bool&, bool,
138 memory_order = memory_order_seq_cst) volatile;
139 void fence( memory_order ) const volatile;
141 CPP0X( atomic_bool() = delete; )
142 CPP0X( constexpr explicit atomic_bool( bool __v__ ) : __f__( __v__ ) { } )
143 CPP0X( atomic_bool( const atomic_bool& ) = delete; )
144 atomic_bool& operator =( const atomic_bool& ) CPP0X(=delete);
146 bool operator =( bool __v__ ) volatile
147 { store( __v__ ); return __v__; }
149 friend void atomic_store_explicit( volatile atomic_bool*, bool,
151 friend bool atomic_load_explicit( volatile atomic_bool*, memory_order );
152 friend bool atomic_swap_explicit( volatile atomic_bool*, bool,
154 friend bool atomic_compare_swap_explicit( volatile atomic_bool*, bool*, bool,
155 memory_order, memory_order );
156 friend void atomic_fence( const volatile atomic_bool*, memory_order );
164 typedef struct atomic_address
167 bool is_lock_free() const volatile;
168 void store( void*, memory_order = memory_order_seq_cst ) volatile;
169 void* load( memory_order = memory_order_seq_cst ) volatile;
170 void* swap( void*, memory_order = memory_order_seq_cst ) volatile;
171 bool compare_swap( void*&, void*, memory_order, memory_order ) volatile;
172 bool compare_swap( void*&, void*,
173 memory_order = memory_order_seq_cst ) volatile;
174 void fence( memory_order ) const volatile;
175 void* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
176 void* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
178 CPP0X( atomic_address() = default; )
179 CPP0X( constexpr explicit atomic_address( void* __v__ ) : __f__( __v__) { } )
180 CPP0X( atomic_address( const atomic_address& ) = delete; )
181 atomic_address& operator =( const atomic_address & ) CPP0X(=delete);
183 void* operator =( void* __v__ ) volatile
184 { store( __v__ ); return __v__; }
186 void* operator +=( ptrdiff_t __v__ ) volatile
187 { return fetch_add( __v__ ); }
189 void* operator -=( ptrdiff_t __v__ ) volatile
190 { return fetch_sub( __v__ ); }
192 friend void atomic_store_explicit( volatile atomic_address*, void*,
194 friend void* atomic_load_explicit( volatile atomic_address*, memory_order );
195 friend void* atomic_swap_explicit( volatile atomic_address*, void*,
197 friend bool atomic_compare_swap_explicit( volatile atomic_address*,
198 void**, void*, memory_order, memory_order );
199 friend void atomic_fence( const volatile atomic_address*, memory_order );
200 friend void* atomic_fetch_add_explicit( volatile atomic_address*, ptrdiff_t,
202 friend void* atomic_fetch_sub_explicit( volatile atomic_address*, ptrdiff_t,
211 typedef struct atomic_char
214 bool is_lock_free() const volatile;
216 memory_order = memory_order_seq_cst ) volatile;
217 char load( memory_order = memory_order_seq_cst ) volatile;
219 memory_order = memory_order_seq_cst ) volatile;
220 bool compare_swap( char&, char,
221 memory_order, memory_order ) volatile;
222 bool compare_swap( char&, char,
223 memory_order = memory_order_seq_cst ) volatile;
224 void fence( memory_order ) const volatile;
225 char fetch_add( char,
226 memory_order = memory_order_seq_cst ) volatile;
227 char fetch_sub( char,
228 memory_order = memory_order_seq_cst ) volatile;
229 char fetch_and( char,
230 memory_order = memory_order_seq_cst ) volatile;
232 memory_order = memory_order_seq_cst ) volatile;
233 char fetch_xor( char,
234 memory_order = memory_order_seq_cst ) volatile;
236 CPP0X( atomic_char() = default; )
237 CPP0X( constexpr atomic_char( char __v__ ) : __f__( __v__) { } )
238 CPP0X( atomic_char( const atomic_char& ) = delete; )
239 atomic_char& operator =( const atomic_char& ) CPP0X(=delete);
241 char operator =( char __v__ ) volatile
242 { store( __v__ ); return __v__; }
244 char operator ++( int ) volatile
245 { return fetch_add( 1 ); }
247 char operator --( int ) volatile
248 { return fetch_sub( 1 ); }
250 char operator ++() volatile
251 { return fetch_add( 1 ) + 1; }
253 char operator --() volatile
254 { return fetch_sub( 1 ) - 1; }
256 char operator +=( char __v__ ) volatile
257 { return fetch_add( __v__ ) + __v__; }
259 char operator -=( char __v__ ) volatile
260 { return fetch_sub( __v__ ) - __v__; }
262 char operator &=( char __v__ ) volatile
263 { return fetch_and( __v__ ) & __v__; }
265 char operator |=( char __v__ ) volatile
266 { return fetch_or( __v__ ) | __v__; }
268 char operator ^=( char __v__ ) volatile
269 { return fetch_xor( __v__ ) ^ __v__; }
271 friend void atomic_store_explicit( volatile atomic_char*, char,
273 friend char atomic_load_explicit( volatile atomic_char*,
275 friend char atomic_swap_explicit( volatile atomic_char*,
276 char, memory_order );
277 friend bool atomic_compare_swap_explicit( volatile atomic_char*,
278 char*, char, memory_order, memory_order );
279 friend void atomic_fence( const volatile atomic_char*, memory_order );
280 friend char atomic_fetch_add_explicit( volatile atomic_char*,
281 char, memory_order );
282 friend char atomic_fetch_sub_explicit( volatile atomic_char*,
283 char, memory_order );
284 friend char atomic_fetch_and_explicit( volatile atomic_char*,
285 char, memory_order );
286 friend char atomic_fetch_or_explicit( volatile atomic_char*,
287 char, memory_order );
288 friend char atomic_fetch_xor_explicit( volatile atomic_char*,
289 char, memory_order );
297 typedef struct atomic_schar
300 bool is_lock_free() const volatile;
301 void store( signed char,
302 memory_order = memory_order_seq_cst ) volatile;
303 signed char load( memory_order = memory_order_seq_cst ) volatile;
304 signed char swap( signed char,
305 memory_order = memory_order_seq_cst ) volatile;
306 bool compare_swap( signed char&, signed char,
307 memory_order, memory_order ) volatile;
308 bool compare_swap( signed char&, signed char,
309 memory_order = memory_order_seq_cst ) volatile;
310 void fence( memory_order ) const volatile;
311 signed char fetch_add( signed char,
312 memory_order = memory_order_seq_cst ) volatile;
313 signed char fetch_sub( signed char,
314 memory_order = memory_order_seq_cst ) volatile;
315 signed char fetch_and( signed char,
316 memory_order = memory_order_seq_cst ) volatile;
317 signed char fetch_or( signed char,
318 memory_order = memory_order_seq_cst ) volatile;
319 signed char fetch_xor( signed char,
320 memory_order = memory_order_seq_cst ) volatile;
322 CPP0X( atomic_schar() = default; )
323 CPP0X( constexpr atomic_schar( signed char __v__ ) : __f__( __v__) { } )
324 CPP0X( atomic_schar( const atomic_schar& ) = delete; )
325 atomic_schar& operator =( const atomic_schar& ) CPP0X(=delete);
327 signed char operator =( signed char __v__ ) volatile
328 { store( __v__ ); return __v__; }
330 signed char operator ++( int ) volatile
331 { return fetch_add( 1 ); }
333 signed char operator --( int ) volatile
334 { return fetch_sub( 1 ); }
336 signed char operator ++() volatile
337 { return fetch_add( 1 ) + 1; }
339 signed char operator --() volatile
340 { return fetch_sub( 1 ) - 1; }
342 signed char operator +=( signed char __v__ ) volatile
343 { return fetch_add( __v__ ) + __v__; }
345 signed char operator -=( signed char __v__ ) volatile
346 { return fetch_sub( __v__ ) - __v__; }
348 signed char operator &=( signed char __v__ ) volatile
349 { return fetch_and( __v__ ) & __v__; }
351 signed char operator |=( signed char __v__ ) volatile
352 { return fetch_or( __v__ ) | __v__; }
354 signed char operator ^=( signed char __v__ ) volatile
355 { return fetch_xor( __v__ ) ^ __v__; }
357 friend void atomic_store_explicit( volatile atomic_schar*, signed char,
359 friend signed char atomic_load_explicit( volatile atomic_schar*,
361 friend signed char atomic_swap_explicit( volatile atomic_schar*,
362 signed char, memory_order );
363 friend bool atomic_compare_swap_explicit( volatile atomic_schar*,
364 signed char*, signed char, memory_order, memory_order );
365 friend void atomic_fence( const volatile atomic_schar*, memory_order );
366 friend signed char atomic_fetch_add_explicit( volatile atomic_schar*,
367 signed char, memory_order );
368 friend signed char atomic_fetch_sub_explicit( volatile atomic_schar*,
369 signed char, memory_order );
370 friend signed char atomic_fetch_and_explicit( volatile atomic_schar*,
371 signed char, memory_order );
372 friend signed char atomic_fetch_or_explicit( volatile atomic_schar*,
373 signed char, memory_order );
374 friend signed char atomic_fetch_xor_explicit( volatile atomic_schar*,
375 signed char, memory_order );
383 typedef struct atomic_uchar
386 bool is_lock_free() const volatile;
387 void store( unsigned char,
388 memory_order = memory_order_seq_cst ) volatile;
389 unsigned char load( memory_order = memory_order_seq_cst ) volatile;
390 unsigned char swap( unsigned char,
391 memory_order = memory_order_seq_cst ) volatile;
392 bool compare_swap( unsigned char&, unsigned char,
393 memory_order, memory_order ) volatile;
394 bool compare_swap( unsigned char&, unsigned char,
395 memory_order = memory_order_seq_cst ) volatile;
396 void fence( memory_order ) const volatile;
397 unsigned char fetch_add( unsigned char,
398 memory_order = memory_order_seq_cst ) volatile;
399 unsigned char fetch_sub( unsigned char,
400 memory_order = memory_order_seq_cst ) volatile;
401 unsigned char fetch_and( unsigned char,
402 memory_order = memory_order_seq_cst ) volatile;
403 unsigned char fetch_or( unsigned char,
404 memory_order = memory_order_seq_cst ) volatile;
405 unsigned char fetch_xor( unsigned char,
406 memory_order = memory_order_seq_cst ) volatile;
408 CPP0X( atomic_uchar() = default; )
409 CPP0X( constexpr atomic_uchar( unsigned char __v__ ) : __f__( __v__) { } )
410 CPP0X( atomic_uchar( const atomic_uchar& ) = delete; )
411 atomic_uchar& operator =( const atomic_uchar& ) CPP0X(=delete);
413 unsigned char operator =( unsigned char __v__ ) volatile
414 { store( __v__ ); return __v__; }
416 unsigned char operator ++( int ) volatile
417 { return fetch_add( 1 ); }
419 unsigned char operator --( int ) volatile
420 { return fetch_sub( 1 ); }
422 unsigned char operator ++() volatile
423 { return fetch_add( 1 ) + 1; }
425 unsigned char operator --() volatile
426 { return fetch_sub( 1 ) - 1; }
428 unsigned char operator +=( unsigned char __v__ ) volatile
429 { return fetch_add( __v__ ) + __v__; }
431 unsigned char operator -=( unsigned char __v__ ) volatile
432 { return fetch_sub( __v__ ) - __v__; }
434 unsigned char operator &=( unsigned char __v__ ) volatile
435 { return fetch_and( __v__ ) & __v__; }
437 unsigned char operator |=( unsigned char __v__ ) volatile
438 { return fetch_or( __v__ ) | __v__; }
440 unsigned char operator ^=( unsigned char __v__ ) volatile
441 { return fetch_xor( __v__ ) ^ __v__; }
443 friend void atomic_store_explicit( volatile atomic_uchar*, unsigned char,
445 friend unsigned char atomic_load_explicit( volatile atomic_uchar*,
447 friend unsigned char atomic_swap_explicit( volatile atomic_uchar*,
448 unsigned char, memory_order );
449 friend bool atomic_compare_swap_explicit( volatile atomic_uchar*,
450 unsigned char*, unsigned char, memory_order, memory_order );
451 friend void atomic_fence( const volatile atomic_uchar*, memory_order );
452 friend unsigned char atomic_fetch_add_explicit( volatile atomic_uchar*,
453 unsigned char, memory_order );
454 friend unsigned char atomic_fetch_sub_explicit( volatile atomic_uchar*,
455 unsigned char, memory_order );
456 friend unsigned char atomic_fetch_and_explicit( volatile atomic_uchar*,
457 unsigned char, memory_order );
458 friend unsigned char atomic_fetch_or_explicit( volatile atomic_uchar*,
459 unsigned char, memory_order );
460 friend unsigned char atomic_fetch_xor_explicit( volatile atomic_uchar*,
461 unsigned char, memory_order );
469 typedef struct atomic_short
472 bool is_lock_free() const volatile;
474 memory_order = memory_order_seq_cst ) volatile;
475 short load( memory_order = memory_order_seq_cst ) volatile;
477 memory_order = memory_order_seq_cst ) volatile;
478 bool compare_swap( short&, short,
479 memory_order, memory_order ) volatile;
480 bool compare_swap( short&, short,
481 memory_order = memory_order_seq_cst ) volatile;
482 void fence( memory_order ) const volatile;
483 short fetch_add( short,
484 memory_order = memory_order_seq_cst ) volatile;
485 short fetch_sub( short,
486 memory_order = memory_order_seq_cst ) volatile;
487 short fetch_and( short,
488 memory_order = memory_order_seq_cst ) volatile;
489 short fetch_or( short,
490 memory_order = memory_order_seq_cst ) volatile;
491 short fetch_xor( short,
492 memory_order = memory_order_seq_cst ) volatile;
494 CPP0X( atomic_short() = default; )
495 CPP0X( constexpr atomic_short( short __v__ ) : __f__( __v__) { } )
496 CPP0X( atomic_short( const atomic_short& ) = delete; )
497 atomic_short& operator =( const atomic_short& ) CPP0X(=delete);
499 short operator =( short __v__ ) volatile
500 { store( __v__ ); return __v__; }
502 short operator ++( int ) volatile
503 { return fetch_add( 1 ); }
505 short operator --( int ) volatile
506 { return fetch_sub( 1 ); }
508 short operator ++() volatile
509 { return fetch_add( 1 ) + 1; }
511 short operator --() volatile
512 { return fetch_sub( 1 ) - 1; }
514 short operator +=( short __v__ ) volatile
515 { return fetch_add( __v__ ) + __v__; }
517 short operator -=( short __v__ ) volatile
518 { return fetch_sub( __v__ ) - __v__; }
520 short operator &=( short __v__ ) volatile
521 { return fetch_and( __v__ ) & __v__; }
523 short operator |=( short __v__ ) volatile
524 { return fetch_or( __v__ ) | __v__; }
526 short operator ^=( short __v__ ) volatile
527 { return fetch_xor( __v__ ) ^ __v__; }
529 friend void atomic_store_explicit( volatile atomic_short*, short,
531 friend short atomic_load_explicit( volatile atomic_short*,
533 friend short atomic_swap_explicit( volatile atomic_short*,
534 short, memory_order );
535 friend bool atomic_compare_swap_explicit( volatile atomic_short*,
536 short*, short, memory_order, memory_order );
537 friend void atomic_fence( const volatile atomic_short*, memory_order );
538 friend short atomic_fetch_add_explicit( volatile atomic_short*,
539 short, memory_order );
540 friend short atomic_fetch_sub_explicit( volatile atomic_short*,
541 short, memory_order );
542 friend short atomic_fetch_and_explicit( volatile atomic_short*,
543 short, memory_order );
544 friend short atomic_fetch_or_explicit( volatile atomic_short*,
545 short, memory_order );
546 friend short atomic_fetch_xor_explicit( volatile atomic_short*,
547 short, memory_order );
555 typedef struct atomic_ushort
558 bool is_lock_free() const volatile;
559 void store( unsigned short,
560 memory_order = memory_order_seq_cst ) volatile;
561 unsigned short load( memory_order = memory_order_seq_cst ) volatile;
562 unsigned short swap( unsigned short,
563 memory_order = memory_order_seq_cst ) volatile;
564 bool compare_swap( unsigned short&, unsigned short,
565 memory_order, memory_order ) volatile;
566 bool compare_swap( unsigned short&, unsigned short,
567 memory_order = memory_order_seq_cst ) volatile;
568 void fence( memory_order ) const volatile;
569 unsigned short fetch_add( unsigned short,
570 memory_order = memory_order_seq_cst ) volatile;
571 unsigned short fetch_sub( unsigned short,
572 memory_order = memory_order_seq_cst ) volatile;
573 unsigned short fetch_and( unsigned short,
574 memory_order = memory_order_seq_cst ) volatile;
575 unsigned short fetch_or( unsigned short,
576 memory_order = memory_order_seq_cst ) volatile;
577 unsigned short fetch_xor( unsigned short,
578 memory_order = memory_order_seq_cst ) volatile;
580 CPP0X( atomic_ushort() = default; )
581 CPP0X( constexpr atomic_ushort( unsigned short __v__ ) : __f__( __v__) { } )
582 CPP0X( atomic_ushort( const atomic_ushort& ) = delete; )
583 atomic_ushort& operator =( const atomic_ushort& ) CPP0X(=delete);
585 unsigned short operator =( unsigned short __v__ ) volatile
586 { store( __v__ ); return __v__; }
588 unsigned short operator ++( int ) volatile
589 { return fetch_add( 1 ); }
591 unsigned short operator --( int ) volatile
592 { return fetch_sub( 1 ); }
594 unsigned short operator ++() volatile
595 { return fetch_add( 1 ) + 1; }
597 unsigned short operator --() volatile
598 { return fetch_sub( 1 ) - 1; }
600 unsigned short operator +=( unsigned short __v__ ) volatile
601 { return fetch_add( __v__ ) + __v__; }
603 unsigned short operator -=( unsigned short __v__ ) volatile
604 { return fetch_sub( __v__ ) - __v__; }
606 unsigned short operator &=( unsigned short __v__ ) volatile
607 { return fetch_and( __v__ ) & __v__; }
609 unsigned short operator |=( unsigned short __v__ ) volatile
610 { return fetch_or( __v__ ) | __v__; }
612 unsigned short operator ^=( unsigned short __v__ ) volatile
613 { return fetch_xor( __v__ ) ^ __v__; }
615 friend void atomic_store_explicit( volatile atomic_ushort*, unsigned short,
617 friend unsigned short atomic_load_explicit( volatile atomic_ushort*,
619 friend unsigned short atomic_swap_explicit( volatile atomic_ushort*,
620 unsigned short, memory_order );
621 friend bool atomic_compare_swap_explicit( volatile atomic_ushort*,
622 unsigned short*, unsigned short, memory_order, memory_order );
623 friend void atomic_fence( const volatile atomic_ushort*, memory_order );
624 friend unsigned short atomic_fetch_add_explicit( volatile atomic_ushort*,
625 unsigned short, memory_order );
626 friend unsigned short atomic_fetch_sub_explicit( volatile atomic_ushort*,
627 unsigned short, memory_order );
628 friend unsigned short atomic_fetch_and_explicit( volatile atomic_ushort*,
629 unsigned short, memory_order );
630 friend unsigned short atomic_fetch_or_explicit( volatile atomic_ushort*,
631 unsigned short, memory_order );
632 friend unsigned short atomic_fetch_xor_explicit( volatile atomic_ushort*,
633 unsigned short, memory_order );
637 unsigned short __f__;
641 typedef struct atomic_int
644 bool is_lock_free() const volatile;
646 memory_order = memory_order_seq_cst ) volatile;
647 int load( memory_order = memory_order_seq_cst ) volatile;
649 memory_order = memory_order_seq_cst ) volatile;
650 bool compare_swap( int&, int,
651 memory_order, memory_order ) volatile;
652 bool compare_swap( int&, int,
653 memory_order = memory_order_seq_cst ) volatile;
654 void fence( memory_order ) const volatile;
656 memory_order = memory_order_seq_cst ) volatile;
658 memory_order = memory_order_seq_cst ) volatile;
660 memory_order = memory_order_seq_cst ) volatile;
662 memory_order = memory_order_seq_cst ) volatile;
664 memory_order = memory_order_seq_cst ) volatile;
666 CPP0X( atomic_int() = default; )
667 CPP0X( constexpr atomic_int( int __v__ ) : __f__( __v__) { } )
668 CPP0X( atomic_int( const atomic_int& ) = delete; )
669 atomic_int& operator =( const atomic_int& ) CPP0X(=delete);
671 int operator =( int __v__ ) volatile
672 { store( __v__ ); return __v__; }
674 int operator ++( int ) volatile
675 { return fetch_add( 1 ); }
677 int operator --( int ) volatile
678 { return fetch_sub( 1 ); }
680 int operator ++() volatile
681 { return fetch_add( 1 ) + 1; }
683 int operator --() volatile
684 { return fetch_sub( 1 ) - 1; }
686 int operator +=( int __v__ ) volatile
687 { return fetch_add( __v__ ) + __v__; }
689 int operator -=( int __v__ ) volatile
690 { return fetch_sub( __v__ ) - __v__; }
692 int operator &=( int __v__ ) volatile
693 { return fetch_and( __v__ ) & __v__; }
695 int operator |=( int __v__ ) volatile
696 { return fetch_or( __v__ ) | __v__; }
698 int operator ^=( int __v__ ) volatile
699 { return fetch_xor( __v__ ) ^ __v__; }
701 friend void atomic_store_explicit( volatile atomic_int*, int,
703 friend int atomic_load_explicit( volatile atomic_int*,
705 friend int atomic_swap_explicit( volatile atomic_int*,
707 friend bool atomic_compare_swap_explicit( volatile atomic_int*,
708 int*, int, memory_order, memory_order );
709 friend void atomic_fence( const volatile atomic_int*, memory_order );
710 friend int atomic_fetch_add_explicit( volatile atomic_int*,
712 friend int atomic_fetch_sub_explicit( volatile atomic_int*,
714 friend int atomic_fetch_and_explicit( volatile atomic_int*,
716 friend int atomic_fetch_or_explicit( volatile atomic_int*,
718 friend int atomic_fetch_xor_explicit( volatile atomic_int*,
727 typedef struct atomic_uint
730 bool is_lock_free() const volatile;
731 void store( unsigned int,
732 memory_order = memory_order_seq_cst ) volatile;
733 unsigned int load( memory_order = memory_order_seq_cst ) volatile;
734 unsigned int swap( unsigned int,
735 memory_order = memory_order_seq_cst ) volatile;
736 bool compare_swap( unsigned int&, unsigned int,
737 memory_order, memory_order ) volatile;
738 bool compare_swap( unsigned int&, unsigned int,
739 memory_order = memory_order_seq_cst ) volatile;
740 void fence( memory_order ) const volatile;
741 unsigned int fetch_add( unsigned int,
742 memory_order = memory_order_seq_cst ) volatile;
743 unsigned int fetch_sub( unsigned int,
744 memory_order = memory_order_seq_cst ) volatile;
745 unsigned int fetch_and( unsigned int,
746 memory_order = memory_order_seq_cst ) volatile;
747 unsigned int fetch_or( unsigned int,
748 memory_order = memory_order_seq_cst ) volatile;
749 unsigned int fetch_xor( unsigned int,
750 memory_order = memory_order_seq_cst ) volatile;
752 CPP0X( atomic_uint() = default; )
753 CPP0X( constexpr atomic_uint( unsigned int __v__ ) : __f__( __v__) { } )
754 CPP0X( atomic_uint( const atomic_uint& ) = delete; )
755 atomic_uint& operator =( const atomic_uint& ) CPP0X(=delete);
757 unsigned int operator =( unsigned int __v__ ) volatile
758 { store( __v__ ); return __v__; }
760 unsigned int operator ++( int ) volatile
761 { return fetch_add( 1 ); }
763 unsigned int operator --( int ) volatile
764 { return fetch_sub( 1 ); }
766 unsigned int operator ++() volatile
767 { return fetch_add( 1 ) + 1; }
769 unsigned int operator --() volatile
770 { return fetch_sub( 1 ) - 1; }
772 unsigned int operator +=( unsigned int __v__ ) volatile
773 { return fetch_add( __v__ ) + __v__; }
775 unsigned int operator -=( unsigned int __v__ ) volatile
776 { return fetch_sub( __v__ ) - __v__; }
778 unsigned int operator &=( unsigned int __v__ ) volatile
779 { return fetch_and( __v__ ) & __v__; }
781 unsigned int operator |=( unsigned int __v__ ) volatile
782 { return fetch_or( __v__ ) | __v__; }
784 unsigned int operator ^=( unsigned int __v__ ) volatile
785 { return fetch_xor( __v__ ) ^ __v__; }
787 friend void atomic_store_explicit( volatile atomic_uint*, unsigned int,
789 friend unsigned int atomic_load_explicit( volatile atomic_uint*,
791 friend unsigned int atomic_swap_explicit( volatile atomic_uint*,
792 unsigned int, memory_order );
793 friend bool atomic_compare_swap_explicit( volatile atomic_uint*,
794 unsigned int*, unsigned int, memory_order, memory_order );
795 friend void atomic_fence( const volatile atomic_uint*, memory_order );
796 friend unsigned int atomic_fetch_add_explicit( volatile atomic_uint*,
797 unsigned int, memory_order );
798 friend unsigned int atomic_fetch_sub_explicit( volatile atomic_uint*,
799 unsigned int, memory_order );
800 friend unsigned int atomic_fetch_and_explicit( volatile atomic_uint*,
801 unsigned int, memory_order );
802 friend unsigned int atomic_fetch_or_explicit( volatile atomic_uint*,
803 unsigned int, memory_order );
804 friend unsigned int atomic_fetch_xor_explicit( volatile atomic_uint*,
805 unsigned int, memory_order );
813 typedef struct atomic_long
816 bool is_lock_free() const volatile;
818 memory_order = memory_order_seq_cst ) volatile;
819 long load( memory_order = memory_order_seq_cst ) volatile;
821 memory_order = memory_order_seq_cst ) volatile;
822 bool compare_swap( long&, long,
823 memory_order, memory_order ) volatile;
824 bool compare_swap( long&, long,
825 memory_order = memory_order_seq_cst ) volatile;
826 void fence( memory_order ) const volatile;
827 long fetch_add( long,
828 memory_order = memory_order_seq_cst ) volatile;
829 long fetch_sub( long,
830 memory_order = memory_order_seq_cst ) volatile;
831 long fetch_and( long,
832 memory_order = memory_order_seq_cst ) volatile;
834 memory_order = memory_order_seq_cst ) volatile;
835 long fetch_xor( long,
836 memory_order = memory_order_seq_cst ) volatile;
838 CPP0X( atomic_long() = default; )
839 CPP0X( constexpr atomic_long( long __v__ ) : __f__( __v__) { } )
840 CPP0X( atomic_long( const atomic_long& ) = delete; )
841 atomic_long& operator =( const atomic_long& ) CPP0X(=delete);
843 long operator =( long __v__ ) volatile
844 { store( __v__ ); return __v__; }
846 long operator ++( int ) volatile
847 { return fetch_add( 1 ); }
849 long operator --( int ) volatile
850 { return fetch_sub( 1 ); }
852 long operator ++() volatile
853 { return fetch_add( 1 ) + 1; }
855 long operator --() volatile
856 { return fetch_sub( 1 ) - 1; }
858 long operator +=( long __v__ ) volatile
859 { return fetch_add( __v__ ) + __v__; }
861 long operator -=( long __v__ ) volatile
862 { return fetch_sub( __v__ ) - __v__; }
864 long operator &=( long __v__ ) volatile
865 { return fetch_and( __v__ ) & __v__; }
867 long operator |=( long __v__ ) volatile
868 { return fetch_or( __v__ ) | __v__; }
870 long operator ^=( long __v__ ) volatile
871 { return fetch_xor( __v__ ) ^ __v__; }
873 friend void atomic_store_explicit( volatile atomic_long*, long,
875 friend long atomic_load_explicit( volatile atomic_long*,
877 friend long atomic_swap_explicit( volatile atomic_long*,
878 long, memory_order );
879 friend bool atomic_compare_swap_explicit( volatile atomic_long*,
880 long*, long, memory_order, memory_order );
881 friend void atomic_fence( const volatile atomic_long*, memory_order );
882 friend long atomic_fetch_add_explicit( volatile atomic_long*,
883 long, memory_order );
884 friend long atomic_fetch_sub_explicit( volatile atomic_long*,
885 long, memory_order );
886 friend long atomic_fetch_and_explicit( volatile atomic_long*,
887 long, memory_order );
888 friend long atomic_fetch_or_explicit( volatile atomic_long*,
889 long, memory_order );
890 friend long atomic_fetch_xor_explicit( volatile atomic_long*,
891 long, memory_order );
899 typedef struct atomic_ulong
902 bool is_lock_free() const volatile;
903 void store( unsigned long,
904 memory_order = memory_order_seq_cst ) volatile;
905 unsigned long load( memory_order = memory_order_seq_cst ) volatile;
906 unsigned long swap( unsigned long,
907 memory_order = memory_order_seq_cst ) volatile;
908 bool compare_swap( unsigned long&, unsigned long,
909 memory_order, memory_order ) volatile;
910 bool compare_swap( unsigned long&, unsigned long,
911 memory_order = memory_order_seq_cst ) volatile;
912 void fence( memory_order ) const volatile;
913 unsigned long fetch_add( unsigned long,
914 memory_order = memory_order_seq_cst ) volatile;
915 unsigned long fetch_sub( unsigned long,
916 memory_order = memory_order_seq_cst ) volatile;
917 unsigned long fetch_and( unsigned long,
918 memory_order = memory_order_seq_cst ) volatile;
919 unsigned long fetch_or( unsigned long,
920 memory_order = memory_order_seq_cst ) volatile;
921 unsigned long fetch_xor( unsigned long,
922 memory_order = memory_order_seq_cst ) volatile;
924 CPP0X( atomic_ulong() = default; )
925 CPP0X( constexpr atomic_ulong( unsigned long __v__ ) : __f__( __v__) { } )
926 CPP0X( atomic_ulong( const atomic_ulong& ) = delete; )
927 atomic_ulong& operator =( const atomic_ulong& ) CPP0X(=delete);
929 unsigned long operator =( unsigned long __v__ ) volatile
930 { store( __v__ ); return __v__; }
932 unsigned long operator ++( int ) volatile
933 { return fetch_add( 1 ); }
935 unsigned long operator --( int ) volatile
936 { return fetch_sub( 1 ); }
938 unsigned long operator ++() volatile
939 { return fetch_add( 1 ) + 1; }
941 unsigned long operator --() volatile
942 { return fetch_sub( 1 ) - 1; }
944 unsigned long operator +=( unsigned long __v__ ) volatile
945 { return fetch_add( __v__ ) + __v__; }
947 unsigned long operator -=( unsigned long __v__ ) volatile
948 { return fetch_sub( __v__ ) - __v__; }
950 unsigned long operator &=( unsigned long __v__ ) volatile
951 { return fetch_and( __v__ ) & __v__; }
953 unsigned long operator |=( unsigned long __v__ ) volatile
954 { return fetch_or( __v__ ) | __v__; }
956 unsigned long operator ^=( unsigned long __v__ ) volatile
957 { return fetch_xor( __v__ ) ^ __v__; }
959 friend void atomic_store_explicit( volatile atomic_ulong*, unsigned long,
961 friend unsigned long atomic_load_explicit( volatile atomic_ulong*,
963 friend unsigned long atomic_swap_explicit( volatile atomic_ulong*,
964 unsigned long, memory_order );
965 friend bool atomic_compare_swap_explicit( volatile atomic_ulong*,
966 unsigned long*, unsigned long, memory_order, memory_order );
967 friend void atomic_fence( const volatile atomic_ulong*, memory_order );
968 friend unsigned long atomic_fetch_add_explicit( volatile atomic_ulong*,
969 unsigned long, memory_order );
970 friend unsigned long atomic_fetch_sub_explicit( volatile atomic_ulong*,
971 unsigned long, memory_order );
972 friend unsigned long atomic_fetch_and_explicit( volatile atomic_ulong*,
973 unsigned long, memory_order );
974 friend unsigned long atomic_fetch_or_explicit( volatile atomic_ulong*,
975 unsigned long, memory_order );
976 friend unsigned long atomic_fetch_xor_explicit( volatile atomic_ulong*,
977 unsigned long, memory_order );
985 typedef struct atomic_llong
988 bool is_lock_free() const volatile;
989 void store( long long,
990 memory_order = memory_order_seq_cst ) volatile;
991 long long load( memory_order = memory_order_seq_cst ) volatile;
992 long long swap( long long,
993 memory_order = memory_order_seq_cst ) volatile;
994 bool compare_swap( long long&, long long,
995 memory_order, memory_order ) volatile;
996 bool compare_swap( long long&, long long,
997 memory_order = memory_order_seq_cst ) volatile;
998 void fence( memory_order ) const volatile;
999 long long fetch_add( long long,
1000 memory_order = memory_order_seq_cst ) volatile;
1001 long long fetch_sub( long long,
1002 memory_order = memory_order_seq_cst ) volatile;
1003 long long fetch_and( long long,
1004 memory_order = memory_order_seq_cst ) volatile;
1005 long long fetch_or( long long,
1006 memory_order = memory_order_seq_cst ) volatile;
1007 long long fetch_xor( long long,
1008 memory_order = memory_order_seq_cst ) volatile;
1010 CPP0X( atomic_llong() = default; )
1011 CPP0X( constexpr atomic_llong( long long __v__ ) : __f__( __v__) { } )
1012 CPP0X( atomic_llong( const atomic_llong& ) = delete; )
1013 atomic_llong& operator =( const atomic_llong& ) CPP0X(=delete);
1015 long long operator =( long long __v__ ) volatile
1016 { store( __v__ ); return __v__; }
1018 long long operator ++( int ) volatile
1019 { return fetch_add( 1 ); }
1021 long long operator --( int ) volatile
1022 { return fetch_sub( 1 ); }
1024 long long operator ++() volatile
1025 { return fetch_add( 1 ) + 1; }
1027 long long operator --() volatile
1028 { return fetch_sub( 1 ) - 1; }
1030 long long operator +=( long long __v__ ) volatile
1031 { return fetch_add( __v__ ) + __v__; }
1033 long long operator -=( long long __v__ ) volatile
1034 { return fetch_sub( __v__ ) - __v__; }
1036 long long operator &=( long long __v__ ) volatile
1037 { return fetch_and( __v__ ) & __v__; }
1039 long long operator |=( long long __v__ ) volatile
1040 { return fetch_or( __v__ ) | __v__; }
1042 long long operator ^=( long long __v__ ) volatile
1043 { return fetch_xor( __v__ ) ^ __v__; }
1045 friend void atomic_store_explicit( volatile atomic_llong*, long long,
1047 friend long long atomic_load_explicit( volatile atomic_llong*,
1049 friend long long atomic_swap_explicit( volatile atomic_llong*,
1050 long long, memory_order );
1051 friend bool atomic_compare_swap_explicit( volatile atomic_llong*,
1052 long long*, long long, memory_order, memory_order );
1053 friend void atomic_fence( const volatile atomic_llong*, memory_order );
1054 friend long long atomic_fetch_add_explicit( volatile atomic_llong*,
1055 long long, memory_order );
1056 friend long long atomic_fetch_sub_explicit( volatile atomic_llong*,
1057 long long, memory_order );
1058 friend long long atomic_fetch_and_explicit( volatile atomic_llong*,
1059 long long, memory_order );
1060 friend long long atomic_fetch_or_explicit( volatile atomic_llong*,
1061 long long, memory_order );
1062 friend long long atomic_fetch_xor_explicit( volatile atomic_llong*,
1063 long long, memory_order );
1071 typedef struct atomic_ullong
1074 bool is_lock_free() const volatile;
1075 void store( unsigned long long,
1076 memory_order = memory_order_seq_cst ) volatile;
1077 unsigned long long load( memory_order = memory_order_seq_cst ) volatile;
1078 unsigned long long swap( unsigned long long,
1079 memory_order = memory_order_seq_cst ) volatile;
1080 bool compare_swap( unsigned long long&, unsigned long long,
1081 memory_order, memory_order ) volatile;
1082 bool compare_swap( unsigned long long&, unsigned long long,
1083 memory_order = memory_order_seq_cst ) volatile;
1084 void fence( memory_order ) const volatile;
1085 unsigned long long fetch_add( unsigned long long,
1086 memory_order = memory_order_seq_cst ) volatile;
1087 unsigned long long fetch_sub( unsigned long long,
1088 memory_order = memory_order_seq_cst ) volatile;
1089 unsigned long long fetch_and( unsigned long long,
1090 memory_order = memory_order_seq_cst ) volatile;
1091 unsigned long long fetch_or( unsigned long long,
1092 memory_order = memory_order_seq_cst ) volatile;
1093 unsigned long long fetch_xor( unsigned long long,
1094 memory_order = memory_order_seq_cst ) volatile;
1096 CPP0X( atomic_ullong() = default; )
1097 CPP0X( constexpr atomic_ullong( unsigned long long __v__ ) : __f__( __v__) { } )
1098 CPP0X( atomic_ullong( const atomic_ullong& ) = delete; )
1099 atomic_ullong& operator =( const atomic_ullong& ) CPP0X(=delete);
1101 unsigned long long operator =( unsigned long long __v__ ) volatile
1102 { store( __v__ ); return __v__; }
1104 unsigned long long operator ++( int ) volatile
1105 { return fetch_add( 1 ); }
1107 unsigned long long operator --( int ) volatile
1108 { return fetch_sub( 1 ); }
1110 unsigned long long operator ++() volatile
1111 { return fetch_add( 1 ) + 1; }
1113 unsigned long long operator --() volatile
1114 { return fetch_sub( 1 ) - 1; }
1116 unsigned long long operator +=( unsigned long long __v__ ) volatile
1117 { return fetch_add( __v__ ) + __v__; }
1119 unsigned long long operator -=( unsigned long long __v__ ) volatile
1120 { return fetch_sub( __v__ ) - __v__; }
1122 unsigned long long operator &=( unsigned long long __v__ ) volatile
1123 { return fetch_and( __v__ ) & __v__; }
1125 unsigned long long operator |=( unsigned long long __v__ ) volatile
1126 { return fetch_or( __v__ ) | __v__; }
1128 unsigned long long operator ^=( unsigned long long __v__ ) volatile
1129 { return fetch_xor( __v__ ) ^ __v__; }
1131 friend void atomic_store_explicit( volatile atomic_ullong*, unsigned long long,
1133 friend unsigned long long atomic_load_explicit( volatile atomic_ullong*,
1135 friend unsigned long long atomic_swap_explicit( volatile atomic_ullong*,
1136 unsigned long long, memory_order );
1137 friend bool atomic_compare_swap_explicit( volatile atomic_ullong*,
1138 unsigned long long*, unsigned long long, memory_order, memory_order );
1139 friend void atomic_fence( const volatile atomic_ullong*, memory_order );
1140 friend unsigned long long atomic_fetch_add_explicit( volatile atomic_ullong*,
1141 unsigned long long, memory_order );
1142 friend unsigned long long atomic_fetch_sub_explicit( volatile atomic_ullong*,
1143 unsigned long long, memory_order );
1144 friend unsigned long long atomic_fetch_and_explicit( volatile atomic_ullong*,
1145 unsigned long long, memory_order );
1146 friend unsigned long long atomic_fetch_or_explicit( volatile atomic_ullong*,
1147 unsigned long long, memory_order );
1148 friend unsigned long long atomic_fetch_xor_explicit( volatile atomic_ullong*,
1149 unsigned long long, memory_order );
1153 unsigned long long __f__;
1157 typedef atomic_schar atomic_int_least8_t;
1158 typedef atomic_uchar atomic_uint_least8_t;
1159 typedef atomic_short atomic_int_least16_t;
1160 typedef atomic_ushort atomic_uint_least16_t;
1161 typedef atomic_int atomic_int_least32_t;
1162 typedef atomic_uint atomic_uint_least32_t;
1163 typedef atomic_llong atomic_int_least64_t;
1164 typedef atomic_ullong atomic_uint_least64_t;
1166 typedef atomic_schar atomic_int_fast8_t;
1167 typedef atomic_uchar atomic_uint_fast8_t;
1168 typedef atomic_short atomic_int_fast16_t;
1169 typedef atomic_ushort atomic_uint_fast16_t;
1170 typedef atomic_int atomic_int_fast32_t;
1171 typedef atomic_uint atomic_uint_fast32_t;
1172 typedef atomic_llong atomic_int_fast64_t;
1173 typedef atomic_ullong atomic_uint_fast64_t;
1175 typedef atomic_long atomic_intptr_t;
1176 typedef atomic_ulong atomic_uintptr_t;
1178 typedef atomic_long atomic_ssize_t;
1179 typedef atomic_ulong atomic_size_t;
1181 typedef atomic_long atomic_ptrdiff_t;
1183 typedef atomic_llong atomic_intmax_t;
1184 typedef atomic_ullong atomic_uintmax_t;
1190 typedef struct atomic_wchar_t
1193 bool is_lock_free() const volatile;
1194 void store( wchar_t, memory_order = memory_order_seq_cst ) volatile;
1195 wchar_t load( memory_order = memory_order_seq_cst ) volatile;
1196 wchar_t swap( wchar_t,
1197 memory_order = memory_order_seq_cst ) volatile;
1198 bool compare_swap( wchar_t&, wchar_t,
1199 memory_order, memory_order ) volatile;
1200 bool compare_swap( wchar_t&, wchar_t,
1201 memory_order = memory_order_seq_cst ) volatile;
1202 void fence( memory_order ) const volatile;
1203 wchar_t fetch_add( wchar_t,
1204 memory_order = memory_order_seq_cst ) volatile;
1205 wchar_t fetch_sub( wchar_t,
1206 memory_order = memory_order_seq_cst ) volatile;
1207 wchar_t fetch_and( wchar_t,
1208 memory_order = memory_order_seq_cst ) volatile;
1209 wchar_t fetch_or( wchar_t,
1210 memory_order = memory_order_seq_cst ) volatile;
1211 wchar_t fetch_xor( wchar_t,
1212 memory_order = memory_order_seq_cst ) volatile;
1214 CPP0X( atomic_wchar_t() = default; )
1215 CPP0X( constexpr atomic_wchar_t( wchar_t __v__ ) : __f__( __v__) { } )
1216 CPP0X( atomic_wchar_t( const atomic_wchar_t& ) = delete; )
1217 atomic_wchar_t& operator =( const atomic_wchar_t& ) CPP0X(=delete);
1219 wchar_t operator =( wchar_t __v__ ) volatile
1220 { store( __v__ ); return __v__; }
1222 wchar_t operator ++( int ) volatile
1223 { return fetch_add( 1 ); }
1225 wchar_t operator --( int ) volatile
1226 { return fetch_sub( 1 ); }
1228 wchar_t operator ++() volatile
1229 { return fetch_add( 1 ) + 1; }
1231 wchar_t operator --() volatile
1232 { return fetch_sub( 1 ) - 1; }
1234 wchar_t operator +=( wchar_t __v__ ) volatile
1235 { return fetch_add( __v__ ) + __v__; }
1237 wchar_t operator -=( wchar_t __v__ ) volatile
1238 { return fetch_sub( __v__ ) - __v__; }
1240 wchar_t operator &=( wchar_t __v__ ) volatile
1241 { return fetch_and( __v__ ) & __v__; }
1243 wchar_t operator |=( wchar_t __v__ ) volatile
1244 { return fetch_or( __v__ ) | __v__; }
1246 wchar_t operator ^=( wchar_t __v__ ) volatile
1247 { return fetch_xor( __v__ ) ^ __v__; }
1249 friend void atomic_store_explicit( volatile atomic_wchar_t*, wchar_t,
1251 friend wchar_t atomic_load_explicit( volatile atomic_wchar_t*,
1253 friend wchar_t atomic_swap_explicit( volatile atomic_wchar_t*,
1254 wchar_t, memory_order );
1255 friend bool atomic_compare_swap_explicit( volatile atomic_wchar_t*,
1256 wchar_t*, wchar_t, memory_order, memory_order );
1257 friend void atomic_fence( const volatile atomic_wchar_t*, memory_order );
1258 friend wchar_t atomic_fetch_add_explicit( volatile atomic_wchar_t*,
1259 wchar_t, memory_order );
1260 friend wchar_t atomic_fetch_sub_explicit( volatile atomic_wchar_t*,
1261 wchar_t, memory_order );
1262 friend wchar_t atomic_fetch_and_explicit( volatile atomic_wchar_t*,
1263 wchar_t, memory_order );
1264 friend wchar_t atomic_fetch_or_explicit( volatile atomic_wchar_t*,
1265 wchar_t, memory_order );
1266 friend wchar_t atomic_fetch_xor_explicit( volatile atomic_wchar_t*,
1267 wchar_t, memory_order );
1277 typedef atomic_int_least16_t atomic_char16_t;
1278 typedef atomic_int_least32_t atomic_char32_t;
1279 typedef atomic_int_least32_t atomic_wchar_t;
1286 template< typename T >
1291 bool is_lock_free() const volatile;
1292 void store( T, memory_order = memory_order_seq_cst ) volatile;
1293 T load( memory_order = memory_order_seq_cst ) volatile;
1294 T swap( T __v__, memory_order = memory_order_seq_cst ) volatile;
1295 bool compare_swap( T&, T, memory_order, memory_order ) volatile;
1296 bool compare_swap( T&, T, memory_order = memory_order_seq_cst ) volatile;
1297 void fence( memory_order ) const volatile;
1299 CPP0X( atomic() = default; )
1300 CPP0X( constexpr explicit atomic( T __v__ ) : __f__( __v__ ) { } )
1301 CPP0X( atomic( const atomic& ) = delete; )
1302 atomic& operator =( const atomic& ) CPP0X(=delete);
1304 T operator =( T __v__ ) volatile
1305 { store( __v__ ); return __v__; }
1316 template<typename T> struct atomic< T* > : atomic_address
1318 T* load( memory_order = memory_order_seq_cst ) volatile;
1319 T* swap( T*, memory_order = memory_order_seq_cst ) volatile;
1320 bool compare_swap( T*&, T*, memory_order, memory_order ) volatile;
1321 bool compare_swap( T*&, T*,
1322 memory_order = memory_order_seq_cst ) volatile;
1323 T* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1324 T* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1326 CPP0X( atomic() = default; )
1327 CPP0X( constexpr explicit atomic( T __v__ ) : atomic_address( __v__ ) { } )
1328 CPP0X( atomic( const atomic& ) = delete; )
1329 atomic& operator =( const atomic& ) CPP0X(=delete);
1331 T* operator =( T* __v__ ) volatile
1332 { store( __v__ ); return __v__; }
1334 T* operator ++( int ) volatile
1335 { return fetch_add( 1 ); }
1337 T* operator --( int ) volatile
1338 { return fetch_sub( 1 ); }
1340 T* operator ++() volatile
1341 { return fetch_add( 1 ) + 1; }
1343 T* operator --() volatile
1344 { return fetch_sub( 1 ) - 1; }
1346 T* operator +=( T* __v__ ) volatile
1347 { return fetch_add( __v__ ) + __v__; }
1349 T* operator -=( T* __v__ ) volatile
1350 { return fetch_sub( __v__ ) - __v__; }
1358 template<> struct atomic< bool > : atomic_bool
1360 CPP0X( atomic() = default; )
1361 CPP0X( constexpr explicit atomic( bool __v__ )
1362 : atomic_bool( __v__ ) { } )
1363 CPP0X( atomic( const atomic& ) = delete; )
1364 atomic& operator =( const atomic& ) CPP0X(=delete);
1366 bool operator =( bool __v__ ) volatile
1367 { store( __v__ ); return __v__; }
1371 template<> struct atomic< void* > : atomic_address
1373 CPP0X( atomic() = default; )
1374 CPP0X( constexpr explicit atomic( void* __v__ )
1375 : atomic_address( __v__ ) { } )
1376 CPP0X( atomic( const atomic& ) = delete; )
1377 atomic& operator =( const atomic& ) CPP0X(=delete);
1379 void* operator =( void* __v__ ) volatile
1380 { store( __v__ ); return __v__; }
1384 template<> struct atomic< char > : atomic_char
1386 CPP0X( atomic() = default; )
1387 CPP0X( constexpr explicit atomic( char __v__ )
1388 : atomic_char( __v__ ) { } )
1389 CPP0X( atomic( const atomic& ) = delete; )
1390 atomic& operator =( const atomic& ) CPP0X(=delete);
1392 char operator =( char __v__ ) volatile
1393 { store( __v__ ); return __v__; }
1397 template<> struct atomic< signed char > : atomic_schar
1399 CPP0X( atomic() = default; )
1400 CPP0X( constexpr explicit atomic( signed char __v__ )
1401 : atomic_schar( __v__ ) { } )
1402 CPP0X( atomic( const atomic& ) = delete; )
1403 atomic& operator =( const atomic& ) CPP0X(=delete);
1405 signed char operator =( signed char __v__ ) volatile
1406 { store( __v__ ); return __v__; }
1410 template<> struct atomic< unsigned char > : atomic_uchar
1412 CPP0X( atomic() = default; )
1413 CPP0X( constexpr explicit atomic( unsigned char __v__ )
1414 : atomic_uchar( __v__ ) { } )
1415 CPP0X( atomic( const atomic& ) = delete; )
1416 atomic& operator =( const atomic& ) CPP0X(=delete);
1418 unsigned char operator =( unsigned char __v__ ) volatile
1419 { store( __v__ ); return __v__; }
1423 template<> struct atomic< short > : atomic_short
1425 CPP0X( atomic() = default; )
1426 CPP0X( constexpr explicit atomic( short __v__ )
1427 : atomic_short( __v__ ) { } )
1428 CPP0X( atomic( const atomic& ) = delete; )
1429 atomic& operator =( const atomic& ) CPP0X(=delete);
1431 short operator =( short __v__ ) volatile
1432 { store( __v__ ); return __v__; }
1436 template<> struct atomic< unsigned short > : atomic_ushort
1438 CPP0X( atomic() = default; )
1439 CPP0X( constexpr explicit atomic( unsigned short __v__ )
1440 : atomic_ushort( __v__ ) { } )
1441 CPP0X( atomic( const atomic& ) = delete; )
1442 atomic& operator =( const atomic& ) CPP0X(=delete);
1444 unsigned short operator =( unsigned short __v__ ) volatile
1445 { store( __v__ ); return __v__; }
1449 template<> struct atomic< int > : atomic_int
1451 CPP0X( atomic() = default; )
1452 CPP0X( constexpr explicit atomic( int __v__ )
1453 : atomic_int( __v__ ) { } )
1454 CPP0X( atomic( const atomic& ) = delete; )
1455 atomic& operator =( const atomic& ) CPP0X(=delete);
1457 int operator =( int __v__ ) volatile
1458 { store( __v__ ); return __v__; }
1462 template<> struct atomic< unsigned int > : atomic_uint
1464 CPP0X( atomic() = default; )
1465 CPP0X( constexpr explicit atomic( unsigned int __v__ )
1466 : atomic_uint( __v__ ) { } )
1467 CPP0X( atomic( const atomic& ) = delete; )
1468 atomic& operator =( const atomic& ) CPP0X(=delete);
1470 unsigned int operator =( unsigned int __v__ ) volatile
1471 { store( __v__ ); return __v__; }
1475 template<> struct atomic< long > : atomic_long
1477 CPP0X( atomic() = default; )
1478 CPP0X( constexpr explicit atomic( long __v__ )
1479 : atomic_long( __v__ ) { } )
1480 CPP0X( atomic( const atomic& ) = delete; )
1481 atomic& operator =( const atomic& ) CPP0X(=delete);
1483 long operator =( long __v__ ) volatile
1484 { store( __v__ ); return __v__; }
1488 template<> struct atomic< unsigned long > : atomic_ulong
1490 CPP0X( atomic() = default; )
1491 CPP0X( constexpr explicit atomic( unsigned long __v__ )
1492 : atomic_ulong( __v__ ) { } )
1493 CPP0X( atomic( const atomic& ) = delete; )
1494 atomic& operator =( const atomic& ) CPP0X(=delete);
1496 unsigned long operator =( unsigned long __v__ ) volatile
1497 { store( __v__ ); return __v__; }
1501 template<> struct atomic< long long > : atomic_llong
1503 CPP0X( atomic() = default; )
1504 CPP0X( constexpr explicit atomic( long long __v__ )
1505 : atomic_llong( __v__ ) { } )
1506 CPP0X( atomic( const atomic& ) = delete; )
1507 atomic& operator =( const atomic& ) CPP0X(=delete);
1509 long long operator =( long long __v__ ) volatile
1510 { store( __v__ ); return __v__; }
1514 template<> struct atomic< unsigned long long > : atomic_ullong
1516 CPP0X( atomic() = default; )
1517 CPP0X( constexpr explicit atomic( unsigned long long __v__ )
1518 : atomic_ullong( __v__ ) { } )
1519 CPP0X( atomic( const atomic& ) = delete; )
1520 atomic& operator =( const atomic& ) CPP0X(=delete);
1522 unsigned long long operator =( unsigned long long __v__ ) volatile
1523 { store( __v__ ); return __v__; }
1527 template<> struct atomic< wchar_t > : atomic_wchar_t
1529 CPP0X( atomic() = default; )
1530 CPP0X( constexpr explicit atomic( wchar_t __v__ )
1531 : atomic_wchar_t( __v__ ) { } )
1532 CPP0X( atomic( const atomic& ) = delete; )
1533 atomic& operator =( const atomic& ) CPP0X(=delete);
1535 wchar_t operator =( wchar_t __v__ ) volatile
1536 { store( __v__ ); return __v__; }
1546 inline bool atomic_is_lock_free( const volatile atomic_bool* __a__ )
1549 inline bool atomic_load_explicit
1550 ( volatile atomic_bool* __a__, memory_order __x__ )
1551 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1553 inline bool atomic_load( volatile atomic_bool* __a__ )
1554 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1556 inline void atomic_store_explicit
1557 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1558 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1560 inline void atomic_store
1561 ( volatile atomic_bool* __a__, bool __m__ )
1562 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1564 inline bool atomic_swap_explicit
1565 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1566 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1568 inline bool atomic_swap
1569 ( volatile atomic_bool* __a__, bool __m__ )
1570 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1572 inline bool atomic_compare_swap_explicit
1573 ( volatile atomic_bool* __a__, bool* __e__, bool __m__,
1574 memory_order __x__, memory_order __y__ )
1575 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1577 inline bool atomic_compare_swap
1578 ( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
1579 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1580 memory_order_seq_cst, memory_order_seq_cst ); }
1582 inline void atomic_fence
1583 ( const volatile atomic_bool* __a__, memory_order __x__ )
1584 { _ATOMIC_FENCE_( __a__, __x__ ); }
1587 inline bool atomic_is_lock_free( const volatile atomic_address* __a__ )
1590 inline void* atomic_load_explicit
1591 ( volatile atomic_address* __a__, memory_order __x__ )
1592 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1594 inline void* atomic_load( volatile atomic_address* __a__ )
1595 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1597 inline void atomic_store_explicit
1598 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1599 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1601 inline void atomic_store
1602 ( volatile atomic_address* __a__, void* __m__ )
1603 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1605 inline void* atomic_swap_explicit
1606 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1607 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1609 inline void* atomic_swap
1610 ( volatile atomic_address* __a__, void* __m__ )
1611 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1613 inline bool atomic_compare_swap_explicit
1614 ( volatile atomic_address* __a__, void** __e__, void* __m__,
1615 memory_order __x__, memory_order __y__ )
1616 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1618 inline bool atomic_compare_swap
1619 ( volatile atomic_address* __a__, void** __e__, void* __m__ )
1620 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1621 memory_order_seq_cst, memory_order_seq_cst ); }
1623 inline void atomic_fence
1624 ( const volatile atomic_address* __a__, memory_order __x__ )
1625 { _ATOMIC_FENCE_( __a__, __x__ ); }
1628 inline bool atomic_is_lock_free( const volatile atomic_char* __a__ )
1631 inline char atomic_load_explicit
1632 ( volatile atomic_char* __a__, memory_order __x__ )
1633 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1635 inline char atomic_load( volatile atomic_char* __a__ )
1636 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1638 inline void atomic_store_explicit
1639 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1640 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1642 inline void atomic_store
1643 ( volatile atomic_char* __a__, char __m__ )
1644 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1646 inline char atomic_swap_explicit
1647 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1648 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1650 inline char atomic_swap
1651 ( volatile atomic_char* __a__, char __m__ )
1652 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1654 inline bool atomic_compare_swap_explicit
1655 ( volatile atomic_char* __a__, char* __e__, char __m__,
1656 memory_order __x__, memory_order __y__ )
1657 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1659 inline bool atomic_compare_swap
1660 ( volatile atomic_char* __a__, char* __e__, char __m__ )
1661 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1662 memory_order_seq_cst, memory_order_seq_cst ); }
1664 inline void atomic_fence
1665 ( const volatile atomic_char* __a__, memory_order __x__ )
1666 { _ATOMIC_FENCE_( __a__, __x__ ); }
1669 inline bool atomic_is_lock_free( const volatile atomic_schar* __a__ )
1672 inline signed char atomic_load_explicit
1673 ( volatile atomic_schar* __a__, memory_order __x__ )
1674 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1676 inline signed char atomic_load( volatile atomic_schar* __a__ )
1677 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1679 inline void atomic_store_explicit
1680 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1681 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1683 inline void atomic_store
1684 ( volatile atomic_schar* __a__, signed char __m__ )
1685 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1687 inline signed char atomic_swap_explicit
1688 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1689 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1691 inline signed char atomic_swap
1692 ( volatile atomic_schar* __a__, signed char __m__ )
1693 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1695 inline bool atomic_compare_swap_explicit
1696 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
1697 memory_order __x__, memory_order __y__ )
1698 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1700 inline bool atomic_compare_swap
1701 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
1702 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1703 memory_order_seq_cst, memory_order_seq_cst ); }
1705 inline void atomic_fence
1706 ( const volatile atomic_schar* __a__, memory_order __x__ )
1707 { _ATOMIC_FENCE_( __a__, __x__ ); }
1710 inline bool atomic_is_lock_free( const volatile atomic_uchar* __a__ )
1713 inline unsigned char atomic_load_explicit
1714 ( volatile atomic_uchar* __a__, memory_order __x__ )
1715 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1717 inline unsigned char atomic_load( volatile atomic_uchar* __a__ )
1718 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1720 inline void atomic_store_explicit
1721 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1722 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1724 inline void atomic_store
1725 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1726 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1728 inline unsigned char atomic_swap_explicit
1729 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1730 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1732 inline unsigned char atomic_swap
1733 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1734 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1736 inline bool atomic_compare_swap_explicit
1737 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
1738 memory_order __x__, memory_order __y__ )
1739 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1741 inline bool atomic_compare_swap
1742 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
1743 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1744 memory_order_seq_cst, memory_order_seq_cst ); }
1746 inline void atomic_fence
1747 ( const volatile atomic_uchar* __a__, memory_order __x__ )
1748 { _ATOMIC_FENCE_( __a__, __x__ ); }
1751 inline bool atomic_is_lock_free( const volatile atomic_short* __a__ )
1754 inline short atomic_load_explicit
1755 ( volatile atomic_short* __a__, memory_order __x__ )
1756 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1758 inline short atomic_load( volatile atomic_short* __a__ )
1759 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1761 inline void atomic_store_explicit
1762 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1763 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1765 inline void atomic_store
1766 ( volatile atomic_short* __a__, short __m__ )
1767 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1769 inline short atomic_swap_explicit
1770 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1771 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1773 inline short atomic_swap
1774 ( volatile atomic_short* __a__, short __m__ )
1775 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1777 inline bool atomic_compare_swap_explicit
1778 ( volatile atomic_short* __a__, short* __e__, short __m__,
1779 memory_order __x__, memory_order __y__ )
1780 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1782 inline bool atomic_compare_swap
1783 ( volatile atomic_short* __a__, short* __e__, short __m__ )
1784 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1785 memory_order_seq_cst, memory_order_seq_cst ); }
1787 inline void atomic_fence
1788 ( const volatile atomic_short* __a__, memory_order __x__ )
1789 { _ATOMIC_FENCE_( __a__, __x__ ); }
1792 inline bool atomic_is_lock_free( const volatile atomic_ushort* __a__ )
1795 inline unsigned short atomic_load_explicit
1796 ( volatile atomic_ushort* __a__, memory_order __x__ )
1797 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1799 inline unsigned short atomic_load( volatile atomic_ushort* __a__ )
1800 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1802 inline void atomic_store_explicit
1803 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1804 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1806 inline void atomic_store
1807 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1808 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1810 inline unsigned short atomic_swap_explicit
1811 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1812 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1814 inline unsigned short atomic_swap
1815 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1816 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1818 inline bool atomic_compare_swap_explicit
1819 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
1820 memory_order __x__, memory_order __y__ )
1821 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1823 inline bool atomic_compare_swap
1824 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
1825 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1826 memory_order_seq_cst, memory_order_seq_cst ); }
1828 inline void atomic_fence
1829 ( const volatile atomic_ushort* __a__, memory_order __x__ )
1830 { _ATOMIC_FENCE_( __a__, __x__ ); }
1833 inline bool atomic_is_lock_free( const volatile atomic_int* __a__ )
1836 inline int atomic_load_explicit
1837 ( volatile atomic_int* __a__, memory_order __x__ )
1838 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1840 inline int atomic_load( volatile atomic_int* __a__ )
1841 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1843 inline void atomic_store_explicit
1844 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
1845 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1847 inline void atomic_store
1848 ( volatile atomic_int* __a__, int __m__ )
1849 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1851 inline int atomic_swap_explicit
1852 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
1853 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1855 inline int atomic_swap
1856 ( volatile atomic_int* __a__, int __m__ )
1857 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1859 inline bool atomic_compare_swap_explicit
1860 ( volatile atomic_int* __a__, int* __e__, int __m__,
1861 memory_order __x__, memory_order __y__ )
1862 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1864 inline bool atomic_compare_swap
1865 ( volatile atomic_int* __a__, int* __e__, int __m__ )
1866 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1867 memory_order_seq_cst, memory_order_seq_cst ); }
1869 inline void atomic_fence
1870 ( const volatile atomic_int* __a__, memory_order __x__ )
1871 { _ATOMIC_FENCE_( __a__, __x__ ); }
1874 inline bool atomic_is_lock_free( const volatile atomic_uint* __a__ )
1877 inline unsigned int atomic_load_explicit
1878 ( volatile atomic_uint* __a__, memory_order __x__ )
1879 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1881 inline unsigned int atomic_load( volatile atomic_uint* __a__ )
1882 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1884 inline void atomic_store_explicit
1885 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
1886 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1888 inline void atomic_store
1889 ( volatile atomic_uint* __a__, unsigned int __m__ )
1890 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1892 inline unsigned int atomic_swap_explicit
1893 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
1894 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1896 inline unsigned int atomic_swap
1897 ( volatile atomic_uint* __a__, unsigned int __m__ )
1898 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1900 inline bool atomic_compare_swap_explicit
1901 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
1902 memory_order __x__, memory_order __y__ )
1903 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1905 inline bool atomic_compare_swap
1906 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
1907 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1908 memory_order_seq_cst, memory_order_seq_cst ); }
1910 inline void atomic_fence
1911 ( const volatile atomic_uint* __a__, memory_order __x__ )
1912 { _ATOMIC_FENCE_( __a__, __x__ ); }
1915 inline bool atomic_is_lock_free( const volatile atomic_long* __a__ )
1918 inline long atomic_load_explicit
1919 ( volatile atomic_long* __a__, memory_order __x__ )
1920 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1922 inline long atomic_load( volatile atomic_long* __a__ )
1923 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1925 inline void atomic_store_explicit
1926 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
1927 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1929 inline void atomic_store
1930 ( volatile atomic_long* __a__, long __m__ )
1931 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1933 inline long atomic_swap_explicit
1934 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
1935 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1937 inline long atomic_swap
1938 ( volatile atomic_long* __a__, long __m__ )
1939 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1941 inline bool atomic_compare_swap_explicit
1942 ( volatile atomic_long* __a__, long* __e__, long __m__,
1943 memory_order __x__, memory_order __y__ )
1944 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1946 inline bool atomic_compare_swap
1947 ( volatile atomic_long* __a__, long* __e__, long __m__ )
1948 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1949 memory_order_seq_cst, memory_order_seq_cst ); }
1951 inline void atomic_fence
1952 ( const volatile atomic_long* __a__, memory_order __x__ )
1953 { _ATOMIC_FENCE_( __a__, __x__ ); }
1956 inline bool atomic_is_lock_free( const volatile atomic_ulong* __a__ )
1959 inline unsigned long atomic_load_explicit
1960 ( volatile atomic_ulong* __a__, memory_order __x__ )
1961 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1963 inline unsigned long atomic_load( volatile atomic_ulong* __a__ )
1964 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1966 inline void atomic_store_explicit
1967 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
1968 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1970 inline void atomic_store
1971 ( volatile atomic_ulong* __a__, unsigned long __m__ )
1972 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1974 inline unsigned long atomic_swap_explicit
1975 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
1976 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1978 inline unsigned long atomic_swap
1979 ( volatile atomic_ulong* __a__, unsigned long __m__ )
1980 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1982 inline bool atomic_compare_swap_explicit
1983 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
1984 memory_order __x__, memory_order __y__ )
1985 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1987 inline bool atomic_compare_swap
1988 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
1989 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1990 memory_order_seq_cst, memory_order_seq_cst ); }
1992 inline void atomic_fence
1993 ( const volatile atomic_ulong* __a__, memory_order __x__ )
1994 { _ATOMIC_FENCE_( __a__, __x__ ); }
1997 inline bool atomic_is_lock_free( const volatile atomic_llong* __a__ )
2000 inline long long atomic_load_explicit
2001 ( volatile atomic_llong* __a__, memory_order __x__ )
2002 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2004 inline long long atomic_load( volatile atomic_llong* __a__ )
2005 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2007 inline void atomic_store_explicit
2008 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2009 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2011 inline void atomic_store
2012 ( volatile atomic_llong* __a__, long long __m__ )
2013 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2015 inline long long atomic_swap_explicit
2016 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2017 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2019 inline long long atomic_swap
2020 ( volatile atomic_llong* __a__, long long __m__ )
2021 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2023 inline bool atomic_compare_swap_explicit
2024 ( volatile atomic_llong* __a__, long long* __e__, long long __m__,
2025 memory_order __x__, memory_order __y__ )
2026 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2028 inline bool atomic_compare_swap
2029 ( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
2030 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2031 memory_order_seq_cst, memory_order_seq_cst ); }
2033 inline void atomic_fence
2034 ( const volatile atomic_llong* __a__, memory_order __x__ )
2035 { _ATOMIC_FENCE_( __a__, __x__ ); }
2038 inline bool atomic_is_lock_free( const volatile atomic_ullong* __a__ )
2041 inline unsigned long long atomic_load_explicit
2042 ( volatile atomic_ullong* __a__, memory_order __x__ )
2043 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2045 inline unsigned long long atomic_load( volatile atomic_ullong* __a__ )
2046 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2048 inline void atomic_store_explicit
2049 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2050 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2052 inline void atomic_store
2053 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2054 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2056 inline unsigned long long atomic_swap_explicit
2057 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2058 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2060 inline unsigned long long atomic_swap
2061 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2062 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2064 inline bool atomic_compare_swap_explicit
2065 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
2066 memory_order __x__, memory_order __y__ )
2067 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2069 inline bool atomic_compare_swap
2070 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
2071 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2072 memory_order_seq_cst, memory_order_seq_cst ); }
2074 inline void atomic_fence
2075 ( const volatile atomic_ullong* __a__, memory_order __x__ )
2076 { _ATOMIC_FENCE_( __a__, __x__ ); }
2079 inline bool atomic_is_lock_free( const volatile atomic_wchar_t* __a__ )
2082 inline wchar_t atomic_load_explicit
2083 ( volatile atomic_wchar_t* __a__, memory_order __x__ )
2084 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2086 inline wchar_t atomic_load( volatile atomic_wchar_t* __a__ )
2087 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2089 inline void atomic_store_explicit
2090 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2091 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2093 inline void atomic_store
2094 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2095 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2097 inline wchar_t atomic_swap_explicit
2098 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2099 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2101 inline wchar_t atomic_swap
2102 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2103 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2105 inline bool atomic_compare_swap_explicit
2106 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
2107 memory_order __x__, memory_order __y__ )
2108 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2110 inline bool atomic_compare_swap
2111 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
2112 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2113 memory_order_seq_cst, memory_order_seq_cst ); }
2115 inline void atomic_fence
2116 ( const volatile atomic_wchar_t* __a__, memory_order __x__ )
2117 { _ATOMIC_FENCE_( __a__, __x__ ); }
2120 inline void* atomic_fetch_add_explicit
2121 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2122 { void* volatile* __p__ = &((__a__)->__f__);
2123 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__));
2124 void* __r__ = (void *) thread_current()->get_return_value();
2125 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, (void*)((char*)(*__p__) + __m__)));
2128 inline void* atomic_fetch_add
2129 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2130 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2133 inline void* atomic_fetch_sub_explicit
2134 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2135 { void* volatile* __p__ = &((__a__)->__f__);
2136 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__));
2137 void* __r__ = (void *) thread_current()->get_return_value();
2138 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, (void*)((char*)(*__p__) - __m__)));
2141 inline void* atomic_fetch_sub
2142 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2143 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2146 inline char atomic_fetch_add_explicit
2147 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2148 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2150 inline char atomic_fetch_add
2151 ( volatile atomic_char* __a__, char __m__ )
2152 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2155 inline char atomic_fetch_sub_explicit
2156 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2157 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2159 inline char atomic_fetch_sub
2160 ( volatile atomic_char* __a__, char __m__ )
2161 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2164 inline char atomic_fetch_and_explicit
2165 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2166 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2168 inline char atomic_fetch_and
2169 ( volatile atomic_char* __a__, char __m__ )
2170 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2173 inline char atomic_fetch_or_explicit
2174 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2175 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2177 inline char atomic_fetch_or
2178 ( volatile atomic_char* __a__, char __m__ )
2179 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2182 inline char atomic_fetch_xor_explicit
2183 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2184 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2186 inline char atomic_fetch_xor
2187 ( volatile atomic_char* __a__, char __m__ )
2188 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2191 inline signed char atomic_fetch_add_explicit
2192 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2193 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2195 inline signed char atomic_fetch_add
2196 ( volatile atomic_schar* __a__, signed char __m__ )
2197 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2200 inline signed char atomic_fetch_sub_explicit
2201 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2202 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2204 inline signed char atomic_fetch_sub
2205 ( volatile atomic_schar* __a__, signed char __m__ )
2206 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2209 inline signed char atomic_fetch_and_explicit
2210 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2211 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2213 inline signed char atomic_fetch_and
2214 ( volatile atomic_schar* __a__, signed char __m__ )
2215 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2218 inline signed char atomic_fetch_or_explicit
2219 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2220 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2222 inline signed char atomic_fetch_or
2223 ( volatile atomic_schar* __a__, signed char __m__ )
2224 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2227 inline signed char atomic_fetch_xor_explicit
2228 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2229 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2231 inline signed char atomic_fetch_xor
2232 ( volatile atomic_schar* __a__, signed char __m__ )
2233 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2236 inline unsigned char atomic_fetch_add_explicit
2237 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2238 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2240 inline unsigned char atomic_fetch_add
2241 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2242 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2245 inline unsigned char atomic_fetch_sub_explicit
2246 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2247 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2249 inline unsigned char atomic_fetch_sub
2250 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2251 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2254 inline unsigned char atomic_fetch_and_explicit
2255 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2256 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2258 inline unsigned char atomic_fetch_and
2259 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2260 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2263 inline unsigned char atomic_fetch_or_explicit
2264 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2265 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2267 inline unsigned char atomic_fetch_or
2268 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2269 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2272 inline unsigned char atomic_fetch_xor_explicit
2273 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2274 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2276 inline unsigned char atomic_fetch_xor
2277 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2278 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2281 inline short atomic_fetch_add_explicit
2282 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2283 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2285 inline short atomic_fetch_add
2286 ( volatile atomic_short* __a__, short __m__ )
2287 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2290 inline short atomic_fetch_sub_explicit
2291 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2292 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2294 inline short atomic_fetch_sub
2295 ( volatile atomic_short* __a__, short __m__ )
2296 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2299 inline short atomic_fetch_and_explicit
2300 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2301 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2303 inline short atomic_fetch_and
2304 ( volatile atomic_short* __a__, short __m__ )
2305 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2308 inline short atomic_fetch_or_explicit
2309 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2310 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2312 inline short atomic_fetch_or
2313 ( volatile atomic_short* __a__, short __m__ )
2314 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2317 inline short atomic_fetch_xor_explicit
2318 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2319 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2321 inline short atomic_fetch_xor
2322 ( volatile atomic_short* __a__, short __m__ )
2323 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2326 inline unsigned short atomic_fetch_add_explicit
2327 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2328 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2330 inline unsigned short atomic_fetch_add
2331 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2332 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2335 inline unsigned short atomic_fetch_sub_explicit
2336 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2337 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2339 inline unsigned short atomic_fetch_sub
2340 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2341 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2344 inline unsigned short atomic_fetch_and_explicit
2345 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2346 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2348 inline unsigned short atomic_fetch_and
2349 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2350 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2353 inline unsigned short atomic_fetch_or_explicit
2354 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2355 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2357 inline unsigned short atomic_fetch_or
2358 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2359 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2362 inline unsigned short atomic_fetch_xor_explicit
2363 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2364 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2366 inline unsigned short atomic_fetch_xor
2367 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2368 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2371 inline int atomic_fetch_add_explicit
2372 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2373 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2375 inline int atomic_fetch_add
2376 ( volatile atomic_int* __a__, int __m__ )
2377 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2380 inline int atomic_fetch_sub_explicit
2381 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2382 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2384 inline int atomic_fetch_sub
2385 ( volatile atomic_int* __a__, int __m__ )
2386 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2389 inline int atomic_fetch_and_explicit
2390 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2391 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2393 inline int atomic_fetch_and
2394 ( volatile atomic_int* __a__, int __m__ )
2395 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2398 inline int atomic_fetch_or_explicit
2399 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2400 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2402 inline int atomic_fetch_or
2403 ( volatile atomic_int* __a__, int __m__ )
2404 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2407 inline int atomic_fetch_xor_explicit
2408 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2409 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2411 inline int atomic_fetch_xor
2412 ( volatile atomic_int* __a__, int __m__ )
2413 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2416 inline unsigned int atomic_fetch_add_explicit
2417 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2418 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2420 inline unsigned int atomic_fetch_add
2421 ( volatile atomic_uint* __a__, unsigned int __m__ )
2422 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2425 inline unsigned int atomic_fetch_sub_explicit
2426 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2427 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2429 inline unsigned int atomic_fetch_sub
2430 ( volatile atomic_uint* __a__, unsigned int __m__ )
2431 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2434 inline unsigned int atomic_fetch_and_explicit
2435 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2436 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2438 inline unsigned int atomic_fetch_and
2439 ( volatile atomic_uint* __a__, unsigned int __m__ )
2440 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2443 inline unsigned int atomic_fetch_or_explicit
2444 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2445 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2447 inline unsigned int atomic_fetch_or
2448 ( volatile atomic_uint* __a__, unsigned int __m__ )
2449 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2452 inline unsigned int atomic_fetch_xor_explicit
2453 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2454 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2456 inline unsigned int atomic_fetch_xor
2457 ( volatile atomic_uint* __a__, unsigned int __m__ )
2458 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2461 inline long atomic_fetch_add_explicit
2462 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2463 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2465 inline long atomic_fetch_add
2466 ( volatile atomic_long* __a__, long __m__ )
2467 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2470 inline long atomic_fetch_sub_explicit
2471 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2472 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2474 inline long atomic_fetch_sub
2475 ( volatile atomic_long* __a__, long __m__ )
2476 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2479 inline long atomic_fetch_and_explicit
2480 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2481 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2483 inline long atomic_fetch_and
2484 ( volatile atomic_long* __a__, long __m__ )
2485 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2488 inline long atomic_fetch_or_explicit
2489 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2490 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2492 inline long atomic_fetch_or
2493 ( volatile atomic_long* __a__, long __m__ )
2494 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2497 inline long atomic_fetch_xor_explicit
2498 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2499 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2501 inline long atomic_fetch_xor
2502 ( volatile atomic_long* __a__, long __m__ )
2503 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2506 inline unsigned long atomic_fetch_add_explicit
2507 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2508 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2510 inline unsigned long atomic_fetch_add
2511 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2512 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2515 inline unsigned long atomic_fetch_sub_explicit
2516 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2517 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2519 inline unsigned long atomic_fetch_sub
2520 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2521 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2524 inline unsigned long atomic_fetch_and_explicit
2525 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2526 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2528 inline unsigned long atomic_fetch_and
2529 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2530 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2533 inline unsigned long atomic_fetch_or_explicit
2534 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2535 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2537 inline unsigned long atomic_fetch_or
2538 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2539 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2542 inline unsigned long atomic_fetch_xor_explicit
2543 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2544 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2546 inline unsigned long atomic_fetch_xor
2547 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2548 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2551 inline long long atomic_fetch_add_explicit
2552 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2553 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2555 inline long long atomic_fetch_add
2556 ( volatile atomic_llong* __a__, long long __m__ )
2557 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2560 inline long long atomic_fetch_sub_explicit
2561 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2562 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2564 inline long long atomic_fetch_sub
2565 ( volatile atomic_llong* __a__, long long __m__ )
2566 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2569 inline long long atomic_fetch_and_explicit
2570 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2571 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2573 inline long long atomic_fetch_and
2574 ( volatile atomic_llong* __a__, long long __m__ )
2575 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2578 inline long long atomic_fetch_or_explicit
2579 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2580 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2582 inline long long atomic_fetch_or
2583 ( volatile atomic_llong* __a__, long long __m__ )
2584 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2587 inline long long atomic_fetch_xor_explicit
2588 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2589 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2591 inline long long atomic_fetch_xor
2592 ( volatile atomic_llong* __a__, long long __m__ )
2593 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2596 inline unsigned long long atomic_fetch_add_explicit
2597 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2598 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2600 inline unsigned long long atomic_fetch_add
2601 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2602 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2605 inline unsigned long long atomic_fetch_sub_explicit
2606 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2607 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2609 inline unsigned long long atomic_fetch_sub
2610 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2611 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2614 inline unsigned long long atomic_fetch_and_explicit
2615 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2616 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2618 inline unsigned long long atomic_fetch_and
2619 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2620 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2623 inline unsigned long long atomic_fetch_or_explicit
2624 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2625 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2627 inline unsigned long long atomic_fetch_or
2628 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2629 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2632 inline unsigned long long atomic_fetch_xor_explicit
2633 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2634 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2636 inline unsigned long long atomic_fetch_xor
2637 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2638 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2641 inline wchar_t atomic_fetch_add_explicit
2642 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2643 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2645 inline wchar_t atomic_fetch_add
2646 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2647 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2650 inline wchar_t atomic_fetch_sub_explicit
2651 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2652 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2654 inline wchar_t atomic_fetch_sub
2655 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2656 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2659 inline wchar_t atomic_fetch_and_explicit
2660 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2661 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2663 inline wchar_t atomic_fetch_and
2664 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2665 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2668 inline wchar_t atomic_fetch_or_explicit
2669 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2670 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2672 inline wchar_t atomic_fetch_or
2673 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2674 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2677 inline wchar_t atomic_fetch_xor_explicit
2678 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2679 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2681 inline wchar_t atomic_fetch_xor
2682 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2683 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2689 #define atomic_is_lock_free( __a__ ) \
2692 #define atomic_load( __a__ ) \
2693 _ATOMIC_LOAD_( __a__, memory_order_seq_cst )
2695 #define atomic_load_explicit( __a__, __x__ ) \
2696 _ATOMIC_LOAD_( __a__, __x__ )
2698 #define atomic_store( __a__, __m__ ) \
2699 _ATOMIC_STORE_( __a__, __m__, memory_order_seq_cst )
2701 #define atomic_store_explicit( __a__, __m__, __x__ ) \
2702 _ATOMIC_STORE_( __a__, __m__, __x__ )
2704 #define atomic_swap( __a__, __m__ ) \
2705 _ATOMIC_MODIFY_( __a__, =, __m__, memory_order_seq_cst )
2707 #define atomic_swap_explicit( __a__, __m__, __x__ ) \
2708 _ATOMIC_MODIFY_( __a__, =, __m__, __x__ )
2710 #define atomic_compare_swap( __a__, __e__, __m__ ) \
2711 _ATOMIC_CMPSWP_( __a__, __e__, __m__, memory_order_seq_cst )
2713 #define atomic_compare_swap_explicit( __a__, __e__, __m__, __x__, __y__ ) \
2714 _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ )
2716 #define atomic_fence( __a__, __x__ ) \
2717 ({ _ATOMIC_FENCE_( __a__, __x__ ); })
2720 #define atomic_fetch_add_explicit( __a__, __m__, __x__ ) \
2721 _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ )
2723 #define atomic_fetch_add( __a__, __m__ ) \
2724 _ATOMIC_MODIFY_( __a__, +=, __m__, memory_order_seq_cst )
2727 #define atomic_fetch_sub_explicit( __a__, __m__, __x__ ) \
2728 _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ )
2730 #define atomic_fetch_sub( __a__, __m__ ) \
2731 _ATOMIC_MODIFY_( __a__, -=, __m__, memory_order_seq_cst )
2734 #define atomic_fetch_and_explicit( __a__, __m__, __x__ ) \
2735 _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ )
2737 #define atomic_fetch_and( __a__, __m__ ) \
2738 _ATOMIC_MODIFY_( __a__, &=, __m__, memory_order_seq_cst )
2741 #define atomic_fetch_or_explicit( __a__, __m__, __x__ ) \
2742 _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ )
2744 #define atomic_fetch_or( __a__, __m__ ) \
2745 _ATOMIC_MODIFY_( __a__, |=, __m__, memory_order_seq_cst )
2748 #define atomic_fetch_xor_explicit( __a__, __m__, __x__ ) \
2749 _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ )
2751 #define atomic_fetch_xor( __a__, __m__ ) \
2752 _ATOMIC_MODIFY_( __a__, ^=, __m__, memory_order_seq_cst )
2761 inline bool atomic_bool::is_lock_free() const volatile
2764 inline void atomic_bool::store
2765 ( bool __m__, memory_order __x__ ) volatile
2766 { atomic_store_explicit( this, __m__, __x__ ); }
2768 inline bool atomic_bool::load
2769 ( memory_order __x__ ) volatile
2770 { return atomic_load_explicit( this, __x__ ); }
2772 inline bool atomic_bool::swap
2773 ( bool __m__, memory_order __x__ ) volatile
2774 { return atomic_swap_explicit( this, __m__, __x__ ); }
2776 inline bool atomic_bool::compare_swap
2777 ( bool& __e__, bool __m__,
2778 memory_order __x__, memory_order __y__ ) volatile
2779 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2781 inline bool atomic_bool::compare_swap
2782 ( bool& __e__, bool __m__, memory_order __x__ ) volatile
2783 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2784 __x__ == memory_order_acq_rel ? memory_order_acquire :
2785 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2787 inline void atomic_bool::fence
2788 ( memory_order __x__ ) const volatile
2789 { return atomic_fence( this, __x__ ); }
2792 inline bool atomic_address::is_lock_free() const volatile
2795 inline void atomic_address::store
2796 ( void* __m__, memory_order __x__ ) volatile
2797 { atomic_store_explicit( this, __m__, __x__ ); }
2799 inline void* atomic_address::load
2800 ( memory_order __x__ ) volatile
2801 { return atomic_load_explicit( this, __x__ ); }
2803 inline void* atomic_address::swap
2804 ( void* __m__, memory_order __x__ ) volatile
2805 { return atomic_swap_explicit( this, __m__, __x__ ); }
2807 inline bool atomic_address::compare_swap
2808 ( void*& __e__, void* __m__,
2809 memory_order __x__, memory_order __y__ ) volatile
2810 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2812 inline bool atomic_address::compare_swap
2813 ( void*& __e__, void* __m__, memory_order __x__ ) volatile
2814 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2815 __x__ == memory_order_acq_rel ? memory_order_acquire :
2816 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2818 inline void atomic_address::fence
2819 ( memory_order __x__ ) const volatile
2820 { return atomic_fence( this, __x__ ); }
2823 inline bool atomic_char::is_lock_free() const volatile
2826 inline void atomic_char::store
2827 ( char __m__, memory_order __x__ ) volatile
2828 { atomic_store_explicit( this, __m__, __x__ ); }
2830 inline char atomic_char::load
2831 ( memory_order __x__ ) volatile
2832 { return atomic_load_explicit( this, __x__ ); }
2834 inline char atomic_char::swap
2835 ( char __m__, memory_order __x__ ) volatile
2836 { return atomic_swap_explicit( this, __m__, __x__ ); }
2838 inline bool atomic_char::compare_swap
2839 ( char& __e__, char __m__,
2840 memory_order __x__, memory_order __y__ ) volatile
2841 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2843 inline bool atomic_char::compare_swap
2844 ( char& __e__, char __m__, memory_order __x__ ) volatile
2845 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2846 __x__ == memory_order_acq_rel ? memory_order_acquire :
2847 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2849 inline void atomic_char::fence
2850 ( memory_order __x__ ) const volatile
2851 { return atomic_fence( this, __x__ ); }
2854 inline bool atomic_schar::is_lock_free() const volatile
2857 inline void atomic_schar::store
2858 ( signed char __m__, memory_order __x__ ) volatile
2859 { atomic_store_explicit( this, __m__, __x__ ); }
2861 inline signed char atomic_schar::load
2862 ( memory_order __x__ ) volatile
2863 { return atomic_load_explicit( this, __x__ ); }
2865 inline signed char atomic_schar::swap
2866 ( signed char __m__, memory_order __x__ ) volatile
2867 { return atomic_swap_explicit( this, __m__, __x__ ); }
2869 inline bool atomic_schar::compare_swap
2870 ( signed char& __e__, signed char __m__,
2871 memory_order __x__, memory_order __y__ ) volatile
2872 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2874 inline bool atomic_schar::compare_swap
2875 ( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
2876 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2877 __x__ == memory_order_acq_rel ? memory_order_acquire :
2878 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2880 inline void atomic_schar::fence
2881 ( memory_order __x__ ) const volatile
2882 { return atomic_fence( this, __x__ ); }
2885 inline bool atomic_uchar::is_lock_free() const volatile
2888 inline void atomic_uchar::store
2889 ( unsigned char __m__, memory_order __x__ ) volatile
2890 { atomic_store_explicit( this, __m__, __x__ ); }
2892 inline unsigned char atomic_uchar::load
2893 ( memory_order __x__ ) volatile
2894 { return atomic_load_explicit( this, __x__ ); }
2896 inline unsigned char atomic_uchar::swap
2897 ( unsigned char __m__, memory_order __x__ ) volatile
2898 { return atomic_swap_explicit( this, __m__, __x__ ); }
2900 inline bool atomic_uchar::compare_swap
2901 ( unsigned char& __e__, unsigned char __m__,
2902 memory_order __x__, memory_order __y__ ) volatile
2903 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2905 inline bool atomic_uchar::compare_swap
2906 ( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
2907 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2908 __x__ == memory_order_acq_rel ? memory_order_acquire :
2909 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2911 inline void atomic_uchar::fence
2912 ( memory_order __x__ ) const volatile
2913 { return atomic_fence( this, __x__ ); }
2916 inline bool atomic_short::is_lock_free() const volatile
2919 inline void atomic_short::store
2920 ( short __m__, memory_order __x__ ) volatile
2921 { atomic_store_explicit( this, __m__, __x__ ); }
2923 inline short atomic_short::load
2924 ( memory_order __x__ ) volatile
2925 { return atomic_load_explicit( this, __x__ ); }
2927 inline short atomic_short::swap
2928 ( short __m__, memory_order __x__ ) volatile
2929 { return atomic_swap_explicit( this, __m__, __x__ ); }
2931 inline bool atomic_short::compare_swap
2932 ( short& __e__, short __m__,
2933 memory_order __x__, memory_order __y__ ) volatile
2934 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2936 inline bool atomic_short::compare_swap
2937 ( short& __e__, short __m__, memory_order __x__ ) volatile
2938 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2939 __x__ == memory_order_acq_rel ? memory_order_acquire :
2940 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2942 inline void atomic_short::fence
2943 ( memory_order __x__ ) const volatile
2944 { return atomic_fence( this, __x__ ); }
2947 inline bool atomic_ushort::is_lock_free() const volatile
2950 inline void atomic_ushort::store
2951 ( unsigned short __m__, memory_order __x__ ) volatile
2952 { atomic_store_explicit( this, __m__, __x__ ); }
2954 inline unsigned short atomic_ushort::load
2955 ( memory_order __x__ ) volatile
2956 { return atomic_load_explicit( this, __x__ ); }
2958 inline unsigned short atomic_ushort::swap
2959 ( unsigned short __m__, memory_order __x__ ) volatile
2960 { return atomic_swap_explicit( this, __m__, __x__ ); }
2962 inline bool atomic_ushort::compare_swap
2963 ( unsigned short& __e__, unsigned short __m__,
2964 memory_order __x__, memory_order __y__ ) volatile
2965 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2967 inline bool atomic_ushort::compare_swap
2968 ( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
2969 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2970 __x__ == memory_order_acq_rel ? memory_order_acquire :
2971 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2973 inline void atomic_ushort::fence
2974 ( memory_order __x__ ) const volatile
2975 { return atomic_fence( this, __x__ ); }
2978 inline bool atomic_int::is_lock_free() const volatile
2981 inline void atomic_int::store
2982 ( int __m__, memory_order __x__ ) volatile
2983 { atomic_store_explicit( this, __m__, __x__ ); }
2985 inline int atomic_int::load
2986 ( memory_order __x__ ) volatile
2987 { return atomic_load_explicit( this, __x__ ); }
2989 inline int atomic_int::swap
2990 ( int __m__, memory_order __x__ ) volatile
2991 { return atomic_swap_explicit( this, __m__, __x__ ); }
2993 inline bool atomic_int::compare_swap
2994 ( int& __e__, int __m__,
2995 memory_order __x__, memory_order __y__ ) volatile
2996 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2998 inline bool atomic_int::compare_swap
2999 ( int& __e__, int __m__, memory_order __x__ ) volatile
3000 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3001 __x__ == memory_order_acq_rel ? memory_order_acquire :
3002 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3004 inline void atomic_int::fence
3005 ( memory_order __x__ ) const volatile
3006 { return atomic_fence( this, __x__ ); }
3009 inline bool atomic_uint::is_lock_free() const volatile
3012 inline void atomic_uint::store
3013 ( unsigned int __m__, memory_order __x__ ) volatile
3014 { atomic_store_explicit( this, __m__, __x__ ); }
3016 inline unsigned int atomic_uint::load
3017 ( memory_order __x__ ) volatile
3018 { return atomic_load_explicit( this, __x__ ); }
3020 inline unsigned int atomic_uint::swap
3021 ( unsigned int __m__, memory_order __x__ ) volatile
3022 { return atomic_swap_explicit( this, __m__, __x__ ); }
3024 inline bool atomic_uint::compare_swap
3025 ( unsigned int& __e__, unsigned int __m__,
3026 memory_order __x__, memory_order __y__ ) volatile
3027 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3029 inline bool atomic_uint::compare_swap
3030 ( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
3031 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3032 __x__ == memory_order_acq_rel ? memory_order_acquire :
3033 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3035 inline void atomic_uint::fence
3036 ( memory_order __x__ ) const volatile
3037 { return atomic_fence( this, __x__ ); }
3040 inline bool atomic_long::is_lock_free() const volatile
3043 inline void atomic_long::store
3044 ( long __m__, memory_order __x__ ) volatile
3045 { atomic_store_explicit( this, __m__, __x__ ); }
3047 inline long atomic_long::load
3048 ( memory_order __x__ ) volatile
3049 { return atomic_load_explicit( this, __x__ ); }
3051 inline long atomic_long::swap
3052 ( long __m__, memory_order __x__ ) volatile
3053 { return atomic_swap_explicit( this, __m__, __x__ ); }
3055 inline bool atomic_long::compare_swap
3056 ( long& __e__, long __m__,
3057 memory_order __x__, memory_order __y__ ) volatile
3058 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3060 inline bool atomic_long::compare_swap
3061 ( long& __e__, long __m__, memory_order __x__ ) volatile
3062 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3063 __x__ == memory_order_acq_rel ? memory_order_acquire :
3064 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3066 inline void atomic_long::fence
3067 ( memory_order __x__ ) const volatile
3068 { return atomic_fence( this, __x__ ); }
3071 inline bool atomic_ulong::is_lock_free() const volatile
3074 inline void atomic_ulong::store
3075 ( unsigned long __m__, memory_order __x__ ) volatile
3076 { atomic_store_explicit( this, __m__, __x__ ); }
3078 inline unsigned long atomic_ulong::load
3079 ( memory_order __x__ ) volatile
3080 { return atomic_load_explicit( this, __x__ ); }
3082 inline unsigned long atomic_ulong::swap
3083 ( unsigned long __m__, memory_order __x__ ) volatile
3084 { return atomic_swap_explicit( this, __m__, __x__ ); }
3086 inline bool atomic_ulong::compare_swap
3087 ( unsigned long& __e__, unsigned long __m__,
3088 memory_order __x__, memory_order __y__ ) volatile
3089 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3091 inline bool atomic_ulong::compare_swap
3092 ( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
3093 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3094 __x__ == memory_order_acq_rel ? memory_order_acquire :
3095 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3097 inline void atomic_ulong::fence
3098 ( memory_order __x__ ) const volatile
3099 { return atomic_fence( this, __x__ ); }
3102 inline bool atomic_llong::is_lock_free() const volatile
3105 inline void atomic_llong::store
3106 ( long long __m__, memory_order __x__ ) volatile
3107 { atomic_store_explicit( this, __m__, __x__ ); }
3109 inline long long atomic_llong::load
3110 ( memory_order __x__ ) volatile
3111 { return atomic_load_explicit( this, __x__ ); }
3113 inline long long atomic_llong::swap
3114 ( long long __m__, memory_order __x__ ) volatile
3115 { return atomic_swap_explicit( this, __m__, __x__ ); }
3117 inline bool atomic_llong::compare_swap
3118 ( long long& __e__, long long __m__,
3119 memory_order __x__, memory_order __y__ ) volatile
3120 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3122 inline bool atomic_llong::compare_swap
3123 ( long long& __e__, long long __m__, memory_order __x__ ) volatile
3124 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3125 __x__ == memory_order_acq_rel ? memory_order_acquire :
3126 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3128 inline void atomic_llong::fence
3129 ( memory_order __x__ ) const volatile
3130 { return atomic_fence( this, __x__ ); }
3133 inline bool atomic_ullong::is_lock_free() const volatile
3136 inline void atomic_ullong::store
3137 ( unsigned long long __m__, memory_order __x__ ) volatile
3138 { atomic_store_explicit( this, __m__, __x__ ); }
3140 inline unsigned long long atomic_ullong::load
3141 ( memory_order __x__ ) volatile
3142 { return atomic_load_explicit( this, __x__ ); }
3144 inline unsigned long long atomic_ullong::swap
3145 ( unsigned long long __m__, memory_order __x__ ) volatile
3146 { return atomic_swap_explicit( this, __m__, __x__ ); }
3148 inline bool atomic_ullong::compare_swap
3149 ( unsigned long long& __e__, unsigned long long __m__,
3150 memory_order __x__, memory_order __y__ ) volatile
3151 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3153 inline bool atomic_ullong::compare_swap
3154 ( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
3155 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3156 __x__ == memory_order_acq_rel ? memory_order_acquire :
3157 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3159 inline void atomic_ullong::fence
3160 ( memory_order __x__ ) const volatile
3161 { return atomic_fence( this, __x__ ); }
3164 inline bool atomic_wchar_t::is_lock_free() const volatile
3167 inline void atomic_wchar_t::store
3168 ( wchar_t __m__, memory_order __x__ ) volatile
3169 { atomic_store_explicit( this, __m__, __x__ ); }
3171 inline wchar_t atomic_wchar_t::load
3172 ( memory_order __x__ ) volatile
3173 { return atomic_load_explicit( this, __x__ ); }
3175 inline wchar_t atomic_wchar_t::swap
3176 ( wchar_t __m__, memory_order __x__ ) volatile
3177 { return atomic_swap_explicit( this, __m__, __x__ ); }
3179 inline bool atomic_wchar_t::compare_swap
3180 ( wchar_t& __e__, wchar_t __m__,
3181 memory_order __x__, memory_order __y__ ) volatile
3182 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3184 inline bool atomic_wchar_t::compare_swap
3185 ( wchar_t& __e__, wchar_t __m__, memory_order __x__ ) volatile
3186 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3187 __x__ == memory_order_acq_rel ? memory_order_acquire :
3188 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3190 inline void atomic_wchar_t::fence
3191 ( memory_order __x__ ) const volatile
3192 { return atomic_fence( this, __x__ ); }
3195 template< typename T >
3196 inline bool atomic<T>::is_lock_free() const volatile
3199 template< typename T >
3200 inline void atomic<T>::store( T __v__, memory_order __x__ ) volatile
3201 { _ATOMIC_STORE_( this, __v__, __x__ ); }
3203 template< typename T >
3204 inline T atomic<T>::load( memory_order __x__ ) volatile
3205 { return _ATOMIC_LOAD_( this, __x__ ); }
3207 template< typename T >
3208 inline T atomic<T>::swap( T __v__, memory_order __x__ ) volatile
3209 { return _ATOMIC_MODIFY_( this, =, __v__, __x__ ); }
3211 template< typename T >
3212 inline bool atomic<T>::compare_swap
3213 ( T& __r__, T __v__, memory_order __x__, memory_order __y__ ) volatile
3214 { return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
3216 template< typename T >
3217 inline bool atomic<T>::compare_swap
3218 ( T& __r__, T __v__, memory_order __x__ ) volatile
3219 { return compare_swap( __r__, __v__, __x__,
3220 __x__ == memory_order_acq_rel ? memory_order_acquire :
3221 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3224 inline void* atomic_address::fetch_add
3225 ( ptrdiff_t __m__, memory_order __x__ ) volatile
3226 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3228 inline void* atomic_address::fetch_sub
3229 ( ptrdiff_t __m__, memory_order __x__ ) volatile
3230 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3233 inline char atomic_char::fetch_add
3234 ( char __m__, memory_order __x__ ) volatile
3235 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3238 inline char atomic_char::fetch_sub
3239 ( char __m__, memory_order __x__ ) volatile
3240 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3243 inline char atomic_char::fetch_and
3244 ( char __m__, memory_order __x__ ) volatile
3245 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3248 inline char atomic_char::fetch_or
3249 ( char __m__, memory_order __x__ ) volatile
3250 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3253 inline char atomic_char::fetch_xor
3254 ( char __m__, memory_order __x__ ) volatile
3255 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3258 inline signed char atomic_schar::fetch_add
3259 ( signed char __m__, memory_order __x__ ) volatile
3260 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3263 inline signed char atomic_schar::fetch_sub
3264 ( signed char __m__, memory_order __x__ ) volatile
3265 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3268 inline signed char atomic_schar::fetch_and
3269 ( signed char __m__, memory_order __x__ ) volatile
3270 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3273 inline signed char atomic_schar::fetch_or
3274 ( signed char __m__, memory_order __x__ ) volatile
3275 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3278 inline signed char atomic_schar::fetch_xor
3279 ( signed char __m__, memory_order __x__ ) volatile
3280 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3283 inline unsigned char atomic_uchar::fetch_add
3284 ( unsigned char __m__, memory_order __x__ ) volatile
3285 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3288 inline unsigned char atomic_uchar::fetch_sub
3289 ( unsigned char __m__, memory_order __x__ ) volatile
3290 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3293 inline unsigned char atomic_uchar::fetch_and
3294 ( unsigned char __m__, memory_order __x__ ) volatile
3295 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3298 inline unsigned char atomic_uchar::fetch_or
3299 ( unsigned char __m__, memory_order __x__ ) volatile
3300 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3303 inline unsigned char atomic_uchar::fetch_xor
3304 ( unsigned char __m__, memory_order __x__ ) volatile
3305 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3308 inline short atomic_short::fetch_add
3309 ( short __m__, memory_order __x__ ) volatile
3310 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3313 inline short atomic_short::fetch_sub
3314 ( short __m__, memory_order __x__ ) volatile
3315 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3318 inline short atomic_short::fetch_and
3319 ( short __m__, memory_order __x__ ) volatile
3320 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3323 inline short atomic_short::fetch_or
3324 ( short __m__, memory_order __x__ ) volatile
3325 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3328 inline short atomic_short::fetch_xor
3329 ( short __m__, memory_order __x__ ) volatile
3330 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3333 inline unsigned short atomic_ushort::fetch_add
3334 ( unsigned short __m__, memory_order __x__ ) volatile
3335 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3338 inline unsigned short atomic_ushort::fetch_sub
3339 ( unsigned short __m__, memory_order __x__ ) volatile
3340 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3343 inline unsigned short atomic_ushort::fetch_and
3344 ( unsigned short __m__, memory_order __x__ ) volatile
3345 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3348 inline unsigned short atomic_ushort::fetch_or
3349 ( unsigned short __m__, memory_order __x__ ) volatile
3350 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3353 inline unsigned short atomic_ushort::fetch_xor
3354 ( unsigned short __m__, memory_order __x__ ) volatile
3355 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3358 inline int atomic_int::fetch_add
3359 ( int __m__, memory_order __x__ ) volatile
3360 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3363 inline int atomic_int::fetch_sub
3364 ( int __m__, memory_order __x__ ) volatile
3365 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3368 inline int atomic_int::fetch_and
3369 ( int __m__, memory_order __x__ ) volatile
3370 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3373 inline int atomic_int::fetch_or
3374 ( int __m__, memory_order __x__ ) volatile
3375 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3378 inline int atomic_int::fetch_xor
3379 ( int __m__, memory_order __x__ ) volatile
3380 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3383 inline unsigned int atomic_uint::fetch_add
3384 ( unsigned int __m__, memory_order __x__ ) volatile
3385 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3388 inline unsigned int atomic_uint::fetch_sub
3389 ( unsigned int __m__, memory_order __x__ ) volatile
3390 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3393 inline unsigned int atomic_uint::fetch_and
3394 ( unsigned int __m__, memory_order __x__ ) volatile
3395 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3398 inline unsigned int atomic_uint::fetch_or
3399 ( unsigned int __m__, memory_order __x__ ) volatile
3400 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3403 inline unsigned int atomic_uint::fetch_xor
3404 ( unsigned int __m__, memory_order __x__ ) volatile
3405 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3408 inline long atomic_long::fetch_add
3409 ( long __m__, memory_order __x__ ) volatile
3410 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3413 inline long atomic_long::fetch_sub
3414 ( long __m__, memory_order __x__ ) volatile
3415 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3418 inline long atomic_long::fetch_and
3419 ( long __m__, memory_order __x__ ) volatile
3420 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3423 inline long atomic_long::fetch_or
3424 ( long __m__, memory_order __x__ ) volatile
3425 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3428 inline long atomic_long::fetch_xor
3429 ( long __m__, memory_order __x__ ) volatile
3430 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3433 inline unsigned long atomic_ulong::fetch_add
3434 ( unsigned long __m__, memory_order __x__ ) volatile
3435 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3438 inline unsigned long atomic_ulong::fetch_sub
3439 ( unsigned long __m__, memory_order __x__ ) volatile
3440 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3443 inline unsigned long atomic_ulong::fetch_and
3444 ( unsigned long __m__, memory_order __x__ ) volatile
3445 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3448 inline unsigned long atomic_ulong::fetch_or
3449 ( unsigned long __m__, memory_order __x__ ) volatile
3450 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3453 inline unsigned long atomic_ulong::fetch_xor
3454 ( unsigned long __m__, memory_order __x__ ) volatile
3455 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3458 inline long long atomic_llong::fetch_add
3459 ( long long __m__, memory_order __x__ ) volatile
3460 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3463 inline long long atomic_llong::fetch_sub
3464 ( long long __m__, memory_order __x__ ) volatile
3465 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3468 inline long long atomic_llong::fetch_and
3469 ( long long __m__, memory_order __x__ ) volatile
3470 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3473 inline long long atomic_llong::fetch_or
3474 ( long long __m__, memory_order __x__ ) volatile
3475 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3478 inline long long atomic_llong::fetch_xor
3479 ( long long __m__, memory_order __x__ ) volatile
3480 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3483 inline unsigned long long atomic_ullong::fetch_add
3484 ( unsigned long long __m__, memory_order __x__ ) volatile
3485 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3488 inline unsigned long long atomic_ullong::fetch_sub
3489 ( unsigned long long __m__, memory_order __x__ ) volatile
3490 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3493 inline unsigned long long atomic_ullong::fetch_and
3494 ( unsigned long long __m__, memory_order __x__ ) volatile
3495 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3498 inline unsigned long long atomic_ullong::fetch_or
3499 ( unsigned long long __m__, memory_order __x__ ) volatile
3500 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3503 inline unsigned long long atomic_ullong::fetch_xor
3504 ( unsigned long long __m__, memory_order __x__ ) volatile
3505 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3508 inline wchar_t atomic_wchar_t::fetch_add
3509 ( wchar_t __m__, memory_order __x__ ) volatile
3510 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3513 inline wchar_t atomic_wchar_t::fetch_sub
3514 ( wchar_t __m__, memory_order __x__ ) volatile
3515 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3518 inline wchar_t atomic_wchar_t::fetch_and
3519 ( wchar_t __m__, memory_order __x__ ) volatile
3520 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3523 inline wchar_t atomic_wchar_t::fetch_or
3524 ( wchar_t __m__, memory_order __x__ ) volatile
3525 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3528 inline wchar_t atomic_wchar_t::fetch_xor
3529 ( wchar_t __m__, memory_order __x__ ) volatile
3530 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3533 template< typename T >
3534 T* atomic<T*>::load( memory_order __x__ ) volatile
3535 { return static_cast<T*>( atomic_address::load( __x__ ) ); }
3537 template< typename T >
3538 T* atomic<T*>::swap( T* __v__, memory_order __x__ ) volatile
3539 { return static_cast<T*>( atomic_address::swap( __v__, __x__ ) ); }
3541 template< typename T >
3542 bool atomic<T*>::compare_swap
3543 ( T*& __r__, T* __v__, memory_order __x__, memory_order __y__) volatile
3544 { return atomic_address::compare_swap( *reinterpret_cast<void**>( &__r__ ),
3545 static_cast<void*>( __v__ ), __x__, __y__ ); }
3546 //{ return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
3548 template< typename T >
3549 bool atomic<T*>::compare_swap
3550 ( T*& __r__, T* __v__, memory_order __x__ ) volatile
3551 { return compare_swap( __r__, __v__, __x__,
3552 __x__ == memory_order_acq_rel ? memory_order_acquire :
3553 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3555 template< typename T >
3556 T* atomic<T*>::fetch_add( ptrdiff_t __v__, memory_order __x__ ) volatile
3557 { return atomic_fetch_add_explicit( this, sizeof(T) * __v__, __x__ ); }
3559 template< typename T >
3560 T* atomic<T*>::fetch_sub( ptrdiff_t __v__, memory_order __x__ ) volatile
3561 { return atomic_fetch_sub_explicit( this, sizeof(T) * __v__, __x__ ); }