include/impatomic.h

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