impatomic: add strong/weak compare_exchange
[model-checker.git] / include / impatomic.h
1 #include "memoryorder.h"
2 #include "cmodelint.h"
3
4 #ifdef __cplusplus
5 namespace std {
6 #endif
7
8 #define CPP0X( feature )
9
10 typedef struct atomic_flag
11 {
12 #ifdef __cplusplus
13     bool test_and_set( memory_order = memory_order_seq_cst ) volatile;
14     void clear( memory_order = memory_order_seq_cst ) volatile;
15     void fence( memory_order ) const volatile;
16
17     CPP0X( atomic_flag() = default; )
18     CPP0X( atomic_flag( const atomic_flag& ) = delete; )
19     atomic_flag& operator =( const atomic_flag& ) CPP0X(=delete);
20
21 CPP0X(private:)
22 #endif
23     bool __f__;
24 } atomic_flag;
25
26 #define ATOMIC_FLAG_INIT { false }
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 extern bool atomic_flag_test_and_set( volatile atomic_flag* );
33 extern bool atomic_flag_test_and_set_explicit
34 ( volatile atomic_flag*, memory_order );
35 extern void atomic_flag_clear( volatile atomic_flag* );
36 extern void atomic_flag_clear_explicit
37 ( volatile atomic_flag*, memory_order );
38 extern void atomic_flag_fence
39 ( const volatile atomic_flag*, memory_order );
40 extern void __atomic_flag_wait__
41 ( volatile atomic_flag* );
42 extern void __atomic_flag_wait_explicit__
43 ( volatile atomic_flag*, memory_order );
44
45 #ifdef __cplusplus
46 }
47 #endif
48
49 #ifdef __cplusplus
50
51 inline bool atomic_flag::test_and_set( memory_order __x__ ) volatile
52 { return atomic_flag_test_and_set_explicit( this, __x__ ); }
53
54 inline void atomic_flag::clear( memory_order __x__ ) volatile
55 { atomic_flag_clear_explicit( this, __x__ ); }
56
57 inline void atomic_flag::fence( memory_order __x__ ) const volatile
58 { atomic_flag_fence( this, __x__ ); }
59
60 #endif
61
62
63 /*
64         The remainder of the example implementation uses the following
65         macros. These macros exploit GNU extensions for value-returning
66         blocks (AKA statement expressions) and __typeof__.
67
68         The macros rely on data fields of atomic structs being named __f__.
69         Other symbols used are __a__=atomic, __e__=expected, __f__=field,
70         __g__=flag, __m__=modified, __o__=operation, __r__=result,
71         __p__=pointer to field, __v__=value (for single evaluation),
72         __x__=memory-ordering, and __y__=memory-ordering.
73 */
74
75 #define _ATOMIC_LOAD_( __a__, __x__ )                                         \
76         ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__);   \
77                 __typeof__((__a__)->__f__) __r__ = (__typeof__((__a__)->__f__))model_read_action((void *)__p__, __x__);  \
78                 __r__; })
79
80 #define _ATOMIC_STORE_( __a__, __m__, __x__ )                                 \
81         ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__);   \
82                 __typeof__(__m__) __v__ = (__m__);                            \
83                 model_write_action((void *) __p__,  __x__, (uint64_t) __v__); \
84                 __v__; })
85
86
87 #define _ATOMIC_INIT_( __a__, __m__ )                                         \
88         ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__);   \
89                 __typeof__(__m__) __v__ = (__m__);                            \
90                 model_init_action((void *) __p__,  (uint64_t) __v__);         \
91                 __v__; })
92
93 #define _ATOMIC_MODIFY_( __a__, __o__, __m__, __x__ )                         \
94         ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__);   \
95         __typeof__((__a__)->__f__) __old__=(__typeof__((__a__)->__f__)) model_rmwr_action((void *)__p__, __x__); \
96         __typeof__(__m__) __v__ = (__m__);                                    \
97         __typeof__((__a__)->__f__) __copy__= __old__;                         \
98         __copy__ __o__ __v__;                                                 \
99         model_rmw_action((void *)__p__, __x__, (uint64_t) __copy__);          \
100         __old__; })
101
102 /* No spurious failure for now */
103 #define _ATOMIC_CMPSWP_WEAK_ _ATOMIC_CMPSWP_
104
105 #define _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ )                         \
106         ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__);   \
107                 __typeof__(__e__) __q__ = (__e__);                            \
108                 __typeof__(__m__) __v__ = (__m__);                            \
109                 bool __r__;                                                   \
110                 __typeof__((__a__)->__f__) __t__=(__typeof__((__a__)->__f__)) model_rmwr_action((void *)__p__, __x__); \
111                 if (__t__ == * __q__ ) {                                      \
112                         model_rmw_action((void *)__p__, __x__, (uint64_t) __v__); __r__ = true; } \
113                 else {  model_rmwc_action((void *)__p__, __x__); *__q__ = __t__;  __r__ = false;} \
114                 __r__; })
115
116 #define _ATOMIC_FENCE_( __a__, __x__ ) \
117         ({ model_fence_action(__x__);})
118  
119
120 #define ATOMIC_CHAR_LOCK_FREE 1
121 #define ATOMIC_CHAR16_T_LOCK_FREE 1
122 #define ATOMIC_CHAR32_T_LOCK_FREE 1
123 #define ATOMIC_WCHAR_T_LOCK_FREE 1
124 #define ATOMIC_SHORT_LOCK_FREE 1
125 #define ATOMIC_INT_LOCK_FREE 1
126 #define ATOMIC_LONG_LOCK_FREE 1
127 #define ATOMIC_LLONG_LOCK_FREE 1
128 #define ATOMIC_ADDRESS_LOCK_FREE 1
129
130 typedef struct atomic_bool
131 {
132 #ifdef __cplusplus
133     bool is_lock_free() const volatile;
134     void store( bool, memory_order = memory_order_seq_cst ) volatile;
135     bool load( memory_order = memory_order_seq_cst ) volatile;
136     bool exchange( bool, memory_order = memory_order_seq_cst ) volatile;
137     bool compare_exchange_weak ( bool&, bool, memory_order, memory_order ) volatile;
138     bool compare_exchange_strong ( bool&, bool, memory_order, memory_order ) volatile;
139     bool compare_exchange_weak ( bool&, bool,
140                         memory_order = memory_order_seq_cst) volatile;
141     bool compare_exchange_strong ( bool&, bool,
142                         memory_order = memory_order_seq_cst) volatile;
143     void fence( memory_order ) const volatile;
144
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);
149
150     bool operator =( bool __v__ ) volatile
151     { store( __v__ ); return __v__; }
152
153     friend void atomic_store_explicit( volatile atomic_bool*, bool,
154                                        memory_order );
155     friend bool atomic_load_explicit( volatile atomic_bool*, memory_order );
156     friend bool atomic_exchange_explicit( volatile atomic_bool*, bool,
157                                       memory_order );
158     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_bool*, bool*, bool,
159                                               memory_order, memory_order );
160     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_bool*, bool*, bool,
161                                               memory_order, memory_order );
162     friend void atomic_fence( const volatile atomic_bool*, memory_order );
163
164 CPP0X(private:)
165 #endif
166     bool __f__;
167 } atomic_bool;
168
169
170 typedef struct atomic_address
171 {
172 #ifdef __cplusplus
173     bool is_lock_free() const volatile;
174     void store( void*, memory_order = memory_order_seq_cst ) volatile;
175     void* load( memory_order = memory_order_seq_cst ) volatile;
176     void* exchange( void*, memory_order = memory_order_seq_cst ) volatile;
177     bool compare_exchange_weak( void*&, void*, memory_order, memory_order ) volatile;
178     bool compare_exchange_strong( void*&, void*, memory_order, memory_order ) volatile;
179     bool compare_exchange_weak( void*&, void*,
180                        memory_order = memory_order_seq_cst ) volatile;
181     bool compare_exchange_strong( void*&, void*,
182                        memory_order = memory_order_seq_cst ) volatile;
183     void fence( memory_order ) const volatile;
184     void* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
185     void* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
186
187     CPP0X( atomic_address() = default; )
188     CPP0X( constexpr explicit atomic_address( void* __v__ ) : __f__( __v__) { } )
189     CPP0X( atomic_address( const atomic_address& ) = delete; )
190     atomic_address& operator =( const atomic_address & ) CPP0X(=delete);
191
192     void* operator =( void* __v__ ) volatile
193     { store( __v__ ); return __v__; }
194
195     void* operator +=( ptrdiff_t __v__ ) volatile
196     { return fetch_add( __v__ ); }
197
198     void* operator -=( ptrdiff_t __v__ ) volatile
199     { return fetch_sub( __v__ ); }
200
201     friend void atomic_store_explicit( volatile atomic_address*, void*,
202                                        memory_order );
203     friend void* atomic_load_explicit( volatile atomic_address*, memory_order );
204     friend void* atomic_exchange_explicit( volatile atomic_address*, void*,
205                                        memory_order );
206     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_address*,
207                               void**, void*, memory_order, memory_order );
208     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_address*,
209                               void**, void*, memory_order, memory_order );
210     friend void atomic_fence( const volatile atomic_address*, memory_order );
211     friend void* atomic_fetch_add_explicit( volatile atomic_address*, ptrdiff_t,
212                                             memory_order );
213     friend void* atomic_fetch_sub_explicit( volatile atomic_address*, ptrdiff_t,
214                                             memory_order );
215
216 CPP0X(private:)
217 #endif
218     void* __f__;
219 } atomic_address;
220
221
222 typedef struct atomic_char
223 {
224 #ifdef __cplusplus
225     bool is_lock_free() const volatile;
226     void store( char,
227                 memory_order = memory_order_seq_cst ) volatile;
228     char load( memory_order = memory_order_seq_cst ) volatile;
229     char exchange( char,
230                       memory_order = memory_order_seq_cst ) volatile;
231     bool compare_exchange_weak( char&, char,
232                        memory_order, memory_order ) volatile;
233     bool compare_exchange_strong( char&, char,
234                        memory_order, memory_order ) volatile;
235     bool compare_exchange_weak( char&, char,
236                        memory_order = memory_order_seq_cst ) volatile;
237     bool compare_exchange_strong( char&, char,
238                        memory_order = memory_order_seq_cst ) volatile;
239     void fence( memory_order ) const volatile;
240     char fetch_add( char,
241                            memory_order = memory_order_seq_cst ) volatile;
242     char fetch_sub( char,
243                            memory_order = memory_order_seq_cst ) volatile;
244     char fetch_and( char,
245                            memory_order = memory_order_seq_cst ) volatile;
246     char fetch_or( char,
247                            memory_order = memory_order_seq_cst ) volatile;
248     char fetch_xor( char,
249                            memory_order = memory_order_seq_cst ) volatile;
250
251     CPP0X( atomic_char() = default; )
252     CPP0X( constexpr atomic_char( char __v__ ) : __f__( __v__) { } )
253     CPP0X( atomic_char( const atomic_char& ) = delete; )
254     atomic_char& operator =( const atomic_char& ) CPP0X(=delete);
255
256     char operator =( char __v__ ) volatile
257     { store( __v__ ); return __v__; }
258
259     char operator ++( int ) volatile
260     { return fetch_add( 1 ); }
261
262     char operator --( int ) volatile
263     { return fetch_sub( 1 ); }
264
265     char operator ++() volatile
266     { return fetch_add( 1 ) + 1; }
267
268     char operator --() volatile
269     { return fetch_sub( 1 ) - 1; }
270
271     char operator +=( char __v__ ) volatile
272     { return fetch_add( __v__ ) + __v__; }
273
274     char operator -=( char __v__ ) volatile
275     { return fetch_sub( __v__ ) - __v__; }
276
277     char operator &=( char __v__ ) volatile
278     { return fetch_and( __v__ ) & __v__; }
279
280     char operator |=( char __v__ ) volatile
281     { return fetch_or( __v__ ) | __v__; }
282
283     char operator ^=( char __v__ ) volatile
284     { return fetch_xor( __v__ ) ^ __v__; }
285
286     friend void atomic_store_explicit( volatile atomic_char*, char,
287                                        memory_order );
288     friend char atomic_load_explicit( volatile atomic_char*,
289                                              memory_order );
290     friend char atomic_exchange_explicit( volatile atomic_char*,
291                                              char, memory_order );
292     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_char*,
293                       char*, char, memory_order, memory_order );
294     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_char*,
295                       char*, char, memory_order, memory_order );
296     friend void atomic_fence( const volatile atomic_char*, memory_order );
297     friend char atomic_fetch_add_explicit( volatile atomic_char*,
298                                                   char, memory_order );
299     friend char atomic_fetch_sub_explicit( volatile atomic_char*,
300                                                   char, memory_order );
301     friend char atomic_fetch_and_explicit( volatile atomic_char*,
302                                                   char, memory_order );
303     friend char atomic_fetch_or_explicit(  volatile atomic_char*,
304                                                   char, memory_order );
305     friend char atomic_fetch_xor_explicit( volatile atomic_char*,
306                                                   char, memory_order );
307
308 CPP0X(private:)
309 #endif
310     char __f__;
311 } atomic_char;
312
313
314 typedef struct atomic_schar
315 {
316 #ifdef __cplusplus
317     bool is_lock_free() const volatile;
318     void store( signed char,
319                 memory_order = memory_order_seq_cst ) volatile;
320     signed char load( memory_order = memory_order_seq_cst ) volatile;
321     signed char exchange( signed char,
322                       memory_order = memory_order_seq_cst ) volatile;
323     bool compare_exchange_weak( signed char&, signed char,
324                        memory_order, memory_order ) volatile;
325     bool compare_exchange_strong( signed char&, signed char,
326                        memory_order, memory_order ) volatile;
327     bool compare_exchange_weak( signed char&, signed char,
328                        memory_order = memory_order_seq_cst ) volatile;
329     bool compare_exchange_strong( signed char&, signed char,
330                        memory_order = memory_order_seq_cst ) volatile;
331     void fence( memory_order ) const volatile;
332     signed char fetch_add( signed char,
333                            memory_order = memory_order_seq_cst ) volatile;
334     signed char fetch_sub( signed char,
335                            memory_order = memory_order_seq_cst ) volatile;
336     signed char fetch_and( signed char,
337                            memory_order = memory_order_seq_cst ) volatile;
338     signed char fetch_or( signed char,
339                            memory_order = memory_order_seq_cst ) volatile;
340     signed char fetch_xor( signed char,
341                            memory_order = memory_order_seq_cst ) volatile;
342
343     CPP0X( atomic_schar() = default; )
344     CPP0X( constexpr atomic_schar( signed char __v__ ) : __f__( __v__) { } )
345     CPP0X( atomic_schar( const atomic_schar& ) = delete; )
346     atomic_schar& operator =( const atomic_schar& ) CPP0X(=delete);
347
348     signed char operator =( signed char __v__ ) volatile
349     { store( __v__ ); return __v__; }
350
351     signed char operator ++( int ) volatile
352     { return fetch_add( 1 ); }
353
354     signed char operator --( int ) volatile
355     { return fetch_sub( 1 ); }
356
357     signed char operator ++() volatile
358     { return fetch_add( 1 ) + 1; }
359
360     signed char operator --() volatile
361     { return fetch_sub( 1 ) - 1; }
362
363     signed char operator +=( signed char __v__ ) volatile
364     { return fetch_add( __v__ ) + __v__; }
365
366     signed char operator -=( signed char __v__ ) volatile
367     { return fetch_sub( __v__ ) - __v__; }
368
369     signed char operator &=( signed char __v__ ) volatile
370     { return fetch_and( __v__ ) & __v__; }
371
372     signed char operator |=( signed char __v__ ) volatile
373     { return fetch_or( __v__ ) | __v__; }
374
375     signed char operator ^=( signed char __v__ ) volatile
376     { return fetch_xor( __v__ ) ^ __v__; }
377
378     friend void atomic_store_explicit( volatile atomic_schar*, signed char,
379                                        memory_order );
380     friend signed char atomic_load_explicit( volatile atomic_schar*,
381                                              memory_order );
382     friend signed char atomic_exchange_explicit( volatile atomic_schar*,
383                                              signed char, memory_order );
384     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_schar*,
385                       signed char*, signed char, memory_order, memory_order );
386     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_schar*,
387                       signed char*, signed char, memory_order, memory_order );
388     friend void atomic_fence( const volatile atomic_schar*, memory_order );
389     friend signed char atomic_fetch_add_explicit( volatile atomic_schar*,
390                                                   signed char, memory_order );
391     friend signed char atomic_fetch_sub_explicit( volatile atomic_schar*,
392                                                   signed char, memory_order );
393     friend signed char atomic_fetch_and_explicit( volatile atomic_schar*,
394                                                   signed char, memory_order );
395     friend signed char atomic_fetch_or_explicit(  volatile atomic_schar*,
396                                                   signed char, memory_order );
397     friend signed char atomic_fetch_xor_explicit( volatile atomic_schar*,
398                                                   signed char, memory_order );
399
400 CPP0X(private:)
401 #endif
402     signed char __f__;
403 } atomic_schar;
404
405
406 typedef struct atomic_uchar
407 {
408 #ifdef __cplusplus
409     bool is_lock_free() const volatile;
410     void store( unsigned char,
411                 memory_order = memory_order_seq_cst ) volatile;
412     unsigned char load( memory_order = memory_order_seq_cst ) volatile;
413     unsigned char exchange( unsigned char,
414                       memory_order = memory_order_seq_cst ) volatile;
415     bool compare_exchange_weak( unsigned char&, unsigned char,
416                        memory_order, memory_order ) volatile;
417     bool compare_exchange_strong( unsigned char&, unsigned char,
418                        memory_order, memory_order ) volatile;
419     bool compare_exchange_weak( unsigned char&, unsigned char,
420                        memory_order = memory_order_seq_cst ) volatile;
421     bool compare_exchange_strong( unsigned char&, unsigned char,
422                        memory_order = memory_order_seq_cst ) volatile;
423     void fence( memory_order ) const volatile;
424     unsigned char fetch_add( unsigned char,
425                            memory_order = memory_order_seq_cst ) volatile;
426     unsigned char fetch_sub( unsigned char,
427                            memory_order = memory_order_seq_cst ) volatile;
428     unsigned char fetch_and( unsigned char,
429                            memory_order = memory_order_seq_cst ) volatile;
430     unsigned char fetch_or( unsigned char,
431                            memory_order = memory_order_seq_cst ) volatile;
432     unsigned char fetch_xor( unsigned char,
433                            memory_order = memory_order_seq_cst ) volatile;
434
435     CPP0X( atomic_uchar() = default; )
436     CPP0X( constexpr atomic_uchar( unsigned char __v__ ) : __f__( __v__) { } )
437     CPP0X( atomic_uchar( const atomic_uchar& ) = delete; )
438     atomic_uchar& operator =( const atomic_uchar& ) CPP0X(=delete);
439
440     unsigned char operator =( unsigned char __v__ ) volatile
441     { store( __v__ ); return __v__; }
442
443     unsigned char operator ++( int ) volatile
444     { return fetch_add( 1 ); }
445
446     unsigned char operator --( int ) volatile
447     { return fetch_sub( 1 ); }
448
449     unsigned char operator ++() volatile
450     { return fetch_add( 1 ) + 1; }
451
452     unsigned char operator --() volatile
453     { return fetch_sub( 1 ) - 1; }
454
455     unsigned char operator +=( unsigned char __v__ ) volatile
456     { return fetch_add( __v__ ) + __v__; }
457
458     unsigned char operator -=( unsigned char __v__ ) volatile
459     { return fetch_sub( __v__ ) - __v__; }
460
461     unsigned char operator &=( unsigned char __v__ ) volatile
462     { return fetch_and( __v__ ) & __v__; }
463
464     unsigned char operator |=( unsigned char __v__ ) volatile
465     { return fetch_or( __v__ ) | __v__; }
466
467     unsigned char operator ^=( unsigned char __v__ ) volatile
468     { return fetch_xor( __v__ ) ^ __v__; }
469
470     friend void atomic_store_explicit( volatile atomic_uchar*, unsigned char,
471                                        memory_order );
472     friend unsigned char atomic_load_explicit( volatile atomic_uchar*,
473                                              memory_order );
474     friend unsigned char atomic_exchange_explicit( volatile atomic_uchar*,
475                                              unsigned char, memory_order );
476     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_uchar*,
477                       unsigned char*, unsigned char, memory_order, memory_order );
478     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_uchar*,
479                       unsigned char*, unsigned char, memory_order, memory_order );
480     friend void atomic_fence( const volatile atomic_uchar*, memory_order );
481     friend unsigned char atomic_fetch_add_explicit( volatile atomic_uchar*,
482                                                   unsigned char, memory_order );
483     friend unsigned char atomic_fetch_sub_explicit( volatile atomic_uchar*,
484                                                   unsigned char, memory_order );
485     friend unsigned char atomic_fetch_and_explicit( volatile atomic_uchar*,
486                                                   unsigned char, memory_order );
487     friend unsigned char atomic_fetch_or_explicit(  volatile atomic_uchar*,
488                                                   unsigned char, memory_order );
489     friend unsigned char atomic_fetch_xor_explicit( volatile atomic_uchar*,
490                                                   unsigned char, memory_order );
491
492 CPP0X(private:)
493 #endif
494     unsigned char __f__;
495 } atomic_uchar;
496
497
498 typedef struct atomic_short
499 {
500 #ifdef __cplusplus
501     bool is_lock_free() const volatile;
502     void store( short,
503                 memory_order = memory_order_seq_cst ) volatile;
504     short load( memory_order = memory_order_seq_cst ) volatile;
505     short exchange( short,
506                       memory_order = memory_order_seq_cst ) volatile;
507     bool compare_exchange_weak( short&, short,
508                        memory_order, memory_order ) volatile;
509     bool compare_exchange_strong( short&, short,
510                        memory_order, memory_order ) volatile;
511     bool compare_exchange_weak( short&, short,
512                        memory_order = memory_order_seq_cst ) volatile;
513     bool compare_exchange_strong( short&, short,
514                        memory_order = memory_order_seq_cst ) volatile;
515     void fence( memory_order ) const volatile;
516     short fetch_add( short,
517                            memory_order = memory_order_seq_cst ) volatile;
518     short fetch_sub( short,
519                            memory_order = memory_order_seq_cst ) volatile;
520     short fetch_and( short,
521                            memory_order = memory_order_seq_cst ) volatile;
522     short fetch_or( short,
523                            memory_order = memory_order_seq_cst ) volatile;
524     short fetch_xor( short,
525                            memory_order = memory_order_seq_cst ) volatile;
526
527     CPP0X( atomic_short() = default; )
528     CPP0X( constexpr atomic_short( short __v__ ) : __f__( __v__) { } )
529     CPP0X( atomic_short( const atomic_short& ) = delete; )
530     atomic_short& operator =( const atomic_short& ) CPP0X(=delete);
531
532     short operator =( short __v__ ) volatile
533     { store( __v__ ); return __v__; }
534
535     short operator ++( int ) volatile
536     { return fetch_add( 1 ); }
537
538     short operator --( int ) volatile
539     { return fetch_sub( 1 ); }
540
541     short operator ++() volatile
542     { return fetch_add( 1 ) + 1; }
543
544     short operator --() volatile
545     { return fetch_sub( 1 ) - 1; }
546
547     short operator +=( short __v__ ) volatile
548     { return fetch_add( __v__ ) + __v__; }
549
550     short operator -=( short __v__ ) volatile
551     { return fetch_sub( __v__ ) - __v__; }
552
553     short operator &=( short __v__ ) volatile
554     { return fetch_and( __v__ ) & __v__; }
555
556     short operator |=( short __v__ ) volatile
557     { return fetch_or( __v__ ) | __v__; }
558
559     short operator ^=( short __v__ ) volatile
560     { return fetch_xor( __v__ ) ^ __v__; }
561
562     friend void atomic_store_explicit( volatile atomic_short*, short,
563                                        memory_order );
564     friend short atomic_load_explicit( volatile atomic_short*,
565                                              memory_order );
566     friend short atomic_exchange_explicit( volatile atomic_short*,
567                                              short, memory_order );
568     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_short*,
569                       short*, short, memory_order, memory_order );
570     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_short*,
571                       short*, short, memory_order, memory_order );
572     friend void atomic_fence( const volatile atomic_short*, memory_order );
573     friend short atomic_fetch_add_explicit( volatile atomic_short*,
574                                                   short, memory_order );
575     friend short atomic_fetch_sub_explicit( volatile atomic_short*,
576                                                   short, memory_order );
577     friend short atomic_fetch_and_explicit( volatile atomic_short*,
578                                                   short, memory_order );
579     friend short atomic_fetch_or_explicit(  volatile atomic_short*,
580                                                   short, memory_order );
581     friend short atomic_fetch_xor_explicit( volatile atomic_short*,
582                                                   short, memory_order );
583
584 CPP0X(private:)
585 #endif
586     short __f__;
587 } atomic_short;
588
589
590 typedef struct atomic_ushort
591 {
592 #ifdef __cplusplus
593     bool is_lock_free() const volatile;
594     void store( unsigned short,
595                 memory_order = memory_order_seq_cst ) volatile;
596     unsigned short load( memory_order = memory_order_seq_cst ) volatile;
597     unsigned short exchange( unsigned short,
598                       memory_order = memory_order_seq_cst ) volatile;
599     bool compare_exchange_weak( unsigned short&, unsigned short,
600                        memory_order, memory_order ) volatile;
601     bool compare_exchange_strong( unsigned short&, unsigned short,
602                        memory_order, memory_order ) volatile;
603     bool compare_exchange_weak( unsigned short&, unsigned short,
604                        memory_order = memory_order_seq_cst ) volatile;
605     bool compare_exchange_strong( unsigned short&, unsigned short,
606                        memory_order = memory_order_seq_cst ) volatile;
607     void fence( memory_order ) const volatile;
608     unsigned short fetch_add( unsigned short,
609                            memory_order = memory_order_seq_cst ) volatile;
610     unsigned short fetch_sub( unsigned short,
611                            memory_order = memory_order_seq_cst ) volatile;
612     unsigned short fetch_and( unsigned short,
613                            memory_order = memory_order_seq_cst ) volatile;
614     unsigned short fetch_or( unsigned short,
615                            memory_order = memory_order_seq_cst ) volatile;
616     unsigned short fetch_xor( unsigned short,
617                            memory_order = memory_order_seq_cst ) volatile;
618
619     CPP0X( atomic_ushort() = default; )
620     CPP0X( constexpr atomic_ushort( unsigned short __v__ ) : __f__( __v__) { } )
621     CPP0X( atomic_ushort( const atomic_ushort& ) = delete; )
622     atomic_ushort& operator =( const atomic_ushort& ) CPP0X(=delete);
623
624     unsigned short operator =( unsigned short __v__ ) volatile
625     { store( __v__ ); return __v__; }
626
627     unsigned short operator ++( int ) volatile
628     { return fetch_add( 1 ); }
629
630     unsigned short operator --( int ) volatile
631     { return fetch_sub( 1 ); }
632
633     unsigned short operator ++() volatile
634     { return fetch_add( 1 ) + 1; }
635
636     unsigned short operator --() volatile
637     { return fetch_sub( 1 ) - 1; }
638
639     unsigned short operator +=( unsigned short __v__ ) volatile
640     { return fetch_add( __v__ ) + __v__; }
641
642     unsigned short operator -=( unsigned short __v__ ) volatile
643     { return fetch_sub( __v__ ) - __v__; }
644
645     unsigned short operator &=( unsigned short __v__ ) volatile
646     { return fetch_and( __v__ ) & __v__; }
647
648     unsigned short operator |=( unsigned short __v__ ) volatile
649     { return fetch_or( __v__ ) | __v__; }
650
651     unsigned short operator ^=( unsigned short __v__ ) volatile
652     { return fetch_xor( __v__ ) ^ __v__; }
653
654     friend void atomic_store_explicit( volatile atomic_ushort*, unsigned short,
655                                        memory_order );
656     friend unsigned short atomic_load_explicit( volatile atomic_ushort*,
657                                              memory_order );
658     friend unsigned short atomic_exchange_explicit( volatile atomic_ushort*,
659                                              unsigned short, memory_order );
660     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ushort*,
661                       unsigned short*, unsigned short, memory_order, memory_order );
662     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ushort*,
663                       unsigned short*, unsigned short, memory_order, memory_order );
664     friend void atomic_fence( const volatile atomic_ushort*, memory_order );
665     friend unsigned short atomic_fetch_add_explicit( volatile atomic_ushort*,
666                                                   unsigned short, memory_order );
667     friend unsigned short atomic_fetch_sub_explicit( volatile atomic_ushort*,
668                                                   unsigned short, memory_order );
669     friend unsigned short atomic_fetch_and_explicit( volatile atomic_ushort*,
670                                                   unsigned short, memory_order );
671     friend unsigned short atomic_fetch_or_explicit(  volatile atomic_ushort*,
672                                                   unsigned short, memory_order );
673     friend unsigned short atomic_fetch_xor_explicit( volatile atomic_ushort*,
674                                                   unsigned short, memory_order );
675
676 CPP0X(private:)
677 #endif
678     unsigned short __f__;
679 } atomic_ushort;
680
681
682 typedef struct atomic_int
683 {
684 #ifdef __cplusplus
685     bool is_lock_free() const volatile;
686     void store( int,
687                 memory_order = memory_order_seq_cst ) volatile;
688     int load( memory_order = memory_order_seq_cst ) volatile;
689     int exchange( int,
690                       memory_order = memory_order_seq_cst ) volatile;
691     bool compare_exchange_weak( int&, int,
692                        memory_order, memory_order ) volatile;
693     bool compare_exchange_strong( int&, int,
694                        memory_order, memory_order ) volatile;
695     bool compare_exchange_weak( int&, int,
696                        memory_order = memory_order_seq_cst ) volatile;
697     bool compare_exchange_strong( int&, int,
698                        memory_order = memory_order_seq_cst ) volatile;
699     void fence( memory_order ) const volatile;
700     int fetch_add( int,
701                            memory_order = memory_order_seq_cst ) volatile;
702     int fetch_sub( int,
703                            memory_order = memory_order_seq_cst ) volatile;
704     int fetch_and( int,
705                            memory_order = memory_order_seq_cst ) volatile;
706     int fetch_or( int,
707                            memory_order = memory_order_seq_cst ) volatile;
708     int fetch_xor( int,
709                            memory_order = memory_order_seq_cst ) volatile;
710
711     CPP0X( atomic_int() = default; )
712     CPP0X( constexpr atomic_int( int __v__ ) : __f__( __v__) { } )
713     CPP0X( atomic_int( const atomic_int& ) = delete; )
714     atomic_int& operator =( const atomic_int& ) CPP0X(=delete);
715
716     int operator =( int __v__ ) volatile
717     { store( __v__ ); return __v__; }
718
719     int operator ++( int ) volatile
720     { return fetch_add( 1 ); }
721
722     int operator --( int ) volatile
723     { return fetch_sub( 1 ); }
724
725     int operator ++() volatile
726     { return fetch_add( 1 ) + 1; }
727
728     int operator --() volatile
729     { return fetch_sub( 1 ) - 1; }
730
731     int operator +=( int __v__ ) volatile
732     { return fetch_add( __v__ ) + __v__; }
733
734     int operator -=( int __v__ ) volatile
735     { return fetch_sub( __v__ ) - __v__; }
736
737     int operator &=( int __v__ ) volatile
738     { return fetch_and( __v__ ) & __v__; }
739
740     int operator |=( int __v__ ) volatile
741     { return fetch_or( __v__ ) | __v__; }
742
743     int operator ^=( int __v__ ) volatile
744     { return fetch_xor( __v__ ) ^ __v__; }
745
746     friend void atomic_store_explicit( volatile atomic_int*, int,
747                                        memory_order );
748     friend int atomic_load_explicit( volatile atomic_int*,
749                                              memory_order );
750     friend int atomic_exchange_explicit( volatile atomic_int*,
751                                              int, memory_order );
752     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_int*,
753                       int*, int, memory_order, memory_order );
754     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_int*,
755                       int*, int, memory_order, memory_order );
756     friend void atomic_fence( const volatile atomic_int*, memory_order );
757     friend int atomic_fetch_add_explicit( volatile atomic_int*,
758                                                   int, memory_order );
759     friend int atomic_fetch_sub_explicit( volatile atomic_int*,
760                                                   int, memory_order );
761     friend int atomic_fetch_and_explicit( volatile atomic_int*,
762                                                   int, memory_order );
763     friend int atomic_fetch_or_explicit(  volatile atomic_int*,
764                                                   int, memory_order );
765     friend int atomic_fetch_xor_explicit( volatile atomic_int*,
766                                                   int, memory_order );
767
768 CPP0X(private:)
769 #endif
770     int __f__;
771 } atomic_int;
772
773
774 typedef struct atomic_uint
775 {
776 #ifdef __cplusplus
777     bool is_lock_free() const volatile;
778     void store( unsigned int,
779                 memory_order = memory_order_seq_cst ) volatile;
780     unsigned int load( memory_order = memory_order_seq_cst ) volatile;
781     unsigned int exchange( unsigned int,
782                       memory_order = memory_order_seq_cst ) volatile;
783     bool compare_exchange_weak( unsigned int&, unsigned int,
784                        memory_order, memory_order ) volatile;
785     bool compare_exchange_strong( unsigned int&, unsigned int,
786                        memory_order, memory_order ) volatile;
787     bool compare_exchange_weak( unsigned int&, unsigned int,
788                        memory_order = memory_order_seq_cst ) volatile;
789     bool compare_exchange_strong( unsigned int&, unsigned int,
790                        memory_order = memory_order_seq_cst ) volatile;
791     void fence( memory_order ) const volatile;
792     unsigned int fetch_add( unsigned int,
793                            memory_order = memory_order_seq_cst ) volatile;
794     unsigned int fetch_sub( unsigned int,
795                            memory_order = memory_order_seq_cst ) volatile;
796     unsigned int fetch_and( unsigned int,
797                            memory_order = memory_order_seq_cst ) volatile;
798     unsigned int fetch_or( unsigned int,
799                            memory_order = memory_order_seq_cst ) volatile;
800     unsigned int fetch_xor( unsigned int,
801                            memory_order = memory_order_seq_cst ) volatile;
802
803     CPP0X( atomic_uint() = default; )
804     CPP0X( constexpr atomic_uint( unsigned int __v__ ) : __f__( __v__) { } )
805     CPP0X( atomic_uint( const atomic_uint& ) = delete; )
806     atomic_uint& operator =( const atomic_uint& ) CPP0X(=delete);
807
808     unsigned int operator =( unsigned int __v__ ) volatile
809     { store( __v__ ); return __v__; }
810
811     unsigned int operator ++( int ) volatile
812     { return fetch_add( 1 ); }
813
814     unsigned int operator --( int ) volatile
815     { return fetch_sub( 1 ); }
816
817     unsigned int operator ++() volatile
818     { return fetch_add( 1 ) + 1; }
819
820     unsigned int operator --() volatile
821     { return fetch_sub( 1 ) - 1; }
822
823     unsigned int operator +=( unsigned int __v__ ) volatile
824     { return fetch_add( __v__ ) + __v__; }
825
826     unsigned int operator -=( unsigned int __v__ ) volatile
827     { return fetch_sub( __v__ ) - __v__; }
828
829     unsigned int operator &=( unsigned int __v__ ) volatile
830     { return fetch_and( __v__ ) & __v__; }
831
832     unsigned int operator |=( unsigned int __v__ ) volatile
833     { return fetch_or( __v__ ) | __v__; }
834
835     unsigned int operator ^=( unsigned int __v__ ) volatile
836     { return fetch_xor( __v__ ) ^ __v__; }
837
838     friend void atomic_store_explicit( volatile atomic_uint*, unsigned int,
839                                        memory_order );
840     friend unsigned int atomic_load_explicit( volatile atomic_uint*,
841                                              memory_order );
842     friend unsigned int atomic_exchange_explicit( volatile atomic_uint*,
843                                              unsigned int, memory_order );
844     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_uint*,
845                       unsigned int*, unsigned int, memory_order, memory_order );
846     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_uint*,
847                       unsigned int*, unsigned int, memory_order, memory_order );
848     friend void atomic_fence( const volatile atomic_uint*, memory_order );
849     friend unsigned int atomic_fetch_add_explicit( volatile atomic_uint*,
850                                                   unsigned int, memory_order );
851     friend unsigned int atomic_fetch_sub_explicit( volatile atomic_uint*,
852                                                   unsigned int, memory_order );
853     friend unsigned int atomic_fetch_and_explicit( volatile atomic_uint*,
854                                                   unsigned int, memory_order );
855     friend unsigned int atomic_fetch_or_explicit(  volatile atomic_uint*,
856                                                   unsigned int, memory_order );
857     friend unsigned int atomic_fetch_xor_explicit( volatile atomic_uint*,
858                                                   unsigned int, memory_order );
859
860 CPP0X(private:)
861 #endif
862     unsigned int __f__;
863 } atomic_uint;
864
865
866 typedef struct atomic_long
867 {
868 #ifdef __cplusplus
869     bool is_lock_free() const volatile;
870     void store( long,
871                 memory_order = memory_order_seq_cst ) volatile;
872     long load( memory_order = memory_order_seq_cst ) volatile;
873     long exchange( long,
874                       memory_order = memory_order_seq_cst ) volatile;
875     bool compare_exchange_weak( long&, long,
876                        memory_order, memory_order ) volatile;
877     bool compare_exchange_strong( long&, long,
878                        memory_order, memory_order ) volatile;
879     bool compare_exchange_weak( long&, long,
880                        memory_order = memory_order_seq_cst ) volatile;
881     bool compare_exchange_strong( long&, long,
882                        memory_order = memory_order_seq_cst ) volatile;
883     void fence( memory_order ) const volatile;
884     long fetch_add( long,
885                            memory_order = memory_order_seq_cst ) volatile;
886     long fetch_sub( long,
887                            memory_order = memory_order_seq_cst ) volatile;
888     long fetch_and( long,
889                            memory_order = memory_order_seq_cst ) volatile;
890     long fetch_or( long,
891                            memory_order = memory_order_seq_cst ) volatile;
892     long fetch_xor( long,
893                            memory_order = memory_order_seq_cst ) volatile;
894
895     CPP0X( atomic_long() = default; )
896     CPP0X( constexpr atomic_long( long __v__ ) : __f__( __v__) { } )
897     CPP0X( atomic_long( const atomic_long& ) = delete; )
898     atomic_long& operator =( const atomic_long& ) CPP0X(=delete);
899
900     long operator =( long __v__ ) volatile
901     { store( __v__ ); return __v__; }
902
903     long operator ++( int ) volatile
904     { return fetch_add( 1 ); }
905
906     long operator --( int ) volatile
907     { return fetch_sub( 1 ); }
908
909     long operator ++() volatile
910     { return fetch_add( 1 ) + 1; }
911
912     long operator --() volatile
913     { return fetch_sub( 1 ) - 1; }
914
915     long operator +=( long __v__ ) volatile
916     { return fetch_add( __v__ ) + __v__; }
917
918     long operator -=( long __v__ ) volatile
919     { return fetch_sub( __v__ ) - __v__; }
920
921     long operator &=( long __v__ ) volatile
922     { return fetch_and( __v__ ) & __v__; }
923
924     long operator |=( long __v__ ) volatile
925     { return fetch_or( __v__ ) | __v__; }
926
927     long operator ^=( long __v__ ) volatile
928     { return fetch_xor( __v__ ) ^ __v__; }
929
930     friend void atomic_store_explicit( volatile atomic_long*, long,
931                                        memory_order );
932     friend long atomic_load_explicit( volatile atomic_long*,
933                                              memory_order );
934     friend long atomic_exchange_explicit( volatile atomic_long*,
935                                              long, memory_order );
936     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_long*,
937                       long*, long, memory_order, memory_order );
938     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_long*,
939                       long*, long, memory_order, memory_order );
940     friend void atomic_fence( const volatile atomic_long*, memory_order );
941     friend long atomic_fetch_add_explicit( volatile atomic_long*,
942                                                   long, memory_order );
943     friend long atomic_fetch_sub_explicit( volatile atomic_long*,
944                                                   long, memory_order );
945     friend long atomic_fetch_and_explicit( volatile atomic_long*,
946                                                   long, memory_order );
947     friend long atomic_fetch_or_explicit(  volatile atomic_long*,
948                                                   long, memory_order );
949     friend long atomic_fetch_xor_explicit( volatile atomic_long*,
950                                                   long, memory_order );
951
952 CPP0X(private:)
953 #endif
954     long __f__;
955 } atomic_long;
956
957
958 typedef struct atomic_ulong
959 {
960 #ifdef __cplusplus
961     bool is_lock_free() const volatile;
962     void store( unsigned long,
963                 memory_order = memory_order_seq_cst ) volatile;
964     unsigned long load( memory_order = memory_order_seq_cst ) volatile;
965     unsigned long exchange( unsigned long,
966                       memory_order = memory_order_seq_cst ) volatile;
967     bool compare_exchange_weak( unsigned long&, unsigned long,
968                        memory_order, memory_order ) volatile;
969     bool compare_exchange_strong( unsigned long&, unsigned long,
970                        memory_order, memory_order ) volatile;
971     bool compare_exchange_weak( unsigned long&, unsigned long,
972                        memory_order = memory_order_seq_cst ) volatile;
973     bool compare_exchange_strong( unsigned long&, unsigned long,
974                        memory_order = memory_order_seq_cst ) volatile;
975     void fence( memory_order ) const volatile;
976     unsigned long fetch_add( unsigned long,
977                            memory_order = memory_order_seq_cst ) volatile;
978     unsigned long fetch_sub( unsigned long,
979                            memory_order = memory_order_seq_cst ) volatile;
980     unsigned long fetch_and( unsigned long,
981                            memory_order = memory_order_seq_cst ) volatile;
982     unsigned long fetch_or( unsigned long,
983                            memory_order = memory_order_seq_cst ) volatile;
984     unsigned long fetch_xor( unsigned long,
985                            memory_order = memory_order_seq_cst ) volatile;
986
987     CPP0X( atomic_ulong() = default; )
988     CPP0X( constexpr atomic_ulong( unsigned long __v__ ) : __f__( __v__) { } )
989     CPP0X( atomic_ulong( const atomic_ulong& ) = delete; )
990     atomic_ulong& operator =( const atomic_ulong& ) CPP0X(=delete);
991
992     unsigned long operator =( unsigned long __v__ ) volatile
993     { store( __v__ ); return __v__; }
994
995     unsigned long operator ++( int ) volatile
996     { return fetch_add( 1 ); }
997
998     unsigned long operator --( int ) volatile
999     { return fetch_sub( 1 ); }
1000
1001     unsigned long operator ++() volatile
1002     { return fetch_add( 1 ) + 1; }
1003
1004     unsigned long operator --() volatile
1005     { return fetch_sub( 1 ) - 1; }
1006
1007     unsigned long operator +=( unsigned long __v__ ) volatile
1008     { return fetch_add( __v__ ) + __v__; }
1009
1010     unsigned long operator -=( unsigned long __v__ ) volatile
1011     { return fetch_sub( __v__ ) - __v__; }
1012
1013     unsigned long operator &=( unsigned long __v__ ) volatile
1014     { return fetch_and( __v__ ) & __v__; }
1015
1016     unsigned long operator |=( unsigned long __v__ ) volatile
1017     { return fetch_or( __v__ ) | __v__; }
1018
1019     unsigned long operator ^=( unsigned long __v__ ) volatile
1020     { return fetch_xor( __v__ ) ^ __v__; }
1021
1022     friend void atomic_store_explicit( volatile atomic_ulong*, unsigned long,
1023                                        memory_order );
1024     friend unsigned long atomic_load_explicit( volatile atomic_ulong*,
1025                                              memory_order );
1026     friend unsigned long atomic_exchange_explicit( volatile atomic_ulong*,
1027                                              unsigned long, memory_order );
1028     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ulong*,
1029                       unsigned long*, unsigned long, memory_order, memory_order );
1030     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ulong*,
1031                       unsigned long*, unsigned long, memory_order, memory_order );
1032     friend void atomic_fence( const volatile atomic_ulong*, memory_order );
1033     friend unsigned long atomic_fetch_add_explicit( volatile atomic_ulong*,
1034                                                   unsigned long, memory_order );
1035     friend unsigned long atomic_fetch_sub_explicit( volatile atomic_ulong*,
1036                                                   unsigned long, memory_order );
1037     friend unsigned long atomic_fetch_and_explicit( volatile atomic_ulong*,
1038                                                   unsigned long, memory_order );
1039     friend unsigned long atomic_fetch_or_explicit(  volatile atomic_ulong*,
1040                                                   unsigned long, memory_order );
1041     friend unsigned long atomic_fetch_xor_explicit( volatile atomic_ulong*,
1042                                                   unsigned long, memory_order );
1043
1044 CPP0X(private:)
1045 #endif
1046     unsigned long __f__;
1047 } atomic_ulong;
1048
1049
1050 typedef struct atomic_llong
1051 {
1052 #ifdef __cplusplus
1053     bool is_lock_free() const volatile;
1054     void store( long long,
1055                 memory_order = memory_order_seq_cst ) volatile;
1056     long long load( memory_order = memory_order_seq_cst ) volatile;
1057     long long exchange( long long,
1058                       memory_order = memory_order_seq_cst ) volatile;
1059     bool compare_exchange_weak( long long&, long long,
1060                        memory_order, memory_order ) volatile;
1061     bool compare_exchange_strong( long long&, long long,
1062                        memory_order, memory_order ) volatile;
1063     bool compare_exchange_weak( long long&, long long,
1064                        memory_order = memory_order_seq_cst ) volatile;
1065     bool compare_exchange_strong( long long&, long long,
1066                        memory_order = memory_order_seq_cst ) volatile;
1067     void fence( memory_order ) const volatile;
1068     long long fetch_add( long long,
1069                            memory_order = memory_order_seq_cst ) volatile;
1070     long long fetch_sub( long long,
1071                            memory_order = memory_order_seq_cst ) volatile;
1072     long long fetch_and( long long,
1073                            memory_order = memory_order_seq_cst ) volatile;
1074     long long fetch_or( long long,
1075                            memory_order = memory_order_seq_cst ) volatile;
1076     long long fetch_xor( long long,
1077                            memory_order = memory_order_seq_cst ) volatile;
1078
1079     CPP0X( atomic_llong() = default; )
1080     CPP0X( constexpr atomic_llong( long long __v__ ) : __f__( __v__) { } )
1081     CPP0X( atomic_llong( const atomic_llong& ) = delete; )
1082     atomic_llong& operator =( const atomic_llong& ) CPP0X(=delete);
1083
1084     long long operator =( long long __v__ ) volatile
1085     { store( __v__ ); return __v__; }
1086
1087     long long operator ++( int ) volatile
1088     { return fetch_add( 1 ); }
1089
1090     long long operator --( int ) volatile
1091     { return fetch_sub( 1 ); }
1092
1093     long long operator ++() volatile
1094     { return fetch_add( 1 ) + 1; }
1095
1096     long long operator --() volatile
1097     { return fetch_sub( 1 ) - 1; }
1098
1099     long long operator +=( long long __v__ ) volatile
1100     { return fetch_add( __v__ ) + __v__; }
1101
1102     long long operator -=( long long __v__ ) volatile
1103     { return fetch_sub( __v__ ) - __v__; }
1104
1105     long long operator &=( long long __v__ ) volatile
1106     { return fetch_and( __v__ ) & __v__; }
1107
1108     long long operator |=( long long __v__ ) volatile
1109     { return fetch_or( __v__ ) | __v__; }
1110
1111     long long operator ^=( long long __v__ ) volatile
1112     { return fetch_xor( __v__ ) ^ __v__; }
1113
1114     friend void atomic_store_explicit( volatile atomic_llong*, long long,
1115                                        memory_order );
1116     friend long long atomic_load_explicit( volatile atomic_llong*,
1117                                              memory_order );
1118     friend long long atomic_exchange_explicit( volatile atomic_llong*,
1119                                              long long, memory_order );
1120     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_llong*,
1121                       long long*, long long, memory_order, memory_order );
1122     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_llong*,
1123                       long long*, long long, memory_order, memory_order );
1124     friend void atomic_fence( const volatile atomic_llong*, memory_order );
1125     friend long long atomic_fetch_add_explicit( volatile atomic_llong*,
1126                                                   long long, memory_order );
1127     friend long long atomic_fetch_sub_explicit( volatile atomic_llong*,
1128                                                   long long, memory_order );
1129     friend long long atomic_fetch_and_explicit( volatile atomic_llong*,
1130                                                   long long, memory_order );
1131     friend long long atomic_fetch_or_explicit(  volatile atomic_llong*,
1132                                                   long long, memory_order );
1133     friend long long atomic_fetch_xor_explicit( volatile atomic_llong*,
1134                                                   long long, memory_order );
1135
1136 CPP0X(private:)
1137 #endif
1138     long long __f__;
1139 } atomic_llong;
1140
1141
1142 typedef struct atomic_ullong
1143 {
1144 #ifdef __cplusplus
1145     bool is_lock_free() const volatile;
1146     void store( unsigned long long,
1147                 memory_order = memory_order_seq_cst ) volatile;
1148     unsigned long long load( memory_order = memory_order_seq_cst ) volatile;
1149     unsigned long long exchange( unsigned long long,
1150                       memory_order = memory_order_seq_cst ) volatile;
1151     bool compare_exchange_weak( unsigned long long&, unsigned long long,
1152                        memory_order, memory_order ) volatile;
1153     bool compare_exchange_strong( unsigned long long&, unsigned long long,
1154                        memory_order, memory_order ) volatile;
1155     bool compare_exchange_weak( unsigned long long&, unsigned long long,
1156                        memory_order = memory_order_seq_cst ) volatile;
1157     bool compare_exchange_strong( unsigned long long&, unsigned long long,
1158                        memory_order = memory_order_seq_cst ) volatile;
1159     void fence( memory_order ) const volatile;
1160     unsigned long long fetch_add( unsigned long long,
1161                            memory_order = memory_order_seq_cst ) volatile;
1162     unsigned long long fetch_sub( unsigned long long,
1163                            memory_order = memory_order_seq_cst ) volatile;
1164     unsigned long long fetch_and( unsigned long long,
1165                            memory_order = memory_order_seq_cst ) volatile;
1166     unsigned long long fetch_or( unsigned long long,
1167                            memory_order = memory_order_seq_cst ) volatile;
1168     unsigned long long fetch_xor( unsigned long long,
1169                            memory_order = memory_order_seq_cst ) volatile;
1170
1171     CPP0X( atomic_ullong() = default; )
1172     CPP0X( constexpr atomic_ullong( unsigned long long __v__ ) : __f__( __v__) { } )
1173     CPP0X( atomic_ullong( const atomic_ullong& ) = delete; )
1174     atomic_ullong& operator =( const atomic_ullong& ) CPP0X(=delete);
1175
1176     unsigned long long operator =( unsigned long long __v__ ) volatile
1177     { store( __v__ ); return __v__; }
1178
1179     unsigned long long operator ++( int ) volatile
1180     { return fetch_add( 1 ); }
1181
1182     unsigned long long operator --( int ) volatile
1183     { return fetch_sub( 1 ); }
1184
1185     unsigned long long operator ++() volatile
1186     { return fetch_add( 1 ) + 1; }
1187
1188     unsigned long long operator --() volatile
1189     { return fetch_sub( 1 ) - 1; }
1190
1191     unsigned long long operator +=( unsigned long long __v__ ) volatile
1192     { return fetch_add( __v__ ) + __v__; }
1193
1194     unsigned long long operator -=( unsigned long long __v__ ) volatile
1195     { return fetch_sub( __v__ ) - __v__; }
1196
1197     unsigned long long operator &=( unsigned long long __v__ ) volatile
1198     { return fetch_and( __v__ ) & __v__; }
1199
1200     unsigned long long operator |=( unsigned long long __v__ ) volatile
1201     { return fetch_or( __v__ ) | __v__; }
1202
1203     unsigned long long operator ^=( unsigned long long __v__ ) volatile
1204     { return fetch_xor( __v__ ) ^ __v__; }
1205
1206     friend void atomic_store_explicit( volatile atomic_ullong*, unsigned long long,
1207                                        memory_order );
1208     friend unsigned long long atomic_load_explicit( volatile atomic_ullong*,
1209                                              memory_order );
1210     friend unsigned long long atomic_exchange_explicit( volatile atomic_ullong*,
1211                                              unsigned long long, memory_order );
1212     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ullong*,
1213                       unsigned long long*, unsigned long long, memory_order, memory_order );
1214     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ullong*,
1215                       unsigned long long*, unsigned long long, memory_order, memory_order );
1216     friend void atomic_fence( const volatile atomic_ullong*, memory_order );
1217     friend unsigned long long atomic_fetch_add_explicit( volatile atomic_ullong*,
1218                                                   unsigned long long, memory_order );
1219     friend unsigned long long atomic_fetch_sub_explicit( volatile atomic_ullong*,
1220                                                   unsigned long long, memory_order );
1221     friend unsigned long long atomic_fetch_and_explicit( volatile atomic_ullong*,
1222                                                   unsigned long long, memory_order );
1223     friend unsigned long long atomic_fetch_or_explicit(  volatile atomic_ullong*,
1224                                                   unsigned long long, memory_order );
1225     friend unsigned long long atomic_fetch_xor_explicit( volatile atomic_ullong*,
1226                                                   unsigned long long, memory_order );
1227
1228 CPP0X(private:)
1229 #endif
1230     unsigned long long __f__;
1231 } atomic_ullong;
1232
1233
1234 typedef atomic_schar atomic_int_least8_t;
1235 typedef atomic_uchar atomic_uint_least8_t;
1236 typedef atomic_short atomic_int_least16_t;
1237 typedef atomic_ushort atomic_uint_least16_t;
1238 typedef atomic_int atomic_int_least32_t;
1239 typedef atomic_uint atomic_uint_least32_t;
1240 typedef atomic_llong atomic_int_least64_t;
1241 typedef atomic_ullong atomic_uint_least64_t;
1242
1243 typedef atomic_schar atomic_int_fast8_t;
1244 typedef atomic_uchar atomic_uint_fast8_t;
1245 typedef atomic_short atomic_int_fast16_t;
1246 typedef atomic_ushort atomic_uint_fast16_t;
1247 typedef atomic_int atomic_int_fast32_t;
1248 typedef atomic_uint atomic_uint_fast32_t;
1249 typedef atomic_llong atomic_int_fast64_t;
1250 typedef atomic_ullong atomic_uint_fast64_t;
1251
1252 typedef atomic_long atomic_intptr_t;
1253 typedef atomic_ulong atomic_uintptr_t;
1254
1255 typedef atomic_long atomic_ssize_t;
1256 typedef atomic_ulong atomic_size_t;
1257
1258 typedef atomic_long atomic_ptrdiff_t;
1259
1260 typedef atomic_llong atomic_intmax_t;
1261 typedef atomic_ullong atomic_uintmax_t;
1262
1263
1264 #ifdef __cplusplus
1265
1266
1267 typedef struct atomic_wchar_t
1268 {
1269 #ifdef __cplusplus
1270     bool is_lock_free() const volatile;
1271     void store( wchar_t, memory_order = memory_order_seq_cst ) volatile;
1272     wchar_t load( memory_order = memory_order_seq_cst ) volatile;
1273     wchar_t exchange( wchar_t,
1274                       memory_order = memory_order_seq_cst ) volatile;
1275     bool compare_exchange_weak( wchar_t&, wchar_t,
1276                        memory_order, memory_order ) volatile;
1277     bool compare_exchange_strong( wchar_t&, wchar_t,
1278                        memory_order, memory_order ) volatile;
1279     bool compare_exchange_weak( wchar_t&, wchar_t,
1280                        memory_order = memory_order_seq_cst ) volatile;
1281     bool compare_exchange_strong( wchar_t&, wchar_t,
1282                        memory_order = memory_order_seq_cst ) volatile;
1283     void fence( memory_order ) const volatile;
1284     wchar_t fetch_add( wchar_t,
1285                            memory_order = memory_order_seq_cst ) volatile;
1286     wchar_t fetch_sub( wchar_t,
1287                            memory_order = memory_order_seq_cst ) volatile;
1288     wchar_t fetch_and( wchar_t,
1289                            memory_order = memory_order_seq_cst ) volatile;
1290     wchar_t fetch_or( wchar_t,
1291                            memory_order = memory_order_seq_cst ) volatile;
1292     wchar_t fetch_xor( wchar_t,
1293                            memory_order = memory_order_seq_cst ) volatile;
1294
1295     CPP0X( atomic_wchar_t() = default; )
1296     CPP0X( constexpr atomic_wchar_t( wchar_t __v__ ) : __f__( __v__) { } )
1297     CPP0X( atomic_wchar_t( const atomic_wchar_t& ) = delete; )
1298     atomic_wchar_t& operator =( const atomic_wchar_t& ) CPP0X(=delete);
1299
1300     wchar_t operator =( wchar_t __v__ ) volatile
1301     { store( __v__ ); return __v__; }
1302
1303     wchar_t operator ++( int ) volatile
1304     { return fetch_add( 1 ); }
1305
1306     wchar_t operator --( int ) volatile
1307     { return fetch_sub( 1 ); }
1308
1309     wchar_t operator ++() volatile
1310     { return fetch_add( 1 ) + 1; }
1311
1312     wchar_t operator --() volatile
1313     { return fetch_sub( 1 ) - 1; }
1314
1315     wchar_t operator +=( wchar_t __v__ ) volatile
1316     { return fetch_add( __v__ ) + __v__; }
1317
1318     wchar_t operator -=( wchar_t __v__ ) volatile
1319     { return fetch_sub( __v__ ) - __v__; }
1320
1321     wchar_t operator &=( wchar_t __v__ ) volatile
1322     { return fetch_and( __v__ ) & __v__; }
1323
1324     wchar_t operator |=( wchar_t __v__ ) volatile
1325     { return fetch_or( __v__ ) | __v__; }
1326
1327     wchar_t operator ^=( wchar_t __v__ ) volatile
1328     { return fetch_xor( __v__ ) ^ __v__; }
1329
1330     friend void atomic_store_explicit( volatile atomic_wchar_t*, wchar_t,
1331                                        memory_order );
1332     friend wchar_t atomic_load_explicit( volatile atomic_wchar_t*,
1333                                              memory_order );
1334     friend wchar_t atomic_exchange_explicit( volatile atomic_wchar_t*,
1335                                              wchar_t, memory_order );
1336     friend bool atomic_compare_exchange_weak_explicit( volatile atomic_wchar_t*,
1337                     wchar_t*, wchar_t, memory_order, memory_order );
1338     friend bool atomic_compare_exchange_strong_explicit( volatile atomic_wchar_t*,
1339                     wchar_t*, wchar_t, memory_order, memory_order );
1340     friend void atomic_fence( const volatile atomic_wchar_t*, memory_order );
1341     friend wchar_t atomic_fetch_add_explicit( volatile atomic_wchar_t*,
1342                                                   wchar_t, memory_order );
1343     friend wchar_t atomic_fetch_sub_explicit( volatile atomic_wchar_t*,
1344                                                   wchar_t, memory_order );
1345     friend wchar_t atomic_fetch_and_explicit( volatile atomic_wchar_t*,
1346                                                   wchar_t, memory_order );
1347     friend wchar_t atomic_fetch_or_explicit( volatile atomic_wchar_t*,
1348                                                   wchar_t, memory_order );
1349     friend wchar_t atomic_fetch_xor_explicit( volatile atomic_wchar_t*,
1350                                                   wchar_t, memory_order );
1351
1352 CPP0X(private:)
1353 #endif
1354     wchar_t __f__;
1355 } atomic_wchar_t;
1356
1357
1358 #else
1359
1360 typedef atomic_int_least16_t atomic_char16_t;
1361 typedef atomic_int_least32_t atomic_char32_t;
1362 typedef atomic_int_least32_t atomic_wchar_t;
1363
1364 #endif
1365
1366
1367 #ifdef __cplusplus
1368
1369 template< typename T >
1370 struct atomic
1371 {
1372 #ifdef __cplusplus
1373
1374     bool is_lock_free() const volatile;
1375     void store( T, memory_order = memory_order_seq_cst ) volatile;
1376     T load( memory_order = memory_order_seq_cst ) volatile;
1377     T exchange( T __v__, memory_order = memory_order_seq_cst ) volatile;
1378     bool compare_exchange_weak( T&, T, memory_order, memory_order ) volatile;
1379     bool compare_exchange_strong( T&, T, memory_order, memory_order ) volatile;
1380     bool compare_exchange_weak( T&, T, memory_order = memory_order_seq_cst ) volatile;
1381     bool compare_exchange_strong( T&, T, memory_order = memory_order_seq_cst ) volatile;
1382     void fence( memory_order ) const volatile;
1383
1384     CPP0X( atomic() = default; )
1385     CPP0X( constexpr explicit atomic( T __v__ ) : __f__( __v__ ) { } )
1386     CPP0X( atomic( const atomic& ) = delete; )
1387     atomic& operator =( const atomic& ) CPP0X(=delete);
1388
1389     T operator =( T __v__ ) volatile
1390     { store( __v__ ); return __v__; }
1391
1392 CPP0X(private:)
1393 #endif
1394     T __f__;
1395 };
1396
1397 #endif
1398
1399 #ifdef __cplusplus
1400
1401 template<typename T> struct atomic< T* > : atomic_address
1402 {
1403     T* load( memory_order = memory_order_seq_cst ) volatile;
1404     T* exchange( T*, memory_order = memory_order_seq_cst ) volatile;
1405     bool compare_exchange_weak( T*&, T*, memory_order, memory_order ) volatile;
1406     bool compare_exchange_strong( T*&, T*, memory_order, memory_order ) volatile;
1407     bool compare_exchange_weak( T*&, T*,
1408                        memory_order = memory_order_seq_cst ) volatile;
1409     bool compare_exchange_strong( T*&, T*,
1410                        memory_order = memory_order_seq_cst ) volatile;
1411     T* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1412     T* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
1413
1414     CPP0X( atomic() = default; )
1415     CPP0X( constexpr explicit atomic( T __v__ ) : atomic_address( __v__ ) { } )
1416     CPP0X( atomic( const atomic& ) = delete; )
1417     atomic& operator =( const atomic& ) CPP0X(=delete);
1418
1419     T* operator =( T* __v__ ) volatile
1420     { store( __v__ ); return __v__; }
1421
1422     T* operator ++( int ) volatile
1423     { return fetch_add( 1 ); }
1424
1425     T* operator --( int ) volatile
1426     { return fetch_sub( 1 ); }
1427
1428     T* operator ++() volatile
1429     { return fetch_add( 1 ) + 1; }
1430
1431     T* operator --() volatile
1432     { return fetch_sub( 1 ) - 1; }
1433
1434     T* operator +=( T* __v__ ) volatile
1435     { return fetch_add( __v__ ) + __v__; }
1436
1437     T* operator -=( T* __v__ ) volatile
1438     { return fetch_sub( __v__ ) - __v__; }
1439 };
1440
1441 #endif
1442
1443 #ifdef __cplusplus
1444
1445
1446 template<> struct atomic< bool > : atomic_bool
1447 {
1448     CPP0X( atomic() = default; )
1449     CPP0X( constexpr explicit atomic( bool __v__ )
1450     : atomic_bool( __v__ ) { } )
1451     CPP0X( atomic( const atomic& ) = delete; )
1452     atomic& operator =( const atomic& ) CPP0X(=delete);
1453
1454     bool operator =( bool __v__ ) volatile
1455     { store( __v__ ); return __v__; }
1456 };
1457
1458
1459 template<> struct atomic< void* > : atomic_address
1460 {
1461     CPP0X( atomic() = default; )
1462     CPP0X( constexpr explicit atomic( void* __v__ )
1463     : atomic_address( __v__ ) { } )
1464     CPP0X( atomic( const atomic& ) = delete; )
1465     atomic& operator =( const atomic& ) CPP0X(=delete);
1466
1467     void* operator =( void* __v__ ) volatile
1468     { store( __v__ ); return __v__; }
1469 };
1470
1471
1472 template<> struct atomic< char > : atomic_char
1473 {
1474     CPP0X( atomic() = default; )
1475     CPP0X( constexpr explicit atomic( char __v__ )
1476     : atomic_char( __v__ ) { } )
1477     CPP0X( atomic( const atomic& ) = delete; )
1478     atomic& operator =( const atomic& ) CPP0X(=delete);
1479
1480     char operator =( char __v__ ) volatile
1481     { store( __v__ ); return __v__; }
1482 };
1483
1484
1485 template<> struct atomic< signed char > : atomic_schar
1486 {
1487     CPP0X( atomic() = default; )
1488     CPP0X( constexpr explicit atomic( signed char __v__ )
1489     : atomic_schar( __v__ ) { } )
1490     CPP0X( atomic( const atomic& ) = delete; )
1491     atomic& operator =( const atomic& ) CPP0X(=delete);
1492
1493     signed char operator =( signed char __v__ ) volatile
1494     { store( __v__ ); return __v__; }
1495 };
1496
1497
1498 template<> struct atomic< unsigned char > : atomic_uchar
1499 {
1500     CPP0X( atomic() = default; )
1501     CPP0X( constexpr explicit atomic( unsigned char __v__ )
1502     : atomic_uchar( __v__ ) { } )
1503     CPP0X( atomic( const atomic& ) = delete; )
1504     atomic& operator =( const atomic& ) CPP0X(=delete);
1505
1506     unsigned char operator =( unsigned char __v__ ) volatile
1507     { store( __v__ ); return __v__; }
1508 };
1509
1510
1511 template<> struct atomic< short > : atomic_short
1512 {
1513     CPP0X( atomic() = default; )
1514     CPP0X( constexpr explicit atomic( short __v__ )
1515     : atomic_short( __v__ ) { } )
1516     CPP0X( atomic( const atomic& ) = delete; )
1517     atomic& operator =( const atomic& ) CPP0X(=delete);
1518
1519     short operator =( short __v__ ) volatile
1520     { store( __v__ ); return __v__; }
1521 };
1522
1523
1524 template<> struct atomic< unsigned short > : atomic_ushort
1525 {
1526     CPP0X( atomic() = default; )
1527     CPP0X( constexpr explicit atomic( unsigned short __v__ )
1528     : atomic_ushort( __v__ ) { } )
1529     CPP0X( atomic( const atomic& ) = delete; )
1530     atomic& operator =( const atomic& ) CPP0X(=delete);
1531
1532     unsigned short operator =( unsigned short __v__ ) volatile
1533     { store( __v__ ); return __v__; }
1534 };
1535
1536
1537 template<> struct atomic< int > : atomic_int
1538 {
1539     CPP0X( atomic() = default; )
1540     CPP0X( constexpr explicit atomic( int __v__ )
1541     : atomic_int( __v__ ) { } )
1542     CPP0X( atomic( const atomic& ) = delete; )
1543     atomic& operator =( const atomic& ) CPP0X(=delete);
1544
1545     int operator =( int __v__ ) volatile
1546     { store( __v__ ); return __v__; }
1547 };
1548
1549
1550 template<> struct atomic< unsigned int > : atomic_uint
1551 {
1552     CPP0X( atomic() = default; )
1553     CPP0X( constexpr explicit atomic( unsigned int __v__ )
1554     : atomic_uint( __v__ ) { } )
1555     CPP0X( atomic( const atomic& ) = delete; )
1556     atomic& operator =( const atomic& ) CPP0X(=delete);
1557
1558     unsigned int operator =( unsigned int __v__ ) volatile
1559     { store( __v__ ); return __v__; }
1560 };
1561
1562
1563 template<> struct atomic< long > : atomic_long
1564 {
1565     CPP0X( atomic() = default; )
1566     CPP0X( constexpr explicit atomic( long __v__ )
1567     : atomic_long( __v__ ) { } )
1568     CPP0X( atomic( const atomic& ) = delete; )
1569     atomic& operator =( const atomic& ) CPP0X(=delete);
1570
1571     long operator =( long __v__ ) volatile
1572     { store( __v__ ); return __v__; }
1573 };
1574
1575
1576 template<> struct atomic< unsigned long > : atomic_ulong
1577 {
1578     CPP0X( atomic() = default; )
1579     CPP0X( constexpr explicit atomic( unsigned long __v__ )
1580     : atomic_ulong( __v__ ) { } )
1581     CPP0X( atomic( const atomic& ) = delete; )
1582     atomic& operator =( const atomic& ) CPP0X(=delete);
1583
1584     unsigned long operator =( unsigned long __v__ ) volatile
1585     { store( __v__ ); return __v__; }
1586 };
1587
1588
1589 template<> struct atomic< long long > : atomic_llong
1590 {
1591     CPP0X( atomic() = default; )
1592     CPP0X( constexpr explicit atomic( long long __v__ )
1593     : atomic_llong( __v__ ) { } )
1594     CPP0X( atomic( const atomic& ) = delete; )
1595     atomic& operator =( const atomic& ) CPP0X(=delete);
1596
1597     long long operator =( long long __v__ ) volatile
1598     { store( __v__ ); return __v__; }
1599 };
1600
1601
1602 template<> struct atomic< unsigned long long > : atomic_ullong
1603 {
1604     CPP0X( atomic() = default; )
1605     CPP0X( constexpr explicit atomic( unsigned long long __v__ )
1606     : atomic_ullong( __v__ ) { } )
1607     CPP0X( atomic( const atomic& ) = delete; )
1608     atomic& operator =( const atomic& ) CPP0X(=delete);
1609
1610     unsigned long long operator =( unsigned long long __v__ ) volatile
1611     { store( __v__ ); return __v__; }
1612 };
1613
1614
1615 template<> struct atomic< wchar_t > : atomic_wchar_t
1616 {
1617     CPP0X( atomic() = default; )
1618     CPP0X( constexpr explicit atomic( wchar_t __v__ )
1619     : atomic_wchar_t( __v__ ) { } )
1620     CPP0X( atomic( const atomic& ) = delete; )
1621     atomic& operator =( const atomic& ) CPP0X(=delete);
1622
1623     wchar_t operator =( wchar_t __v__ ) volatile
1624     { store( __v__ ); return __v__; }
1625 };
1626
1627
1628 #endif
1629
1630
1631 #ifdef __cplusplus
1632
1633
1634 inline bool atomic_is_lock_free
1635 ( const volatile atomic_bool* __a__ )
1636 { return false; }
1637
1638 inline bool atomic_load_explicit
1639 ( volatile atomic_bool* __a__, memory_order __x__ )
1640 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1641
1642 inline bool atomic_load
1643 ( volatile atomic_bool* __a__ ) { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1644
1645 inline void atomic_store_explicit
1646 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1647 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1648
1649 inline void atomic_store
1650 ( volatile atomic_bool* __a__, bool __m__ )
1651 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1652
1653 inline bool atomic_exchange_explicit
1654 ( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
1655 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1656
1657 inline bool atomic_exchange
1658 ( volatile atomic_bool* __a__, bool __m__ )
1659 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1660
1661 inline bool atomic_compare_exchange_weak_explicit
1662 ( volatile atomic_bool* __a__, bool* __e__, bool __m__,
1663   memory_order __x__, memory_order __y__ )
1664 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1665
1666 inline bool atomic_compare_exchange_strong_explicit
1667 ( volatile atomic_bool* __a__, bool* __e__, bool __m__,
1668   memory_order __x__, memory_order __y__ )
1669 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1670
1671 inline bool atomic_compare_exchange_weak
1672 ( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
1673 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1674                  memory_order_seq_cst, memory_order_seq_cst ); }
1675
1676 inline bool atomic_compare_exchange_strong
1677 ( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
1678 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1679                  memory_order_seq_cst, memory_order_seq_cst ); }
1680
1681 inline void atomic_fence
1682 ( const volatile atomic_bool* __a__, memory_order __x__ )
1683 { _ATOMIC_FENCE_( __a__, __x__ ); }
1684
1685
1686 inline bool atomic_is_lock_free( const volatile atomic_address* __a__ )
1687 { return false; }
1688
1689 inline void* atomic_load_explicit
1690 ( volatile atomic_address* __a__, memory_order __x__ )
1691 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1692
1693 inline void* atomic_load( volatile atomic_address* __a__ )
1694 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1695
1696 inline void atomic_store_explicit
1697 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1698 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1699
1700 inline void atomic_store
1701 ( volatile atomic_address* __a__, void* __m__ )
1702 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1703
1704 inline void* atomic_exchange_explicit
1705 ( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
1706 { return _ATOMIC_MODIFY_( __a__, =, __m__,  __x__ ); }
1707
1708 inline void* atomic_exchange
1709 ( volatile atomic_address* __a__, void* __m__ )
1710 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1711
1712 inline bool atomic_compare_exchange_weak_explicit
1713 ( volatile atomic_address* __a__, void** __e__, void* __m__,
1714   memory_order __x__, memory_order __y__ )
1715 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1716
1717 inline bool atomic_compare_exchange_strong_explicit
1718 ( volatile atomic_address* __a__, void** __e__, void* __m__,
1719   memory_order __x__, memory_order __y__ )
1720 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1721
1722 inline bool atomic_compare_exchange_weak
1723 ( volatile atomic_address* __a__, void** __e__, void* __m__ )
1724 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1725                  memory_order_seq_cst, memory_order_seq_cst ); }
1726
1727 inline bool atomic_compare_exchange_strong
1728 ( volatile atomic_address* __a__, void** __e__, void* __m__ )
1729 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1730                  memory_order_seq_cst, memory_order_seq_cst ); }
1731
1732 inline void atomic_fence
1733 ( const volatile atomic_address* __a__, memory_order __x__ )
1734 { _ATOMIC_FENCE_( __a__, __x__ ); }
1735
1736
1737 inline bool atomic_is_lock_free( const volatile atomic_char* __a__ )
1738 { return false; }
1739
1740 inline char atomic_load_explicit
1741 ( volatile atomic_char* __a__, memory_order __x__ )
1742 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1743
1744 inline char atomic_load( volatile atomic_char* __a__ )
1745 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1746
1747 inline void atomic_store_explicit
1748 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1749 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1750
1751 inline void atomic_store
1752 ( volatile atomic_char* __a__, char __m__ )
1753 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1754
1755 inline char atomic_exchange_explicit
1756 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
1757 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1758
1759 inline char atomic_exchange
1760 ( volatile atomic_char* __a__, char __m__ )
1761 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1762
1763 inline bool atomic_compare_exchange_weak_explicit
1764 ( volatile atomic_char* __a__, char* __e__, char __m__,
1765   memory_order __x__, memory_order __y__ )
1766 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1767
1768 inline bool atomic_compare_exchange_strong_explicit
1769 ( volatile atomic_char* __a__, char* __e__, char __m__,
1770   memory_order __x__, memory_order __y__ )
1771 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1772
1773 inline bool atomic_compare_exchange_weak
1774 ( volatile atomic_char* __a__, char* __e__, char __m__ )
1775 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1776                  memory_order_seq_cst, memory_order_seq_cst ); }
1777
1778 inline bool atomic_compare_exchange_strong
1779 ( volatile atomic_char* __a__, char* __e__, char __m__ )
1780 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1781                  memory_order_seq_cst, memory_order_seq_cst ); }
1782
1783 inline void atomic_fence
1784 ( const volatile atomic_char* __a__, memory_order __x__ )
1785 { _ATOMIC_FENCE_( __a__, __x__ ); }
1786
1787
1788 inline bool atomic_is_lock_free( const volatile atomic_schar* __a__ )
1789 { return false; }
1790
1791 inline signed char atomic_load_explicit
1792 ( volatile atomic_schar* __a__, memory_order __x__ )
1793 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1794
1795 inline signed char atomic_load( volatile atomic_schar* __a__ )
1796 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1797
1798 inline void atomic_store_explicit
1799 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1800 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1801
1802 inline void atomic_store
1803 ( volatile atomic_schar* __a__, signed char __m__ )
1804 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1805
1806 inline signed char atomic_exchange_explicit
1807 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
1808 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1809
1810 inline signed char atomic_exchange
1811 ( volatile atomic_schar* __a__, signed char __m__ )
1812 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1813
1814 inline bool atomic_compare_exchange_weak_explicit
1815 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
1816   memory_order __x__, memory_order __y__ )
1817 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1818
1819 inline bool atomic_compare_exchange_strong_explicit
1820 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
1821   memory_order __x__, memory_order __y__ )
1822 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1823
1824 inline bool atomic_compare_exchange_weak
1825 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
1826 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1827                  memory_order_seq_cst, memory_order_seq_cst ); }
1828
1829 inline bool atomic_compare_exchange_strong
1830 ( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
1831 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1832                  memory_order_seq_cst, memory_order_seq_cst ); }
1833
1834 inline void atomic_fence
1835 ( const volatile atomic_schar* __a__, memory_order __x__ )
1836 { _ATOMIC_FENCE_( __a__, __x__ ); }
1837
1838
1839 inline bool atomic_is_lock_free( const volatile atomic_uchar* __a__ )
1840 { return false; }
1841
1842 inline unsigned char atomic_load_explicit
1843 ( volatile atomic_uchar* __a__, memory_order __x__ )
1844 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1845
1846 inline unsigned char atomic_load( volatile atomic_uchar* __a__ )
1847 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1848
1849 inline void atomic_store_explicit
1850 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1851 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1852
1853 inline void atomic_store
1854 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1855 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1856
1857 inline unsigned char atomic_exchange_explicit
1858 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
1859 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1860
1861 inline unsigned char atomic_exchange
1862 ( volatile atomic_uchar* __a__, unsigned char __m__ )
1863 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1864
1865 inline bool atomic_compare_exchange_weak_explicit
1866 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
1867   memory_order __x__, memory_order __y__ )
1868 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1869
1870 inline bool atomic_compare_exchange_strong_explicit
1871 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
1872   memory_order __x__, memory_order __y__ )
1873 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1874
1875 inline bool atomic_compare_exchange_weak
1876 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
1877 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1878                  memory_order_seq_cst, memory_order_seq_cst ); }
1879
1880 inline bool atomic_compare_exchange_strong
1881 ( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
1882 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1883                  memory_order_seq_cst, memory_order_seq_cst ); }
1884
1885 inline void atomic_fence
1886 ( const volatile atomic_uchar* __a__, memory_order __x__ )
1887 { _ATOMIC_FENCE_( __a__, __x__ ); }
1888
1889
1890 inline bool atomic_is_lock_free( const volatile atomic_short* __a__ )
1891 { return false; }
1892
1893 inline short atomic_load_explicit
1894 ( volatile atomic_short* __a__, memory_order __x__ )
1895 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1896
1897 inline short atomic_load( volatile atomic_short* __a__ )
1898 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1899
1900 inline void atomic_store_explicit
1901 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1902 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1903
1904 inline void atomic_store
1905 ( volatile atomic_short* __a__, short __m__ )
1906 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1907
1908 inline short atomic_exchange_explicit
1909 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
1910 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1911
1912 inline short atomic_exchange
1913 ( volatile atomic_short* __a__, short __m__ )
1914 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1915
1916 inline bool atomic_compare_exchange_weak_explicit
1917 ( volatile atomic_short* __a__, short* __e__, short __m__,
1918   memory_order __x__, memory_order __y__ )
1919 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1920
1921 inline bool atomic_compare_exchange_strong_explicit
1922 ( volatile atomic_short* __a__, short* __e__, short __m__,
1923   memory_order __x__, memory_order __y__ )
1924 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1925
1926 inline bool atomic_compare_exchange_weak
1927 ( volatile atomic_short* __a__, short* __e__, short __m__ )
1928 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1929                  memory_order_seq_cst, memory_order_seq_cst ); }
1930
1931 inline bool atomic_compare_exchange_strong
1932 ( volatile atomic_short* __a__, short* __e__, short __m__ )
1933 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1934                  memory_order_seq_cst, memory_order_seq_cst ); }
1935
1936 inline void atomic_fence
1937 ( const volatile atomic_short* __a__, memory_order __x__ )
1938 { _ATOMIC_FENCE_( __a__, __x__ ); }
1939
1940
1941 inline bool atomic_is_lock_free( const volatile atomic_ushort* __a__ )
1942 { return false; }
1943
1944 inline unsigned short atomic_load_explicit
1945 ( volatile atomic_ushort* __a__, memory_order __x__ )
1946 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1947
1948 inline unsigned short atomic_load( volatile atomic_ushort* __a__ )
1949 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
1950
1951 inline void atomic_store_explicit
1952 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1953 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
1954
1955 inline void atomic_store
1956 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1957 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
1958
1959 inline unsigned short atomic_exchange_explicit
1960 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
1961 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
1962
1963 inline unsigned short atomic_exchange
1964 ( volatile atomic_ushort* __a__, unsigned short __m__ )
1965 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
1966
1967 inline bool atomic_compare_exchange_weak_explicit
1968 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
1969   memory_order __x__, memory_order __y__ )
1970 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
1971
1972 inline bool atomic_compare_exchange_strong_explicit
1973 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
1974   memory_order __x__, memory_order __y__ )
1975 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
1976
1977 inline bool atomic_compare_exchange_weak
1978 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
1979 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
1980                  memory_order_seq_cst, memory_order_seq_cst ); }
1981
1982 inline bool atomic_compare_exchange_strong
1983 ( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
1984 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
1985                  memory_order_seq_cst, memory_order_seq_cst ); }
1986
1987 inline void atomic_fence
1988 ( const volatile atomic_ushort* __a__, memory_order __x__ )
1989 { _ATOMIC_FENCE_( __a__, __x__ ); }
1990
1991
1992 inline bool atomic_is_lock_free( const volatile atomic_int* __a__ )
1993 { return false; }
1994
1995 inline int atomic_load_explicit
1996 ( volatile atomic_int* __a__, memory_order __x__ )
1997 { return _ATOMIC_LOAD_( __a__, __x__ ); }
1998
1999 inline int atomic_load( volatile atomic_int* __a__ )
2000 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2001
2002 inline void atomic_store_explicit
2003 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2004 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2005
2006 inline void atomic_store
2007 ( volatile atomic_int* __a__, int __m__ )
2008 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2009
2010 inline int atomic_exchange_explicit
2011 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2012 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2013
2014 inline int atomic_exchange
2015 ( volatile atomic_int* __a__, int __m__ )
2016 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2017
2018 inline bool atomic_compare_exchange_weak_explicit
2019 ( volatile atomic_int* __a__, int* __e__, int __m__,
2020   memory_order __x__, memory_order __y__ )
2021 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2022
2023 inline bool atomic_compare_exchange_strong_explicit
2024 ( volatile atomic_int* __a__, int* __e__, int __m__,
2025   memory_order __x__, memory_order __y__ )
2026 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2027
2028 inline bool atomic_compare_exchange_weak
2029 ( volatile atomic_int* __a__, int* __e__, int __m__ )
2030 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2031                  memory_order_seq_cst, memory_order_seq_cst ); }
2032
2033 inline bool atomic_compare_exchange_strong
2034 ( volatile atomic_int* __a__, int* __e__, int __m__ )
2035 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2036                  memory_order_seq_cst, memory_order_seq_cst ); }
2037
2038 inline void atomic_fence
2039 ( const volatile atomic_int* __a__, memory_order __x__ )
2040 { _ATOMIC_FENCE_( __a__, __x__ ); }
2041
2042
2043 inline bool atomic_is_lock_free( const volatile atomic_uint* __a__ )
2044 { return false; }
2045
2046 inline unsigned int atomic_load_explicit
2047 ( volatile atomic_uint* __a__, memory_order __x__ )
2048 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2049
2050 inline unsigned int atomic_load( volatile atomic_uint* __a__ )
2051 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2052
2053 inline void atomic_store_explicit
2054 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2055 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2056
2057 inline void atomic_store
2058 ( volatile atomic_uint* __a__, unsigned int __m__ )
2059 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2060
2061 inline unsigned int atomic_exchange_explicit
2062 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2063 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2064
2065 inline unsigned int atomic_exchange
2066 ( volatile atomic_uint* __a__, unsigned int __m__ )
2067 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2068
2069 inline bool atomic_compare_exchange_weak_explicit
2070 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
2071   memory_order __x__, memory_order __y__ )
2072 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2073
2074 inline bool atomic_compare_exchange_strong_explicit
2075 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
2076   memory_order __x__, memory_order __y__ )
2077 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2078
2079 inline bool atomic_compare_exchange_weak
2080 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
2081 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2082                  memory_order_seq_cst, memory_order_seq_cst ); }
2083
2084 inline bool atomic_compare_exchange_strong
2085 ( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
2086 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2087                  memory_order_seq_cst, memory_order_seq_cst ); }
2088
2089 inline void atomic_fence
2090 ( const volatile atomic_uint* __a__, memory_order __x__ )
2091 { _ATOMIC_FENCE_( __a__, __x__ ); }
2092
2093
2094 inline bool atomic_is_lock_free( const volatile atomic_long* __a__ )
2095 { return false; }
2096
2097 inline long atomic_load_explicit
2098 ( volatile atomic_long* __a__, memory_order __x__ )
2099 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2100
2101 inline long atomic_load( volatile atomic_long* __a__ )
2102 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2103
2104 inline void atomic_store_explicit
2105 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2106 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2107
2108 inline void atomic_store
2109 ( volatile atomic_long* __a__, long __m__ )
2110 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2111
2112 inline long atomic_exchange_explicit
2113 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2114 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2115
2116 inline long atomic_exchange
2117 ( volatile atomic_long* __a__, long __m__ )
2118 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2119
2120 inline bool atomic_compare_exchange_weak_explicit
2121 ( volatile atomic_long* __a__, long* __e__, long __m__,
2122   memory_order __x__, memory_order __y__ )
2123 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2124
2125 inline bool atomic_compare_exchange_strong_explicit
2126 ( volatile atomic_long* __a__, long* __e__, long __m__,
2127   memory_order __x__, memory_order __y__ )
2128 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2129
2130 inline bool atomic_compare_exchange_weak
2131 ( volatile atomic_long* __a__, long* __e__, long __m__ )
2132 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2133                  memory_order_seq_cst, memory_order_seq_cst ); }
2134
2135 inline bool atomic_compare_exchange_strong
2136 ( volatile atomic_long* __a__, long* __e__, long __m__ )
2137 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2138                  memory_order_seq_cst, memory_order_seq_cst ); }
2139
2140 inline void atomic_fence
2141 ( const volatile atomic_long* __a__, memory_order __x__ )
2142 { _ATOMIC_FENCE_( __a__, __x__ ); }
2143
2144
2145 inline bool atomic_is_lock_free( const volatile atomic_ulong* __a__ )
2146 { return false; }
2147
2148 inline unsigned long atomic_load_explicit
2149 ( volatile atomic_ulong* __a__, memory_order __x__ )
2150 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2151
2152 inline unsigned long atomic_load( volatile atomic_ulong* __a__ )
2153 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2154
2155 inline void atomic_store_explicit
2156 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2157 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2158
2159 inline void atomic_store
2160 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2161 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2162
2163 inline unsigned long atomic_exchange_explicit
2164 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2165 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2166
2167 inline unsigned long atomic_exchange
2168 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2169 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2170
2171 inline bool atomic_compare_exchange_weak_explicit
2172 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
2173   memory_order __x__, memory_order __y__ )
2174 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2175
2176 inline bool atomic_compare_exchange_strong_explicit
2177 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
2178   memory_order __x__, memory_order __y__ )
2179 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2180
2181 inline bool atomic_compare_exchange_weak
2182 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
2183 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2184                  memory_order_seq_cst, memory_order_seq_cst ); }
2185
2186 inline bool atomic_compare_exchange_strong
2187 ( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
2188 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2189                  memory_order_seq_cst, memory_order_seq_cst ); }
2190
2191 inline void atomic_fence
2192 ( const volatile atomic_ulong* __a__, memory_order __x__ )
2193 { _ATOMIC_FENCE_( __a__, __x__ ); }
2194
2195
2196 inline bool atomic_is_lock_free( const volatile atomic_llong* __a__ )
2197 { return false; }
2198
2199 inline long long atomic_load_explicit
2200 ( volatile atomic_llong* __a__, memory_order __x__ )
2201 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2202
2203 inline long long atomic_load( volatile atomic_llong* __a__ )
2204 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2205
2206 inline void atomic_store_explicit
2207 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2208 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2209
2210 inline void atomic_store
2211 ( volatile atomic_llong* __a__, long long __m__ )
2212 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2213
2214 inline long long atomic_exchange_explicit
2215 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2216 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2217
2218 inline long long atomic_exchange
2219 ( volatile atomic_llong* __a__, long long __m__ )
2220 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2221
2222 inline bool atomic_compare_exchange_weak_explicit
2223 ( volatile atomic_llong* __a__, long long* __e__, long long __m__,
2224   memory_order __x__, memory_order __y__ )
2225 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2226
2227 inline bool atomic_compare_exchange_strong_explicit
2228 ( volatile atomic_llong* __a__, long long* __e__, long long __m__,
2229   memory_order __x__, memory_order __y__ )
2230 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2231
2232 inline bool atomic_compare_exchange_weak
2233 ( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
2234 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2235                  memory_order_seq_cst, memory_order_seq_cst ); }
2236
2237 inline bool atomic_compare_exchange_strong
2238 ( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
2239 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2240                  memory_order_seq_cst, memory_order_seq_cst ); }
2241
2242 inline void atomic_fence
2243 ( const volatile atomic_llong* __a__, memory_order __x__ )
2244 { _ATOMIC_FENCE_( __a__, __x__ ); }
2245
2246
2247 inline bool atomic_is_lock_free( const volatile atomic_ullong* __a__ )
2248 { return false; }
2249
2250 inline unsigned long long atomic_load_explicit
2251 ( volatile atomic_ullong* __a__, memory_order __x__ )
2252 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2253
2254 inline unsigned long long atomic_load( volatile atomic_ullong* __a__ )
2255 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2256
2257 inline void atomic_store_explicit
2258 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2259 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2260
2261 inline void atomic_store
2262 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2263 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2264
2265 inline unsigned long long atomic_exchange_explicit
2266 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2267 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2268
2269 inline unsigned long long atomic_exchange
2270 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2271 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2272
2273 inline bool atomic_compare_exchange_weak_explicit
2274 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
2275   memory_order __x__, memory_order __y__ )
2276 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2277
2278 inline bool atomic_compare_exchange_strong_explicit
2279 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
2280   memory_order __x__, memory_order __y__ )
2281 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2282
2283 inline bool atomic_compare_exchange_weak
2284 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
2285 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2286                  memory_order_seq_cst, memory_order_seq_cst ); }
2287
2288 inline bool atomic_compare_exchange_strong
2289 ( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
2290 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2291                  memory_order_seq_cst, memory_order_seq_cst ); }
2292
2293 inline void atomic_fence
2294 ( const volatile atomic_ullong* __a__, memory_order __x__ )
2295 { _ATOMIC_FENCE_( __a__, __x__ ); }
2296
2297
2298 inline bool atomic_is_lock_free( const volatile atomic_wchar_t* __a__ )
2299 { return false; }
2300
2301 inline wchar_t atomic_load_explicit
2302 ( volatile atomic_wchar_t* __a__, memory_order __x__ )
2303 { return _ATOMIC_LOAD_( __a__, __x__ ); }
2304
2305 inline wchar_t atomic_load( volatile atomic_wchar_t* __a__ )
2306 { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
2307
2308 inline void atomic_store_explicit
2309 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2310 { _ATOMIC_STORE_( __a__, __m__, __x__ ); }
2311
2312 inline void atomic_store
2313 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2314 { atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
2315
2316 inline wchar_t atomic_exchange_explicit
2317 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2318 { return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
2319
2320 inline wchar_t atomic_exchange
2321 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2322 { return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
2323
2324 inline bool atomic_compare_exchange_weak_explicit
2325 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
2326   memory_order __x__, memory_order __y__ )
2327 { return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
2328
2329 inline bool atomic_compare_exchange_strong_explicit
2330 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
2331   memory_order __x__, memory_order __y__ )
2332 { return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
2333
2334 inline bool atomic_compare_exchange_weak
2335 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
2336 { return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
2337                  memory_order_seq_cst, memory_order_seq_cst ); }
2338
2339 inline bool atomic_compare_exchange_strong
2340 ( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
2341 { return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
2342                  memory_order_seq_cst, memory_order_seq_cst ); }
2343
2344 inline void atomic_fence
2345 ( const volatile atomic_wchar_t* __a__, memory_order __x__ )
2346 { _ATOMIC_FENCE_( __a__, __x__ ); }
2347
2348
2349 inline void* atomic_fetch_add_explicit
2350 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2351 {
2352         void* volatile* __p__ = &((__a__)->__f__);
2353         void* __r__ = (void *) model_rmwr_action((void *)__p__, __x__);
2354         model_rmw_action((void *)__p__, __x__, (uint64_t) ((char*)(*__p__) + __m__));
2355   return __r__; }
2356
2357 inline void* atomic_fetch_add
2358 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2359 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2360
2361
2362 inline void* atomic_fetch_sub_explicit
2363 ( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
2364 {
2365         void* volatile* __p__ = &((__a__)->__f__);
2366         void* __r__ = (void *) model_rmwr_action((void *)__p__, __x__);
2367         model_rmw_action((void *)__p__, __x__, (uint64_t)((char*)(*__p__) - __m__));
2368   return __r__; }
2369
2370 inline void* atomic_fetch_sub
2371 ( volatile atomic_address* __a__, ptrdiff_t __m__ )
2372 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2373
2374 inline char atomic_fetch_add_explicit
2375 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2376 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2377
2378 inline char atomic_fetch_add
2379 ( volatile atomic_char* __a__, char __m__ )
2380 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2381
2382
2383 inline char atomic_fetch_sub_explicit
2384 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2385 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2386
2387 inline char atomic_fetch_sub
2388 ( volatile atomic_char* __a__, char __m__ )
2389 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2390
2391
2392 inline char atomic_fetch_and_explicit
2393 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2394 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2395
2396 inline char atomic_fetch_and
2397 ( volatile atomic_char* __a__, char __m__ )
2398 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2399
2400
2401 inline char atomic_fetch_or_explicit
2402 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2403 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2404
2405 inline char atomic_fetch_or
2406 ( volatile atomic_char* __a__, char __m__ )
2407 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2408
2409
2410 inline char atomic_fetch_xor_explicit
2411 ( volatile atomic_char* __a__, char __m__, memory_order __x__ )
2412 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2413
2414 inline char atomic_fetch_xor
2415 ( volatile atomic_char* __a__, char __m__ )
2416 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2417
2418
2419 inline signed char atomic_fetch_add_explicit
2420 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2421 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2422
2423 inline signed char atomic_fetch_add
2424 ( volatile atomic_schar* __a__, signed char __m__ )
2425 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2426
2427
2428 inline signed char atomic_fetch_sub_explicit
2429 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2430 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2431
2432 inline signed char atomic_fetch_sub
2433 ( volatile atomic_schar* __a__, signed char __m__ )
2434 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2435
2436
2437 inline signed char atomic_fetch_and_explicit
2438 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2439 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2440
2441 inline signed char atomic_fetch_and
2442 ( volatile atomic_schar* __a__, signed char __m__ )
2443 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2444
2445
2446 inline signed char atomic_fetch_or_explicit
2447 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2448 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2449
2450 inline signed char atomic_fetch_or
2451 ( volatile atomic_schar* __a__, signed char __m__ )
2452 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2453
2454
2455 inline signed char atomic_fetch_xor_explicit
2456 ( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
2457 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2458
2459 inline signed char atomic_fetch_xor
2460 ( volatile atomic_schar* __a__, signed char __m__ )
2461 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2462
2463
2464 inline unsigned char atomic_fetch_add_explicit
2465 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2466 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2467
2468 inline unsigned char atomic_fetch_add
2469 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2470 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2471
2472
2473 inline unsigned char atomic_fetch_sub_explicit
2474 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2475 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2476
2477 inline unsigned char atomic_fetch_sub
2478 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2479 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2480
2481
2482 inline unsigned char atomic_fetch_and_explicit
2483 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2484 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2485
2486 inline unsigned char atomic_fetch_and
2487 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2488 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2489
2490
2491 inline unsigned char atomic_fetch_or_explicit
2492 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2493 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2494
2495 inline unsigned char atomic_fetch_or
2496 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2497 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2498
2499
2500 inline unsigned char atomic_fetch_xor_explicit
2501 ( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
2502 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2503
2504 inline unsigned char atomic_fetch_xor
2505 ( volatile atomic_uchar* __a__, unsigned char __m__ )
2506 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2507
2508
2509 inline short atomic_fetch_add_explicit
2510 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2511 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2512
2513 inline short atomic_fetch_add
2514 ( volatile atomic_short* __a__, short __m__ )
2515 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2516
2517
2518 inline short atomic_fetch_sub_explicit
2519 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2520 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2521
2522 inline short atomic_fetch_sub
2523 ( volatile atomic_short* __a__, short __m__ )
2524 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2525
2526
2527 inline short atomic_fetch_and_explicit
2528 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2529 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2530
2531 inline short atomic_fetch_and
2532 ( volatile atomic_short* __a__, short __m__ )
2533 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2534
2535
2536 inline short atomic_fetch_or_explicit
2537 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2538 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2539
2540 inline short atomic_fetch_or
2541 ( volatile atomic_short* __a__, short __m__ )
2542 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2543
2544
2545 inline short atomic_fetch_xor_explicit
2546 ( volatile atomic_short* __a__, short __m__, memory_order __x__ )
2547 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2548
2549 inline short atomic_fetch_xor
2550 ( volatile atomic_short* __a__, short __m__ )
2551 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2552
2553
2554 inline unsigned short atomic_fetch_add_explicit
2555 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2556 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2557
2558 inline unsigned short atomic_fetch_add
2559 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2560 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2561
2562
2563 inline unsigned short atomic_fetch_sub_explicit
2564 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2565 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2566
2567 inline unsigned short atomic_fetch_sub
2568 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2569 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2570
2571
2572 inline unsigned short atomic_fetch_and_explicit
2573 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2574 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2575
2576 inline unsigned short atomic_fetch_and
2577 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2578 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2579
2580
2581 inline unsigned short atomic_fetch_or_explicit
2582 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2583 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2584
2585 inline unsigned short atomic_fetch_or
2586 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2587 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2588
2589
2590 inline unsigned short atomic_fetch_xor_explicit
2591 ( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
2592 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2593
2594 inline unsigned short atomic_fetch_xor
2595 ( volatile atomic_ushort* __a__, unsigned short __m__ )
2596 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2597
2598
2599 inline int atomic_fetch_add_explicit
2600 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2601 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2602
2603 inline int atomic_fetch_add
2604 ( volatile atomic_int* __a__, int __m__ )
2605 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2606
2607
2608 inline int atomic_fetch_sub_explicit
2609 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2610 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2611
2612 inline int atomic_fetch_sub
2613 ( volatile atomic_int* __a__, int __m__ )
2614 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2615
2616
2617 inline int atomic_fetch_and_explicit
2618 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2619 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2620
2621 inline int atomic_fetch_and
2622 ( volatile atomic_int* __a__, int __m__ )
2623 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2624
2625
2626 inline int atomic_fetch_or_explicit
2627 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2628 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2629
2630 inline int atomic_fetch_or
2631 ( volatile atomic_int* __a__, int __m__ )
2632 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2633
2634
2635 inline int atomic_fetch_xor_explicit
2636 ( volatile atomic_int* __a__, int __m__, memory_order __x__ )
2637 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2638
2639 inline int atomic_fetch_xor
2640 ( volatile atomic_int* __a__, int __m__ )
2641 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2642
2643
2644 inline unsigned int atomic_fetch_add_explicit
2645 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2646 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2647
2648 inline unsigned int atomic_fetch_add
2649 ( volatile atomic_uint* __a__, unsigned int __m__ )
2650 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2651
2652
2653 inline unsigned int atomic_fetch_sub_explicit
2654 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2655 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2656
2657 inline unsigned int atomic_fetch_sub
2658 ( volatile atomic_uint* __a__, unsigned int __m__ )
2659 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2660
2661
2662 inline unsigned int atomic_fetch_and_explicit
2663 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2664 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2665
2666 inline unsigned int atomic_fetch_and
2667 ( volatile atomic_uint* __a__, unsigned int __m__ )
2668 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2669
2670
2671 inline unsigned int atomic_fetch_or_explicit
2672 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2673 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2674
2675 inline unsigned int atomic_fetch_or
2676 ( volatile atomic_uint* __a__, unsigned int __m__ )
2677 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2678
2679
2680 inline unsigned int atomic_fetch_xor_explicit
2681 ( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
2682 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2683
2684 inline unsigned int atomic_fetch_xor
2685 ( volatile atomic_uint* __a__, unsigned int __m__ )
2686 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2687
2688
2689 inline long atomic_fetch_add_explicit
2690 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2691 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2692
2693 inline long atomic_fetch_add
2694 ( volatile atomic_long* __a__, long __m__ )
2695 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2696
2697
2698 inline long atomic_fetch_sub_explicit
2699 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2700 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2701
2702 inline long atomic_fetch_sub
2703 ( volatile atomic_long* __a__, long __m__ )
2704 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2705
2706
2707 inline long atomic_fetch_and_explicit
2708 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2709 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2710
2711 inline long atomic_fetch_and
2712 ( volatile atomic_long* __a__, long __m__ )
2713 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2714
2715
2716 inline long atomic_fetch_or_explicit
2717 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2718 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2719
2720 inline long atomic_fetch_or
2721 ( volatile atomic_long* __a__, long __m__ )
2722 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2723
2724
2725 inline long atomic_fetch_xor_explicit
2726 ( volatile atomic_long* __a__, long __m__, memory_order __x__ )
2727 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2728
2729 inline long atomic_fetch_xor
2730 ( volatile atomic_long* __a__, long __m__ )
2731 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2732
2733
2734 inline unsigned long atomic_fetch_add_explicit
2735 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2736 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2737
2738 inline unsigned long atomic_fetch_add
2739 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2740 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2741
2742
2743 inline unsigned long atomic_fetch_sub_explicit
2744 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2745 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2746
2747 inline unsigned long atomic_fetch_sub
2748 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2749 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2750
2751
2752 inline unsigned long atomic_fetch_and_explicit
2753 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2754 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2755
2756 inline unsigned long atomic_fetch_and
2757 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2758 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2759
2760
2761 inline unsigned long atomic_fetch_or_explicit
2762 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2763 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2764
2765 inline unsigned long atomic_fetch_or
2766 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2767 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2768
2769
2770 inline unsigned long atomic_fetch_xor_explicit
2771 ( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
2772 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2773
2774 inline unsigned long atomic_fetch_xor
2775 ( volatile atomic_ulong* __a__, unsigned long __m__ )
2776 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2777
2778
2779 inline long long atomic_fetch_add_explicit
2780 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2781 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2782
2783 inline long long atomic_fetch_add
2784 ( volatile atomic_llong* __a__, long long __m__ )
2785 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2786
2787
2788 inline long long atomic_fetch_sub_explicit
2789 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2790 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2791
2792 inline long long atomic_fetch_sub
2793 ( volatile atomic_llong* __a__, long long __m__ )
2794 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2795
2796
2797 inline long long atomic_fetch_and_explicit
2798 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2799 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2800
2801 inline long long atomic_fetch_and
2802 ( volatile atomic_llong* __a__, long long __m__ )
2803 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2804
2805
2806 inline long long atomic_fetch_or_explicit
2807 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2808 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2809
2810 inline long long atomic_fetch_or
2811 ( volatile atomic_llong* __a__, long long __m__ )
2812 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2813
2814
2815 inline long long atomic_fetch_xor_explicit
2816 ( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
2817 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2818
2819 inline long long atomic_fetch_xor
2820 ( volatile atomic_llong* __a__, long long __m__ )
2821 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2822
2823
2824 inline unsigned long long atomic_fetch_add_explicit
2825 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2826 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2827
2828 inline unsigned long long atomic_fetch_add
2829 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2830 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2831
2832
2833 inline unsigned long long atomic_fetch_sub_explicit
2834 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2835 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2836
2837 inline unsigned long long atomic_fetch_sub
2838 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2839 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2840
2841
2842 inline unsigned long long atomic_fetch_and_explicit
2843 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2844 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2845
2846 inline unsigned long long atomic_fetch_and
2847 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2848 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2849
2850
2851 inline unsigned long long atomic_fetch_or_explicit
2852 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2853 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2854
2855 inline unsigned long long atomic_fetch_or
2856 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2857 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2858
2859
2860 inline unsigned long long atomic_fetch_xor_explicit
2861 ( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
2862 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2863
2864 inline unsigned long long atomic_fetch_xor
2865 ( volatile atomic_ullong* __a__, unsigned long long __m__ )
2866 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2867
2868
2869 inline wchar_t atomic_fetch_add_explicit
2870 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2871 { return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
2872
2873 inline wchar_t atomic_fetch_add
2874 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2875 { return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
2876
2877
2878 inline wchar_t atomic_fetch_sub_explicit
2879 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2880 { return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
2881
2882 inline wchar_t atomic_fetch_sub
2883 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2884 { return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
2885
2886
2887 inline wchar_t atomic_fetch_and_explicit
2888 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2889 { return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
2890
2891 inline wchar_t atomic_fetch_and
2892 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2893 { return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
2894
2895
2896 inline wchar_t atomic_fetch_or_explicit
2897 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2898 { return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
2899
2900 inline wchar_t atomic_fetch_or
2901 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2902 { return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
2903
2904
2905 inline wchar_t atomic_fetch_xor_explicit
2906 ( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
2907 { return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
2908
2909 inline wchar_t atomic_fetch_xor
2910 ( volatile atomic_wchar_t* __a__, wchar_t __m__ )
2911 { return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
2912
2913
2914 #else
2915
2916
2917 #define atomic_is_lock_free( __a__ ) \
2918 false
2919
2920 #define atomic_load( __a__ ) \
2921 _ATOMIC_LOAD_( __a__, memory_order_seq_cst )
2922
2923 #define atomic_load_explicit( __a__, __x__ ) \
2924 _ATOMIC_LOAD_( __a__, __x__ )
2925
2926 #define atomic_init( __a__, __m__ ) \
2927 _ATOMIC_INIT_( __a__, __m__ )
2928
2929 #define atomic_store( __a__, __m__ ) \
2930 _ATOMIC_STORE_( __a__, __m__, memory_order_seq_cst )
2931
2932 #define atomic_store_explicit( __a__, __m__, __x__ ) \
2933 _ATOMIC_STORE_( __a__, __m__, __x__ )
2934
2935 #define atomic_exchange( __a__, __m__ ) \
2936 _ATOMIC_MODIFY_( __a__, =, __m__, memory_order_seq_cst )
2937
2938 #define atomic_exchange_explicit( __a__, __m__, __x__ ) \
2939 _ATOMIC_MODIFY_( __a__, =, __m__, __x__ )
2940
2941 #define atomic_compare_exchange_weak( __a__, __e__, __m__ ) \
2942 _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, memory_order_seq_cst )
2943
2944 #define atomic_compare_exchange_strong( __a__, __e__, __m__ ) \
2945 _ATOMIC_CMPSWP_( __a__, __e__, __m__, memory_order_seq_cst )
2946
2947 #define atomic_compare_exchange_weak_explicit( __a__, __e__, __m__, __x__, __y__ ) \
2948 _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ )
2949
2950 #define atomic_compare_exchange_strong_explicit( __a__, __e__, __m__, __x__, __y__ ) \
2951 _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ )
2952
2953 #define atomic_fence( __a__, __x__ ) \
2954 ({ _ATOMIC_FENCE_( __a__, __x__ ); })
2955
2956
2957 #define atomic_fetch_add_explicit( __a__, __m__, __x__ ) \
2958 _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ )
2959
2960 #define atomic_fetch_add( __a__, __m__ ) \
2961 _ATOMIC_MODIFY_( __a__, +=, __m__, memory_order_seq_cst )
2962
2963
2964 #define atomic_fetch_sub_explicit( __a__, __m__, __x__ ) \
2965 _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ )
2966
2967 #define atomic_fetch_sub( __a__, __m__ ) \
2968 _ATOMIC_MODIFY_( __a__, -=, __m__, memory_order_seq_cst )
2969
2970
2971 #define atomic_fetch_and_explicit( __a__, __m__, __x__ ) \
2972 _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ )
2973
2974 #define atomic_fetch_and( __a__, __m__ ) \
2975 _ATOMIC_MODIFY_( __a__, &=, __m__, memory_order_seq_cst )
2976
2977
2978 #define atomic_fetch_or_explicit( __a__, __m__, __x__ ) \
2979 _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ )
2980
2981 #define atomic_fetch_or( __a__, __m__ ) \
2982 _ATOMIC_MODIFY_( __a__, |=, __m__, memory_order_seq_cst )
2983
2984
2985 #define atomic_fetch_xor_explicit( __a__, __m__, __x__ ) \
2986 _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ )
2987
2988 #define atomic_fetch_xor( __a__, __m__ ) \
2989 _ATOMIC_MODIFY_( __a__, ^=, __m__, memory_order_seq_cst )
2990
2991
2992 #endif
2993
2994
2995 #ifdef __cplusplus
2996
2997
2998 inline bool atomic_bool::is_lock_free() const volatile
2999 { return false; }
3000
3001 inline void atomic_bool::store
3002 ( bool __m__, memory_order __x__ ) volatile
3003 { atomic_store_explicit( this, __m__, __x__ ); }
3004
3005 inline bool atomic_bool::load
3006 ( memory_order __x__ ) volatile
3007 { return atomic_load_explicit( this, __x__ ); }
3008
3009 inline bool atomic_bool::exchange
3010 ( bool __m__, memory_order __x__ ) volatile
3011 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3012
3013 inline bool atomic_bool::compare_exchange_weak
3014 ( bool& __e__, bool __m__,
3015   memory_order __x__, memory_order __y__ ) volatile
3016 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3017
3018 inline bool atomic_bool::compare_exchange_strong
3019 ( bool& __e__, bool __m__,
3020   memory_order __x__, memory_order __y__ ) volatile
3021 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3022
3023 inline bool atomic_bool::compare_exchange_weak
3024 ( bool& __e__, bool __m__, memory_order __x__ ) volatile
3025 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3026       __x__ == memory_order_acq_rel ? memory_order_acquire :
3027       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3028
3029 inline bool atomic_bool::compare_exchange_strong
3030 ( bool& __e__, bool __m__, memory_order __x__ ) volatile
3031 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3032       __x__ == memory_order_acq_rel ? memory_order_acquire :
3033       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3034
3035 inline void atomic_bool::fence
3036 ( memory_order __x__ ) const volatile
3037 { return atomic_fence( this, __x__ ); }
3038
3039
3040 inline bool atomic_address::is_lock_free() const volatile
3041 { return false; }
3042
3043 inline void atomic_address::store
3044 ( void* __m__, memory_order __x__ ) volatile
3045 { atomic_store_explicit( this, __m__, __x__ ); }
3046
3047 inline void* atomic_address::load
3048 ( memory_order __x__ ) volatile
3049 { return atomic_load_explicit( this, __x__ ); }
3050
3051 inline void* atomic_address::exchange
3052 ( void* __m__, memory_order __x__ ) volatile
3053 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3054
3055 inline bool atomic_address::compare_exchange_weak
3056 ( void*& __e__, void* __m__,
3057   memory_order __x__, memory_order __y__ ) volatile
3058 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3059
3060 inline bool atomic_address::compare_exchange_strong
3061 ( void*& __e__, void* __m__,
3062   memory_order __x__, memory_order __y__ ) volatile
3063 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3064
3065 inline bool atomic_address::compare_exchange_weak
3066 ( void*& __e__, void* __m__, memory_order __x__ ) volatile
3067 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3068       __x__ == memory_order_acq_rel ? memory_order_acquire :
3069       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3070
3071 inline bool atomic_address::compare_exchange_strong
3072 ( void*& __e__, void* __m__, memory_order __x__ ) volatile
3073 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3074       __x__ == memory_order_acq_rel ? memory_order_acquire :
3075       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3076
3077 inline void atomic_address::fence
3078 ( memory_order __x__ ) const volatile
3079 { return atomic_fence( this, __x__ ); }
3080
3081
3082 inline bool atomic_char::is_lock_free() const volatile
3083 { return false; }
3084
3085 inline void atomic_char::store
3086 ( char __m__, memory_order __x__ ) volatile
3087 { atomic_store_explicit( this, __m__, __x__ ); }
3088
3089 inline char atomic_char::load
3090 ( memory_order __x__ ) volatile
3091 { return atomic_load_explicit( this, __x__ ); }
3092
3093 inline char atomic_char::exchange
3094 ( char __m__, memory_order __x__ ) volatile
3095 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3096
3097 inline bool atomic_char::compare_exchange_weak
3098 ( char& __e__, char __m__,
3099   memory_order __x__, memory_order __y__ ) volatile
3100 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3101
3102 inline bool atomic_char::compare_exchange_strong
3103 ( char& __e__, char __m__,
3104   memory_order __x__, memory_order __y__ ) volatile
3105 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3106
3107 inline bool atomic_char::compare_exchange_weak
3108 ( char& __e__, char __m__, memory_order __x__ ) volatile
3109 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3110       __x__ == memory_order_acq_rel ? memory_order_acquire :
3111       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3112
3113 inline bool atomic_char::compare_exchange_strong
3114 ( char& __e__, char __m__, memory_order __x__ ) volatile
3115 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3116       __x__ == memory_order_acq_rel ? memory_order_acquire :
3117       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3118
3119 inline void atomic_char::fence
3120 ( memory_order __x__ ) const volatile
3121 { return atomic_fence( this, __x__ ); }
3122
3123
3124 inline bool atomic_schar::is_lock_free() const volatile
3125 { return false; }
3126
3127 inline void atomic_schar::store
3128 ( signed char __m__, memory_order __x__ ) volatile
3129 { atomic_store_explicit( this, __m__, __x__ ); }
3130
3131 inline signed char atomic_schar::load
3132 ( memory_order __x__ ) volatile
3133 { return atomic_load_explicit( this, __x__ ); }
3134
3135 inline signed char atomic_schar::exchange
3136 ( signed char __m__, memory_order __x__ ) volatile
3137 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3138
3139 inline bool atomic_schar::compare_exchange_weak
3140 ( signed char& __e__, signed char __m__,
3141   memory_order __x__, memory_order __y__ ) volatile
3142 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3143
3144 inline bool atomic_schar::compare_exchange_strong
3145 ( signed char& __e__, signed char __m__,
3146   memory_order __x__, memory_order __y__ ) volatile
3147 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3148
3149 inline bool atomic_schar::compare_exchange_weak
3150 ( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
3151 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3152       __x__ == memory_order_acq_rel ? memory_order_acquire :
3153       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3154
3155 inline bool atomic_schar::compare_exchange_strong
3156 ( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
3157 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3158       __x__ == memory_order_acq_rel ? memory_order_acquire :
3159       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3160
3161 inline void atomic_schar::fence
3162 ( memory_order __x__ ) const volatile
3163 { return atomic_fence( this, __x__ ); }
3164
3165
3166 inline bool atomic_uchar::is_lock_free() const volatile
3167 { return false; }
3168
3169 inline void atomic_uchar::store
3170 ( unsigned char __m__, memory_order __x__ ) volatile
3171 { atomic_store_explicit( this, __m__, __x__ ); }
3172
3173 inline unsigned char atomic_uchar::load
3174 ( memory_order __x__ ) volatile
3175 { return atomic_load_explicit( this, __x__ ); }
3176
3177 inline unsigned char atomic_uchar::exchange
3178 ( unsigned char __m__, memory_order __x__ ) volatile
3179 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3180
3181 inline bool atomic_uchar::compare_exchange_weak
3182 ( unsigned char& __e__, unsigned char __m__,
3183   memory_order __x__, memory_order __y__ ) volatile
3184 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3185
3186 inline bool atomic_uchar::compare_exchange_strong
3187 ( unsigned char& __e__, unsigned char __m__,
3188   memory_order __x__, memory_order __y__ ) volatile
3189 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3190
3191 inline bool atomic_uchar::compare_exchange_weak
3192 ( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
3193 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3194       __x__ == memory_order_acq_rel ? memory_order_acquire :
3195       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3196
3197 inline bool atomic_uchar::compare_exchange_strong
3198 ( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
3199 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3200       __x__ == memory_order_acq_rel ? memory_order_acquire :
3201       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3202
3203 inline void atomic_uchar::fence
3204 ( memory_order __x__ ) const volatile
3205 { return atomic_fence( this, __x__ ); }
3206
3207
3208 inline bool atomic_short::is_lock_free() const volatile
3209 { return false; }
3210
3211 inline void atomic_short::store
3212 ( short __m__, memory_order __x__ ) volatile
3213 { atomic_store_explicit( this, __m__, __x__ ); }
3214
3215 inline short atomic_short::load
3216 ( memory_order __x__ ) volatile
3217 { return atomic_load_explicit( this, __x__ ); }
3218
3219 inline short atomic_short::exchange
3220 ( short __m__, memory_order __x__ ) volatile
3221 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3222
3223 inline bool atomic_short::compare_exchange_weak
3224 ( short& __e__, short __m__,
3225   memory_order __x__, memory_order __y__ ) volatile
3226 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3227
3228 inline bool atomic_short::compare_exchange_strong
3229 ( short& __e__, short __m__,
3230   memory_order __x__, memory_order __y__ ) volatile
3231 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3232
3233 inline bool atomic_short::compare_exchange_weak
3234 ( short& __e__, short __m__, memory_order __x__ ) volatile
3235 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3236       __x__ == memory_order_acq_rel ? memory_order_acquire :
3237       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3238
3239 inline bool atomic_short::compare_exchange_strong
3240 ( short& __e__, short __m__, memory_order __x__ ) volatile
3241 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3242       __x__ == memory_order_acq_rel ? memory_order_acquire :
3243       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3244
3245 inline void atomic_short::fence
3246 ( memory_order __x__ ) const volatile
3247 { return atomic_fence( this, __x__ ); }
3248
3249
3250 inline bool atomic_ushort::is_lock_free() const volatile
3251 { return false; }
3252
3253 inline void atomic_ushort::store
3254 ( unsigned short __m__, memory_order __x__ ) volatile
3255 { atomic_store_explicit( this, __m__, __x__ ); }
3256
3257 inline unsigned short atomic_ushort::load
3258 ( memory_order __x__ ) volatile
3259 { return atomic_load_explicit( this, __x__ ); }
3260
3261 inline unsigned short atomic_ushort::exchange
3262 ( unsigned short __m__, memory_order __x__ ) volatile
3263 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3264
3265 inline bool atomic_ushort::compare_exchange_weak
3266 ( unsigned short& __e__, unsigned short __m__,
3267   memory_order __x__, memory_order __y__ ) volatile
3268 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3269
3270 inline bool atomic_ushort::compare_exchange_strong
3271 ( unsigned short& __e__, unsigned short __m__,
3272   memory_order __x__, memory_order __y__ ) volatile
3273 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3274
3275 inline bool atomic_ushort::compare_exchange_weak
3276 ( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
3277 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3278       __x__ == memory_order_acq_rel ? memory_order_acquire :
3279       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3280
3281 inline bool atomic_ushort::compare_exchange_strong
3282 ( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
3283 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3284       __x__ == memory_order_acq_rel ? memory_order_acquire :
3285       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3286
3287 inline void atomic_ushort::fence
3288 ( memory_order __x__ ) const volatile
3289 { return atomic_fence( this, __x__ ); }
3290
3291
3292 inline bool atomic_int::is_lock_free() const volatile
3293 { return false; }
3294
3295 inline void atomic_int::store
3296 ( int __m__, memory_order __x__ ) volatile
3297 { atomic_store_explicit( this, __m__, __x__ ); }
3298
3299 inline int atomic_int::load
3300 ( memory_order __x__ ) volatile
3301 { return atomic_load_explicit( this, __x__ ); }
3302
3303 inline int atomic_int::exchange
3304 ( int __m__, memory_order __x__ ) volatile
3305 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3306
3307 inline bool atomic_int::compare_exchange_weak
3308 ( int& __e__, int __m__,
3309   memory_order __x__, memory_order __y__ ) volatile
3310 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3311
3312 inline bool atomic_int::compare_exchange_strong
3313 ( int& __e__, int __m__,
3314   memory_order __x__, memory_order __y__ ) volatile
3315 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3316
3317 inline bool atomic_int::compare_exchange_weak
3318 ( int& __e__, int __m__, memory_order __x__ ) volatile
3319 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3320       __x__ == memory_order_acq_rel ? memory_order_acquire :
3321       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3322
3323 inline bool atomic_int::compare_exchange_strong
3324 ( int& __e__, int __m__, memory_order __x__ ) volatile
3325 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3326       __x__ == memory_order_acq_rel ? memory_order_acquire :
3327       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3328
3329 inline void atomic_int::fence
3330 ( memory_order __x__ ) const volatile
3331 { return atomic_fence( this, __x__ ); }
3332
3333
3334 inline bool atomic_uint::is_lock_free() const volatile
3335 { return false; }
3336
3337 inline void atomic_uint::store
3338 ( unsigned int __m__, memory_order __x__ ) volatile
3339 { atomic_store_explicit( this, __m__, __x__ ); }
3340
3341 inline unsigned int atomic_uint::load
3342 ( memory_order __x__ ) volatile
3343 { return atomic_load_explicit( this, __x__ ); }
3344
3345 inline unsigned int atomic_uint::exchange
3346 ( unsigned int __m__, memory_order __x__ ) volatile
3347 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3348
3349 inline bool atomic_uint::compare_exchange_weak
3350 ( unsigned int& __e__, unsigned int __m__,
3351   memory_order __x__, memory_order __y__ ) volatile
3352 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3353
3354 inline bool atomic_uint::compare_exchange_strong
3355 ( unsigned int& __e__, unsigned int __m__,
3356   memory_order __x__, memory_order __y__ ) volatile
3357 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3358
3359 inline bool atomic_uint::compare_exchange_weak
3360 ( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
3361 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3362       __x__ == memory_order_acq_rel ? memory_order_acquire :
3363       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3364
3365 inline bool atomic_uint::compare_exchange_strong
3366 ( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
3367 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3368       __x__ == memory_order_acq_rel ? memory_order_acquire :
3369       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3370
3371 inline void atomic_uint::fence
3372 ( memory_order __x__ ) const volatile
3373 { return atomic_fence( this, __x__ ); }
3374
3375
3376 inline bool atomic_long::is_lock_free() const volatile
3377 { return false; }
3378
3379 inline void atomic_long::store
3380 ( long __m__, memory_order __x__ ) volatile
3381 { atomic_store_explicit( this, __m__, __x__ ); }
3382
3383 inline long atomic_long::load
3384 ( memory_order __x__ ) volatile
3385 { return atomic_load_explicit( this, __x__ ); }
3386
3387 inline long atomic_long::exchange
3388 ( long __m__, memory_order __x__ ) volatile
3389 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3390
3391 inline bool atomic_long::compare_exchange_weak
3392 ( long& __e__, long __m__,
3393   memory_order __x__, memory_order __y__ ) volatile
3394 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3395
3396 inline bool atomic_long::compare_exchange_strong
3397 ( long& __e__, long __m__,
3398   memory_order __x__, memory_order __y__ ) volatile
3399 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3400
3401 inline bool atomic_long::compare_exchange_weak
3402 ( long& __e__, long __m__, memory_order __x__ ) volatile
3403 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3404       __x__ == memory_order_acq_rel ? memory_order_acquire :
3405       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3406
3407 inline bool atomic_long::compare_exchange_strong
3408 ( long& __e__, long __m__, memory_order __x__ ) volatile
3409 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3410       __x__ == memory_order_acq_rel ? memory_order_acquire :
3411       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3412
3413 inline void atomic_long::fence
3414 ( memory_order __x__ ) const volatile
3415 { return atomic_fence( this, __x__ ); }
3416
3417
3418 inline bool atomic_ulong::is_lock_free() const volatile
3419 { return false; }
3420
3421 inline void atomic_ulong::store
3422 ( unsigned long __m__, memory_order __x__ ) volatile
3423 { atomic_store_explicit( this, __m__, __x__ ); }
3424
3425 inline unsigned long atomic_ulong::load
3426 ( memory_order __x__ ) volatile
3427 { return atomic_load_explicit( this, __x__ ); }
3428
3429 inline unsigned long atomic_ulong::exchange
3430 ( unsigned long __m__, memory_order __x__ ) volatile
3431 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3432
3433 inline bool atomic_ulong::compare_exchange_weak
3434 ( unsigned long& __e__, unsigned long __m__,
3435   memory_order __x__, memory_order __y__ ) volatile
3436 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3437
3438 inline bool atomic_ulong::compare_exchange_strong
3439 ( unsigned long& __e__, unsigned long __m__,
3440   memory_order __x__, memory_order __y__ ) volatile
3441 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3442
3443 inline bool atomic_ulong::compare_exchange_weak
3444 ( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
3445 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3446       __x__ == memory_order_acq_rel ? memory_order_acquire :
3447       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3448
3449 inline bool atomic_ulong::compare_exchange_strong
3450 ( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
3451 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3452       __x__ == memory_order_acq_rel ? memory_order_acquire :
3453       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3454
3455 inline void atomic_ulong::fence
3456 ( memory_order __x__ ) const volatile
3457 { return atomic_fence( this, __x__ ); }
3458
3459
3460 inline bool atomic_llong::is_lock_free() const volatile
3461 { return false; }
3462
3463 inline void atomic_llong::store
3464 ( long long __m__, memory_order __x__ ) volatile
3465 { atomic_store_explicit( this, __m__, __x__ ); }
3466
3467 inline long long atomic_llong::load
3468 ( memory_order __x__ ) volatile
3469 { return atomic_load_explicit( this, __x__ ); }
3470
3471 inline long long atomic_llong::exchange
3472 ( long long __m__, memory_order __x__ ) volatile
3473 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3474
3475 inline bool atomic_llong::compare_exchange_weak
3476 ( long long& __e__, long long __m__,
3477   memory_order __x__, memory_order __y__ ) volatile
3478 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3479
3480 inline bool atomic_llong::compare_exchange_strong
3481 ( long long& __e__, long long __m__,
3482   memory_order __x__, memory_order __y__ ) volatile
3483 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3484
3485 inline bool atomic_llong::compare_exchange_weak
3486 ( long long& __e__, long long __m__, memory_order __x__ ) volatile
3487 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3488       __x__ == memory_order_acq_rel ? memory_order_acquire :
3489       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3490
3491 inline bool atomic_llong::compare_exchange_strong
3492 ( long long& __e__, long long __m__, memory_order __x__ ) volatile
3493 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3494       __x__ == memory_order_acq_rel ? memory_order_acquire :
3495       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3496
3497 inline void atomic_llong::fence
3498 ( memory_order __x__ ) const volatile
3499 { return atomic_fence( this, __x__ ); }
3500
3501
3502 inline bool atomic_ullong::is_lock_free() const volatile
3503 { return false; }
3504
3505 inline void atomic_ullong::store
3506 ( unsigned long long __m__, memory_order __x__ ) volatile
3507 { atomic_store_explicit( this, __m__, __x__ ); }
3508
3509 inline unsigned long long atomic_ullong::load
3510 ( memory_order __x__ ) volatile
3511 { return atomic_load_explicit( this, __x__ ); }
3512
3513 inline unsigned long long atomic_ullong::exchange
3514 ( unsigned long long __m__, memory_order __x__ ) volatile
3515 { return atomic_exchange_explicit( this, __m__, __x__ ); }
3516
3517 inline bool atomic_ullong::compare_exchange_weak
3518 ( unsigned long long& __e__, unsigned long long __m__,
3519   memory_order __x__, memory_order __y__ ) volatile
3520 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
3521
3522 inline bool atomic_ullong::compare_exchange_strong
3523 ( unsigned long long& __e__, unsigned long long __m__,
3524   memory_order __x__, memory_order __y__ ) volatile
3525 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
3526
3527 inline bool atomic_ullong::compare_exchange_weak
3528 ( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
3529 { return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
3530       __x__ == memory_order_acq_rel ? memory_order_acquire :
3531       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3532
3533 inline bool atomic_ullong::compare_exchange_strong
3534 ( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
3535 { return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
3536       __x__ == memory_order_acq_rel ? memory_order_acquire :
3537       __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
3538
3539 inline void atomic_ullong::fence
3540 ( memory_order __x__ ) const volatile
3541 { return atomic_fence( this, __x__ ); }
3542
3543
3544 inline bool atomic_wchar_t::is_lock_free() const volatile
3545 { return false; }
3546
3547 inline void atomic_wchar_t::store
3548 ( wchar_t __m__, memory_order __x__ ) volatile
3549 { atomic_store_explicit( this, __m__, __x__ ); }
3550
3551 inline wchar_t atomic_wchar_t::load
3552