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