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