diff options
Diffstat (limited to 'libstdc++-v3/include/bits')
-rw-r--r-- | libstdc++-v3/include/bits/atomic_0.h | 677 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/atomic_2.h | 685 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/atomic_base.h | 721 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/basic_string.h | 51 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/c++config | 5 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/random.h | 11 | ||||
-rw-r--r-- | libstdc++-v3/include/bits/random.tcc | 8 |
7 files changed, 693 insertions, 1465 deletions
diff --git a/libstdc++-v3/include/bits/atomic_0.h b/libstdc++-v3/include/bits/atomic_0.h deleted file mode 100644 index 4f8b0929f16..00000000000 --- a/libstdc++-v3/include/bits/atomic_0.h +++ /dev/null @@ -1,677 +0,0 @@ -// -*- C++ -*- header. - -// Copyright (C) 2008, 2009, 2010, 2011 -// Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 3, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// Under Section 7 of GPL version 3, you are granted additional -// permissions described in the GCC Runtime Library Exception, version -// 3.1, as published by the Free Software Foundation. - -// You should have received a copy of the GNU General Public License and -// a copy of the GCC Runtime Library Exception along with this program; -// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -// <http://www.gnu.org/licenses/>. - -/** @file bits/atomic_0.h - * This is an internal header file, included by other library headers. - * Do not attempt to use it directly. @headername{atomic} - */ - -#ifndef _GLIBCXX_ATOMIC_0_H -#define _GLIBCXX_ATOMIC_0_H 1 - -#pragma GCC system_header - -namespace std _GLIBCXX_VISIBILITY(default) -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - -// 0 == __atomic0 == Never lock-free -namespace __atomic0 -{ - _GLIBCXX_BEGIN_EXTERN_C - - void - atomic_flag_clear_explicit(__atomic_flag_base*, memory_order) - _GLIBCXX_NOTHROW; - - void - __atomic_flag_wait_explicit(__atomic_flag_base*, memory_order) - _GLIBCXX_NOTHROW; - - _GLIBCXX_CONST __atomic_flag_base* - __atomic_flag_for_address(const volatile void* __z) _GLIBCXX_NOTHROW; - - _GLIBCXX_END_EXTERN_C - - // Implementation specific defines. -#define _ATOMIC_MEMBER_ _M_i - - // Implementation specific defines. -#define _ATOMIC_LOAD_(__a, __x) \ - ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ - __i_type* __p = &_ATOMIC_MEMBER_; \ - __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __i_type __r = *__p; \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) - -#define _ATOMIC_STORE_(__a, __n, __x) \ - ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ - __i_type* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__n) __w = (__n); \ - __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - *__p = __w; \ - atomic_flag_clear_explicit(__g, __x); \ - __w; }) - -#define _ATOMIC_MODIFY_(__a, __o, __n, __x) \ - ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ - __i_type* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__n) __w = (__n); \ - __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __i_type __r = *__p; \ - *__p __o __w; \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) - -#define _ATOMIC_CMPEXCHNG_(__a, __e, __n, __x) \ - ({typedef __typeof__(_ATOMIC_MEMBER_) __i_type; \ - __i_type* __p = &_ATOMIC_MEMBER_; \ - __typeof__(__e) __q = (__e); \ - __typeof__(__n) __w = (__n); \ - bool __r; \ - __atomic_flag_base* __g = __atomic_flag_for_address(__p); \ - __atomic_flag_wait_explicit(__g, __x); \ - __i_type __t = *__p; \ - if (*__q == __t) \ - { \ - *__p = (__i_type)__w; \ - __r = true; \ - } \ - else { *__q = __t; __r = false; } \ - atomic_flag_clear_explicit(__g, __x); \ - __r; }) - - - /// atomic_flag - struct atomic_flag : public __atomic_flag_base - { - atomic_flag() noexcept = default; - ~atomic_flag() noexcept = default; - atomic_flag(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) volatile = delete; - - // Conversion to ATOMIC_FLAG_INIT. - atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } - - bool - test_and_set(memory_order __m = memory_order_seq_cst) noexcept; - - bool - test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept; - - void - clear(memory_order __m = memory_order_seq_cst) noexcept; - - void - clear(memory_order __m = memory_order_seq_cst) volatile noexcept; - }; - - - /// Base class for atomic integrals. - // - // For each of the integral types, define atomic_[integral type] struct - // - // atomic_bool bool - // atomic_char char - // atomic_schar signed char - // atomic_uchar unsigned char - // atomic_short short - // atomic_ushort unsigned short - // atomic_int int - // atomic_uint unsigned int - // atomic_long long - // atomic_ulong unsigned long - // atomic_llong long long - // atomic_ullong unsigned long long - // atomic_char16_t char16_t - // atomic_char32_t char32_t - // atomic_wchar_t wchar_t - - // Base type. - // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or 8 bytes, - // since that is what GCC built-in functions for atomic memory access work on. - template<typename _ITp> - struct __atomic_base - { - private: - typedef _ITp __int_type; - - __int_type _M_i; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - // Requires __int_type convertible to _M_base._M_i. - constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } - - operator __int_type() const noexcept - { return load(); } - - operator __int_type() const volatile noexcept - { return load(); } - - __int_type - operator=(__int_type __i) noexcept - { - store(__i); - return __i; - } - - __int_type - operator=(__int_type __i) volatile noexcept - { - store(__i); - return __i; - } - - __int_type - operator++(int) noexcept - { return fetch_add(1); } - - __int_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __int_type - operator--(int) noexcept - { return fetch_sub(1); } - - __int_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __int_type - operator++() noexcept - { return fetch_add(1) + 1; } - - __int_type - operator++() volatile noexcept - { return fetch_add(1) + 1; } - - __int_type - operator--() noexcept - { return fetch_sub(1) - 1; } - - __int_type - operator--() volatile noexcept - { return fetch_sub(1) - 1; } - - __int_type - operator+=(__int_type __i) noexcept - { return fetch_add(__i) + __i; } - - __int_type - operator+=(__int_type __i) volatile noexcept - { return fetch_add(__i) + __i; } - - __int_type - operator-=(__int_type __i) noexcept - { return fetch_sub(__i) - __i; } - - __int_type - operator-=(__int_type __i) volatile noexcept - { return fetch_sub(__i) - __i; } - - __int_type - operator&=(__int_type __i) noexcept - { return fetch_and(__i) & __i; } - - __int_type - operator&=(__int_type __i) volatile noexcept - { return fetch_and(__i) & __i; } - - __int_type - operator|=(__int_type __i) noexcept - { return fetch_or(__i) | __i; } - - __int_type - operator|=(__int_type __i) volatile noexcept - { return fetch_or(__i) | __i; } - - __int_type - operator^=(__int_type __i) noexcept - { return fetch_xor(__i) ^ __i; } - - __int_type - operator^=(__int_type __i) volatile noexcept - { return fetch_xor(__i) ^ __i; } - - bool - is_lock_free() const noexcept - { return false; } - - bool - is_lock_free() const volatile noexcept - { return false; } - - void - store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - _ATOMIC_STORE_(this, __i, __m); - } - - void - store(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - _ATOMIC_STORE_(this, __i, __m); - } - - __int_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - return _ATOMIC_LOAD_(this, __m); - } - - __int_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - return _ATOMIC_LOAD_(this, __m); - } - - __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, =, __i, __m); } - - __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, =, __i, __m); } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); - } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); - } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, +=, __i, __m); } - - __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, +=, __i, __m); } - - __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, -=, __i, __m); } - - __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, -=, __i, __m); } - - __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, &=, __i, __m); } - - __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, &=, __i, __m); } - - __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, |=, __i, __m); } - - __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, |=, __i, __m); } - - __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return _ATOMIC_MODIFY_(this, ^=, __i, __m); } - - __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return _ATOMIC_MODIFY_(this, ^=, __i, __m); } - }; - - - /// Partial specialization for pointer types. - template<typename _PTp> - struct __atomic_base<_PTp*> - { - private: - typedef _PTp* __return_pointer_type; - typedef void* __pointer_type; - __pointer_type _M_i; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - // Requires __pointer_type convertible to _M_i. - constexpr __atomic_base(__return_pointer_type __p) noexcept - : _M_i (__p) { } - - operator __return_pointer_type() const noexcept - { return reinterpret_cast<__return_pointer_type>(load()); } - - operator __return_pointer_type() const volatile noexcept - { return reinterpret_cast<__return_pointer_type>(load()); } - - __return_pointer_type - operator=(__pointer_type __p) noexcept - { - store(__p); - return reinterpret_cast<__return_pointer_type>(__p); - } - - __return_pointer_type - operator=(__pointer_type __p) volatile noexcept - { - store(__p); - return reinterpret_cast<__return_pointer_type>(__p); - } - - __return_pointer_type - operator++(int) noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(1)); } - - __return_pointer_type - operator++(int) volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(1)); } - - __return_pointer_type - operator--(int) noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(1)); } - - __return_pointer_type - operator--(int) volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(1)); } - - __return_pointer_type - operator++() noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(1) + 1); } - - __return_pointer_type - operator++() volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(1) + 1); } - - __return_pointer_type - operator--() noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(1) - 1); } - - __return_pointer_type - operator--() volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(1) - 1); } - - __return_pointer_type - operator+=(ptrdiff_t __d) noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(__d) + __d); } - - __return_pointer_type - operator+=(ptrdiff_t __d) volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_add(__d) + __d); } - - __return_pointer_type - operator-=(ptrdiff_t __d) noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(__d) - __d); } - - __return_pointer_type - operator-=(ptrdiff_t __d) volatile noexcept - { return reinterpret_cast<__return_pointer_type>(fetch_sub(__d) - __d); } - - bool - is_lock_free() const noexcept - { return true; } - - bool - is_lock_free() const volatile noexcept - { return true; } - - void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - _ATOMIC_STORE_(this, __p, __m); - } - - void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - volatile __pointer_type* __p2 = &_M_i; - __typeof__(__p) __w = (__p); - __atomic_flag_base* __g = __atomic_flag_for_address(__p2); - __atomic_flag_wait_explicit(__g, __m); - *__p2 = reinterpret_cast<__pointer_type>(__w); - atomic_flag_clear_explicit(__g, __m); - __w; - } - - __return_pointer_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - void* __v = _ATOMIC_LOAD_(this, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - void* __v = _ATOMIC_LOAD_(this, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - void* __v = _ATOMIC_MODIFY_(this, =, __p, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - volatile __pointer_type* __p2 = &_M_i; - __typeof__(__p) __w = (__p); - __atomic_flag_base* __g = __atomic_flag_for_address(__p2); - __atomic_flag_wait_explicit(__g, __m); - __pointer_type __r = *__p2; - *__p2 = __w; - atomic_flag_clear_explicit(__g, __m); - __r; - return reinterpret_cast<__return_pointer_type>(_M_i); - } - - bool - compare_exchange_strong(__return_pointer_type& __rp1, __pointer_type __p2, - memory_order __m1, memory_order __m2) noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - __pointer_type& __p1 = reinterpret_cast<void*&>(__rp1); - return _ATOMIC_CMPEXCHNG_(this, &__p1, __p2, __m1); - } - - bool - compare_exchange_strong(__return_pointer_type& __rp1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - __pointer_type& __p1 = reinterpret_cast<void*&>(__rp1); - return _ATOMIC_CMPEXCHNG_(this, &__p1, __p2, __m1); - } - - __return_pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { - void* __v = _ATOMIC_MODIFY_(this, +=, __d, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - void* __v = _ATOMIC_MODIFY_(this, +=, __d, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { - void* __v = _ATOMIC_MODIFY_(this, -=, __d, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - - __return_pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - void* __v = _ATOMIC_MODIFY_(this, -=, __d, __m); - return reinterpret_cast<__return_pointer_type>(__v); - } - }; - -#undef _ATOMIC_LOAD_ -#undef _ATOMIC_STORE_ -#undef _ATOMIC_MODIFY_ -#undef _ATOMIC_CMPEXCHNG_ -} // namespace __atomic0 - -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace std - -#endif diff --git a/libstdc++-v3/include/bits/atomic_2.h b/libstdc++-v3/include/bits/atomic_2.h deleted file mode 100644 index 072e82a0a9f..00000000000 --- a/libstdc++-v3/include/bits/atomic_2.h +++ /dev/null @@ -1,685 +0,0 @@ -// -*- C++ -*- header. - -// Copyright (C) 2008, 2009, 2010, 2011 -// Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the -// Free Software Foundation; either version 3, or (at your option) -// any later version. - -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// Under Section 7 of GPL version 3, you are granted additional -// permissions described in the GCC Runtime Library Exception, version -// 3.1, as published by the Free Software Foundation. - -// You should have received a copy of the GNU General Public License and -// a copy of the GCC Runtime Library Exception along with this program; -// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -// <http://www.gnu.org/licenses/>. - -/** @file bits/atomic_2.h - * This is an internal header file, included by other library headers. - * Do not attempt to use it directly. @headername{atomic} - */ - -#ifndef _GLIBCXX_ATOMIC_2_H -#define _GLIBCXX_ATOMIC_2_H 1 - -#pragma GCC system_header - -namespace std _GLIBCXX_VISIBILITY(default) -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - -// 2 == __atomic2 == Always lock-free -// Assumed: -// _GLIBCXX_ATOMIC_BUILTINS_1 -// _GLIBCXX_ATOMIC_BUILTINS_2 -// _GLIBCXX_ATOMIC_BUILTINS_4 -// _GLIBCXX_ATOMIC_BUILTINS_8 -namespace __atomic2 -{ - /// atomic_flag - struct atomic_flag : public __atomic_flag_base - { - atomic_flag() noexcept = default; - ~atomic_flag() noexcept = default; - atomic_flag(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) volatile = delete; - - // Conversion to ATOMIC_FLAG_INIT. - atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } - - bool - test_and_set(memory_order __m = memory_order_seq_cst) noexcept - { - // Redundant synchronize if built-in for lock is a full barrier. - if (__m != memory_order_acquire && __m != memory_order_acq_rel) - __sync_synchronize(); - return __sync_lock_test_and_set(&_M_i, 1); - } - - bool - test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept - { - // Redundant synchronize if built-in for lock is a full barrier. - if (__m != memory_order_acquire && __m != memory_order_acq_rel) - __sync_synchronize(); - return __sync_lock_test_and_set(&_M_i, 1); - } - - void - clear(memory_order __m = memory_order_seq_cst) noexcept - { - __glibcxx_assert(__m != memory_order_consume); - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_lock_release(&_M_i); - if (__m != memory_order_acquire && __m != memory_order_acq_rel) - __sync_synchronize(); - } - - void - clear(memory_order __m = memory_order_seq_cst) volatile noexcept - { - __glibcxx_assert(__m != memory_order_consume); - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_lock_release(&_M_i); - if (__m != memory_order_acquire && __m != memory_order_acq_rel) - __sync_synchronize(); - } - }; - - - /// Base class for atomic integrals. - // - // For each of the integral types, define atomic_[integral type] struct - // - // atomic_bool bool - // atomic_char char - // atomic_schar signed char - // atomic_uchar unsigned char - // atomic_short short - // atomic_ushort unsigned short - // atomic_int int - // atomic_uint unsigned int - // atomic_long long - // atomic_ulong unsigned long - // atomic_llong long long - // atomic_ullong unsigned long long - // atomic_char16_t char16_t - // atomic_char32_t char32_t - // atomic_wchar_t wchar_t - // - // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or - // 8 bytes, since that is what GCC built-in functions for atomic - // memory access expect. - template<typename _ITp> - struct __atomic_base - { - private: - typedef _ITp __int_type; - - __int_type _M_i; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - // Requires __int_type convertible to _M_i. - constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } - - operator __int_type() const noexcept - { return load(); } - - operator __int_type() const volatile noexcept - { return load(); } - - __int_type - operator=(__int_type __i) noexcept - { - store(__i); - return __i; - } - - __int_type - operator=(__int_type __i) volatile noexcept - { - store(__i); - return __i; - } - - __int_type - operator++(int) noexcept - { return fetch_add(1); } - - __int_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __int_type - operator--(int) noexcept - { return fetch_sub(1); } - - __int_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __int_type - operator++() noexcept - { return __sync_add_and_fetch(&_M_i, 1); } - - __int_type - operator++() volatile noexcept - { return __sync_add_and_fetch(&_M_i, 1); } - - __int_type - operator--() noexcept - { return __sync_sub_and_fetch(&_M_i, 1); } - - __int_type - operator--() volatile noexcept - { return __sync_sub_and_fetch(&_M_i, 1); } - - __int_type - operator+=(__int_type __i) noexcept - { return __sync_add_and_fetch(&_M_i, __i); } - - __int_type - operator+=(__int_type __i) volatile noexcept - { return __sync_add_and_fetch(&_M_i, __i); } - - __int_type - operator-=(__int_type __i) noexcept - { return __sync_sub_and_fetch(&_M_i, __i); } - - __int_type - operator-=(__int_type __i) volatile noexcept - { return __sync_sub_and_fetch(&_M_i, __i); } - - __int_type - operator&=(__int_type __i) noexcept - { return __sync_and_and_fetch(&_M_i, __i); } - - __int_type - operator&=(__int_type __i) volatile noexcept - { return __sync_and_and_fetch(&_M_i, __i); } - - __int_type - operator|=(__int_type __i) noexcept - { return __sync_or_and_fetch(&_M_i, __i); } - - __int_type - operator|=(__int_type __i) volatile noexcept - { return __sync_or_and_fetch(&_M_i, __i); } - - __int_type - operator^=(__int_type __i) noexcept - { return __sync_xor_and_fetch(&_M_i, __i); } - - __int_type - operator^=(__int_type __i) volatile noexcept - { return __sync_xor_and_fetch(&_M_i, __i); } - - bool - is_lock_free() const noexcept - { return true; } - - bool - is_lock_free() const volatile noexcept - { return true; } - - void - store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - - if (__m == memory_order_relaxed) - _M_i = __i; - else - { - // write_mem_barrier(); - _M_i = __i; - if (__m == memory_order_seq_cst) - __sync_synchronize(); - } - } - - void - store(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - - if (__m == memory_order_relaxed) - _M_i = __i; - else - { - // write_mem_barrier(); - _M_i = __i; - if (__m == memory_order_seq_cst) - __sync_synchronize(); - } - } - - __int_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_synchronize(); - __int_type __ret = _M_i; - __sync_synchronize(); - return __ret; - } - - __int_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_synchronize(); - __int_type __ret = _M_i; - __sync_synchronize(); - return __ret; - } - - __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { - // XXX built-in assumes memory_order_acquire. - return __sync_lock_test_and_set(&_M_i, __i); - } - - - __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - // XXX built-in assumes memory_order_acquire. - return __sync_lock_test_and_set(&_M_i, __i); - } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { return compare_exchange_strong(__i1, __i2, __m1, __m2); } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { return compare_exchange_strong(__i1, __i2, __m1, __m2); } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - - __int_type __i1o = __i1; - __int_type __i1n = __sync_val_compare_and_swap(&_M_i, __i1o, __i2); - - // Assume extra stores (of same value) allowed in true case. - __i1 = __i1n; - return __i1o == __i1n; - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - - __int_type __i1o = __i1; - __int_type __i1n = __sync_val_compare_and_swap(&_M_i, __i1o, __i2); - - // Assume extra stores (of same value) allowed in true case. - __i1 = __i1n; - return __i1o == __i1n; - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __calculate_memory_order(__m)); - } - - __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_add(&_M_i, __i); } - - __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_add(&_M_i, __i); } - - __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_sub(&_M_i, __i); } - - __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_sub(&_M_i, __i); } - - __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_and(&_M_i, __i); } - - __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_and(&_M_i, __i); } - - __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_or(&_M_i, __i); } - - __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_or(&_M_i, __i); } - - __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_xor(&_M_i, __i); } - - __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_xor(&_M_i, __i); } - }; - - - /// Partial specialization for pointer types. - template<typename _PTp> - struct __atomic_base<_PTp*> - { - private: - typedef _PTp* __pointer_type; - - __pointer_type _M_p; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - // Requires __pointer_type convertible to _M_p. - constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } - - operator __pointer_type() const noexcept - { return load(); } - - operator __pointer_type() const volatile noexcept - { return load(); } - - __pointer_type - operator=(__pointer_type __p) noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator=(__pointer_type __p) volatile noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator++(int) noexcept - { return fetch_add(1); } - - __pointer_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __pointer_type - operator--(int) noexcept - { return fetch_sub(1); } - - __pointer_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __pointer_type - operator++() noexcept - { return fetch_add(1) + 1; } - - __pointer_type - operator++() volatile noexcept - { return fetch_add(1) + 1; } - - __pointer_type - operator--() noexcept - { return fetch_sub(1) -1; } - - __pointer_type - operator--() volatile noexcept - { return fetch_sub(1) -1; } - - __pointer_type - operator+=(ptrdiff_t __d) noexcept - { return fetch_add(__d) + __d; } - - __pointer_type - operator+=(ptrdiff_t __d) volatile noexcept - { return fetch_add(__d) + __d; } - - __pointer_type - operator-=(ptrdiff_t __d) noexcept - { return fetch_sub(__d) - __d; } - - __pointer_type - operator-=(ptrdiff_t __d) volatile noexcept - { return fetch_sub(__d) - __d; } - - bool - is_lock_free() const noexcept - { return true; } - - bool - is_lock_free() const volatile noexcept - { return true; } - - void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - - if (__m == memory_order_relaxed) - _M_p = __p; - else - { - // write_mem_barrier(); - _M_p = __p; - if (__m == memory_order_seq_cst) - __sync_synchronize(); - } - } - - void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - __glibcxx_assert(__m != memory_order_acquire); - __glibcxx_assert(__m != memory_order_acq_rel); - __glibcxx_assert(__m != memory_order_consume); - - if (__m == memory_order_relaxed) - _M_p = __p; - else - { - // write_mem_barrier(); - _M_p = __p; - if (__m == memory_order_seq_cst) - __sync_synchronize(); - } - } - - __pointer_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_synchronize(); - __pointer_type __ret = _M_p; - __sync_synchronize(); - return __ret; - } - - __pointer_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - __glibcxx_assert(__m != memory_order_release); - __glibcxx_assert(__m != memory_order_acq_rel); - - __sync_synchronize(); - __pointer_type __ret = _M_p; - __sync_synchronize(); - return __ret; - } - - __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - // XXX built-in assumes memory_order_acquire. - return __sync_lock_test_and_set(&_M_p, __p); - } - - - __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - // XXX built-in assumes memory_order_acquire. - return __sync_lock_test_and_set(&_M_p, __p); - } - - bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - - __pointer_type __p1o = __p1; - __pointer_type __p1n = __sync_val_compare_and_swap(&_M_p, __p1o, __p2); - - // Assume extra stores (of same value) allowed in true case. - __p1 = __p1n; - return __p1o == __p1n; - } - - bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - __glibcxx_assert(__m2 != memory_order_release); - __glibcxx_assert(__m2 != memory_order_acq_rel); - __glibcxx_assert(__m2 <= __m1); - - __pointer_type __p1o = __p1; - __pointer_type __p1n = __sync_val_compare_and_swap(&_M_p, __p1o, __p2); - - // Assume extra stores (of same value) allowed in true case. - __p1 = __p1n; - return __p1o == __p1n; - } - - __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_add(&_M_p, __d); } - - __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_add(&_M_p, __d); } - - __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __sync_fetch_and_sub(&_M_p, __d); } - - __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __sync_fetch_and_sub(&_M_p, __d); } - }; - -} // namespace __atomic2 - -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace std - -#endif diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h index ebb7d58ac72..5327c1bfa21 100644 --- a/libstdc++-v3/include/bits/atomic_base.h +++ b/libstdc++-v3/include/bits/atomic_base.h @@ -69,10 +69,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } void - atomic_thread_fence(memory_order) noexcept; + atomic_thread_fence(memory_order __m) noexcept; void - atomic_signal_fence(memory_order) noexcept; + atomic_signal_fence(memory_order __m) noexcept; /// kill_dependency template<typename _Tp> @@ -83,86 +83,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __ret; } - /** - * @brief Base type for atomic_flag. - * - * Base type is POD with data, allowing atomic_flag to derive from - * it and meet the standard layout type requirement. In addition to - * compatibilty with a C interface, this allows different - * implementations of atomic_flag to use the same atomic operation - * functions, via a standard conversion to the __atomic_flag_base - * argument. - */ - _GLIBCXX_BEGIN_EXTERN_C + /// Lock-free Property - struct __atomic_flag_base - { - bool _M_i; - }; +#define LOCKFREE_PROP(T) (__atomic_always_lock_free (sizeof (T), 0) ? 2 : 1) - _GLIBCXX_END_EXTERN_C - -#define ATOMIC_FLAG_INIT { false } +#define ATOMIC_CHAR_LOCK_FREE LOCKFREE_PROP (char) +#define ATOMIC_CHAR16_T_LOCK_FREE LOCKFREE_PROP (char16_t) +#define ATOMIC_CHAR32_T_LOCK_FREE LOCKFREE_PROP (char32_t) +#define ATOMIC_WCHAR_T_LOCK_FREE LOCKFREE_PROP (wchar_t) +#define ATOMIC_SHORT_LOCK_FREE LOCKFREE_PROP (short) +#define ATOMIC_INT_LOCK_FREE LOCKFREE_PROP (int) +#define ATOMIC_LONG_LOCK_FREE LOCKFREE_PROP (long) +#define ATOMIC_LLONG_LOCK_FREE LOCKFREE_PROP (long long) // Base types for atomics. - // - // Three nested namespaces for atomic implementation details. - // - // The nested namespace inlined into std:: is determined by the value - // of the _GLIBCXX_ATOMIC_PROPERTY macro and the resulting - // ATOMIC_*_LOCK_FREE macros. - // - // 0 == __atomic0 == Never lock-free - // 1 == __atomic1 == Best available, sometimes lock-free - // 2 == __atomic2 == Always lock-free - - namespace __atomic0 - { - struct atomic_flag; - - template<typename _IntTp> - struct __atomic_base; - } - - namespace __atomic2 - { - struct atomic_flag; - - template<typename _IntTp> - struct __atomic_base; - } - - namespace __atomic1 - { - using __atomic2::atomic_flag; - using __atomic0::__atomic_base; - } - - /// Lock-free Property -#if defined(_GLIBCXX_ATOMIC_BUILTINS_1) && defined(_GLIBCXX_ATOMIC_BUILTINS_2) \ - && defined(_GLIBCXX_ATOMIC_BUILTINS_4) && defined(_GLIBCXX_ATOMIC_BUILTINS_8) -# define _GLIBCXX_ATOMIC_PROPERTY 2 -# define _GLIBCXX_ATOMIC_NAMESPACE __atomic2 -#elif defined(_GLIBCXX_ATOMIC_BUILTINS_1) -# define _GLIBCXX_ATOMIC_PROPERTY 1 -# define _GLIBCXX_ATOMIC_NAMESPACE __atomic1 -#else -# define _GLIBCXX_ATOMIC_PROPERTY 0 -# define _GLIBCXX_ATOMIC_NAMESPACE __atomic0 -#endif - -#define ATOMIC_CHAR_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_CHAR16_T_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_CHAR32_T_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_WCHAR_T_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_SHORT_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_INT_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_LONG_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY -#define ATOMIC_LLONG_LOCK_FREE _GLIBCXX_ATOMIC_PROPERTY - - inline namespace _GLIBCXX_ATOMIC_NAMESPACE { } - + template<typename _IntTp> + struct __atomic_base; /// atomic_char typedef __atomic_base<char> atomic_char; @@ -287,6 +224,636 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp> struct atomic<_Tp*>; + + /** + * @brief Base type for atomic_flag. + * + * Base type is POD with data, allowing atomic_flag to derive from + * it and meet the standard layout type requirement. In addition to + * compatibilty with a C interface, this allows different + * implementations of atomic_flag to use the same atomic operation + * functions, via a standard conversion to the __atomic_flag_base + * argument. + */ + _GLIBCXX_BEGIN_EXTERN_C + + struct __atomic_flag_base + { + bool _M_i; + }; + + _GLIBCXX_END_EXTERN_C + +#define ATOMIC_FLAG_INIT { false } + + /// atomic_flag + struct atomic_flag : public __atomic_flag_base + { + atomic_flag() noexcept = default; + ~atomic_flag() noexcept = default; + atomic_flag(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) volatile = delete; + + // Conversion to ATOMIC_FLAG_INIT. + atomic_flag(bool __i) noexcept : __atomic_flag_base({ __i }) { } + + bool + test_and_set(memory_order __m = memory_order_seq_cst) noexcept + { + /* The standard *requires* this to be lock free. If exchange is not + always lock free, the resort to the old test_and_set. */ + if (__atomic_always_lock_free (sizeof (_M_i), 0)) + return __atomic_exchange_n(&_M_i, 1, __m); + else + { + /* Sync test and set is only guaranteed to be acquire. */ + if (__m == memory_order_seq_cst || __m == memory_order_release + || __m == memory_order_acq_rel) + atomic_thread_fence (__m); + return __sync_lock_test_and_set (&_M_i, 1); + } + } + + bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept + { + /* The standard *requires* this to be lock free. If exchange is not + always lock free, the resort to the old test_and_set. */ + if (__atomic_always_lock_free (sizeof (_M_i), 0)) + return __atomic_exchange_n(&_M_i, 1, __m); + else + { + /* Sync test and set is only guaranteed to be acquire. */ + if (__m == memory_order_seq_cst || __m == memory_order_release + || __m == memory_order_acq_rel) + atomic_thread_fence (__m); + return __sync_lock_test_and_set (&_M_i, 1); + } + } + + void + clear(memory_order __m = memory_order_seq_cst) noexcept + { + __glibcxx_assert(__m != memory_order_consume); + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + + /* The standard *requires* this to be lock free. If store is not always + lock free, the resort to the old style __sync_lock_release. */ + if (__atomic_always_lock_free (sizeof (_M_i), 0)) + __atomic_store_n(&_M_i, 0, __m); + else + { + __sync_lock_release (&_M_i, 0); + /* __sync_lock_release is only guaranteed to be a release barrier. */ + if (__m == memory_order_seq_cst) + atomic_thread_fence (__m); + } + } + + void + clear(memory_order __m = memory_order_seq_cst) volatile noexcept + { + __glibcxx_assert(__m != memory_order_consume); + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + + /* The standard *requires* this to be lock free. If store is not always + lock free, the resort to the old style __sync_lock_release. */ + if (__atomic_always_lock_free (sizeof (_M_i), 0)) + __atomic_store_n(&_M_i, 0, __m); + else + { + __sync_lock_release (&_M_i, 0); + /* __sync_lock_release is only guaranteed to be a release barrier. */ + if (__m == memory_order_seq_cst) + atomic_thread_fence (__m); + } + } + }; + + + /// Base class for atomic integrals. + // + // For each of the integral types, define atomic_[integral type] struct + // + // atomic_bool bool + // atomic_char char + // atomic_schar signed char + // atomic_uchar unsigned char + // atomic_short short + // atomic_ushort unsigned short + // atomic_int int + // atomic_uint unsigned int + // atomic_long long + // atomic_ulong unsigned long + // atomic_llong long long + // atomic_ullong unsigned long long + // atomic_char16_t char16_t + // atomic_char32_t char32_t + // atomic_wchar_t wchar_t + // + // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or + // 8 bytes, since that is what GCC built-in functions for atomic + // memory access expect. + template<typename _ITp> + struct __atomic_base + { + private: + typedef _ITp __int_type; + + __int_type _M_i; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + // Requires __int_type convertible to _M_i. + constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + + operator __int_type() const noexcept + { return load(); } + + operator __int_type() const volatile noexcept + { return load(); } + + __int_type + operator=(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile noexcept + { + store(__i); + return __i; + } + + __int_type + operator++(int) noexcept + { return fetch_add(1); } + + __int_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __int_type + operator--(int) noexcept + { return fetch_sub(1); } + + __int_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __int_type + operator++() noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) volatile noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); } + + bool + is_lock_free() const volatile noexcept + { return __atomic_is_lock_free (sizeof (_M_i), &_M_i); } + + void + store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept + { + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + __glibcxx_assert(__m != memory_order_consume); + + __atomic_store_n(&_M_i, __i, __m); + } + + void + store(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + __glibcxx_assert(__m != memory_order_consume); + + __atomic_store_n(&_M_i, __i, __m); + } + + __int_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + + return __atomic_load_n(&_M_i, __m); + } + + __int_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + + return __atomic_load_n(&_M_i, __m); + } + + __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + + __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __calculate_memory_order(__m)); + } + + bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __calculate_memory_order(__m)); + } + + __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + + __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + }; + + + /// Partial specialization for pointer types. + template<typename _PTp> + struct __atomic_base<_PTp*> + { + private: + typedef _PTp* __pointer_type; + + __pointer_type _M_p; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + // Requires __pointer_type convertible to _M_p. + constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } + + operator __pointer_type() const noexcept + { return load(); } + + operator __pointer_type() const volatile noexcept + { return load(); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator++(int) noexcept + { return fetch_add(1); } + + __pointer_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __pointer_type + operator--(int) noexcept + { return fetch_sub(1); } + + __pointer_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __pointer_type + operator++() noexcept + { return __atomic_add_fetch(&_M_p, 1, memory_order_seq_cst); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, 1, memory_order_seq_cst); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, 1, memory_order_seq_cst); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, 1, memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, __d, memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, __d, memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, __d, memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, __d, memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); } + + bool + is_lock_free() const volatile noexcept + { return __atomic_is_lock_free (sizeof (_M_p), &_M_p); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + __glibcxx_assert(__m != memory_order_consume); + + __atomic_store_n(&_M_p, __p, __m); + } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + __glibcxx_assert(__m != memory_order_acquire); + __glibcxx_assert(__m != memory_order_acq_rel); + __glibcxx_assert(__m != memory_order_consume); + + __atomic_store_n(&_M_p, __p, __m); + } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + + return __atomic_load_n(&_M_p, __m); + } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + __glibcxx_assert(__m != memory_order_release); + __glibcxx_assert(__m != memory_order_acq_rel); + + return __atomic_load_n(&_M_p, __m); + } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + __glibcxx_assert(__m2 != memory_order_release); + __glibcxx_assert(__m2 != memory_order_acq_rel); + __glibcxx_assert(__m2 <= __m1); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, __d, __m); } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, __d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, __d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, __d, __m); } + }; + // @} group atomics _GLIBCXX_END_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h index 0edb8b2f8df..00f9bccd419 100644 --- a/libstdc++-v3/include/bits/basic_string.h +++ b/libstdc++-v3/include/bits/basic_string.h @@ -865,6 +865,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return _M_data()[__n]; } + /** + * @brief Provides access to the data contained in the %string. + * @param __n The index of the character to access. + * @return Read/write reference to the character. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is + * first checked that it is in the range of the string. The function + * throws out_of_range if the check fails. Success results in + * unsharing the string. + */ + reference + at(size_type __n) + { + if (__n >= size()) + __throw_out_of_range(__N("basic_string::at")); + _M_leak(); + return _M_data()[__n]; + } + #ifdef __GXX_EXPERIMENTAL_CXX0X__ /** * Returns a read/write reference to the data at the first @@ -899,26 +919,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return operator[](this->size() - 1); } #endif - /** - * @brief Provides access to the data contained in the %string. - * @param __n The index of the character to access. - * @return Read/write reference to the character. - * @throw std::out_of_range If @a n is an invalid index. - * - * This function provides for safer data access. The parameter is - * first checked that it is in the range of the string. The function - * throws out_of_range if the check fails. Success results in - * unsharing the string. - */ - reference - at(size_type __n) - { - if (__n >= size()) - __throw_out_of_range(__N("basic_string::at")); - _M_leak(); - return _M_data()[__n]; - } - // Modifiers: /** * @brief Append a string to this string. @@ -1394,6 +1394,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION iterator erase(iterator __first, iterator __last); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Remove the last character. + * + * The string must be non-empty. + */ + void + pop_back() + { erase(size()-1, 1); } +#endif // __GXX_EXPERIMENTAL_CXX0X__ + /** * @brief Replace characters with value from another string. * @param __pos Index of first character to replace. diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index f77da5ee1a7..e76e7423021 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -148,6 +148,8 @@ namespace __detail { } } + namespace tr2 { } + namespace decimal { } namespace chrono { } @@ -197,6 +199,9 @@ namespace std namespace __detail { inline namespace __7 { } } } + namespace tr2 + { inline namespace __7 { } } + namespace decimal { inline namespace __7 { } } namespace chrono { inline namespace __7 { } } diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index 7c66d633863..d109224d1bf 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -491,7 +491,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const mersenne_twister_engine& __lhs, const mersenne_twister_engine& __rhs) - { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); } + { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x) + && __lhs._M_p == __rhs._M_p); } /** * @brief Inserts the current state of a % mersenne_twister_engine @@ -705,7 +706,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const subtract_with_carry_engine& __lhs, const subtract_with_carry_engine& __rhs) - { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); } + { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x) + && __lhs._M_carry == __rhs._M_carry + && __lhs._M_p == __rhs._M_p); } /** * @brief Inserts the current state of a % subtract_with_carry_engine @@ -1370,7 +1373,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION friend bool operator==(const shuffle_order_engine& __lhs, const shuffle_order_engine& __rhs) - { return __lhs._M_b == __rhs._M_b; } + { return (__lhs._M_b == __rhs._M_b + && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v) + && __lhs._M_y == __rhs._M_y); } /** * @brief Inserts the current state of a %shuffle_order_engine random diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc index 0e74848ff3c..8936a62316a 100644 --- a/libstdc++-v3/include/bits/random.tcc +++ b/libstdc++-v3/include/bits/random.tcc @@ -471,9 +471,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); - for (size_t __i = 0; __i < __n - 1; ++__i) + for (size_t __i = 0; __i < __n; ++__i) __os << __x._M_x[__i] << __space; - __os << __x._M_x[__n - 1]; + __os << __x._M_p; __os.flags(__flags); __os.fill(__fill); @@ -498,6 +498,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION for (size_t __i = 0; __i < __n; ++__i) __is >> __x._M_x[__i]; + __is >> __x._M_p; __is.flags(__flags); return __is; @@ -627,7 +628,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION for (size_t __i = 0; __i < __r; ++__i) __os << __x._M_x[__i] << __space; - __os << __x._M_carry; + __os << __x._M_carry << __space << __x._M_p; __os.flags(__flags); __os.fill(__fill); @@ -649,6 +650,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION for (size_t __i = 0; __i < __r; ++__i) __is >> __x._M_x[__i]; __is >> __x._M_carry; + __is >> __x._M_p; __is.flags(__flags); return __is; |