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