00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #ifndef _GLIBCXX_ATOMIC
00033 #define _GLIBCXX_ATOMIC 1
00034
00035 #pragma GCC system_header
00036
00037 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00038 # include <bits/c++0x_warning.h>
00039 #endif
00040
00041 #include <bits/atomic_base.h>
00042 #include <bits/atomic_0.h>
00043 #include <bits/atomic_2.h>
00044
00045 namespace std _GLIBCXX_VISIBILITY(default)
00046 {
00047 _GLIBCXX_BEGIN_NAMESPACE_VERSION
00048
00049
00050
00051
00052
00053
00054
00055
00056 struct atomic_bool
00057 {
00058 private:
00059 __atomic_base<bool> _M_base;
00060
00061 public:
00062 atomic_bool() = default;
00063 ~atomic_bool() = default;
00064 atomic_bool(const atomic_bool&) = delete;
00065 atomic_bool& operator=(const atomic_bool&) = delete;
00066 atomic_bool& operator=(const atomic_bool&) volatile = delete;
00067
00068 constexpr atomic_bool(bool __i) : _M_base(__i) { }
00069
00070 bool
00071 operator=(bool __i)
00072 { return _M_base.operator=(__i); }
00073
00074 operator bool() const
00075 { return _M_base.load(); }
00076
00077 operator bool() const volatile
00078 { return _M_base.load(); }
00079
00080 bool
00081 is_lock_free() const { return _M_base.is_lock_free(); }
00082
00083 bool
00084 is_lock_free() const volatile { return _M_base.is_lock_free(); }
00085
00086 void
00087 store(bool __i, memory_order __m = memory_order_seq_cst)
00088 { _M_base.store(__i, __m); }
00089
00090 void
00091 store(bool __i, memory_order __m = memory_order_seq_cst) volatile
00092 { _M_base.store(__i, __m); }
00093
00094 bool
00095 load(memory_order __m = memory_order_seq_cst) const
00096 { return _M_base.load(__m); }
00097
00098 bool
00099 load(memory_order __m = memory_order_seq_cst) const volatile
00100 { return _M_base.load(__m); }
00101
00102 bool
00103 exchange(bool __i, memory_order __m = memory_order_seq_cst)
00104 { return _M_base.exchange(__i, __m); }
00105
00106 bool
00107 exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile
00108 { return _M_base.exchange(__i, __m); }
00109
00110 bool
00111 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
00112 memory_order __m2)
00113 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
00114
00115 bool
00116 compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
00117 memory_order __m2) volatile
00118 { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
00119
00120 bool
00121 compare_exchange_weak(bool& __i1, bool __i2,
00122 memory_order __m = memory_order_seq_cst)
00123 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
00124
00125 bool
00126 compare_exchange_weak(bool& __i1, bool __i2,
00127 memory_order __m = memory_order_seq_cst) volatile
00128 { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
00129
00130 bool
00131 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
00132 memory_order __m2)
00133 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
00134
00135 bool
00136 compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
00137 memory_order __m2) volatile
00138 { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
00139
00140 bool
00141 compare_exchange_strong(bool& __i1, bool __i2,
00142 memory_order __m = memory_order_seq_cst)
00143 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
00144
00145 bool
00146 compare_exchange_strong(bool& __i1, bool __i2,
00147 memory_order __m = memory_order_seq_cst) volatile
00148 { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
00149 };
00150
00151
00152
00153
00154 template<typename _Tp>
00155 struct atomic
00156 {
00157 private:
00158 _Tp _M_i;
00159
00160 public:
00161 atomic() = default;
00162 ~atomic() = default;
00163 atomic(const atomic&) = delete;
00164 atomic& operator=(const atomic&) = delete;
00165 atomic& operator=(const atomic&) volatile = delete;
00166
00167 constexpr atomic(_Tp __i) : _M_i(__i) { }
00168
00169 operator _Tp() const;
00170
00171 operator _Tp() const volatile;
00172
00173 _Tp
00174 operator=(_Tp __i) { store(__i); return __i; }
00175
00176 _Tp
00177 operator=(_Tp __i) volatile { store(__i); return __i; }
00178
00179 bool
00180 is_lock_free() const;
00181
00182 bool
00183 is_lock_free() const volatile;
00184
00185 void
00186 store(_Tp, memory_order = memory_order_seq_cst);
00187
00188 void
00189 store(_Tp, memory_order = memory_order_seq_cst) volatile;
00190
00191 _Tp
00192 load(memory_order = memory_order_seq_cst) const;
00193
00194 _Tp
00195 load(memory_order = memory_order_seq_cst) const volatile;
00196
00197 _Tp
00198 exchange(_Tp __i, memory_order = memory_order_seq_cst);
00199
00200 _Tp
00201 exchange(_Tp __i, memory_order = memory_order_seq_cst) volatile;
00202
00203 bool
00204 compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order);
00205
00206 bool
00207 compare_exchange_weak(_Tp&, _Tp, memory_order, memory_order) volatile;
00208
00209 bool
00210 compare_exchange_weak(_Tp&, _Tp, memory_order = memory_order_seq_cst);
00211
00212 bool
00213 compare_exchange_weak(_Tp&, _Tp,
00214 memory_order = memory_order_seq_cst) volatile;
00215
00216 bool
00217 compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order);
00218
00219 bool
00220 compare_exchange_strong(_Tp&, _Tp, memory_order, memory_order) volatile;
00221
00222 bool
00223 compare_exchange_strong(_Tp&, _Tp, memory_order = memory_order_seq_cst);
00224
00225 bool
00226 compare_exchange_strong(_Tp&, _Tp,
00227 memory_order = memory_order_seq_cst) volatile;
00228 };
00229
00230
00231
00232 template<typename _Tp>
00233 struct atomic<_Tp*> : atomic_address
00234 {
00235 atomic() = default;
00236 ~atomic() = default;
00237 atomic(const atomic&) = delete;
00238 atomic& operator=(const atomic&) volatile = delete;
00239
00240 constexpr atomic(_Tp* __v) : atomic_address(__v) { }
00241
00242 void
00243 store(_Tp*, memory_order = memory_order_seq_cst);
00244
00245 void
00246 store(_Tp*, memory_order = memory_order_seq_cst) volatile;
00247
00248 _Tp*
00249 load(memory_order = memory_order_seq_cst) const;
00250
00251 _Tp*
00252 load(memory_order = memory_order_seq_cst) const volatile;
00253
00254 _Tp*
00255 exchange(_Tp*, memory_order = memory_order_seq_cst);
00256
00257 _Tp*
00258 exchange(_Tp*, memory_order = memory_order_seq_cst) volatile;
00259
00260 bool
00261 compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order);
00262
00263 bool
00264 compare_exchange_weak(_Tp*&, _Tp*, memory_order, memory_order) volatile;
00265
00266 bool
00267 compare_exchange_weak(_Tp*&, _Tp*, memory_order = memory_order_seq_cst);
00268
00269 bool
00270 compare_exchange_weak(_Tp*&, _Tp*,
00271 memory_order = memory_order_seq_cst) volatile;
00272
00273 bool
00274 compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order);
00275
00276 bool
00277 compare_exchange_strong(_Tp*&, _Tp*, memory_order, memory_order) volatile;
00278
00279 bool
00280 compare_exchange_strong(_Tp*&, _Tp*, memory_order = memory_order_seq_cst);
00281
00282 bool
00283 compare_exchange_strong(_Tp*&, _Tp*,
00284 memory_order = memory_order_seq_cst) volatile;
00285
00286 _Tp*
00287 fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
00288
00289 _Tp*
00290 fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
00291
00292 _Tp*
00293 fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
00294
00295 _Tp*
00296 fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
00297
00298 operator _Tp*() const
00299 { return load(); }
00300
00301 operator _Tp*() const volatile
00302 { return load(); }
00303
00304 _Tp*
00305 operator=(_Tp* __v)
00306 {
00307 store(__v);
00308 return __v;
00309 }
00310
00311 _Tp*
00312 operator=(_Tp* __v) volatile
00313 {
00314 store(__v);
00315 return __v;
00316 }
00317
00318 _Tp*
00319 operator++(int) { return fetch_add(1); }
00320
00321 _Tp*
00322 operator++(int) volatile { return fetch_add(1); }
00323
00324 _Tp*
00325 operator--(int) { return fetch_sub(1); }
00326
00327 _Tp*
00328 operator--(int) volatile { return fetch_sub(1); }
00329
00330 _Tp*
00331 operator++() { return fetch_add(1) + 1; }
00332
00333 _Tp*
00334 operator++() volatile { return fetch_add(1) + 1; }
00335
00336 _Tp*
00337 operator--() { return fetch_sub(1) - 1; }
00338
00339 _Tp*
00340 operator--() volatile { return fetch_sub(1) - 1; }
00341
00342 _Tp*
00343 operator+=(ptrdiff_t __d)
00344 { return fetch_add(__d) + __d; }
00345
00346 _Tp*
00347 operator+=(ptrdiff_t __d) volatile
00348 { return fetch_add(__d) + __d; }
00349
00350 _Tp*
00351 operator-=(ptrdiff_t __d)
00352 { return fetch_sub(__d) - __d; }
00353
00354 _Tp*
00355 operator-=(ptrdiff_t __d) volatile
00356 { return fetch_sub(__d) - __d; }
00357 };
00358
00359
00360 template<>
00361 struct atomic<bool> : public atomic_bool
00362 {
00363 typedef bool __integral_type;
00364 typedef atomic_bool __base_type;
00365
00366 atomic() = default;
00367 ~atomic() = default;
00368 atomic(const atomic&) = delete;
00369 atomic& operator=(const atomic&) = delete;
00370 atomic& operator=(const atomic&) volatile = delete;
00371
00372 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00373
00374 using __base_type::operator __integral_type;
00375 using __base_type::operator=;
00376 };
00377
00378
00379 template<>
00380 struct atomic<char> : public atomic_char
00381 {
00382 typedef char __integral_type;
00383 typedef atomic_char __base_type;
00384
00385 atomic() = default;
00386 ~atomic() = default;
00387 atomic(const atomic&) = delete;
00388 atomic& operator=(const atomic&) = delete;
00389 atomic& operator=(const atomic&) volatile = delete;
00390
00391 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00392
00393 using __base_type::operator __integral_type;
00394 using __base_type::operator=;
00395 };
00396
00397
00398 template<>
00399 struct atomic<signed char> : public atomic_schar
00400 {
00401 typedef signed char __integral_type;
00402 typedef atomic_schar __base_type;
00403
00404 atomic() = default;
00405 ~atomic() = default;
00406 atomic(const atomic&) = delete;
00407 atomic& operator=(const atomic&) = delete;
00408 atomic& operator=(const atomic&) volatile = delete;
00409
00410 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00411
00412 using __base_type::operator __integral_type;
00413 using __base_type::operator=;
00414 };
00415
00416
00417 template<>
00418 struct atomic<unsigned char> : public atomic_uchar
00419 {
00420 typedef unsigned char __integral_type;
00421 typedef atomic_uchar __base_type;
00422
00423 atomic() = default;
00424 ~atomic() = default;
00425 atomic(const atomic&) = delete;
00426 atomic& operator=(const atomic&) = delete;
00427 atomic& operator=(const atomic&) volatile = delete;
00428
00429 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00430
00431 using __base_type::operator __integral_type;
00432 using __base_type::operator=;
00433 };
00434
00435
00436 template<>
00437 struct atomic<short> : public atomic_short
00438 {
00439 typedef short __integral_type;
00440 typedef atomic_short __base_type;
00441
00442 atomic() = default;
00443 ~atomic() = default;
00444 atomic(const atomic&) = delete;
00445 atomic& operator=(const atomic&) = delete;
00446 atomic& operator=(const atomic&) volatile = delete;
00447
00448 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00449
00450 using __base_type::operator __integral_type;
00451 using __base_type::operator=;
00452 };
00453
00454
00455 template<>
00456 struct atomic<unsigned short> : public atomic_ushort
00457 {
00458 typedef unsigned short __integral_type;
00459 typedef atomic_ushort __base_type;
00460
00461 atomic() = default;
00462 ~atomic() = default;
00463 atomic(const atomic&) = delete;
00464 atomic& operator=(const atomic&) = delete;
00465 atomic& operator=(const atomic&) volatile = delete;
00466
00467 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00468
00469 using __base_type::operator __integral_type;
00470 using __base_type::operator=;
00471 };
00472
00473
00474 template<>
00475 struct atomic<int> : atomic_int
00476 {
00477 typedef int __integral_type;
00478 typedef atomic_int __base_type;
00479
00480 atomic() = default;
00481 ~atomic() = default;
00482 atomic(const atomic&) = delete;
00483 atomic& operator=(const atomic&) = delete;
00484 atomic& operator=(const atomic&) volatile = delete;
00485
00486 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00487
00488 using __base_type::operator __integral_type;
00489 using __base_type::operator=;
00490 };
00491
00492
00493 template<>
00494 struct atomic<unsigned int> : public atomic_uint
00495 {
00496 typedef unsigned int __integral_type;
00497 typedef atomic_uint __base_type;
00498
00499 atomic() = default;
00500 ~atomic() = default;
00501 atomic(const atomic&) = delete;
00502 atomic& operator=(const atomic&) = delete;
00503 atomic& operator=(const atomic&) volatile = delete;
00504
00505 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00506
00507 using __base_type::operator __integral_type;
00508 using __base_type::operator=;
00509 };
00510
00511
00512 template<>
00513 struct atomic<long> : public atomic_long
00514 {
00515 typedef long __integral_type;
00516 typedef atomic_long __base_type;
00517
00518 atomic() = default;
00519 ~atomic() = default;
00520 atomic(const atomic&) = delete;
00521 atomic& operator=(const atomic&) = delete;
00522 atomic& operator=(const atomic&) volatile = delete;
00523
00524 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00525
00526 using __base_type::operator __integral_type;
00527 using __base_type::operator=;
00528 };
00529
00530
00531 template<>
00532 struct atomic<unsigned long> : public atomic_ulong
00533 {
00534 typedef unsigned long __integral_type;
00535 typedef atomic_ulong __base_type;
00536
00537 atomic() = default;
00538 ~atomic() = default;
00539 atomic(const atomic&) = delete;
00540 atomic& operator=(const atomic&) = delete;
00541 atomic& operator=(const atomic&) volatile = delete;
00542
00543 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00544
00545 using __base_type::operator __integral_type;
00546 using __base_type::operator=;
00547 };
00548
00549
00550 template<>
00551 struct atomic<long long> : public atomic_llong
00552 {
00553 typedef long long __integral_type;
00554 typedef atomic_llong __base_type;
00555
00556 atomic() = default;
00557 ~atomic() = default;
00558 atomic(const atomic&) = delete;
00559 atomic& operator=(const atomic&) = delete;
00560 atomic& operator=(const atomic&) volatile = delete;
00561
00562 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00563
00564 using __base_type::operator __integral_type;
00565 using __base_type::operator=;
00566 };
00567
00568
00569 template<>
00570 struct atomic<unsigned long long> : public atomic_ullong
00571 {
00572 typedef unsigned long long __integral_type;
00573 typedef atomic_ullong __base_type;
00574
00575 atomic() = default;
00576 ~atomic() = default;
00577 atomic(const atomic&) = delete;
00578 atomic& operator=(const atomic&) = delete;
00579 atomic& operator=(const atomic&) volatile = delete;
00580
00581 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00582
00583 using __base_type::operator __integral_type;
00584 using __base_type::operator=;
00585 };
00586
00587
00588 template<>
00589 struct atomic<wchar_t> : public atomic_wchar_t
00590 {
00591 typedef wchar_t __integral_type;
00592 typedef atomic_wchar_t __base_type;
00593
00594 atomic() = default;
00595 ~atomic() = default;
00596 atomic(const atomic&) = delete;
00597 atomic& operator=(const atomic&) = delete;
00598 atomic& operator=(const atomic&) volatile = delete;
00599
00600 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00601
00602 using __base_type::operator __integral_type;
00603 using __base_type::operator=;
00604 };
00605
00606
00607 template<>
00608 struct atomic<char16_t> : public atomic_char16_t
00609 {
00610 typedef char16_t __integral_type;
00611 typedef atomic_char16_t __base_type;
00612
00613 atomic() = default;
00614 ~atomic() = default;
00615 atomic(const atomic&) = delete;
00616 atomic& operator=(const atomic&) = delete;
00617 atomic& operator=(const atomic&) volatile = delete;
00618
00619 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00620
00621 using __base_type::operator __integral_type;
00622 using __base_type::operator=;
00623 };
00624
00625
00626 template<>
00627 struct atomic<char32_t> : public atomic_char32_t
00628 {
00629 typedef char32_t __integral_type;
00630 typedef atomic_char32_t __base_type;
00631
00632 atomic() = default;
00633 ~atomic() = default;
00634 atomic(const atomic&) = delete;
00635 atomic& operator=(const atomic&) = delete;
00636 atomic& operator=(const atomic&) volatile = delete;
00637
00638 constexpr atomic(__integral_type __i) : __base_type(__i) { }
00639
00640 using __base_type::operator __integral_type;
00641 using __base_type::operator=;
00642 };
00643
00644
00645 template<typename _Tp>
00646 _Tp*
00647 atomic<_Tp*>::load(memory_order __m) const
00648 { return static_cast<_Tp*>(atomic_address::load(__m)); }
00649
00650 template<typename _Tp>
00651 _Tp*
00652 atomic<_Tp*>::load(memory_order __m) const volatile
00653 { return static_cast<_Tp*>(atomic_address::load(__m)); }
00654
00655 template<typename _Tp>
00656 _Tp*
00657 atomic<_Tp*>::exchange(_Tp* __v, memory_order __m)
00658 { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); }
00659
00660 template<typename _Tp>
00661 _Tp*
00662 atomic<_Tp*>::exchange(_Tp* __v, memory_order __m) volatile
00663 { return static_cast<_Tp*>(atomic_address::exchange(__v, __m)); }
00664
00665 template<typename _Tp>
00666 bool
00667 atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1,
00668 memory_order __m2)
00669 {
00670 void** __vr = reinterpret_cast<void**>(&__r);
00671 void* __vv = static_cast<void*>(__v);
00672 return atomic_address::compare_exchange_weak(*__vr, __vv, __m1, __m2);
00673 }
00674
00675 template<typename _Tp>
00676 bool
00677 atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m1,
00678 memory_order __m2) volatile
00679 {
00680 void** __vr = reinterpret_cast<void**>(&__r);
00681 void* __vv = static_cast<void*>(__v);
00682 return atomic_address::compare_exchange_weak(*__vr, __vv, __m1, __m2);
00683 }
00684
00685 template<typename _Tp>
00686 bool
00687 atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v, memory_order __m)
00688 {
00689 return compare_exchange_weak(__r, __v, __m,
00690 __calculate_memory_order(__m));
00691 }
00692
00693 template<typename _Tp>
00694 bool
00695 atomic<_Tp*>::compare_exchange_weak(_Tp*& __r, _Tp* __v,
00696 memory_order __m) volatile
00697 {
00698 return compare_exchange_weak(__r, __v, __m,
00699 __calculate_memory_order(__m));
00700 }
00701
00702 template<typename _Tp>
00703 bool
00704 atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
00705 memory_order __m1,
00706 memory_order __m2)
00707 {
00708 void** __vr = reinterpret_cast<void**>(&__r);
00709 void* __vv = static_cast<void*>(__v);
00710 return atomic_address::compare_exchange_strong(*__vr, __vv, __m1, __m2);
00711 }
00712
00713 template<typename _Tp>
00714 bool
00715 atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
00716 memory_order __m1,
00717 memory_order __m2) volatile
00718 {
00719 void** __vr = reinterpret_cast<void**>(&__r);
00720 void* __vv = static_cast<void*>(__v);
00721 return atomic_address::compare_exchange_strong(*__vr, __vv, __m1, __m2);
00722 }
00723
00724 template<typename _Tp>
00725 bool
00726 atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
00727 memory_order __m)
00728 {
00729 return compare_exchange_strong(__r, __v, __m,
00730 __calculate_memory_order(__m));
00731 }
00732
00733 template<typename _Tp>
00734 bool
00735 atomic<_Tp*>::compare_exchange_strong(_Tp*& __r, _Tp* __v,
00736 memory_order __m) volatile
00737 {
00738 return compare_exchange_strong(__r, __v, __m,
00739 __calculate_memory_order(__m));
00740 }
00741
00742 template<typename _Tp>
00743 _Tp*
00744 atomic<_Tp*>::fetch_add(ptrdiff_t __d, memory_order __m)
00745 {
00746 void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __d, __m);
00747 return static_cast<_Tp*>(__p);
00748 }
00749
00750 template<typename _Tp>
00751 _Tp*
00752 atomic<_Tp*>::fetch_add(ptrdiff_t __d, memory_order __m) volatile
00753 {
00754 void* __p = atomic_fetch_add_explicit(this, sizeof(_Tp) * __d, __m);
00755 return static_cast<_Tp*>(__p);
00756 }
00757
00758 template<typename _Tp>
00759 _Tp*
00760 atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m)
00761 {
00762 void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m);
00763 return static_cast<_Tp*>(__p);
00764 }
00765
00766 template<typename _Tp>
00767 _Tp*
00768 atomic<_Tp*>::fetch_sub(ptrdiff_t __d, memory_order __m) volatile
00769 {
00770 void* __p = atomic_fetch_sub_explicit(this, sizeof(_Tp) * __d, __m);
00771 return static_cast<_Tp*>(__p);
00772 }
00773
00774
00775
00776 inline bool
00777 atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m)
00778 { return __a->test_and_set(__m); }
00779
00780 inline bool
00781 atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
00782 memory_order __m)
00783 { return __a->test_and_set(__m); }
00784
00785 inline void
00786 atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m)
00787 { __a->clear(__m); }
00788
00789 inline void
00790 atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m)
00791 { __a->clear(__m); }
00792
00793 inline bool
00794 atomic_flag_test_and_set(atomic_flag* __a)
00795 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
00796
00797 inline bool
00798 atomic_flag_test_and_set(volatile atomic_flag* __a)
00799 { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
00800
00801 inline void
00802 atomic_flag_clear(atomic_flag* __a)
00803 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
00804
00805 inline void
00806 atomic_flag_clear(volatile atomic_flag* __a)
00807 { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
00808
00809
00810
00811 inline bool
00812 atomic_is_lock_free(const atomic_address* __a)
00813 { return __a->is_lock_free(); }
00814
00815 inline bool
00816 atomic_is_lock_free(const volatile atomic_address* __a)
00817 { return __a->is_lock_free(); }
00818
00819 inline void
00820 atomic_init(atomic_address* __a, void* __v);
00821
00822 inline void
00823 atomic_init(volatile atomic_address* __a, void* __v);
00824
00825 inline void
00826 atomic_store_explicit(atomic_address* __a, void* __v, memory_order __m)
00827 { __a->store(__v, __m); }
00828
00829 inline void
00830 atomic_store_explicit(volatile atomic_address* __a, void* __v,
00831 memory_order __m)
00832 { __a->store(__v, __m); }
00833
00834 inline void
00835 atomic_store(atomic_address* __a, void* __v)
00836 { __a->store(__v); }
00837
00838 inline void
00839 atomic_store(volatile atomic_address* __a, void* __v)
00840 { __a->store(__v); }
00841
00842 inline void*
00843 atomic_load_explicit(const atomic_address* __a, memory_order __m)
00844 { return __a->load(__m); }
00845
00846 inline void*
00847 atomic_load_explicit(const volatile atomic_address* __a, memory_order __m)
00848 { return __a->load(__m); }
00849
00850 inline void*
00851 atomic_load(const atomic_address* __a)
00852 { return __a->load(); }
00853
00854 inline void*
00855 atomic_load(const volatile atomic_address* __a)
00856 { return __a->load(); }
00857
00858 inline void*
00859 atomic_exchange_explicit(atomic_address* __a, void* __v, memory_order __m)
00860 { return __a->exchange(__v, __m); }
00861
00862 inline void*
00863 atomic_exchange_explicit(volatile atomic_address* __a, void* __v,
00864 memory_order __m)
00865 { return __a->exchange(__v, __m); }
00866
00867 inline void*
00868 atomic_exchange(atomic_address* __a, void* __v)
00869 { return __a->exchange(__v); }
00870
00871 inline void*
00872 atomic_exchange(volatile atomic_address* __a, void* __v)
00873 { return __a->exchange(__v); }
00874
00875
00876 inline bool
00877 atomic_compare_exchange_weak_explicit(atomic_address* __a,
00878 void** __v1, void* __v2,
00879 memory_order __m1, memory_order __m2)
00880 { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); }
00881
00882 inline bool
00883 atomic_compare_exchange_weak_explicit(volatile atomic_address* __a,
00884 void** __v1, void* __v2,
00885 memory_order __m1, memory_order __m2)
00886 { return __a->compare_exchange_weak(*__v1, __v2, __m1, __m2); }
00887
00888 inline bool
00889 atomic_compare_exchange_weak(atomic_address* __a, void** __v1, void* __v2)
00890 {
00891 return __a->compare_exchange_weak(*__v1, __v2, memory_order_seq_cst,
00892 memory_order_seq_cst);
00893 }
00894
00895 inline bool
00896 atomic_compare_exchange_weak(volatile atomic_address* __a, void** __v1,
00897 void* __v2)
00898 {
00899 return __a->compare_exchange_weak(*__v1, __v2, memory_order_seq_cst,
00900 memory_order_seq_cst);
00901 }
00902
00903 inline bool
00904 atomic_compare_exchange_strong_explicit(atomic_address* __a,
00905 void** __v1, void* __v2,
00906 memory_order __m1, memory_order __m2)
00907 { return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); }
00908
00909 inline bool
00910 atomic_compare_exchange_strong_explicit(volatile atomic_address* __a,
00911 void** __v1, void* __v2,
00912 memory_order __m1, memory_order __m2)
00913 { return __a->compare_exchange_strong(*__v1, __v2, __m1, __m2); }
00914
00915 inline bool
00916 atomic_compare_exchange_strong(atomic_address* __a, void** __v1, void* __v2)
00917 {
00918 return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst,
00919 memory_order_seq_cst);
00920 }
00921
00922 inline bool
00923 atomic_compare_exchange_strong(volatile atomic_address* __a,
00924 void** __v1, void* __v2)
00925 {
00926 return __a->compare_exchange_strong(*__v1, __v2, memory_order_seq_cst,
00927 memory_order_seq_cst);
00928 }
00929
00930 inline void*
00931 atomic_fetch_add_explicit(atomic_address* __a, ptrdiff_t __d,
00932 memory_order __m)
00933 { return __a->fetch_add(__d, __m); }
00934
00935 inline void*
00936 atomic_fetch_add_explicit(volatile atomic_address* __a, ptrdiff_t __d,
00937 memory_order __m)
00938 { return __a->fetch_add(__d, __m); }
00939
00940 inline void*
00941 atomic_fetch_add(atomic_address* __a, ptrdiff_t __d)
00942 { return __a->fetch_add(__d); }
00943
00944 inline void*
00945 atomic_fetch_add(volatile atomic_address* __a, ptrdiff_t __d)
00946 { return __a->fetch_add(__d); }
00947
00948 inline void*
00949 atomic_fetch_sub_explicit(atomic_address* __a, ptrdiff_t __d,
00950 memory_order __m)
00951 { return __a->fetch_sub(__d, __m); }
00952
00953 inline void*
00954 atomic_fetch_sub_explicit(volatile atomic_address* __a, ptrdiff_t __d,
00955 memory_order __m)
00956 { return __a->fetch_sub(__d, __m); }
00957
00958 inline void*
00959 atomic_fetch_sub(atomic_address* __a, ptrdiff_t __d)
00960 { return __a->fetch_sub(__d); }
00961
00962 inline void*
00963 atomic_fetch_sub(volatile atomic_address* __a, ptrdiff_t __d)
00964 { return __a->fetch_sub(__d); }
00965
00966
00967
00968 inline bool
00969 atomic_is_lock_free(const atomic_bool* __a)
00970 { return __a->is_lock_free(); }
00971
00972 inline bool
00973 atomic_is_lock_free(const volatile atomic_bool* __a)
00974 { return __a->is_lock_free(); }
00975
00976 inline void
00977 atomic_init(atomic_bool* __a, bool __b);
00978
00979 inline void
00980 atomic_init(volatile atomic_bool* __a, bool __b);
00981
00982 inline void
00983 atomic_store_explicit(atomic_bool* __a, bool __i, memory_order __m)
00984 { __a->store(__i, __m); }
00985
00986 inline void
00987 atomic_store_explicit(volatile atomic_bool* __a, bool __i, memory_order __m)
00988 { __a->store(__i, __m); }
00989
00990 inline void
00991 atomic_store(atomic_bool* __a, bool __i)
00992 { __a->store(__i); }
00993
00994 inline void
00995 atomic_store(volatile atomic_bool* __a, bool __i)
00996 { __a->store(__i); }
00997
00998 inline bool
00999 atomic_load_explicit(const atomic_bool* __a, memory_order __m)
01000 { return __a->load(__m); }
01001
01002 inline bool
01003 atomic_load_explicit(const volatile atomic_bool* __a, memory_order __m)
01004 { return __a->load(__m); }
01005
01006 inline bool
01007 atomic_load(const atomic_bool* __a)
01008 { return __a->load(); }
01009
01010 inline bool
01011 atomic_load(const volatile atomic_bool* __a)
01012 { return __a->load(); }
01013
01014 inline bool
01015 atomic_exchange_explicit(atomic_bool* __a, bool __i, memory_order __m)
01016 { return __a->exchange(__i, __m); }
01017
01018 inline bool
01019 atomic_exchange_explicit(volatile atomic_bool* __a, bool __i,
01020 memory_order __m)
01021 { return __a->exchange(__i, __m); }
01022
01023 inline bool
01024 atomic_exchange(atomic_bool* __a, bool __i)
01025 { return __a->exchange(__i); }
01026
01027 inline bool
01028 atomic_exchange(volatile atomic_bool* __a, bool __i)
01029 { return __a->exchange(__i); }
01030
01031 inline bool
01032 atomic_compare_exchange_weak_explicit(atomic_bool* __a, bool* __i1,
01033 bool __i2, memory_order __m1,
01034 memory_order __m2)
01035 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
01036
01037 inline bool
01038 atomic_compare_exchange_weak_explicit(volatile atomic_bool* __a, bool* __i1,
01039 bool __i2, memory_order __m1,
01040 memory_order __m2)
01041 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
01042
01043 inline bool
01044 atomic_compare_exchange_weak(atomic_bool* __a, bool* __i1, bool __i2)
01045 {
01046 return __a->compare_exchange_weak(*__i1, __i2, memory_order_seq_cst,
01047 memory_order_seq_cst);
01048 }
01049
01050 inline bool
01051 atomic_compare_exchange_weak(volatile atomic_bool* __a, bool* __i1, bool __i2)
01052 {
01053 return __a->compare_exchange_weak(*__i1, __i2, memory_order_seq_cst,
01054 memory_order_seq_cst);
01055 }
01056
01057 inline bool
01058 atomic_compare_exchange_strong_explicit(atomic_bool* __a,
01059 bool* __i1, bool __i2,
01060 memory_order __m1, memory_order __m2)
01061 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
01062
01063 inline bool
01064 atomic_compare_exchange_strong_explicit(volatile atomic_bool* __a,
01065 bool* __i1, bool __i2,
01066 memory_order __m1, memory_order __m2)
01067 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
01068
01069 inline bool
01070 atomic_compare_exchange_strong(atomic_bool* __a, bool* __i1, bool __i2)
01071 {
01072 return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst,
01073 memory_order_seq_cst);
01074 }
01075
01076 inline bool
01077 atomic_compare_exchange_strong(volatile atomic_bool* __a,
01078 bool* __i1, bool __i2)
01079 {
01080 return __a->compare_exchange_strong(*__i1, __i2, memory_order_seq_cst,
01081 memory_order_seq_cst);
01082 }
01083
01084
01085
01086
01087
01088 template<typename _ITp>
01089 inline bool
01090 atomic_is_lock_free(const __atomic_base<_ITp>* __a)
01091 { return __a->is_lock_free(); }
01092
01093 template<typename _ITp>
01094 inline bool
01095 atomic_is_lock_free(const volatile __atomic_base<_ITp>* __a)
01096 { return __a->is_lock_free(); }
01097
01098 template<typename _ITp>
01099 inline void
01100 atomic_init(__atomic_base<_ITp>* __a, _ITp __i);
01101
01102 template<typename _ITp>
01103 inline void
01104 atomic_init(volatile __atomic_base<_ITp>* __a, _ITp __i);
01105
01106 template<typename _ITp>
01107 inline void
01108 atomic_store_explicit(__atomic_base<_ITp>* __a, _ITp __i, memory_order __m)
01109 { __a->store(__i, __m); }
01110
01111 template<typename _ITp>
01112 inline void
01113 atomic_store_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01114 memory_order __m)
01115 { __a->store(__i, __m); }
01116
01117 template<typename _ITp>
01118 inline _ITp
01119 atomic_load_explicit(const __atomic_base<_ITp>* __a, memory_order __m)
01120 { return __a->load(__m); }
01121
01122 template<typename _ITp>
01123 inline _ITp
01124 atomic_load_explicit(const volatile __atomic_base<_ITp>* __a,
01125 memory_order __m)
01126 { return __a->load(__m); }
01127
01128 template<typename _ITp>
01129 inline _ITp
01130 atomic_exchange_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01131 memory_order __m)
01132 { return __a->exchange(__i, __m); }
01133
01134 template<typename _ITp>
01135 inline _ITp
01136 atomic_exchange_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01137 memory_order __m)
01138 { return __a->exchange(__i, __m); }
01139
01140 template<typename _ITp>
01141 inline bool
01142 atomic_compare_exchange_weak_explicit(__atomic_base<_ITp>* __a,
01143 _ITp* __i1, _ITp __i2,
01144 memory_order __m1, memory_order __m2)
01145 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
01146
01147 template<typename _ITp>
01148 inline bool
01149 atomic_compare_exchange_weak_explicit(volatile __atomic_base<_ITp>* __a,
01150 _ITp* __i1, _ITp __i2,
01151 memory_order __m1, memory_order __m2)
01152 { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
01153
01154 template<typename _ITp>
01155 inline bool
01156 atomic_compare_exchange_strong_explicit(__atomic_base<_ITp>* __a,
01157 _ITp* __i1, _ITp __i2,
01158 memory_order __m1,
01159 memory_order __m2)
01160 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
01161
01162 template<typename _ITp>
01163 inline bool
01164 atomic_compare_exchange_strong_explicit(volatile __atomic_base<_ITp>* __a,
01165 _ITp* __i1, _ITp __i2,
01166 memory_order __m1,
01167 memory_order __m2)
01168 { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
01169
01170 template<typename _ITp>
01171 inline _ITp
01172 atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01173 memory_order __m)
01174 { return __a->fetch_add(__i, __m); }
01175
01176 template<typename _ITp>
01177 inline _ITp
01178 atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01179 memory_order __m)
01180 { return __a->fetch_add(__i, __m); }
01181
01182 template<typename _ITp>
01183 inline _ITp
01184 atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01185 memory_order __m)
01186 { return __a->fetch_sub(__i, __m); }
01187
01188 template<typename _ITp>
01189 inline _ITp
01190 atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01191 memory_order __m)
01192 { return __a->fetch_sub(__i, __m); }
01193
01194 template<typename _ITp>
01195 inline _ITp
01196 atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01197 memory_order __m)
01198 { return __a->fetch_and(__i, __m); }
01199
01200 template<typename _ITp>
01201 inline _ITp
01202 atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01203 memory_order __m)
01204 { return __a->fetch_and(__i, __m); }
01205
01206 template<typename _ITp>
01207 inline _ITp
01208 atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01209 memory_order __m)
01210 { return __a->fetch_or(__i, __m); }
01211
01212 template<typename _ITp>
01213 inline _ITp
01214 atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01215 memory_order __m)
01216 { return __a->fetch_or(__i, __m); }
01217
01218 template<typename _ITp>
01219 inline _ITp
01220 atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
01221 memory_order __m)
01222 { return __a->fetch_xor(__i, __m); }
01223
01224 template<typename _ITp>
01225 inline _ITp
01226 atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
01227 memory_order __m)
01228 { return __a->fetch_xor(__i, __m); }
01229
01230 template<typename _ITp>
01231 inline void
01232 atomic_store(__atomic_base<_ITp>* __a, _ITp __i)
01233 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
01234
01235 template<typename _ITp>
01236 inline void
01237 atomic_store(volatile __atomic_base<_ITp>* __a, _ITp __i)
01238 { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
01239
01240 template<typename _ITp>
01241 inline _ITp
01242 atomic_load(const __atomic_base<_ITp>* __a)
01243 { return atomic_load_explicit(__a, memory_order_seq_cst); }
01244
01245 template<typename _ITp>
01246 inline _ITp
01247 atomic_load(const volatile __atomic_base<_ITp>* __a)
01248 { return atomic_load_explicit(__a, memory_order_seq_cst); }
01249
01250 template<typename _ITp>
01251 inline _ITp
01252 atomic_exchange(__atomic_base<_ITp>* __a, _ITp __i)
01253 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
01254
01255 template<typename _ITp>
01256 inline _ITp
01257 atomic_exchange(volatile __atomic_base<_ITp>* __a, _ITp __i)
01258 { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
01259
01260 template<typename _ITp>
01261 inline bool
01262 atomic_compare_exchange_weak(__atomic_base<_ITp>* __a,
01263 _ITp* __i1, _ITp __i2)
01264 {
01265 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
01266 memory_order_seq_cst,
01267 memory_order_seq_cst);
01268 }
01269
01270 template<typename _ITp>
01271 inline bool
01272 atomic_compare_exchange_weak(volatile __atomic_base<_ITp>* __a,
01273 _ITp* __i1, _ITp __i2)
01274 {
01275 return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
01276 memory_order_seq_cst,
01277 memory_order_seq_cst);
01278 }
01279
01280 template<typename _ITp>
01281 inline bool
01282 atomic_compare_exchange_strong(__atomic_base<_ITp>* __a,
01283 _ITp* __i1, _ITp __i2)
01284 {
01285 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
01286 memory_order_seq_cst,
01287 memory_order_seq_cst);
01288 }
01289
01290 template<typename _ITp>
01291 inline bool
01292 atomic_compare_exchange_strong(volatile __atomic_base<_ITp>* __a,
01293 _ITp* __i1, _ITp __i2)
01294 {
01295 return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
01296 memory_order_seq_cst,
01297 memory_order_seq_cst);
01298 }
01299
01300 template<typename _ITp>
01301 inline _ITp
01302 atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i)
01303 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
01304
01305 template<typename _ITp>
01306 inline _ITp
01307 atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i)
01308 { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
01309
01310 template<typename _ITp>
01311 inline _ITp
01312 atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i)
01313 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
01314
01315 template<typename _ITp>
01316 inline _ITp
01317 atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i)
01318 { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
01319
01320 template<typename _ITp>
01321 inline _ITp
01322 atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i)
01323 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
01324
01325 template<typename _ITp>
01326 inline _ITp
01327 atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i)
01328 { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
01329
01330 template<typename _ITp>
01331 inline _ITp
01332 atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i)
01333 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
01334
01335 template<typename _ITp>
01336 inline _ITp
01337 atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i)
01338 { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
01339
01340 template<typename _ITp>
01341 inline _ITp
01342 atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i)
01343 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
01344
01345 template<typename _ITp>
01346 inline _ITp
01347 atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i)
01348 { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
01349
01350
01351
01352 _GLIBCXX_END_NAMESPACE_VERSION
01353 }
01354
01355 #endif