include/impatomic.h

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