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 );
61 inline bool atomic_flag::test_and_set( memory_order __x__ ) volatile
62 { return atomic_flag_test_and_set_explicit( this, __x__ ); }
64 inline void atomic_flag::clear( memory_order __x__ ) volatile
65 { atomic_flag_clear_explicit( this, __x__ ); }
67 inline void atomic_flag::fence( memory_order __x__ ) const volatile
68 { atomic_flag_fence( this, __x__ ); }
74 The remainder of the example implementation uses the following
75 macros. These macros exploit GNU extensions for value-returning
76 blocks (AKA statement expressions) and __typeof__.
78 The macros rely on data fields of atomic structs being named __f__.
79 Other symbols used are __a__=atomic, __e__=expected, __f__=field,
80 __g__=flag, __m__=modified, __o__=operation, __r__=result,
81 __p__=pointer to field, __v__=value (for single evaluation),
82 __x__=memory-ordering, and __y__=memory-ordering.
85 #define _ATOMIC_LOAD_( __a__, __x__ ) \
86 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
87 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
88 ((__typeof__((__a__)->__f__)) (thread_current()->get_return_value())); \
92 #define _ATOMIC_STORE_( __a__, __m__, __x__ ) \
93 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
94 __typeof__(__m__) __v__ = (__m__); \
95 model->switch_to_master(new ModelAction(ATOMIC_WRITE, __x__, __p__, __v__)); \
98 #define _ATOMIC_MODIFY_( __a__, __o__, __m__, __x__ ) \
99 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
100 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
101 __typeof__((__a__)->__f__) __old__=(__typeof__((__a__)->__f__)) thread_current()->get_return_value(); \
102 __typeof__(__m__) __v__ = (__m__); \
103 __typeof__((__a__)->__f__) __copy__= __old__; \
104 __copy__ __o__ __v__; \
105 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, __copy__)); \
108 #define _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ) \
109 ({ volatile __typeof__((__a__)->__f__)* __p__ = ((__a__)->__f__); \
110 __typeof__(__e__) __q__ = (__e__); \
111 __typeof__(__m__) __v__ = (__m__); \
113 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__)); \
114 __typeof__((__a__)->__f__) __t__=(__typeof__((__a__)->__f__)) thread_current()->get_return_value(); \
115 if (__t__ == * __q__ ) { \
116 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, __v__)); __r__ = true; } \
117 else { *__q__ = __t__; __r__ = false;} \
120 #define _ATOMIC_FENCE_( __a__, __x__ ) \
123 #define ATOMIC_CHAR_LOCK_FREE 1
124 #define ATOMIC_CHAR16_T_LOCK_FREE 1
125 #define ATOMIC_CHAR32_T_LOCK_FREE 1
126 #define ATOMIC_WCHAR_T_LOCK_FREE 1
127 #define ATOMIC_SHORT_LOCK_FREE 1
128 #define ATOMIC_INT_LOCK_FREE 1
129 #define ATOMIC_LONG_LOCK_FREE 1
130 #define ATOMIC_LLONG_LOCK_FREE 1
131 #define ATOMIC_ADDRESS_LOCK_FREE 1
133 typedef struct atomic_bool
136 bool is_lock_free() const volatile;
137 void store( bool, memory_order = memory_order_seq_cst ) volatile;
138 bool load( memory_order = memory_order_seq_cst ) volatile;
139 bool swap( bool, memory_order = memory_order_seq_cst ) volatile;
140 bool compare_swap ( bool&, bool, memory_order, memory_order ) volatile;
141 bool compare_swap ( bool&, bool,
142 memory_order = memory_order_seq_cst) volatile;
143 void fence( memory_order ) const volatile;
145 CPP0X( atomic_bool() = delete; )
146 CPP0X( constexpr explicit atomic_bool( bool __v__ ) : __f__( __v__ ) { } )
147 CPP0X( atomic_bool( const atomic_bool& ) = delete; )
148 atomic_bool& operator =( const atomic_bool& ) CPP0X(=delete);
150 bool operator =( bool __v__ ) volatile
151 { store( __v__ ); return __v__; }
153 friend void atomic_store_explicit( volatile atomic_bool*, bool,
155 friend bool atomic_load_explicit( volatile atomic_bool*, memory_order );
156 friend bool atomic_swap_explicit( volatile atomic_bool*, bool,
158 friend bool atomic_compare_swap_explicit( volatile atomic_bool*, bool*, bool,
159 memory_order, memory_order );
160 friend void atomic_fence( const volatile atomic_bool*, memory_order );
168 typedef struct atomic_address
171 bool is_lock_free() const volatile;
172 void store( void*, memory_order = memory_order_seq_cst ) volatile;
173 void* load( memory_order = memory_order_seq_cst ) volatile;
174 void* swap( void*, memory_order = memory_order_seq_cst ) volatile;
175 bool compare_swap( void*&, void*, memory_order, memory_order ) volatile;
176 bool compare_swap( void*&, void*,
177 memory_order = memory_order_seq_cst ) volatile;
178 void fence( memory_order ) const volatile;
179 void* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
180 void* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
182 CPP0X( atomic_address() = default; )
183 CPP0X( constexpr explicit atomic_address( void* __v__ ) : __f__( __v__) { } )
184 CPP0X( atomic_address( const atomic_address& ) = delete; )
185 atomic_address& operator =( const atomic_address & ) CPP0X(=delete);
187 void* operator =( void* __v__ ) volatile
188 { store( __v__ ); return __v__; }
190 void* operator +=( ptrdiff_t __v__ ) volatile
191 { return fetch_add( __v__ ); }
193 void* operator -=( ptrdiff_t __v__ ) volatile
194 { return fetch_sub( __v__ ); }
196 friend void atomic_store_explicit( volatile atomic_address*, void*,
198 friend void* atomic_load_explicit( volatile atomic_address*, memory_order );
199 friend void* atomic_swap_explicit( volatile atomic_address*, void*,
201 friend bool atomic_compare_swap_explicit( volatile atomic_address*,
202 void**, void*, memory_order, memory_order );
203 friend void atomic_fence( const volatile atomic_address*, memory_order );
204 friend void* atomic_fetch_add_explicit( volatile atomic_address*, ptrdiff_t,
206 friend void* atomic_fetch_sub_explicit( volatile atomic_address*, ptrdiff_t,
215 typedef struct atomic_char
218 bool is_lock_free() const volatile;
220 memory_order = memory_order_seq_cst ) volatile;
221 char load( memory_order = memory_order_seq_cst ) volatile;
223 memory_order = memory_order_seq_cst ) volatile;
224 bool compare_swap( char&, char,
225 memory_order, memory_order ) volatile;
226 bool compare_swap( char&, char,
227 memory_order = memory_order_seq_cst ) volatile;
228 void fence( memory_order ) const volatile;
229 char fetch_add( char,
230 memory_order = memory_order_seq_cst ) volatile;
231 char fetch_sub( char,
232 memory_order = memory_order_seq_cst ) volatile;
233 char fetch_and( char,
234 memory_order = memory_order_seq_cst ) volatile;
236 memory_order = memory_order_seq_cst ) volatile;
237 char fetch_xor( char,
238 memory_order = memory_order_seq_cst ) volatile;
240 CPP0X( atomic_char() = default; )
241 CPP0X( constexpr atomic_char( char __v__ ) : __f__( __v__) { } )
242 CPP0X( atomic_char( const atomic_char& ) = delete; )
243 atomic_char& operator =( const atomic_char& ) CPP0X(=delete);
245 char operator =( char __v__ ) volatile
246 { store( __v__ ); return __v__; }
248 char operator ++( int ) volatile
249 { return fetch_add( 1 ); }
251 char operator --( int ) volatile
252 { return fetch_sub( 1 ); }
254 char operator ++() volatile
255 { return fetch_add( 1 ) + 1; }
257 char operator --() volatile
258 { return fetch_sub( 1 ) - 1; }
260 char operator +=( char __v__ ) volatile
261 { return fetch_add( __v__ ) + __v__; }
263 char operator -=( char __v__ ) volatile
264 { return fetch_sub( __v__ ) - __v__; }
266 char operator &=( char __v__ ) volatile
267 { return fetch_and( __v__ ) & __v__; }
269 char operator |=( char __v__ ) volatile
270 { return fetch_or( __v__ ) | __v__; }
272 char operator ^=( char __v__ ) volatile
273 { return fetch_xor( __v__ ) ^ __v__; }
275 friend void atomic_store_explicit( volatile atomic_char*, char,
277 friend char atomic_load_explicit( volatile atomic_char*,
279 friend char atomic_swap_explicit( volatile atomic_char*,
280 char, memory_order );
281 friend bool atomic_compare_swap_explicit( volatile atomic_char*,
282 char*, char, memory_order, memory_order );
283 friend void atomic_fence( const volatile atomic_char*, memory_order );
284 friend char atomic_fetch_add_explicit( volatile atomic_char*,
285 char, memory_order );
286 friend char atomic_fetch_sub_explicit( volatile atomic_char*,
287 char, memory_order );
288 friend char atomic_fetch_and_explicit( volatile atomic_char*,
289 char, memory_order );
290 friend char atomic_fetch_or_explicit( volatile atomic_char*,
291 char, memory_order );
292 friend char atomic_fetch_xor_explicit( volatile atomic_char*,
293 char, memory_order );
301 typedef struct atomic_schar
304 bool is_lock_free() const volatile;
305 void store( signed char,
306 memory_order = memory_order_seq_cst ) volatile;
307 signed char load( memory_order = memory_order_seq_cst ) volatile;
308 signed char swap( signed char,
309 memory_order = memory_order_seq_cst ) volatile;
310 bool compare_swap( signed char&, signed char,
311 memory_order, memory_order ) volatile;
312 bool compare_swap( signed char&, signed char,
313 memory_order = memory_order_seq_cst ) volatile;
314 void fence( memory_order ) const volatile;
315 signed char fetch_add( signed char,
316 memory_order = memory_order_seq_cst ) volatile;
317 signed char fetch_sub( signed char,
318 memory_order = memory_order_seq_cst ) volatile;
319 signed char fetch_and( signed char,
320 memory_order = memory_order_seq_cst ) volatile;
321 signed char fetch_or( signed char,
322 memory_order = memory_order_seq_cst ) volatile;
323 signed char fetch_xor( signed char,
324 memory_order = memory_order_seq_cst ) volatile;
326 CPP0X( atomic_schar() = default; )
327 CPP0X( constexpr atomic_schar( signed char __v__ ) : __f__( __v__) { } )
328 CPP0X( atomic_schar( const atomic_schar& ) = delete; )
329 atomic_schar& operator =( const atomic_schar& ) CPP0X(=delete);
331 signed char operator =( signed char __v__ ) volatile
332 { store( __v__ ); return __v__; }
334 signed char operator ++( int ) volatile
335 { return fetch_add( 1 ); }
337 signed char operator --( int ) volatile
338 { return fetch_sub( 1 ); }
340 signed char operator ++() volatile
341 { return fetch_add( 1 ) + 1; }
343 signed char operator --() volatile
344 { return fetch_sub( 1 ) - 1; }
346 signed char operator +=( signed char __v__ ) volatile
347 { return fetch_add( __v__ ) + __v__; }
349 signed char operator -=( signed char __v__ ) volatile
350 { return fetch_sub( __v__ ) - __v__; }
352 signed char operator &=( signed char __v__ ) volatile
353 { return fetch_and( __v__ ) & __v__; }
355 signed char operator |=( signed char __v__ ) volatile
356 { return fetch_or( __v__ ) | __v__; }
358 signed char operator ^=( signed char __v__ ) volatile
359 { return fetch_xor( __v__ ) ^ __v__; }
361 friend void atomic_store_explicit( volatile atomic_schar*, signed char,
363 friend signed char atomic_load_explicit( volatile atomic_schar*,
365 friend signed char atomic_swap_explicit( volatile atomic_schar*,
366 signed char, memory_order );
367 friend bool atomic_compare_swap_explicit( volatile atomic_schar*,
368 signed char*, signed char, memory_order, memory_order );
369 friend void atomic_fence( const volatile atomic_schar*, memory_order );
370 friend signed char atomic_fetch_add_explicit( volatile atomic_schar*,
371 signed char, memory_order );
372 friend signed char atomic_fetch_sub_explicit( volatile atomic_schar*,
373 signed char, memory_order );
374 friend signed char atomic_fetch_and_explicit( volatile atomic_schar*,
375 signed char, memory_order );
376 friend signed char atomic_fetch_or_explicit( volatile atomic_schar*,
377 signed char, memory_order );
378 friend signed char atomic_fetch_xor_explicit( volatile atomic_schar*,
379 signed char, memory_order );
387 typedef struct atomic_uchar
390 bool is_lock_free() const volatile;
391 void store( unsigned char,
392 memory_order = memory_order_seq_cst ) volatile;
393 unsigned char load( memory_order = memory_order_seq_cst ) volatile;
394 unsigned char swap( unsigned char,
395 memory_order = memory_order_seq_cst ) volatile;
396 bool compare_swap( unsigned char&, unsigned char,
397 memory_order, memory_order ) volatile;
398 bool compare_swap( unsigned char&, unsigned char,
399 memory_order = memory_order_seq_cst ) volatile;
400 void fence( memory_order ) const volatile;
401 unsigned char fetch_add( unsigned char,
402 memory_order = memory_order_seq_cst ) volatile;
403 unsigned char fetch_sub( unsigned char,
404 memory_order = memory_order_seq_cst ) volatile;
405 unsigned char fetch_and( unsigned char,
406 memory_order = memory_order_seq_cst ) volatile;
407 unsigned char fetch_or( unsigned char,
408 memory_order = memory_order_seq_cst ) volatile;
409 unsigned char fetch_xor( unsigned char,
410 memory_order = memory_order_seq_cst ) volatile;
412 CPP0X( atomic_uchar() = default; )
413 CPP0X( constexpr atomic_uchar( unsigned char __v__ ) : __f__( __v__) { } )
414 CPP0X( atomic_uchar( const atomic_uchar& ) = delete; )
415 atomic_uchar& operator =( const atomic_uchar& ) CPP0X(=delete);
417 unsigned char operator =( unsigned char __v__ ) volatile
418 { store( __v__ ); return __v__; }
420 unsigned char operator ++( int ) volatile
421 { return fetch_add( 1 ); }
423 unsigned char operator --( int ) volatile
424 { return fetch_sub( 1 ); }
426 unsigned char operator ++() volatile
427 { return fetch_add( 1 ) + 1; }
429 unsigned char operator --() volatile
430 { return fetch_sub( 1 ) - 1; }
432 unsigned char operator +=( unsigned char __v__ ) volatile
433 { return fetch_add( __v__ ) + __v__; }
435 unsigned char operator -=( unsigned char __v__ ) volatile
436 { return fetch_sub( __v__ ) - __v__; }
438 unsigned char operator &=( unsigned char __v__ ) volatile
439 { return fetch_and( __v__ ) & __v__; }
441 unsigned char operator |=( unsigned char __v__ ) volatile
442 { return fetch_or( __v__ ) | __v__; }
444 unsigned char operator ^=( unsigned char __v__ ) volatile
445 { return fetch_xor( __v__ ) ^ __v__; }
447 friend void atomic_store_explicit( volatile atomic_uchar*, unsigned char,
449 friend unsigned char atomic_load_explicit( volatile atomic_uchar*,
451 friend unsigned char atomic_swap_explicit( volatile atomic_uchar*,
452 unsigned char, memory_order );
453 friend bool atomic_compare_swap_explicit( volatile atomic_uchar*,
454 unsigned char*, unsigned char, memory_order, memory_order );
455 friend void atomic_fence( const volatile atomic_uchar*, memory_order );
456 friend unsigned char atomic_fetch_add_explicit( volatile atomic_uchar*,
457 unsigned char, memory_order );
458 friend unsigned char atomic_fetch_sub_explicit( volatile atomic_uchar*,
459 unsigned char, memory_order );
460 friend unsigned char atomic_fetch_and_explicit( volatile atomic_uchar*,
461 unsigned char, memory_order );
462 friend unsigned char atomic_fetch_or_explicit( volatile atomic_uchar*,
463 unsigned char, memory_order );
464 friend unsigned char atomic_fetch_xor_explicit( volatile atomic_uchar*,
465 unsigned char, memory_order );
473 typedef struct atomic_short
476 bool is_lock_free() const volatile;
478 memory_order = memory_order_seq_cst ) volatile;
479 short load( memory_order = memory_order_seq_cst ) volatile;
481 memory_order = memory_order_seq_cst ) volatile;
482 bool compare_swap( short&, short,
483 memory_order, memory_order ) volatile;
484 bool compare_swap( short&, short,
485 memory_order = memory_order_seq_cst ) volatile;
486 void fence( memory_order ) const volatile;
487 short fetch_add( short,
488 memory_order = memory_order_seq_cst ) volatile;
489 short fetch_sub( short,
490 memory_order = memory_order_seq_cst ) volatile;
491 short fetch_and( short,
492 memory_order = memory_order_seq_cst ) volatile;
493 short fetch_or( short,
494 memory_order = memory_order_seq_cst ) volatile;
495 short fetch_xor( short,
496 memory_order = memory_order_seq_cst ) volatile;
498 CPP0X( atomic_short() = default; )
499 CPP0X( constexpr atomic_short( short __v__ ) : __f__( __v__) { } )
500 CPP0X( atomic_short( const atomic_short& ) = delete; )
501 atomic_short& operator =( const atomic_short& ) CPP0X(=delete);
503 short operator =( short __v__ ) volatile
504 { store( __v__ ); return __v__; }
506 short operator ++( int ) volatile
507 { return fetch_add( 1 ); }
509 short operator --( int ) volatile
510 { return fetch_sub( 1 ); }
512 short operator ++() volatile
513 { return fetch_add( 1 ) + 1; }
515 short operator --() volatile
516 { return fetch_sub( 1 ) - 1; }
518 short operator +=( short __v__ ) volatile
519 { return fetch_add( __v__ ) + __v__; }
521 short operator -=( short __v__ ) volatile
522 { return fetch_sub( __v__ ) - __v__; }
524 short operator &=( short __v__ ) volatile
525 { return fetch_and( __v__ ) & __v__; }
527 short operator |=( short __v__ ) volatile
528 { return fetch_or( __v__ ) | __v__; }
530 short operator ^=( short __v__ ) volatile
531 { return fetch_xor( __v__ ) ^ __v__; }
533 friend void atomic_store_explicit( volatile atomic_short*, short,
535 friend short atomic_load_explicit( volatile atomic_short*,
537 friend short atomic_swap_explicit( volatile atomic_short*,
538 short, memory_order );
539 friend bool atomic_compare_swap_explicit( volatile atomic_short*,
540 short*, short, memory_order, memory_order );
541 friend void atomic_fence( const volatile atomic_short*, memory_order );
542 friend short atomic_fetch_add_explicit( volatile atomic_short*,
543 short, memory_order );
544 friend short atomic_fetch_sub_explicit( volatile atomic_short*,
545 short, memory_order );
546 friend short atomic_fetch_and_explicit( volatile atomic_short*,
547 short, memory_order );
548 friend short atomic_fetch_or_explicit( volatile atomic_short*,
549 short, memory_order );
550 friend short atomic_fetch_xor_explicit( volatile atomic_short*,
551 short, memory_order );
559 typedef struct atomic_ushort
562 bool is_lock_free() const volatile;
563 void store( unsigned short,
564 memory_order = memory_order_seq_cst ) volatile;
565 unsigned short load( memory_order = memory_order_seq_cst ) volatile;
566 unsigned short swap( unsigned short,
567 memory_order = memory_order_seq_cst ) volatile;
568 bool compare_swap( unsigned short&, unsigned short,
569 memory_order, memory_order ) volatile;
570 bool compare_swap( unsigned short&, unsigned short,
571 memory_order = memory_order_seq_cst ) volatile;
572 void fence( memory_order ) const volatile;
573 unsigned short fetch_add( unsigned short,
574 memory_order = memory_order_seq_cst ) volatile;
575 unsigned short fetch_sub( unsigned short,
576 memory_order = memory_order_seq_cst ) volatile;
577 unsigned short fetch_and( unsigned short,
578 memory_order = memory_order_seq_cst ) volatile;
579 unsigned short fetch_or( unsigned short,
580 memory_order = memory_order_seq_cst ) volatile;
581 unsigned short fetch_xor( unsigned short,
582 memory_order = memory_order_seq_cst ) volatile;
584 CPP0X( atomic_ushort() = default; )
585 CPP0X( constexpr atomic_ushort( unsigned short __v__ ) : __f__( __v__) { } )
586 CPP0X( atomic_ushort( const atomic_ushort& ) = delete; )
587 atomic_ushort& operator =( const atomic_ushort& ) CPP0X(=delete);
589 unsigned short operator =( unsigned short __v__ ) volatile
590 { store( __v__ ); return __v__; }
592 unsigned short operator ++( int ) volatile
593 { return fetch_add( 1 ); }
595 unsigned short operator --( int ) volatile
596 { return fetch_sub( 1 ); }
598 unsigned short operator ++() volatile
599 { return fetch_add( 1 ) + 1; }
601 unsigned short operator --() volatile
602 { return fetch_sub( 1 ) - 1; }
604 unsigned short operator +=( unsigned short __v__ ) volatile
605 { return fetch_add( __v__ ) + __v__; }
607 unsigned short operator -=( unsigned short __v__ ) volatile
608 { return fetch_sub( __v__ ) - __v__; }
610 unsigned short operator &=( unsigned short __v__ ) volatile
611 { return fetch_and( __v__ ) & __v__; }
613 unsigned short operator |=( unsigned short __v__ ) volatile
614 { return fetch_or( __v__ ) | __v__; }
616 unsigned short operator ^=( unsigned short __v__ ) volatile
617 { return fetch_xor( __v__ ) ^ __v__; }
619 friend void atomic_store_explicit( volatile atomic_ushort*, unsigned short,
621 friend unsigned short atomic_load_explicit( volatile atomic_ushort*,
623 friend unsigned short atomic_swap_explicit( volatile atomic_ushort*,
624 unsigned short, memory_order );
625 friend bool atomic_compare_swap_explicit( volatile atomic_ushort*,
626 unsigned short*, unsigned short, memory_order, memory_order );
627 friend void atomic_fence( const volatile atomic_ushort*, memory_order );
628 friend unsigned short atomic_fetch_add_explicit( volatile atomic_ushort*,
629 unsigned short, memory_order );
630 friend unsigned short atomic_fetch_sub_explicit( volatile atomic_ushort*,
631 unsigned short, memory_order );
632 friend unsigned short atomic_fetch_and_explicit( volatile atomic_ushort*,
633 unsigned short, memory_order );
634 friend unsigned short atomic_fetch_or_explicit( volatile atomic_ushort*,
635 unsigned short, memory_order );
636 friend unsigned short atomic_fetch_xor_explicit( volatile atomic_ushort*,
637 unsigned short, memory_order );
641 unsigned short __f__;
645 typedef struct atomic_int
648 bool is_lock_free() const volatile;
650 memory_order = memory_order_seq_cst ) volatile;
651 int load( memory_order = memory_order_seq_cst ) volatile;
653 memory_order = memory_order_seq_cst ) volatile;
654 bool compare_swap( int&, int,
655 memory_order, memory_order ) volatile;
656 bool compare_swap( int&, int,
657 memory_order = memory_order_seq_cst ) volatile;
658 void fence( memory_order ) const 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 memory_order = memory_order_seq_cst ) volatile;
668 memory_order = memory_order_seq_cst ) volatile;
670 CPP0X( atomic_int() = default; )
671 CPP0X( constexpr atomic_int( int __v__ ) : __f__( __v__) { } )
672 CPP0X( atomic_int( const atomic_int& ) = delete; )
673 atomic_int& operator =( const atomic_int& ) CPP0X(=delete);
675 int operator =( int __v__ ) volatile
676 { store( __v__ ); return __v__; }
678 int operator ++( int ) volatile
679 { return fetch_add( 1 ); }
681 int operator --( int ) volatile
682 { return fetch_sub( 1 ); }
684 int operator ++() volatile
685 { return fetch_add( 1 ) + 1; }
687 int operator --() volatile
688 { return fetch_sub( 1 ) - 1; }
690 int operator +=( int __v__ ) volatile
691 { return fetch_add( __v__ ) + __v__; }
693 int operator -=( int __v__ ) volatile
694 { return fetch_sub( __v__ ) - __v__; }
696 int operator &=( int __v__ ) volatile
697 { return fetch_and( __v__ ) & __v__; }
699 int operator |=( int __v__ ) volatile
700 { return fetch_or( __v__ ) | __v__; }
702 int operator ^=( int __v__ ) volatile
703 { return fetch_xor( __v__ ) ^ __v__; }
705 friend void atomic_store_explicit( volatile atomic_int*, int,
707 friend int atomic_load_explicit( volatile atomic_int*,
709 friend int atomic_swap_explicit( volatile atomic_int*,
711 friend bool atomic_compare_swap_explicit( volatile atomic_int*,
712 int*, int, memory_order, memory_order );
713 friend void atomic_fence( const volatile atomic_int*, memory_order );
714 friend int atomic_fetch_add_explicit( volatile atomic_int*,
716 friend int atomic_fetch_sub_explicit( volatile atomic_int*,
718 friend int atomic_fetch_and_explicit( volatile atomic_int*,
720 friend int atomic_fetch_or_explicit( volatile atomic_int*,
722 friend int atomic_fetch_xor_explicit( volatile atomic_int*,
731 typedef struct atomic_uint
734 bool is_lock_free() const volatile;
735 void store( unsigned int,
736 memory_order = memory_order_seq_cst ) volatile;
737 unsigned int load( memory_order = memory_order_seq_cst ) volatile;
738 unsigned int swap( unsigned int,
739 memory_order = memory_order_seq_cst ) volatile;
740 bool compare_swap( unsigned int&, unsigned int,
741 memory_order, memory_order ) volatile;
742 bool compare_swap( unsigned int&, unsigned int,
743 memory_order = memory_order_seq_cst ) volatile;
744 void fence( memory_order ) const volatile;
745 unsigned int fetch_add( unsigned int,
746 memory_order = memory_order_seq_cst ) volatile;
747 unsigned int fetch_sub( unsigned int,
748 memory_order = memory_order_seq_cst ) volatile;
749 unsigned int fetch_and( unsigned int,
750 memory_order = memory_order_seq_cst ) volatile;
751 unsigned int fetch_or( unsigned int,
752 memory_order = memory_order_seq_cst ) volatile;
753 unsigned int fetch_xor( unsigned int,
754 memory_order = memory_order_seq_cst ) volatile;
756 CPP0X( atomic_uint() = default; )
757 CPP0X( constexpr atomic_uint( unsigned int __v__ ) : __f__( __v__) { } )
758 CPP0X( atomic_uint( const atomic_uint& ) = delete; )
759 atomic_uint& operator =( const atomic_uint& ) CPP0X(=delete);
761 unsigned int operator =( unsigned int __v__ ) volatile
762 { store( __v__ ); return __v__; }
764 unsigned int operator ++( int ) volatile
765 { return fetch_add( 1 ); }
767 unsigned int operator --( int ) volatile
768 { return fetch_sub( 1 ); }
770 unsigned int operator ++() volatile
771 { return fetch_add( 1 ) + 1; }
773 unsigned int operator --() volatile
774 { return fetch_sub( 1 ) - 1; }
776 unsigned int operator +=( unsigned int __v__ ) volatile
777 { return fetch_add( __v__ ) + __v__; }
779 unsigned int operator -=( unsigned int __v__ ) volatile
780 { return fetch_sub( __v__ ) - __v__; }
782 unsigned int operator &=( unsigned int __v__ ) volatile
783 { return fetch_and( __v__ ) & __v__; }
785 unsigned int operator |=( unsigned int __v__ ) volatile
786 { return fetch_or( __v__ ) | __v__; }
788 unsigned int operator ^=( unsigned int __v__ ) volatile
789 { return fetch_xor( __v__ ) ^ __v__; }
791 friend void atomic_store_explicit( volatile atomic_uint*, unsigned int,
793 friend unsigned int atomic_load_explicit( volatile atomic_uint*,
795 friend unsigned int atomic_swap_explicit( volatile atomic_uint*,
796 unsigned int, memory_order );
797 friend bool atomic_compare_swap_explicit( volatile atomic_uint*,
798 unsigned int*, unsigned int, memory_order, memory_order );
799 friend void atomic_fence( const volatile atomic_uint*, memory_order );
800 friend unsigned int atomic_fetch_add_explicit( volatile atomic_uint*,
801 unsigned int, memory_order );
802 friend unsigned int atomic_fetch_sub_explicit( volatile atomic_uint*,
803 unsigned int, memory_order );
804 friend unsigned int atomic_fetch_and_explicit( volatile atomic_uint*,
805 unsigned int, memory_order );
806 friend unsigned int atomic_fetch_or_explicit( volatile atomic_uint*,
807 unsigned int, memory_order );
808 friend unsigned int atomic_fetch_xor_explicit( volatile atomic_uint*,
809 unsigned int, memory_order );
817 typedef struct atomic_long
820 bool is_lock_free() const volatile;
822 memory_order = memory_order_seq_cst ) volatile;
823 long load( memory_order = memory_order_seq_cst ) volatile;
825 memory_order = memory_order_seq_cst ) volatile;
826 bool compare_swap( long&, long,
827 memory_order, memory_order ) volatile;
828 bool compare_swap( long&, long,
829 memory_order = memory_order_seq_cst ) volatile;
830 void fence( memory_order ) const volatile;
831 long fetch_add( long,
832 memory_order = memory_order_seq_cst ) volatile;
833 long fetch_sub( long,
834 memory_order = memory_order_seq_cst ) volatile;
835 long fetch_and( long,
836 memory_order = memory_order_seq_cst ) volatile;
838 memory_order = memory_order_seq_cst ) volatile;
839 long fetch_xor( long,
840 memory_order = memory_order_seq_cst ) volatile;
842 CPP0X( atomic_long() = default; )
843 CPP0X( constexpr atomic_long( long __v__ ) : __f__( __v__) { } )
844 CPP0X( atomic_long( const atomic_long& ) = delete; )
845 atomic_long& operator =( const atomic_long& ) CPP0X(=delete);
847 long operator =( long __v__ ) volatile
848 { store( __v__ ); return __v__; }
850 long operator ++( int ) volatile
851 { return fetch_add( 1 ); }
853 long operator --( int ) volatile
854 { return fetch_sub( 1 ); }
856 long operator ++() volatile
857 { return fetch_add( 1 ) + 1; }
859 long operator --() volatile
860 { return fetch_sub( 1 ) - 1; }
862 long operator +=( long __v__ ) volatile
863 { return fetch_add( __v__ ) + __v__; }
865 long operator -=( long __v__ ) volatile
866 { return fetch_sub( __v__ ) - __v__; }
868 long operator &=( long __v__ ) volatile
869 { return fetch_and( __v__ ) & __v__; }
871 long operator |=( long __v__ ) volatile
872 { return fetch_or( __v__ ) | __v__; }
874 long operator ^=( long __v__ ) volatile
875 { return fetch_xor( __v__ ) ^ __v__; }
877 friend void atomic_store_explicit( volatile atomic_long*, long,
879 friend long atomic_load_explicit( volatile atomic_long*,
881 friend long atomic_swap_explicit( volatile atomic_long*,
882 long, memory_order );
883 friend bool atomic_compare_swap_explicit( volatile atomic_long*,
884 long*, long, memory_order, memory_order );
885 friend void atomic_fence( const volatile atomic_long*, memory_order );
886 friend long atomic_fetch_add_explicit( volatile atomic_long*,
887 long, memory_order );
888 friend long atomic_fetch_sub_explicit( volatile atomic_long*,
889 long, memory_order );
890 friend long atomic_fetch_and_explicit( volatile atomic_long*,
891 long, memory_order );
892 friend long atomic_fetch_or_explicit( volatile atomic_long*,
893 long, memory_order );
894 friend long atomic_fetch_xor_explicit( volatile atomic_long*,
895 long, memory_order );
903 typedef struct atomic_ulong
906 bool is_lock_free() const volatile;
907 void store( unsigned long,
908 memory_order = memory_order_seq_cst ) volatile;
909 unsigned long load( memory_order = memory_order_seq_cst ) volatile;
910 unsigned long swap( unsigned long,
911 memory_order = memory_order_seq_cst ) volatile;
912 bool compare_swap( unsigned long&, unsigned long,
913 memory_order, memory_order ) volatile;
914 bool compare_swap( unsigned long&, unsigned long,
915 memory_order = memory_order_seq_cst ) volatile;
916 void fence( memory_order ) const volatile;
917 unsigned long fetch_add( unsigned long,
918 memory_order = memory_order_seq_cst ) volatile;
919 unsigned long fetch_sub( unsigned long,
920 memory_order = memory_order_seq_cst ) volatile;
921 unsigned long fetch_and( unsigned long,
922 memory_order = memory_order_seq_cst ) volatile;
923 unsigned long fetch_or( unsigned long,
924 memory_order = memory_order_seq_cst ) volatile;
925 unsigned long fetch_xor( unsigned long,
926 memory_order = memory_order_seq_cst ) volatile;
928 CPP0X( atomic_ulong() = default; )
929 CPP0X( constexpr atomic_ulong( unsigned long __v__ ) : __f__( __v__) { } )
930 CPP0X( atomic_ulong( const atomic_ulong& ) = delete; )
931 atomic_ulong& operator =( const atomic_ulong& ) CPP0X(=delete);
933 unsigned long operator =( unsigned long __v__ ) volatile
934 { store( __v__ ); return __v__; }
936 unsigned long operator ++( int ) volatile
937 { return fetch_add( 1 ); }
939 unsigned long operator --( int ) volatile
940 { return fetch_sub( 1 ); }
942 unsigned long operator ++() volatile
943 { return fetch_add( 1 ) + 1; }
945 unsigned long operator --() volatile
946 { return fetch_sub( 1 ) - 1; }
948 unsigned long operator +=( unsigned long __v__ ) volatile
949 { return fetch_add( __v__ ) + __v__; }
951 unsigned long operator -=( unsigned long __v__ ) volatile
952 { return fetch_sub( __v__ ) - __v__; }
954 unsigned long operator &=( unsigned long __v__ ) volatile
955 { return fetch_and( __v__ ) & __v__; }
957 unsigned long operator |=( unsigned long __v__ ) volatile
958 { return fetch_or( __v__ ) | __v__; }
960 unsigned long operator ^=( unsigned long __v__ ) volatile
961 { return fetch_xor( __v__ ) ^ __v__; }
963 friend void atomic_store_explicit( volatile atomic_ulong*, unsigned long,
965 friend unsigned long atomic_load_explicit( volatile atomic_ulong*,
967 friend unsigned long atomic_swap_explicit( volatile atomic_ulong*,
968 unsigned long, memory_order );
969 friend bool atomic_compare_swap_explicit( volatile atomic_ulong*,
970 unsigned long*, unsigned long, memory_order, memory_order );
971 friend void atomic_fence( const volatile atomic_ulong*, memory_order );
972 friend unsigned long atomic_fetch_add_explicit( volatile atomic_ulong*,
973 unsigned long, memory_order );
974 friend unsigned long atomic_fetch_sub_explicit( volatile atomic_ulong*,
975 unsigned long, memory_order );
976 friend unsigned long atomic_fetch_and_explicit( volatile atomic_ulong*,
977 unsigned long, memory_order );
978 friend unsigned long atomic_fetch_or_explicit( volatile atomic_ulong*,
979 unsigned long, memory_order );
980 friend unsigned long atomic_fetch_xor_explicit( volatile atomic_ulong*,
981 unsigned long, memory_order );
989 typedef struct atomic_llong
992 bool is_lock_free() const volatile;
993 void store( long long,
994 memory_order = memory_order_seq_cst ) volatile;
995 long long load( memory_order = memory_order_seq_cst ) volatile;
996 long long swap( long long,
997 memory_order = memory_order_seq_cst ) volatile;
998 bool compare_swap( long long&, long long,
999 memory_order, memory_order ) volatile;
1000 bool compare_swap( long long&, long long,
1001 memory_order = memory_order_seq_cst ) volatile;
1002 void fence( memory_order ) const volatile;
1003 long long fetch_add( long long,
1004 memory_order = memory_order_seq_cst ) volatile;
1005 long long fetch_sub( long long,
1006 memory_order = memory_order_seq_cst ) volatile;
1007 long long fetch_and( long long,
1008 memory_order = memory_order_seq_cst ) volatile;
1009 long long fetch_or( long long,
1010 memory_order = memory_order_seq_cst ) volatile;
1011 long long fetch_xor( long long,
1012 memory_order = memory_order_seq_cst ) volatile;
1014 CPP0X( atomic_llong() = default; )
1015 CPP0X( constexpr atomic_llong( long long __v__ ) : __f__( __v__) { } )
1016 CPP0X( atomic_llong( const atomic_llong& ) = delete; )
1017 atomic_llong& operator =( const atomic_llong& ) CPP0X(=delete);
1019 long long operator =( long long __v__ ) volatile
1020 { store( __v__ ); return __v__; }
1022 long long operator ++( int ) volatile
1023 { return fetch_add( 1 ); }
1025 long long operator --( int ) volatile
1026 { return fetch_sub( 1 ); }
1028 long long operator ++() volatile
1029 { return fetch_add( 1 ) + 1; }
1031 long long operator --() volatile
1032 { return fetch_sub( 1 ) - 1; }
1034 long long operator +=( long long __v__ ) volatile
1035 { return fetch_add( __v__ ) + __v__; }
1037 long long operator -=( long long __v__ ) volatile
1038 { return fetch_sub( __v__ ) - __v__; }
1040 long long operator &=( long long __v__ ) volatile
1041 { return fetch_and( __v__ ) & __v__; }
1043 long long operator |=( long long __v__ ) volatile
1044 { return fetch_or( __v__ ) | __v__; }
1046 long long operator ^=( long long __v__ ) volatile
1047 { return fetch_xor( __v__ ) ^ __v__; }
1049 friend void atomic_store_explicit( volatile atomic_llong*, long long,
1051 friend long long atomic_load_explicit( volatile atomic_llong*,
1053 friend long long atomic_swap_explicit( volatile atomic_llong*,
1054 long long, memory_order );
1055 friend bool atomic_compare_swap_explicit( volatile atomic_llong*,
1056 long long*, long long, memory_order, memory_order );
1057 friend void atomic_fence( const volatile atomic_llong*, memory_order );
1058 friend long long atomic_fetch_add_explicit( volatile atomic_llong*,
1059 long long, memory_order );
1060 friend long long atomic_fetch_sub_explicit( volatile atomic_llong*,
1061 long long, memory_order );
1062 friend long long atomic_fetch_and_explicit( volatile atomic_llong*,
1063 long long, memory_order );
1064 friend long long atomic_fetch_or_explicit( volatile atomic_llong*,
1065 long long, memory_order );
1066 friend long long atomic_fetch_xor_explicit( volatile atomic_llong*,
1067 long long, memory_order );
1075 typedef struct atomic_ullong
1078 bool is_lock_free() const volatile;
1079 void store( unsigned long long,
1080 memory_order = memory_order_seq_cst ) volatile;
1081 unsigned long long load( memory_order = memory_order_seq_cst ) volatile;
1082 unsigned long long swap( unsigned long long,
1083 memory_order = memory_order_seq_cst ) volatile;
1084 bool compare_swap( unsigned long long&, unsigned long long,
1085 memory_order, memory_order ) volatile;
1086 bool compare_swap( unsigned long long&, unsigned long long,
1087 memory_order = memory_order_seq_cst ) volatile;
1088 void fence( memory_order ) const volatile;
1089 unsigned long long fetch_add( unsigned long long,
1090 memory_order = memory_order_seq_cst ) volatile;
1091 unsigned long long fetch_sub( unsigned long long,
1092 memory_order = memory_order_seq_cst ) volatile;
1093 unsigned long long fetch_and( unsigned long long,
1094 memory_order = memory_order_seq_cst ) volatile;
1095 unsigned long long fetch_or( unsigned long long,
1096 memory_order = memory_order_seq_cst ) volatile;
1097 unsigned long long fetch_xor( unsigned long long,
1098 memory_order = memory_order_seq_cst ) volatile;
1100 CPP0X( atomic_ullong() = default; )
1101 CPP0X( constexpr atomic_ullong( unsigned long long __v__ ) : __f__( __v__) { } )
1102 CPP0X( atomic_ullong( const atomic_ullong& ) = delete; )
1103 atomic_ullong& operator =( const atomic_ullong& ) CPP0X(=delete);
1105 unsigned long long operator =( unsigned long long __v__ ) volatile
1106 { store( __v__ ); return __v__; }
1108 unsigned long long operator ++( int ) volatile
1109 { return fetch_add( 1 ); }
1111 unsigned long long operator --( int ) volatile
1112 { return fetch_sub( 1 ); }
1114 unsigned long long operator ++() volatile
1115 { return fetch_add( 1 ) + 1; }
1117 unsigned long long operator --() volatile
1118 { return fetch_sub( 1 ) - 1; }
1120 unsigned long long operator +=( unsigned long long __v__ ) volatile
1121 { return fetch_add( __v__ ) + __v__; }
1123 unsigned long long operator -=( unsigned long long __v__ ) volatile
1124 { return fetch_sub( __v__ ) - __v__; }
1126 unsigned long long operator &=( unsigned long long __v__ ) volatile
1127 { return fetch_and( __v__ ) & __v__; }
1129 unsigned long long operator |=( unsigned long long __v__ ) volatile
1130 { return fetch_or( __v__ ) | __v__; }
1132 unsigned long long operator ^=( unsigned long long __v__ ) volatile
1133 { return fetch_xor( __v__ ) ^ __v__; }
1135 friend void atomic_store_explicit( volatile atomic_ullong*, unsigned long long,
1137 friend unsigned long long atomic_load_explicit( volatile atomic_ullong*,
1139 friend unsigned long long atomic_swap_explicit( volatile atomic_ullong*,
1140 unsigned long long, memory_order );
1141 friend bool atomic_compare_swap_explicit( volatile atomic_ullong*,
1142 unsigned long long*, unsigned long long, memory_order, memory_order );
1143 friend void atomic_fence( const volatile atomic_ullong*, memory_order );
1144 friend unsigned long long atomic_fetch_add_explicit( volatile atomic_ullong*,
1145 unsigned long long, memory_order );
1146 friend unsigned long long atomic_fetch_sub_explicit( volatile atomic_ullong*,
1147 unsigned long long, memory_order );
1148 friend unsigned long long atomic_fetch_and_explicit( volatile atomic_ullong*,
1149 unsigned long long, memory_order );
1150 friend unsigned long long atomic_fetch_or_explicit( volatile atomic_ullong*,
1151 unsigned long long, memory_order );
1152 friend unsigned long long atomic_fetch_xor_explicit( volatile atomic_ullong*,
1153 unsigned long long, memory_order );
1157 unsigned long long __f__;
1161 typedef atomic_schar atomic_int_least8_t;
1162 typedef atomic_uchar atomic_uint_least8_t;
1163 typedef atomic_short atomic_int_least16_t;
1164 typedef atomic_ushort atomic_uint_least16_t;
1165 typedef atomic_int atomic_int_least32_t;
1166 typedef atomic_uint atomic_uint_least32_t;
1167 typedef atomic_llong atomic_int_least64_t;
1168 typedef atomic_ullong atomic_uint_least64_t;
1170 typedef atomic_schar atomic_int_fast8_t;
1171 typedef atomic_uchar atomic_uint_fast8_t;
1172 typedef atomic_short atomic_int_fast16_t;
1173 typedef atomic_ushort atomic_uint_fast16_t;
1174 typedef atomic_int atomic_int_fast32_t;
1175 typedef atomic_uint atomic_uint_fast32_t;
1176 typedef atomic_llong atomic_int_fast64_t;
1177 typedef atomic_ullong atomic_uint_fast64_t;
1179 typedef atomic_long atomic_intptr_t;
1180 typedef atomic_ulong atomic_uintptr_t;
1182 typedef atomic_long atomic_ssize_t;
1183 typedef atomic_ulong atomic_size_t;
1185 typedef atomic_long atomic_ptrdiff_t;
1187 typedef atomic_llong atomic_intmax_t;
1188 typedef atomic_ullong atomic_uintmax_t;
1194 typedef struct atomic_wchar_t
1197 bool is_lock_free() const volatile;
1198 void store( wchar_t, memory_order = memory_order_seq_cst ) volatile;
1199 wchar_t load( memory_order = memory_order_seq_cst ) volatile;
1200 wchar_t swap( wchar_t,
1201 memory_order = memory_order_seq_cst ) volatile;
1202 bool compare_swap( wchar_t&, wchar_t,
1203 memory_order, memory_order ) volatile;
1204 bool compare_swap( wchar_t&, wchar_t,
1205 memory_order = memory_order_seq_cst ) volatile;
1206 void fence( memory_order ) const volatile;
1207 wchar_t fetch_add( wchar_t,
1208 memory_order = memory_order_seq_cst ) volatile;
1209 wchar_t fetch_sub( wchar_t,
1210 memory_order = memory_order_seq_cst ) volatile;
1211 wchar_t fetch_and( wchar_t,
1212 memory_order = memory_order_seq_cst ) volatile;
1213 wchar_t fetch_or( wchar_t,
1214 memory_order = memory_order_seq_cst ) volatile;
1215 wchar_t fetch_xor( wchar_t,
1216 memory_order = memory_order_seq_cst ) volatile;
1218 CPP0X( atomic_wchar_t() = default; )
1219 CPP0X( constexpr atomic_wchar_t( wchar_t __v__ ) : __f__( __v__) { } )
1220 CPP0X( atomic_wchar_t( const atomic_wchar_t& ) = delete; )
1221 atomic_wchar_t& operator =( const atomic_wchar_t& ) CPP0X(=delete);
1223 wchar_t operator =( wchar_t __v__ ) volatile
1224 { store( __v__ ); return __v__; }
1226 wchar_t operator ++( int ) volatile
1227 { return fetch_add( 1 ); }
1229 wchar_t operator --( int ) volatile
1230 { return fetch_sub( 1 ); }
1232 wchar_t operator ++() volatile
1233 { return fetch_add( 1 ) + 1; }
1235 wchar_t operator --() volatile
1236 { return fetch_sub( 1 ) - 1; }
1238 wchar_t operator +=( wchar_t __v__ ) volatile
1239 { return fetch_add( __v__ ) + __v__; }
1241 wchar_t operator -=( wchar_t __v__ ) volatile
1242 { return fetch_sub( __v__ ) - __v__; }
1244 wchar_t operator &=( wchar_t __v__ ) volatile
1245 { return fetch_and( __v__ ) & __v__; }
1247 wchar_t operator |=( wchar_t __v__ ) volatile
1248 { return fetch_or( __v__ ) | __v__; }
1250 wchar_t operator ^=( wchar_t __v__ ) volatile
1251 { return fetch_xor( __v__ ) ^ __v__; }
1253 friend void atomic_store_explicit( volatile atomic_wchar_t*, wchar_t,
1255 friend wchar_t atomic_load_explicit( volatile atomic_wchar_t*,
1257 friend wchar_t atomic_swap_explicit( volatile atomic_wchar_t*,
1258 wchar_t, memory_order );
1259 friend bool atomic_compare_swap_explicit( volatile atomic_wchar_t*,
1260 wchar_t*, wchar_t, memory_order, memory_order );
1261 friend void atomic_fence( const volatile atomic_wchar_t*, memory_order );
1262 friend wchar_t atomic_fetch_add_explicit( volatile atomic_wchar_t*,
1263 wchar_t, memory_order );
1264 friend wchar_t atomic_fetch_sub_explicit( volatile atomic_wchar_t*,
1265 wchar_t, memory_order );
1266 friend wchar_t atomic_fetch_and_explicit( volatile atomic_wchar_t*,
1267 wchar_t, memory_order );
1268 friend wchar_t atomic_fetch_or_explicit( volatile atomic_wchar_t*,
1269 wchar_t, memory_order );
1270 friend wchar_t atomic_fetch_xor_explicit( volatile atomic_wchar_t*,
1271 wchar_t, memory_order );
1281 typedef atomic_int_least16_t atomic_char16_t;
1282 typedef atomic_int_least32_t atomic_char32_t;
1283 typedef atomic_int_least32_t atomic_wchar_t;
1290 template< typename T >
1295 bool is_lock_free() const volatile;
1296 void store( T, memory_order = memory_order_seq_cst ) volatile;
1297 T load( memory_order = memory_order_seq_cst ) volatile;
1298 T swap( T __v__, memory_order = memory_order_seq_cst ) volatile;
1299 bool compare_swap( T&, T, memory_order, memory_order ) volatile;
1300 bool compare_swap( T&, T, memory_order = memory_order_seq_cst ) volatile;
1301 void fence( memory_order ) const volatile;
1303 CPP0X( atomic() = default; )
1304 CPP0X( constexpr explicit atomic( T __v__ ) : __f__( __v__ ) { } )
1305 CPP0X( atomic( const atomic& ) = delete; )
1306 atomic& operator =( const atomic& ) CPP0X(=delete);
1308 T operator =( T __v__ ) volatile
1309 { store( __v__ ); return __v__; }
1320 template<typename T> struct atomic< T* > : atomic_address
1322 T* load( memory_order = memory_order_seq_cst ) volatile;
1323 T* swap( T*, memory_order = memory_order_seq_cst ) volatile;
1324 bool compare_swap( T*&, T*, memory_order, memory_order ) volatile;
1325 bool compare_swap( T*&, T*,
1326 memory_order = memory_order_seq_cst ) volatile;
1327 T* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1328 T* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1330 CPP0X( atomic() = default; )
1331 CPP0X( constexpr explicit atomic( T __v__ ) : atomic_address( __v__ ) { } )
1332 CPP0X( atomic( const atomic& ) = delete; )
1333 atomic& operator =( const atomic& ) CPP0X(=delete);
1335 T* operator =( T* __v__ ) volatile
1336 { store( __v__ ); return __v__; }
1338 T* operator ++( int ) volatile
1339 { return fetch_add( 1 ); }
1341 T* operator --( int ) volatile
1342 { return fetch_sub( 1 ); }
1344 T* operator ++() volatile
1345 { return fetch_add( 1 ) + 1; }
1347 T* operator --() volatile
1348 { return fetch_sub( 1 ) - 1; }
1350 T* operator +=( T* __v__ ) volatile
1351 { return fetch_add( __v__ ) + __v__; }
1353 T* operator -=( T* __v__ ) volatile
1354 { return fetch_sub( __v__ ) - __v__; }
1362 template<> struct atomic< bool > : atomic_bool
1364 CPP0X( atomic() = default; )
1365 CPP0X( constexpr explicit atomic( bool __v__ )
1366 : atomic_bool( __v__ ) { } )
1367 CPP0X( atomic( const atomic& ) = delete; )
1368 atomic& operator =( const atomic& ) CPP0X(=delete);
1370 bool operator =( bool __v__ ) volatile
1371 { store( __v__ ); return __v__; }
1375 template<> struct atomic< void* > : atomic_address
1377 CPP0X( atomic() = default; )
1378 CPP0X( constexpr explicit atomic( void* __v__ )
1379 : atomic_address( __v__ ) { } )
1380 CPP0X( atomic( const atomic& ) = delete; )
1381 atomic& operator =( const atomic& ) CPP0X(=delete);
1383 void* operator =( void* __v__ ) volatile
1384 { store( __v__ ); return __v__; }
1388 template<> struct atomic< char > : atomic_char
1390 CPP0X( atomic() = default; )
1391 CPP0X( constexpr explicit atomic( char __v__ )
1392 : atomic_char( __v__ ) { } )
1393 CPP0X( atomic( const atomic& ) = delete; )
1394 atomic& operator =( const atomic& ) CPP0X(=delete);
1396 char operator =( char __v__ ) volatile
1397 { store( __v__ ); return __v__; }
1401 template<> struct atomic< signed char > : atomic_schar
1403 CPP0X( atomic() = default; )
1404 CPP0X( constexpr explicit atomic( signed char __v__ )
1405 : atomic_schar( __v__ ) { } )
1406 CPP0X( atomic( const atomic& ) = delete; )
1407 atomic& operator =( const atomic& ) CPP0X(=delete);
1409 signed char operator =( signed char __v__ ) volatile
1410 { store( __v__ ); return __v__; }
1414 template<> struct atomic< unsigned char > : atomic_uchar
1416 CPP0X( atomic() = default; )
1417 CPP0X( constexpr explicit atomic( unsigned char __v__ )
1418 : atomic_uchar( __v__ ) { } )
1419 CPP0X( atomic( const atomic& ) = delete; )
1420 atomic& operator =( const atomic& ) CPP0X(=delete);
1422 unsigned char operator =( unsigned char __v__ ) volatile
1423 { store( __v__ ); return __v__; }
1427 template<> struct atomic< short > : atomic_short
1429 CPP0X( atomic() = default; )
1430 CPP0X( constexpr explicit atomic( short __v__ )
1431 : atomic_short( __v__ ) { } )
1432 CPP0X( atomic( const atomic& ) = delete; )
1433 atomic& operator =( const atomic& ) CPP0X(=delete);
1435 short operator =( short __v__ ) volatile
1436 { store( __v__ ); return __v__; }
1440 template<> struct atomic< unsigned short > : atomic_ushort
1442 CPP0X( atomic() = default; )
1443 CPP0X( constexpr explicit atomic( unsigned short __v__ )
1444 : atomic_ushort( __v__ ) { } )
1445 CPP0X( atomic( const atomic& ) = delete; )
1446 atomic& operator =( const atomic& ) CPP0X(=delete);
1448 unsigned short operator =( unsigned short __v__ ) volatile
1449 { store( __v__ ); return __v__; }
1453 template<> struct atomic< int > : atomic_int
1455 CPP0X( atomic() = default; )
1456 CPP0X( constexpr explicit atomic( int __v__ )
1457 : atomic_int( __v__ ) { } )
1458 CPP0X( atomic( const atomic& ) = delete; )
1459 atomic& operator =( const atomic& ) CPP0X(=delete);
1461 int operator =( int __v__ ) volatile
1462 { store( __v__ ); return __v__; }
1466 template<> struct atomic< unsigned int > : atomic_uint
1468 CPP0X( atomic() = default; )
1469 CPP0X( constexpr explicit atomic( unsigned int __v__ )
1470 : atomic_uint( __v__ ) { } )
1471 CPP0X( atomic( const atomic& ) = delete; )
1472 atomic& operator =( const atomic& ) CPP0X(=delete);
1474 unsigned int operator =( unsigned int __v__ ) volatile
1475 { store( __v__ ); return __v__; }
1479 template<> struct atomic< long > : atomic_long
1481 CPP0X( atomic() = default; )
1482 CPP0X( constexpr explicit atomic( long __v__ )
1483 : atomic_long( __v__ ) { } )
1484 CPP0X( atomic( const atomic& ) = delete; )
1485 atomic& operator =( const atomic& ) CPP0X(=delete);
1487 long operator =( long __v__ ) volatile
1488 { store( __v__ ); return __v__; }
1492 template<> struct atomic< unsigned long > : atomic_ulong
1494 CPP0X( atomic() = default; )
1495 CPP0X( constexpr explicit atomic( unsigned long __v__ )
1496 : atomic_ulong( __v__ ) { } )
1497 CPP0X( atomic( const atomic& ) = delete; )
1498 atomic& operator =( const atomic& ) CPP0X(=delete);
1500 unsigned long operator =( unsigned long __v__ ) volatile
1501 { store( __v__ ); return __v__; }
1505 template<> struct atomic< long long > : atomic_llong
1507 CPP0X( atomic() = default; )
1508 CPP0X( constexpr explicit atomic( long long __v__ )
1509 : atomic_llong( __v__ ) { } )
1510 CPP0X( atomic( const atomic& ) = delete; )
1511 atomic& operator =( const atomic& ) CPP0X(=delete);
1513 long long operator =( long long __v__ ) volatile
1514 { store( __v__ ); return __v__; }
1518 template<> struct atomic< unsigned long long > : atomic_ullong
1520 CPP0X( atomic() = default; )
1521 CPP0X( constexpr explicit atomic( unsigned long long __v__ )
1522 : atomic_ullong( __v__ ) { } )
1523 CPP0X( atomic( const atomic& ) = delete; )
1524 atomic& operator =( const atomic& ) CPP0X(=delete);
1526 unsigned long long operator =( unsigned long long __v__ ) volatile
1527 { store( __v__ ); return __v__; }
1531 template<> struct atomic< wchar_t > : atomic_wchar_t
1533 CPP0X( atomic() = default; )
1534 CPP0X( constexpr explicit atomic( wchar_t __v__ )
1535 : atomic_wchar_t( __v__ ) { } )
1536 CPP0X( atomic( const atomic& ) = delete; )
1537 atomic& operator =( const atomic& ) CPP0X(=delete);
1539 wchar_t operator =( wchar_t __v__ ) volatile
1540 { store( __v__ ); return __v__; }
1550 inline bool atomic_is_lock_free( const volatile atomic_bool* __a__ )
1553 inline bool atomic_load_explicit
1554 ( volatile atomic_bool* __a__, memory_order __x__ )
1555 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1557 inline bool atomic_load( volatile atomic_bool* __a__ )
1558 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1560 inline void atomic_store_explicit
1561 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1562 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1564 inline void atomic_store
1565 ( volatile atomic_bool* __a__, bool __m__ )
1566 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1568 inline bool atomic_swap_explicit
1569 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1570 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1572 inline bool atomic_swap
1573 ( volatile atomic_bool* __a__, bool __m__ )
1574 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1576 inline bool atomic_compare_swap_explicit
1577 ( volatile atomic_bool* __a__, bool* __e__, bool __m__,
1578 memory_order __x__, memory_order __y__ )
1579 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1581 inline bool atomic_compare_swap
1582 ( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
1583 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1584 memory_order_seq_cst, memory_order_seq_cst ); }
1586 inline void atomic_fence
1587 ( const volatile atomic_bool* __a__, memory_order __x__ )
1588 { _ATOMIC_FENCE_( __a__, __x__ ); }
1591 inline bool atomic_is_lock_free( const volatile atomic_address* __a__ )
1594 inline void* atomic_load_explicit
1595 ( volatile atomic_address* __a__, memory_order __x__ )
1596 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1598 inline void* atomic_load( volatile atomic_address* __a__ )
1599 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1601 inline void atomic_store_explicit
1602 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1603 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1605 inline void atomic_store
1606 ( volatile atomic_address* __a__, void* __m__ )
1607 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1609 inline void* atomic_swap_explicit
1610 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1611 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1613 inline void* atomic_swap
1614 ( volatile atomic_address* __a__, void* __m__ )
1615 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1617 inline bool atomic_compare_swap_explicit
1618 ( volatile atomic_address* __a__, void** __e__, void* __m__,
1619 memory_order __x__, memory_order __y__ )
1620 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1622 inline bool atomic_compare_swap
1623 ( volatile atomic_address* __a__, void** __e__, void* __m__ )
1624 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1625 memory_order_seq_cst, memory_order_seq_cst ); }
1627 inline void atomic_fence
1628 ( const volatile atomic_address* __a__, memory_order __x__ )
1629 { _ATOMIC_FENCE_( __a__, __x__ ); }
1632 inline bool atomic_is_lock_free( const volatile atomic_char* __a__ )
1635 inline char atomic_load_explicit
1636 ( volatile atomic_char* __a__, memory_order __x__ )
1637 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1639 inline char atomic_load( volatile atomic_char* __a__ )
1640 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1642 inline void atomic_store_explicit
1643 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1644 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1646 inline void atomic_store
1647 ( volatile atomic_char* __a__, char __m__ )
1648 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1650 inline char atomic_swap_explicit
1651 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1652 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1654 inline char atomic_swap
1655 ( volatile atomic_char* __a__, char __m__ )
1656 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1658 inline bool atomic_compare_swap_explicit
1659 ( volatile atomic_char* __a__, char* __e__, char __m__,
1660 memory_order __x__, memory_order __y__ )
1661 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1663 inline bool atomic_compare_swap
1664 ( volatile atomic_char* __a__, char* __e__, char __m__ )
1665 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1666 memory_order_seq_cst, memory_order_seq_cst ); }
1668 inline void atomic_fence
1669 ( const volatile atomic_char* __a__, memory_order __x__ )
1670 { _ATOMIC_FENCE_( __a__, __x__ ); }
1673 inline bool atomic_is_lock_free( const volatile atomic_schar* __a__ )
1676 inline signed char atomic_load_explicit
1677 ( volatile atomic_schar* __a__, memory_order __x__ )
1678 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1680 inline signed char atomic_load( volatile atomic_schar* __a__ )
1681 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1683 inline void atomic_store_explicit
1684 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1685 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1687 inline void atomic_store
1688 ( volatile atomic_schar* __a__, signed char __m__ )
1689 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1691 inline signed char atomic_swap_explicit
1692 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1693 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1695 inline signed char atomic_swap
1696 ( volatile atomic_schar* __a__, signed char __m__ )
1697 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1699 inline bool atomic_compare_swap_explicit
1700 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
1701 memory_order __x__, memory_order __y__ )
1702 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1704 inline bool atomic_compare_swap
1705 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
1706 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1707 memory_order_seq_cst, memory_order_seq_cst ); }
1709 inline void atomic_fence
1710 ( const volatile atomic_schar* __a__, memory_order __x__ )
1711 { _ATOMIC_FENCE_( __a__, __x__ ); }
1714 inline bool atomic_is_lock_free( const volatile atomic_uchar* __a__ )
1717 inline unsigned char atomic_load_explicit
1718 ( volatile atomic_uchar* __a__, memory_order __x__ )
1719 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1721 inline unsigned char atomic_load( volatile atomic_uchar* __a__ )
1722 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1724 inline void atomic_store_explicit
1725 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1726 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1728 inline void atomic_store
1729 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1730 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1732 inline unsigned char atomic_swap_explicit
1733 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1734 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1736 inline unsigned char atomic_swap
1737 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1738 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1740 inline bool atomic_compare_swap_explicit
1741 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
1742 memory_order __x__, memory_order __y__ )
1743 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1745 inline bool atomic_compare_swap
1746 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
1747 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1748 memory_order_seq_cst, memory_order_seq_cst ); }
1750 inline void atomic_fence
1751 ( const volatile atomic_uchar* __a__, memory_order __x__ )
1752 { _ATOMIC_FENCE_( __a__, __x__ ); }
1755 inline bool atomic_is_lock_free( const volatile atomic_short* __a__ )
1758 inline short atomic_load_explicit
1759 ( volatile atomic_short* __a__, memory_order __x__ )
1760 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1762 inline short atomic_load( volatile atomic_short* __a__ )
1763 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1765 inline void atomic_store_explicit
1766 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1767 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1769 inline void atomic_store
1770 ( volatile atomic_short* __a__, short __m__ )
1771 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1773 inline short atomic_swap_explicit
1774 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1775 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1777 inline short atomic_swap
1778 ( volatile atomic_short* __a__, short __m__ )
1779 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1781 inline bool atomic_compare_swap_explicit
1782 ( volatile atomic_short* __a__, short* __e__, short __m__,
1783 memory_order __x__, memory_order __y__ )
1784 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1786 inline bool atomic_compare_swap
1787 ( volatile atomic_short* __a__, short* __e__, short __m__ )
1788 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1789 memory_order_seq_cst, memory_order_seq_cst ); }
1791 inline void atomic_fence
1792 ( const volatile atomic_short* __a__, memory_order __x__ )
1793 { _ATOMIC_FENCE_( __a__, __x__ ); }
1796 inline bool atomic_is_lock_free( const volatile atomic_ushort* __a__ )
1799 inline unsigned short atomic_load_explicit
1800 ( volatile atomic_ushort* __a__, memory_order __x__ )
1801 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1803 inline unsigned short atomic_load( volatile atomic_ushort* __a__ )
1804 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1806 inline void atomic_store_explicit
1807 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1808 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1810 inline void atomic_store
1811 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1812 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1814 inline unsigned short atomic_swap_explicit
1815 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1816 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1818 inline unsigned short atomic_swap
1819 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1820 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1822 inline bool atomic_compare_swap_explicit
1823 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
1824 memory_order __x__, memory_order __y__ )
1825 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1827 inline bool atomic_compare_swap
1828 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
1829 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1830 memory_order_seq_cst, memory_order_seq_cst ); }
1832 inline void atomic_fence
1833 ( const volatile atomic_ushort* __a__, memory_order __x__ )
1834 { _ATOMIC_FENCE_( __a__, __x__ ); }
1837 inline bool atomic_is_lock_free( const volatile atomic_int* __a__ )
1840 inline int atomic_load_explicit
1841 ( volatile atomic_int* __a__, memory_order __x__ )
1842 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1844 inline int atomic_load( volatile atomic_int* __a__ )
1845 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1847 inline void atomic_store_explicit
1848 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
1849 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1851 inline void atomic_store
1852 ( volatile atomic_int* __a__, int __m__ )
1853 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1855 inline int atomic_swap_explicit
1856 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
1857 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1859 inline int atomic_swap
1860 ( volatile atomic_int* __a__, int __m__ )
1861 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1863 inline bool atomic_compare_swap_explicit
1864 ( volatile atomic_int* __a__, int* __e__, int __m__,
1865 memory_order __x__, memory_order __y__ )
1866 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1868 inline bool atomic_compare_swap
1869 ( volatile atomic_int* __a__, int* __e__, int __m__ )
1870 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1871 memory_order_seq_cst, memory_order_seq_cst ); }
1873 inline void atomic_fence
1874 ( const volatile atomic_int* __a__, memory_order __x__ )
1875 { _ATOMIC_FENCE_( __a__, __x__ ); }
1878 inline bool atomic_is_lock_free( const volatile atomic_uint* __a__ )
1881 inline unsigned int atomic_load_explicit
1882 ( volatile atomic_uint* __a__, memory_order __x__ )
1883 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1885 inline unsigned int atomic_load( volatile atomic_uint* __a__ )
1886 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1888 inline void atomic_store_explicit
1889 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
1890 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1892 inline void atomic_store
1893 ( volatile atomic_uint* __a__, unsigned int __m__ )
1894 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1896 inline unsigned int atomic_swap_explicit
1897 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
1898 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1900 inline unsigned int atomic_swap
1901 ( volatile atomic_uint* __a__, unsigned int __m__ )
1902 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1904 inline bool atomic_compare_swap_explicit
1905 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
1906 memory_order __x__, memory_order __y__ )
1907 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1909 inline bool atomic_compare_swap
1910 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
1911 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1912 memory_order_seq_cst, memory_order_seq_cst ); }
1914 inline void atomic_fence
1915 ( const volatile atomic_uint* __a__, memory_order __x__ )
1916 { _ATOMIC_FENCE_( __a__, __x__ ); }
1919 inline bool atomic_is_lock_free( const volatile atomic_long* __a__ )
1922 inline long atomic_load_explicit
1923 ( volatile atomic_long* __a__, memory_order __x__ )
1924 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1926 inline long atomic_load( volatile atomic_long* __a__ )
1927 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1929 inline void atomic_store_explicit
1930 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
1931 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1933 inline void atomic_store
1934 ( volatile atomic_long* __a__, long __m__ )
1935 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1937 inline long atomic_swap_explicit
1938 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
1939 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1941 inline long atomic_swap
1942 ( volatile atomic_long* __a__, long __m__ )
1943 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1945 inline bool atomic_compare_swap_explicit
1946 ( volatile atomic_long* __a__, long* __e__, long __m__,
1947 memory_order __x__, memory_order __y__ )
1948 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1950 inline bool atomic_compare_swap
1951 ( volatile atomic_long* __a__, long* __e__, long __m__ )
1952 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1953 memory_order_seq_cst, memory_order_seq_cst ); }
1955 inline void atomic_fence
1956 ( const volatile atomic_long* __a__, memory_order __x__ )
1957 { _ATOMIC_FENCE_( __a__, __x__ ); }
1960 inline bool atomic_is_lock_free( const volatile atomic_ulong* __a__ )
1963 inline unsigned long atomic_load_explicit
1964 ( volatile atomic_ulong* __a__, memory_order __x__ )
1965 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1967 inline unsigned long atomic_load( volatile atomic_ulong* __a__ )
1968 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1970 inline void atomic_store_explicit
1971 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
1972 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1974 inline void atomic_store
1975 ( volatile atomic_ulong* __a__, unsigned long __m__ )
1976 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1978 inline unsigned long atomic_swap_explicit
1979 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
1980 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1982 inline unsigned long atomic_swap
1983 ( volatile atomic_ulong* __a__, unsigned long __m__ )
1984 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
1986 inline bool atomic_compare_swap_explicit
1987 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
1988 memory_order __x__, memory_order __y__ )
1989 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1991 inline bool atomic_compare_swap
1992 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
1993 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
1994 memory_order_seq_cst, memory_order_seq_cst ); }
1996 inline void atomic_fence
1997 ( const volatile atomic_ulong* __a__, memory_order __x__ )
1998 { _ATOMIC_FENCE_( __a__, __x__ ); }
2001 inline bool atomic_is_lock_free( const volatile atomic_llong* __a__ )
2004 inline long long atomic_load_explicit
2005 ( volatile atomic_llong* __a__, memory_order __x__ )
2006 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2008 inline long long atomic_load( volatile atomic_llong* __a__ )
2009 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2011 inline void atomic_store_explicit
2012 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2013 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2015 inline void atomic_store
2016 ( volatile atomic_llong* __a__, long long __m__ )
2017 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2019 inline long long atomic_swap_explicit
2020 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2021 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2023 inline long long atomic_swap
2024 ( volatile atomic_llong* __a__, long long __m__ )
2025 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2027 inline bool atomic_compare_swap_explicit
2028 ( volatile atomic_llong* __a__, long long* __e__, long long __m__,
2029 memory_order __x__, memory_order __y__ )
2030 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2032 inline bool atomic_compare_swap
2033 ( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
2034 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2035 memory_order_seq_cst, memory_order_seq_cst ); }
2037 inline void atomic_fence
2038 ( const volatile atomic_llong* __a__, memory_order __x__ )
2039 { _ATOMIC_FENCE_( __a__, __x__ ); }
2042 inline bool atomic_is_lock_free( const volatile atomic_ullong* __a__ )
2045 inline unsigned long long atomic_load_explicit
2046 ( volatile atomic_ullong* __a__, memory_order __x__ )
2047 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2049 inline unsigned long long atomic_load( volatile atomic_ullong* __a__ )
2050 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2052 inline void atomic_store_explicit
2053 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2054 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2056 inline void atomic_store
2057 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2058 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2060 inline unsigned long long atomic_swap_explicit
2061 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2062 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2064 inline unsigned long long atomic_swap
2065 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2066 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2068 inline bool atomic_compare_swap_explicit
2069 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
2070 memory_order __x__, memory_order __y__ )
2071 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2073 inline bool atomic_compare_swap
2074 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
2075 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2076 memory_order_seq_cst, memory_order_seq_cst ); }
2078 inline void atomic_fence
2079 ( const volatile atomic_ullong* __a__, memory_order __x__ )
2080 { _ATOMIC_FENCE_( __a__, __x__ ); }
2083 inline bool atomic_is_lock_free( const volatile atomic_wchar_t* __a__ )
2086 inline wchar_t atomic_load_explicit
2087 ( volatile atomic_wchar_t* __a__, memory_order __x__ )
2088 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2090 inline wchar_t atomic_load( volatile atomic_wchar_t* __a__ )
2091 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2093 inline void atomic_store_explicit
2094 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2095 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2097 inline void atomic_store
2098 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2099 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2101 inline wchar_t atomic_swap_explicit
2102 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2103 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2105 inline wchar_t atomic_swap
2106 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2107 { return atomic_swap_explicit( __a__, __m__, memory_order_seq_cst ); }
2109 inline bool atomic_compare_swap_explicit
2110 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
2111 memory_order __x__, memory_order __y__ )
2112 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2114 inline bool atomic_compare_swap
2115 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
2116 { return atomic_compare_swap_explicit( __a__, __e__, __m__,
2117 memory_order_seq_cst, memory_order_seq_cst ); }
2119 inline void atomic_fence
2120 ( const volatile atomic_wchar_t* __a__, memory_order __x__ )
2121 { _ATOMIC_FENCE_( __a__, __x__ ); }
2124 inline void* atomic_fetch_add_explicit
2125 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2126 { void* volatile* __p__ = &((__a__)->__f__);
2127 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__));
2128 void* __r__ = (void *) thread_current()->get_return_value();
2129 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, (void*)((char*)(*__p__) + __m__)));
2132 inline void* atomic_fetch_add
2133 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2134 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2137 inline void* atomic_fetch_sub_explicit
2138 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2139 { void* volatile* __p__ = &((__a__)->__f__);
2140 model->switch_to_master(new ModelAction(ATOMIC_READ, __x__, __p__));
2141 void* __r__ = (void *) thread_current()->get_return_value();
2142 model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, __p__, (void*)((char*)(*__p__) - __m__)));
2145 inline void* atomic_fetch_sub
2146 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2147 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2150 inline char atomic_fetch_add_explicit
2151 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2152 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2154 inline char atomic_fetch_add
2155 ( volatile atomic_char* __a__, char __m__ )
2156 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2159 inline char atomic_fetch_sub_explicit
2160 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2161 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2163 inline char atomic_fetch_sub
2164 ( volatile atomic_char* __a__, char __m__ )
2165 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2168 inline char atomic_fetch_and_explicit
2169 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2170 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2172 inline char atomic_fetch_and
2173 ( volatile atomic_char* __a__, char __m__ )
2174 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2177 inline char atomic_fetch_or_explicit
2178 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2179 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2181 inline char atomic_fetch_or
2182 ( volatile atomic_char* __a__, char __m__ )
2183 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2186 inline char atomic_fetch_xor_explicit
2187 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2188 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2190 inline char atomic_fetch_xor
2191 ( volatile atomic_char* __a__, char __m__ )
2192 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2195 inline signed char atomic_fetch_add_explicit
2196 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2197 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2199 inline signed char atomic_fetch_add
2200 ( volatile atomic_schar* __a__, signed char __m__ )
2201 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2204 inline signed char atomic_fetch_sub_explicit
2205 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2206 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2208 inline signed char atomic_fetch_sub
2209 ( volatile atomic_schar* __a__, signed char __m__ )
2210 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2213 inline signed char atomic_fetch_and_explicit
2214 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2215 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2217 inline signed char atomic_fetch_and
2218 ( volatile atomic_schar* __a__, signed char __m__ )
2219 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2222 inline signed char atomic_fetch_or_explicit
2223 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2224 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2226 inline signed char atomic_fetch_or
2227 ( volatile atomic_schar* __a__, signed char __m__ )
2228 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2231 inline signed char atomic_fetch_xor_explicit
2232 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2233 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2235 inline signed char atomic_fetch_xor
2236 ( volatile atomic_schar* __a__, signed char __m__ )
2237 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2240 inline unsigned char atomic_fetch_add_explicit
2241 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2242 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2244 inline unsigned char atomic_fetch_add
2245 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2246 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2249 inline unsigned char atomic_fetch_sub_explicit
2250 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2251 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2253 inline unsigned char atomic_fetch_sub
2254 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2255 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2258 inline unsigned char atomic_fetch_and_explicit
2259 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2260 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2262 inline unsigned char atomic_fetch_and
2263 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2264 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2267 inline unsigned char atomic_fetch_or_explicit
2268 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2269 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2271 inline unsigned char atomic_fetch_or
2272 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2273 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2276 inline unsigned char atomic_fetch_xor_explicit
2277 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2278 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2280 inline unsigned char atomic_fetch_xor
2281 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2282 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2285 inline short atomic_fetch_add_explicit
2286 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2287 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2289 inline short atomic_fetch_add
2290 ( volatile atomic_short* __a__, short __m__ )
2291 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2294 inline short atomic_fetch_sub_explicit
2295 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2296 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2298 inline short atomic_fetch_sub
2299 ( volatile atomic_short* __a__, short __m__ )
2300 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2303 inline short atomic_fetch_and_explicit
2304 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2305 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2307 inline short atomic_fetch_and
2308 ( volatile atomic_short* __a__, short __m__ )
2309 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2312 inline short atomic_fetch_or_explicit
2313 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2314 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2316 inline short atomic_fetch_or
2317 ( volatile atomic_short* __a__, short __m__ )
2318 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2321 inline short atomic_fetch_xor_explicit
2322 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2323 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2325 inline short atomic_fetch_xor
2326 ( volatile atomic_short* __a__, short __m__ )
2327 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2330 inline unsigned short atomic_fetch_add_explicit
2331 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2332 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2334 inline unsigned short atomic_fetch_add
2335 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2336 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2339 inline unsigned short atomic_fetch_sub_explicit
2340 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2341 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2343 inline unsigned short atomic_fetch_sub
2344 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2345 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2348 inline unsigned short atomic_fetch_and_explicit
2349 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2350 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2352 inline unsigned short atomic_fetch_and
2353 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2354 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2357 inline unsigned short atomic_fetch_or_explicit
2358 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2359 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2361 inline unsigned short atomic_fetch_or
2362 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2363 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2366 inline unsigned short atomic_fetch_xor_explicit
2367 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2368 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2370 inline unsigned short atomic_fetch_xor
2371 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2372 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2375 inline int atomic_fetch_add_explicit
2376 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2377 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2379 inline int atomic_fetch_add
2380 ( volatile atomic_int* __a__, int __m__ )
2381 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2384 inline int atomic_fetch_sub_explicit
2385 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2386 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2388 inline int atomic_fetch_sub
2389 ( volatile atomic_int* __a__, int __m__ )
2390 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2393 inline int atomic_fetch_and_explicit
2394 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2395 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2397 inline int atomic_fetch_and
2398 ( volatile atomic_int* __a__, int __m__ )
2399 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2402 inline int atomic_fetch_or_explicit
2403 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2404 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2406 inline int atomic_fetch_or
2407 ( volatile atomic_int* __a__, int __m__ )
2408 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2411 inline int atomic_fetch_xor_explicit
2412 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2413 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2415 inline int atomic_fetch_xor
2416 ( volatile atomic_int* __a__, int __m__ )
2417 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2420 inline unsigned int atomic_fetch_add_explicit
2421 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2422 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2424 inline unsigned int atomic_fetch_add
2425 ( volatile atomic_uint* __a__, unsigned int __m__ )
2426 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2429 inline unsigned int atomic_fetch_sub_explicit
2430 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2431 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2433 inline unsigned int atomic_fetch_sub
2434 ( volatile atomic_uint* __a__, unsigned int __m__ )
2435 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2438 inline unsigned int atomic_fetch_and_explicit
2439 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2440 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2442 inline unsigned int atomic_fetch_and
2443 ( volatile atomic_uint* __a__, unsigned int __m__ )
2444 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2447 inline unsigned int atomic_fetch_or_explicit
2448 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2449 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2451 inline unsigned int atomic_fetch_or
2452 ( volatile atomic_uint* __a__, unsigned int __m__ )
2453 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2456 inline unsigned int atomic_fetch_xor_explicit
2457 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2458 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2460 inline unsigned int atomic_fetch_xor
2461 ( volatile atomic_uint* __a__, unsigned int __m__ )
2462 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2465 inline long atomic_fetch_add_explicit
2466 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2467 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2469 inline long atomic_fetch_add
2470 ( volatile atomic_long* __a__, long __m__ )
2471 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2474 inline long atomic_fetch_sub_explicit
2475 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2476 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2478 inline long atomic_fetch_sub
2479 ( volatile atomic_long* __a__, long __m__ )
2480 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2483 inline long atomic_fetch_and_explicit
2484 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2485 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2487 inline long atomic_fetch_and
2488 ( volatile atomic_long* __a__, long __m__ )
2489 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2492 inline long atomic_fetch_or_explicit
2493 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2494 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2496 inline long atomic_fetch_or
2497 ( volatile atomic_long* __a__, long __m__ )
2498 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2501 inline long atomic_fetch_xor_explicit
2502 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2503 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2505 inline long atomic_fetch_xor
2506 ( volatile atomic_long* __a__, long __m__ )
2507 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2510 inline unsigned long atomic_fetch_add_explicit
2511 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2512 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2514 inline unsigned long atomic_fetch_add
2515 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2516 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2519 inline unsigned long atomic_fetch_sub_explicit
2520 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2521 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2523 inline unsigned long atomic_fetch_sub
2524 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2525 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2528 inline unsigned long atomic_fetch_and_explicit
2529 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2530 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2532 inline unsigned long atomic_fetch_and
2533 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2534 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2537 inline unsigned long atomic_fetch_or_explicit
2538 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2539 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2541 inline unsigned long atomic_fetch_or
2542 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2543 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2546 inline unsigned long atomic_fetch_xor_explicit
2547 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2548 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2550 inline unsigned long atomic_fetch_xor
2551 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2552 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2555 inline long long atomic_fetch_add_explicit
2556 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2557 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2559 inline long long atomic_fetch_add
2560 ( volatile atomic_llong* __a__, long long __m__ )
2561 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2564 inline long long atomic_fetch_sub_explicit
2565 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2566 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2568 inline long long atomic_fetch_sub
2569 ( volatile atomic_llong* __a__, long long __m__ )
2570 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2573 inline long long atomic_fetch_and_explicit
2574 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2575 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2577 inline long long atomic_fetch_and
2578 ( volatile atomic_llong* __a__, long long __m__ )
2579 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2582 inline long long atomic_fetch_or_explicit
2583 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2584 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2586 inline long long atomic_fetch_or
2587 ( volatile atomic_llong* __a__, long long __m__ )
2588 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2591 inline long long atomic_fetch_xor_explicit
2592 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2593 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2595 inline long long atomic_fetch_xor
2596 ( volatile atomic_llong* __a__, long long __m__ )
2597 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2600 inline unsigned long long atomic_fetch_add_explicit
2601 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2602 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2604 inline unsigned long long atomic_fetch_add
2605 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2606 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2609 inline unsigned long long atomic_fetch_sub_explicit
2610 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2611 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2613 inline unsigned long long atomic_fetch_sub
2614 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2615 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2618 inline unsigned long long atomic_fetch_and_explicit
2619 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2620 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2622 inline unsigned long long atomic_fetch_and
2623 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2624 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2627 inline unsigned long long atomic_fetch_or_explicit
2628 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2629 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2631 inline unsigned long long atomic_fetch_or
2632 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2633 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2636 inline unsigned long long atomic_fetch_xor_explicit
2637 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2638 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2640 inline unsigned long long atomic_fetch_xor
2641 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2642 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2645 inline wchar_t atomic_fetch_add_explicit
2646 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2647 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2649 inline wchar_t atomic_fetch_add
2650 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2651 { atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2654 inline wchar_t atomic_fetch_sub_explicit
2655 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2656 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2658 inline wchar_t atomic_fetch_sub
2659 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2660 { atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2663 inline wchar_t atomic_fetch_and_explicit
2664 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2665 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2667 inline wchar_t atomic_fetch_and
2668 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2669 { atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2672 inline wchar_t atomic_fetch_or_explicit
2673 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2674 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2676 inline wchar_t atomic_fetch_or
2677 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2678 { atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2681 inline wchar_t atomic_fetch_xor_explicit
2682 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2683 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2685 inline wchar_t atomic_fetch_xor
2686 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2687 { atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2693 #define atomic_is_lock_free( __a__ ) \
2696 #define atomic_load( __a__ ) \
2697 _ATOMIC_LOAD_( __a__, memory_order_seq_cst )
2699 #define atomic_load_explicit( __a__, __x__ ) \
2700 _ATOMIC_LOAD_( __a__, __x__ )
2702 #define atomic_store( __a__, __m__ ) \
2703 _ATOMIC_STORE_( __a__, __m__, memory_order_seq_cst )
2705 #define atomic_store_explicit( __a__, __m__, __x__ ) \
2706 _ATOMIC_STORE_( __a__, __m__, __x__ )
2708 #define atomic_swap( __a__, __m__ ) \
2709 _ATOMIC_MODIFY_( __a__, =, __m__, memory_order_seq_cst )
2711 #define atomic_swap_explicit( __a__, __m__, __x__ ) \
2712 _ATOMIC_MODIFY_( __a__, =, __m__, __x__ )
2714 #define atomic_compare_swap( __a__, __e__, __m__ ) \
2715 _ATOMIC_CMPSWP_( __a__, __e__, __m__, memory_order_seq_cst )
2717 #define atomic_compare_swap_explicit( __a__, __e__, __m__, __x__, __y__ ) \
2718 _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ )
2720 #define atomic_fence( __a__, __x__ ) \
2721 ({ _ATOMIC_FENCE_( __a__, __x__ ); })
2724 #define atomic_fetch_add_explicit( __a__, __m__, __x__ ) \
2725 _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ )
2727 #define atomic_fetch_add( __a__, __m__ ) \
2728 _ATOMIC_MODIFY_( __a__, +=, __m__, memory_order_seq_cst )
2731 #define atomic_fetch_sub_explicit( __a__, __m__, __x__ ) \
2732 _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ )
2734 #define atomic_fetch_sub( __a__, __m__ ) \
2735 _ATOMIC_MODIFY_( __a__, -=, __m__, memory_order_seq_cst )
2738 #define atomic_fetch_and_explicit( __a__, __m__, __x__ ) \
2739 _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ )
2741 #define atomic_fetch_and( __a__, __m__ ) \
2742 _ATOMIC_MODIFY_( __a__, &=, __m__, memory_order_seq_cst )
2745 #define atomic_fetch_or_explicit( __a__, __m__, __x__ ) \
2746 _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ )
2748 #define atomic_fetch_or( __a__, __m__ ) \
2749 _ATOMIC_MODIFY_( __a__, |=, __m__, memory_order_seq_cst )
2752 #define atomic_fetch_xor_explicit( __a__, __m__, __x__ ) \
2753 _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ )
2755 #define atomic_fetch_xor( __a__, __m__ ) \
2756 _ATOMIC_MODIFY_( __a__, ^=, __m__, memory_order_seq_cst )
2765 inline bool atomic_bool::is_lock_free() const volatile
2768 inline void atomic_bool::store
2769 ( bool __m__, memory_order __x__ ) volatile
2770 { atomic_store_explicit( this, __m__, __x__ ); }
2772 inline bool atomic_bool::load
2773 ( memory_order __x__ ) volatile
2774 { return atomic_load_explicit( this, __x__ ); }
2776 inline bool atomic_bool::swap
2777 ( bool __m__, memory_order __x__ ) volatile
2778 { return atomic_swap_explicit( this, __m__, __x__ ); }
2780 inline bool atomic_bool::compare_swap
2781 ( bool& __e__, bool __m__,
2782 memory_order __x__, memory_order __y__ ) volatile
2783 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2785 inline bool atomic_bool::compare_swap
2786 ( bool& __e__, bool __m__, memory_order __x__ ) volatile
2787 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2788 __x__ == memory_order_acq_rel ? memory_order_acquire :
2789 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2791 inline void atomic_bool::fence
2792 ( memory_order __x__ ) const volatile
2793 { return atomic_fence( this, __x__ ); }
2796 inline bool atomic_address::is_lock_free() const volatile
2799 inline void atomic_address::store
2800 ( void* __m__, memory_order __x__ ) volatile
2801 { atomic_store_explicit( this, __m__, __x__ ); }
2803 inline void* atomic_address::load
2804 ( memory_order __x__ ) volatile
2805 { return atomic_load_explicit( this, __x__ ); }
2807 inline void* atomic_address::swap
2808 ( void* __m__, memory_order __x__ ) volatile
2809 { return atomic_swap_explicit( this, __m__, __x__ ); }
2811 inline bool atomic_address::compare_swap
2812 ( void*& __e__, void* __m__,
2813 memory_order __x__, memory_order __y__ ) volatile
2814 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2816 inline bool atomic_address::compare_swap
2817 ( void*& __e__, void* __m__, memory_order __x__ ) volatile
2818 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2819 __x__ == memory_order_acq_rel ? memory_order_acquire :
2820 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2822 inline void atomic_address::fence
2823 ( memory_order __x__ ) const volatile
2824 { return atomic_fence( this, __x__ ); }
2827 inline bool atomic_char::is_lock_free() const volatile
2830 inline void atomic_char::store
2831 ( char __m__, memory_order __x__ ) volatile
2832 { atomic_store_explicit( this, __m__, __x__ ); }
2834 inline char atomic_char::load
2835 ( memory_order __x__ ) volatile
2836 { return atomic_load_explicit( this, __x__ ); }
2838 inline char atomic_char::swap
2839 ( char __m__, memory_order __x__ ) volatile
2840 { return atomic_swap_explicit( this, __m__, __x__ ); }
2842 inline bool atomic_char::compare_swap
2843 ( char& __e__, char __m__,
2844 memory_order __x__, memory_order __y__ ) volatile
2845 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2847 inline bool atomic_char::compare_swap
2848 ( char& __e__, char __m__, memory_order __x__ ) volatile
2849 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2850 __x__ == memory_order_acq_rel ? memory_order_acquire :
2851 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2853 inline void atomic_char::fence
2854 ( memory_order __x__ ) const volatile
2855 { return atomic_fence( this, __x__ ); }
2858 inline bool atomic_schar::is_lock_free() const volatile
2861 inline void atomic_schar::store
2862 ( signed char __m__, memory_order __x__ ) volatile
2863 { atomic_store_explicit( this, __m__, __x__ ); }
2865 inline signed char atomic_schar::load
2866 ( memory_order __x__ ) volatile
2867 { return atomic_load_explicit( this, __x__ ); }
2869 inline signed char atomic_schar::swap
2870 ( signed char __m__, memory_order __x__ ) volatile
2871 { return atomic_swap_explicit( this, __m__, __x__ ); }
2873 inline bool atomic_schar::compare_swap
2874 ( signed char& __e__, signed char __m__,
2875 memory_order __x__, memory_order __y__ ) volatile
2876 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2878 inline bool atomic_schar::compare_swap
2879 ( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
2880 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2881 __x__ == memory_order_acq_rel ? memory_order_acquire :
2882 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2884 inline void atomic_schar::fence
2885 ( memory_order __x__ ) const volatile
2886 { return atomic_fence( this, __x__ ); }
2889 inline bool atomic_uchar::is_lock_free() const volatile
2892 inline void atomic_uchar::store
2893 ( unsigned char __m__, memory_order __x__ ) volatile
2894 { atomic_store_explicit( this, __m__, __x__ ); }
2896 inline unsigned char atomic_uchar::load
2897 ( memory_order __x__ ) volatile
2898 { return atomic_load_explicit( this, __x__ ); }
2900 inline unsigned char atomic_uchar::swap
2901 ( unsigned char __m__, memory_order __x__ ) volatile
2902 { return atomic_swap_explicit( this, __m__, __x__ ); }
2904 inline bool atomic_uchar::compare_swap
2905 ( unsigned char& __e__, unsigned char __m__,
2906 memory_order __x__, memory_order __y__ ) volatile
2907 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2909 inline bool atomic_uchar::compare_swap
2910 ( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
2911 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2912 __x__ == memory_order_acq_rel ? memory_order_acquire :
2913 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2915 inline void atomic_uchar::fence
2916 ( memory_order __x__ ) const volatile
2917 { return atomic_fence( this, __x__ ); }
2920 inline bool atomic_short::is_lock_free() const volatile
2923 inline void atomic_short::store
2924 ( short __m__, memory_order __x__ ) volatile
2925 { atomic_store_explicit( this, __m__, __x__ ); }
2927 inline short atomic_short::load
2928 ( memory_order __x__ ) volatile
2929 { return atomic_load_explicit( this, __x__ ); }
2931 inline short atomic_short::swap
2932 ( short __m__, memory_order __x__ ) volatile
2933 { return atomic_swap_explicit( this, __m__, __x__ ); }
2935 inline bool atomic_short::compare_swap
2936 ( short& __e__, short __m__,
2937 memory_order __x__, memory_order __y__ ) volatile
2938 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2940 inline bool atomic_short::compare_swap
2941 ( short& __e__, short __m__, memory_order __x__ ) volatile
2942 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2943 __x__ == memory_order_acq_rel ? memory_order_acquire :
2944 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2946 inline void atomic_short::fence
2947 ( memory_order __x__ ) const volatile
2948 { return atomic_fence( this, __x__ ); }
2951 inline bool atomic_ushort::is_lock_free() const volatile
2954 inline void atomic_ushort::store
2955 ( unsigned short __m__, memory_order __x__ ) volatile
2956 { atomic_store_explicit( this, __m__, __x__ ); }
2958 inline unsigned short atomic_ushort::load
2959 ( memory_order __x__ ) volatile
2960 { return atomic_load_explicit( this, __x__ ); }
2962 inline unsigned short atomic_ushort::swap
2963 ( unsigned short __m__, memory_order __x__ ) volatile
2964 { return atomic_swap_explicit( this, __m__, __x__ ); }
2966 inline bool atomic_ushort::compare_swap
2967 ( unsigned short& __e__, unsigned short __m__,
2968 memory_order __x__, memory_order __y__ ) volatile
2969 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
2971 inline bool atomic_ushort::compare_swap
2972 ( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
2973 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
2974 __x__ == memory_order_acq_rel ? memory_order_acquire :
2975 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
2977 inline void atomic_ushort::fence
2978 ( memory_order __x__ ) const volatile
2979 { return atomic_fence( this, __x__ ); }
2982 inline bool atomic_int::is_lock_free() const volatile
2985 inline void atomic_int::store
2986 ( int __m__, memory_order __x__ ) volatile
2987 { atomic_store_explicit( this, __m__, __x__ ); }
2989 inline int atomic_int::load
2990 ( memory_order __x__ ) volatile
2991 { return atomic_load_explicit( this, __x__ ); }
2993 inline int atomic_int::swap
2994 ( int __m__, memory_order __x__ ) volatile
2995 { return atomic_swap_explicit( this, __m__, __x__ ); }
2997 inline bool atomic_int::compare_swap
2998 ( int& __e__, int __m__,
2999 memory_order __x__, memory_order __y__ ) volatile
3000 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3002 inline bool atomic_int::compare_swap
3003 ( int& __e__, int __m__, memory_order __x__ ) volatile
3004 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3005 __x__ == memory_order_acq_rel ? memory_order_acquire :
3006 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3008 inline void atomic_int::fence
3009 ( memory_order __x__ ) const volatile
3010 { return atomic_fence( this, __x__ ); }
3013 inline bool atomic_uint::is_lock_free() const volatile
3016 inline void atomic_uint::store
3017 ( unsigned int __m__, memory_order __x__ ) volatile
3018 { atomic_store_explicit( this, __m__, __x__ ); }
3020 inline unsigned int atomic_uint::load
3021 ( memory_order __x__ ) volatile
3022 { return atomic_load_explicit( this, __x__ ); }
3024 inline unsigned int atomic_uint::swap
3025 ( unsigned int __m__, memory_order __x__ ) volatile
3026 { return atomic_swap_explicit( this, __m__, __x__ ); }
3028 inline bool atomic_uint::compare_swap
3029 ( unsigned int& __e__, unsigned int __m__,
3030 memory_order __x__, memory_order __y__ ) volatile
3031 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3033 inline bool atomic_uint::compare_swap
3034 ( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
3035 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3036 __x__ == memory_order_acq_rel ? memory_order_acquire :
3037 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3039 inline void atomic_uint::fence
3040 ( memory_order __x__ ) const volatile
3041 { return atomic_fence( this, __x__ ); }
3044 inline bool atomic_long::is_lock_free() const volatile
3047 inline void atomic_long::store
3048 ( long __m__, memory_order __x__ ) volatile
3049 { atomic_store_explicit( this, __m__, __x__ ); }
3051 inline long atomic_long::load
3052 ( memory_order __x__ ) volatile
3053 { return atomic_load_explicit( this, __x__ ); }
3055 inline long atomic_long::swap
3056 ( long __m__, memory_order __x__ ) volatile
3057 { return atomic_swap_explicit( this, __m__, __x__ ); }
3059 inline bool atomic_long::compare_swap
3060 ( long& __e__, long __m__,
3061 memory_order __x__, memory_order __y__ ) volatile
3062 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3064 inline bool atomic_long::compare_swap
3065 ( long& __e__, long __m__, memory_order __x__ ) volatile
3066 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3067 __x__ == memory_order_acq_rel ? memory_order_acquire :
3068 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3070 inline void atomic_long::fence
3071 ( memory_order __x__ ) const volatile
3072 { return atomic_fence( this, __x__ ); }
3075 inline bool atomic_ulong::is_lock_free() const volatile
3078 inline void atomic_ulong::store
3079 ( unsigned long __m__, memory_order __x__ ) volatile
3080 { atomic_store_explicit( this, __m__, __x__ ); }
3082 inline unsigned long atomic_ulong::load
3083 ( memory_order __x__ ) volatile
3084 { return atomic_load_explicit( this, __x__ ); }
3086 inline unsigned long atomic_ulong::swap
3087 ( unsigned long __m__, memory_order __x__ ) volatile
3088 { return atomic_swap_explicit( this, __m__, __x__ ); }
3090 inline bool atomic_ulong::compare_swap
3091 ( unsigned long& __e__, unsigned long __m__,
3092 memory_order __x__, memory_order __y__ ) volatile
3093 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3095 inline bool atomic_ulong::compare_swap
3096 ( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
3097 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3098 __x__ == memory_order_acq_rel ? memory_order_acquire :
3099 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3101 inline void atomic_ulong::fence
3102 ( memory_order __x__ ) const volatile
3103 { return atomic_fence( this, __x__ ); }
3106 inline bool atomic_llong::is_lock_free() const volatile
3109 inline void atomic_llong::store
3110 ( long long __m__, memory_order __x__ ) volatile
3111 { atomic_store_explicit( this, __m__, __x__ ); }
3113 inline long long atomic_llong::load
3114 ( memory_order __x__ ) volatile
3115 { return atomic_load_explicit( this, __x__ ); }
3117 inline long long atomic_llong::swap
3118 ( long long __m__, memory_order __x__ ) volatile
3119 { return atomic_swap_explicit( this, __m__, __x__ ); }
3121 inline bool atomic_llong::compare_swap
3122 ( long long& __e__, long long __m__,
3123 memory_order __x__, memory_order __y__ ) volatile
3124 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3126 inline bool atomic_llong::compare_swap
3127 ( long long& __e__, long long __m__, memory_order __x__ ) volatile
3128 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3129 __x__ == memory_order_acq_rel ? memory_order_acquire :
3130 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3132 inline void atomic_llong::fence
3133 ( memory_order __x__ ) const volatile
3134 { return atomic_fence( this, __x__ ); }
3137 inline bool atomic_ullong::is_lock_free() const volatile
3140 inline void atomic_ullong::store
3141 ( unsigned long long __m__, memory_order __x__ ) volatile
3142 { atomic_store_explicit( this, __m__, __x__ ); }
3144 inline unsigned long long atomic_ullong::load
3145 ( memory_order __x__ ) volatile
3146 { return atomic_load_explicit( this, __x__ ); }
3148 inline unsigned long long atomic_ullong::swap
3149 ( unsigned long long __m__, memory_order __x__ ) volatile
3150 { return atomic_swap_explicit( this, __m__, __x__ ); }
3152 inline bool atomic_ullong::compare_swap
3153 ( unsigned long long& __e__, unsigned long long __m__,
3154 memory_order __x__, memory_order __y__ ) volatile
3155 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3157 inline bool atomic_ullong::compare_swap
3158 ( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
3159 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3160 __x__ == memory_order_acq_rel ? memory_order_acquire :
3161 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3163 inline void atomic_ullong::fence
3164 ( memory_order __x__ ) const volatile
3165 { return atomic_fence( this, __x__ ); }
3168 inline bool atomic_wchar_t::is_lock_free() const volatile
3171 inline void atomic_wchar_t::store
3172 ( wchar_t __m__, memory_order __x__ ) volatile
3173 { atomic_store_explicit( this, __m__, __x__ ); }
3175 inline wchar_t atomic_wchar_t::load
3176 ( memory_order __x__ ) volatile
3177 { return atomic_load_explicit( this, __x__ ); }
3179 inline wchar_t atomic_wchar_t::swap
3180 ( wchar_t __m__, memory_order __x__ ) volatile
3181 { return atomic_swap_explicit( this, __m__, __x__ ); }
3183 inline bool atomic_wchar_t::compare_swap
3184 ( wchar_t& __e__, wchar_t __m__,
3185 memory_order __x__, memory_order __y__ ) volatile
3186 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__, __y__ ); }
3188 inline bool atomic_wchar_t::compare_swap
3189 ( wchar_t& __e__, wchar_t __m__, memory_order __x__ ) volatile
3190 { return atomic_compare_swap_explicit( this, &__e__, __m__, __x__,
3191 __x__ == memory_order_acq_rel ? memory_order_acquire :
3192 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3194 inline void atomic_wchar_t::fence
3195 ( memory_order __x__ ) const volatile
3196 { return atomic_fence( this, __x__ ); }
3199 template< typename T >
3200 inline bool atomic<T>::is_lock_free() const volatile
3203 template< typename T >
3204 inline void atomic<T>::store( T __v__, memory_order __x__ ) volatile
3205 { _ATOMIC_STORE_( this, __v__, __x__ ); }
3207 template< typename T >
3208 inline T atomic<T>::load( memory_order __x__ ) volatile
3209 { return _ATOMIC_LOAD_( this, __x__ ); }
3211 template< typename T >
3212 inline T atomic<T>::swap( T __v__, memory_order __x__ ) volatile
3213 { return _ATOMIC_MODIFY_( this, =, __v__, __x__ ); }
3215 template< typename T >
3216 inline bool atomic<T>::compare_swap
3217 ( T& __r__, T __v__, memory_order __x__, memory_order __y__ ) volatile
3218 { return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
3220 template< typename T >
3221 inline bool atomic<T>::compare_swap
3222 ( T& __r__, T __v__, memory_order __x__ ) volatile
3223 { return compare_swap( __r__, __v__, __x__,
3224 __x__ == memory_order_acq_rel ? memory_order_acquire :
3225 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3228 inline void* atomic_address::fetch_add
3229 ( ptrdiff_t __m__, memory_order __x__ ) volatile
3230 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3232 inline void* atomic_address::fetch_sub
3233 ( ptrdiff_t __m__, memory_order __x__ ) volatile
3234 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3237 inline char atomic_char::fetch_add
3238 ( char __m__, memory_order __x__ ) volatile
3239 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3242 inline char atomic_char::fetch_sub
3243 ( char __m__, memory_order __x__ ) volatile
3244 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3247 inline char atomic_char::fetch_and
3248 ( char __m__, memory_order __x__ ) volatile
3249 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3252 inline char atomic_char::fetch_or
3253 ( char __m__, memory_order __x__ ) volatile
3254 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3257 inline char atomic_char::fetch_xor
3258 ( char __m__, memory_order __x__ ) volatile
3259 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3262 inline signed char atomic_schar::fetch_add
3263 ( signed char __m__, memory_order __x__ ) volatile
3264 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3267 inline signed char atomic_schar::fetch_sub
3268 ( signed char __m__, memory_order __x__ ) volatile
3269 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3272 inline signed char atomic_schar::fetch_and
3273 ( signed char __m__, memory_order __x__ ) volatile
3274 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3277 inline signed char atomic_schar::fetch_or
3278 ( signed char __m__, memory_order __x__ ) volatile
3279 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3282 inline signed char atomic_schar::fetch_xor
3283 ( signed char __m__, memory_order __x__ ) volatile
3284 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3287 inline unsigned char atomic_uchar::fetch_add
3288 ( unsigned char __m__, memory_order __x__ ) volatile
3289 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3292 inline unsigned char atomic_uchar::fetch_sub
3293 ( unsigned char __m__, memory_order __x__ ) volatile
3294 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3297 inline unsigned char atomic_uchar::fetch_and
3298 ( unsigned char __m__, memory_order __x__ ) volatile
3299 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3302 inline unsigned char atomic_uchar::fetch_or
3303 ( unsigned char __m__, memory_order __x__ ) volatile
3304 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3307 inline unsigned char atomic_uchar::fetch_xor
3308 ( unsigned char __m__, memory_order __x__ ) volatile
3309 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3312 inline short atomic_short::fetch_add
3313 ( short __m__, memory_order __x__ ) volatile
3314 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3317 inline short atomic_short::fetch_sub
3318 ( short __m__, memory_order __x__ ) volatile
3319 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3322 inline short atomic_short::fetch_and
3323 ( short __m__, memory_order __x__ ) volatile
3324 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3327 inline short atomic_short::fetch_or
3328 ( short __m__, memory_order __x__ ) volatile
3329 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3332 inline short atomic_short::fetch_xor
3333 ( short __m__, memory_order __x__ ) volatile
3334 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3337 inline unsigned short atomic_ushort::fetch_add
3338 ( unsigned short __m__, memory_order __x__ ) volatile
3339 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3342 inline unsigned short atomic_ushort::fetch_sub
3343 ( unsigned short __m__, memory_order __x__ ) volatile
3344 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3347 inline unsigned short atomic_ushort::fetch_and
3348 ( unsigned short __m__, memory_order __x__ ) volatile
3349 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3352 inline unsigned short atomic_ushort::fetch_or
3353 ( unsigned short __m__, memory_order __x__ ) volatile
3354 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3357 inline unsigned short atomic_ushort::fetch_xor
3358 ( unsigned short __m__, memory_order __x__ ) volatile
3359 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3362 inline int atomic_int::fetch_add
3363 ( int __m__, memory_order __x__ ) volatile
3364 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3367 inline int atomic_int::fetch_sub
3368 ( int __m__, memory_order __x__ ) volatile
3369 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3372 inline int atomic_int::fetch_and
3373 ( int __m__, memory_order __x__ ) volatile
3374 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3377 inline int atomic_int::fetch_or
3378 ( int __m__, memory_order __x__ ) volatile
3379 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3382 inline int atomic_int::fetch_xor
3383 ( int __m__, memory_order __x__ ) volatile
3384 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3387 inline unsigned int atomic_uint::fetch_add
3388 ( unsigned int __m__, memory_order __x__ ) volatile
3389 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3392 inline unsigned int atomic_uint::fetch_sub
3393 ( unsigned int __m__, memory_order __x__ ) volatile
3394 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3397 inline unsigned int atomic_uint::fetch_and
3398 ( unsigned int __m__, memory_order __x__ ) volatile
3399 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3402 inline unsigned int atomic_uint::fetch_or
3403 ( unsigned int __m__, memory_order __x__ ) volatile
3404 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3407 inline unsigned int atomic_uint::fetch_xor
3408 ( unsigned int __m__, memory_order __x__ ) volatile
3409 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3412 inline long atomic_long::fetch_add
3413 ( long __m__, memory_order __x__ ) volatile
3414 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3417 inline long atomic_long::fetch_sub
3418 ( long __m__, memory_order __x__ ) volatile
3419 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3422 inline long atomic_long::fetch_and
3423 ( long __m__, memory_order __x__ ) volatile
3424 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3427 inline long atomic_long::fetch_or
3428 ( long __m__, memory_order __x__ ) volatile
3429 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3432 inline long atomic_long::fetch_xor
3433 ( long __m__, memory_order __x__ ) volatile
3434 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3437 inline unsigned long atomic_ulong::fetch_add
3438 ( unsigned long __m__, memory_order __x__ ) volatile
3439 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3442 inline unsigned long atomic_ulong::fetch_sub
3443 ( unsigned long __m__, memory_order __x__ ) volatile
3444 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3447 inline unsigned long atomic_ulong::fetch_and
3448 ( unsigned long __m__, memory_order __x__ ) volatile
3449 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3452 inline unsigned long atomic_ulong::fetch_or
3453 ( unsigned long __m__, memory_order __x__ ) volatile
3454 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3457 inline unsigned long atomic_ulong::fetch_xor
3458 ( unsigned long __m__, memory_order __x__ ) volatile
3459 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3462 inline long long atomic_llong::fetch_add
3463 ( long long __m__, memory_order __x__ ) volatile
3464 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3467 inline long long atomic_llong::fetch_sub
3468 ( long long __m__, memory_order __x__ ) volatile
3469 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3472 inline long long atomic_llong::fetch_and
3473 ( long long __m__, memory_order __x__ ) volatile
3474 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3477 inline long long atomic_llong::fetch_or
3478 ( long long __m__, memory_order __x__ ) volatile
3479 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3482 inline long long atomic_llong::fetch_xor
3483 ( long long __m__, memory_order __x__ ) volatile
3484 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3487 inline unsigned long long atomic_ullong::fetch_add
3488 ( unsigned long long __m__, memory_order __x__ ) volatile
3489 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3492 inline unsigned long long atomic_ullong::fetch_sub
3493 ( unsigned long long __m__, memory_order __x__ ) volatile
3494 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3497 inline unsigned long long atomic_ullong::fetch_and
3498 ( unsigned long long __m__, memory_order __x__ ) volatile
3499 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3502 inline unsigned long long atomic_ullong::fetch_or
3503 ( unsigned long long __m__, memory_order __x__ ) volatile
3504 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3507 inline unsigned long long atomic_ullong::fetch_xor
3508 ( unsigned long long __m__, memory_order __x__ ) volatile
3509 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3512 inline wchar_t atomic_wchar_t::fetch_add
3513 ( wchar_t __m__, memory_order __x__ ) volatile
3514 { return atomic_fetch_add_explicit( this, __m__, __x__ ); }
3517 inline wchar_t atomic_wchar_t::fetch_sub
3518 ( wchar_t __m__, memory_order __x__ ) volatile
3519 { return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
3522 inline wchar_t atomic_wchar_t::fetch_and
3523 ( wchar_t __m__, memory_order __x__ ) volatile
3524 { return atomic_fetch_and_explicit( this, __m__, __x__ ); }
3527 inline wchar_t atomic_wchar_t::fetch_or
3528 ( wchar_t __m__, memory_order __x__ ) volatile
3529 { return atomic_fetch_or_explicit( this, __m__, __x__ ); }
3532 inline wchar_t atomic_wchar_t::fetch_xor
3533 ( wchar_t __m__, memory_order __x__ ) volatile
3534 { return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
3537 template< typename T >
3538 T* atomic<T*>::load( memory_order __x__ ) volatile
3539 { return static_cast<T*>( atomic_address::load( __x__ ) ); }
3541 template< typename T >
3542 T* atomic<T*>::swap( T* __v__, memory_order __x__ ) volatile
3543 { return static_cast<T*>( atomic_address::swap( __v__, __x__ ) ); }
3545 template< typename T >
3546 bool atomic<T*>::compare_swap
3547 ( T*& __r__, T* __v__, memory_order __x__, memory_order __y__) volatile
3548 { return atomic_address::compare_swap( *reinterpret_cast<void**>( &__r__ ),
3549 static_cast<void*>( __v__ ), __x__, __y__ ); }
3550 //{ return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
3552 template< typename T >
3553 bool atomic<T*>::compare_swap
3554 ( T*& __r__, T* __v__, memory_order __x__ ) volatile
3555 { return compare_swap( __r__, __v__, __x__,
3556 __x__ == memory_order_acq_rel ? memory_order_acquire :
3557 __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3559 template< typename T >
3560 T* atomic<T*>::fetch_add( ptrdiff_t __v__, memory_order __x__ ) volatile
3561 { return atomic_fetch_add_explicit( this, sizeof(T) * __v__, __x__ ); }
3563 template< typename T >
3564 T* atomic<T*>::fetch_sub( ptrdiff_t __v__, memory_order __x__ ) volatile
3565 { return atomic_fetch_sub_explicit( this, sizeof(T) * __v__, __x__ ); }