include/impatomic.h

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