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